Module: Metanorma::Mirror::Handlers::Section

Defined in:
lib/metanorma/mirror/handlers/section.rb

Class Method Summary collapse

Class Method Details

.annex(element, context:) ⇒ Object 



14
15
16
17
18
19
20
21
22
23
 
# File 'lib/metanorma/mirror/handlers/section.rb', line 14

def self.annex(element, context:)
  attrs = section_attrs(element, context:)
  attrs[:commentary] = SafeAttr.read(element, :commentary)
  attrs[:language] = SafeAttr.read(element, :language)
  attrs[:script] = SafeAttr.read(element, :script)

  content = context.extract_blocks(element)

  Handlers.build_node("annex", attrs: attrs.compact, content: content)
end

.clause(element, context:) ⇒ Object 



7
8
9
10
11
12
 
# File 'lib/metanorma/mirror/handlers/section.rb', line 7

def self.clause(element, context:)
  attrs = section_attrs(element, context:)
  content = context.extract_blocks(element)

  Handlers.build_node("clause", attrs: attrs, content: content)
end

.content_section(element, context:) ⇒ Object 



25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/metanorma/mirror/handlers/section.rb', line 25

def self.content_section(element, context:)
  attrs = section_attrs(element, context:)
  content = context.extract_blocks(element)

  subsection = SafeAttr.read(element, :subsection)
  subsection&.each do |sub|
    result = context.registry.handle(sub, context: context)
    result.append_to(content)
  end

  Handlers.build_node("content_section", attrs: attrs, content: content)
end

.definitions(element, context:) ⇒ Object 



49
50
51
52
53
54
 
# File 'lib/metanorma/mirror/handlers/section.rb', line 49

def self.definitions(element, context:)
  attrs = section_attrs(element, context:)
  content = context.extract_blocks(element)

  Handlers.build_node("definitions", attrs: attrs, content: content)
end

.extract_biblio_text(ref) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/metanorma/mirror/handlers/section.rb', line 80

def self.extract_biblio_text(ref)
  parts = []

  tag = SafeAttr.read(ref, :biblio_tag)
  if tag
    tag_text = Inline.extract_formatted_text(tag).strip
    parts << tag_text unless tag_text.empty?
  end

  formatted = SafeAttr.read(ref, :formatted_ref)
  if formatted
    fmt_text = Inline.extract_formatted_text(formatted).strip
    parts << fmt_text unless fmt_text.empty?
  end

  return parts.join(" ") unless parts.empty?

  docid = SafeAttr.read(ref, :docidentifier)
  if docid
    text = Inline.extract_formatted_text(docid)
    return text unless text.strip.empty?
  end

  ""
end

.extract_title(element) ⇒ Object 



135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/metanorma/mirror/handlers/section.rb', line 135

def self.extract_title(element)
  title = SafeAttr.read(element, :title)
  return nil unless title

  case title
  when String then title
  else
    rich = Inline.extract_rich_html(title)
    rich.empty? ? Inline.extract_element_text(title) : rich
  end
end

.floating_title(element, context:) ⇒ Object 



106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/metanorma/mirror/handlers/section.rb', line 106

def self.floating_title(element, context:)
  attrs = {}
  attrs[:id] = context.id_strategy.assign_id(element)
  attrs[:depth] = SafeAttr.read(element, :depth)
  attrs[:semx_id] = SafeAttr.read(element, :semx_id)

  title = extract_title(element)
  attrs[:title] = title if title

  Handlers.build_node("floating_title", attrs: attrs.compact)
end

.references(element, context:) ⇒ Object 



56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/metanorma/mirror/handlers/section.rb', line 56

def self.references(element, context:)
  attrs = section_attrs(element, context:)
  attrs[:normative] = SafeAttr.read(element, :normative)
  attrs[:hidden] = SafeAttr.read(element, :hidden)

  # Prefatory paragraphs (e.g. "The following documents are referred to...")
  content = context.extract_named_collections(element,
                                              %i[p])

  # Bibliographic items
  refs = SafeAttr.read(element, :references)
  refs&.each do |ref|
    text = extract_biblio_text(ref)
    next if text.strip.empty?

    content << Handlers.build_node("paragraph",
                                   attrs: { id: SafeAttr.read(ref,
                                                              :id) }.compact,
                                   content: [context.text_node(text)])
  end

  Handlers.build_node("references", attrs: attrs, content: content)
end

.section_attrs(element, context:) ⇒ Object 



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/metanorma/mirror/handlers/section.rb', line 118

def self.section_attrs(element, context:)
  attrs = {}
  attrs[:id] = context.id_strategy.assign_id(element)
  attrs[:number] = SafeAttr.read(element, :number)
  attrs[:obligation] = SafeAttr.read(element, :obligation)
  attrs[:unnumbered] = SafeAttr.read(element, :unnumbered)
  attrs[:toc] = SafeAttr.read(element, :toc)
  attrs[:type] = SafeAttr.read(element, :type)
  attrs[:semx_id] = SafeAttr.read(element, :semx_id)
  attrs[:autonum] = SafeAttr.read(element, :autonum)
  attrs[:displayorder] = SafeAttr.read(element, :displayorder)

  title = extract_title(element)
  attrs[:title] = title if title
  attrs.compact
end

.terms(element, context:) ⇒ Object 



38
39
40
41
42
43
44
45
46
47
 
# File 'lib/metanorma/mirror/handlers/section.rb', line 38

def self.terms(element, context:)
  attrs = section_attrs(element, context:)
  content = context.extract_named_collections(element,
                                              %i[p term dl example
                                                 admonition])
  children = context.extract_section_children(element)

  Handlers.build_node("terms", attrs: attrs,
                               content: content + children)
end