Class: IsoDoc::Ietf::RfcConvert

Inherits:
Convert
  • Object
show all
Includes:
Init
Defined in:
lib/isodoc/ietf/reqt.rb,
lib/isodoc/ietf/front.rb,
lib/isodoc/ietf/table.rb,
lib/isodoc/ietf/terms.rb,
lib/isodoc/ietf/blocks.rb,
lib/isodoc/ietf/inline.rb,
lib/isodoc/ietf/cleanup.rb,
lib/isodoc/ietf/section.rb,
lib/isodoc/ietf/footnotes.rb,
lib/isodoc/ietf/references.rb,
lib/isodoc/ietf/validation.rb,
lib/isodoc/ietf/rfc_convert.rb,
lib/isodoc/ietf/cleanup_inline.rb

Constant Summary collapse

OL_STYLE = 
{
  arabic: "1",
  roman: "i",
  alphabet: "a",
  roman_upper: "I",
  alphabet_upper: "A",
}.freeze

Instance Method Summary collapse

Methods included from Init

#fileloc, #i18n_init

Constructor Details

#initialize(options) ⇒ RfcConvert

Returns a new instance of RfcConvert.



102
103
104
105
106
107
108
109
 
# File 'lib/isodoc/ietf/rfc_convert.rb', line 102

def initialize(options)
  super
  @xinclude = options[:usexinclude]
  @format = :rfc
  @suffix = "rfc.xml"
  @isodoc = IsoDoc::PresentationXMLConvert.new({})
  @isodoc.i18n_init("en", "Latn", nil, nil)
end

Instance Method Details

#abstract(isoxml, front) ⇒ Object 



223
224
225
226
227
228
229
230
 
# File 'lib/isodoc/ietf/front.rb', line 223

def abstract(isoxml, front)
  a = isoxml.at(ns("//preface/abstract | //preface/foreword")) || return
  front.abstract **attr_code(anchor: a["id"]) do |abs|
    a.children.reject { |c1| %w(title note).include? c1.name }.each do |c1|
      parse(c1, abs)
    end
  end
end

#address(addr, phone, fax, email, uri, out) ⇒ Object 



135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/isodoc/ietf/front.rb', line 135

def address(addr, phone, fax, email, uri, out)
  return unless addr || phone || fax || email || uri

  out.address do |a|
    addr and postal(addr, a)
    phone and a.phone phone.text
    fax and a.facsimile fax.text
    email and email(email, a)
    uri and a.uri uri.text
  end
end

#admitted_term_parse(node, out) ⇒ Object 



22
23
24
25
26
27
 
# File 'lib/isodoc/ietf/terms.rb', line 22

def admitted_term_parse(node, out)
  name = node.at(ns(".//name"))
  out.t do |p|
    name.children.each { |c| parse(c, p) }
  end
end

#admonition_name(node, type) ⇒ Object 



197
198
199
200
201
202
203
204
 
# File 'lib/isodoc/ietf/blocks.rb', line 197

def admonition_name(node, type)
  name = node&.at(ns("./name")) and return name
  name = Nokogiri::XML::Node.new("name", node.document)
  return unless type && @i18n.admonition[type]

  name << @i18n.admonition[type]&.upcase
  name
end

#admonition_name_parse(_node, div, name) ⇒ Object 



206
207
208
209
210
 
# File 'lib/isodoc/ietf/blocks.rb', line 206

def admonition_name_parse(_node, div, name)
  div.t keepWithNext: "true" do |p|
    name.children.each { |n| parse(n, p) }
  end
end

#admonition_parse(node, out) ⇒ Object 



212
213
214
215
216
217
218
219
 
# File 'lib/isodoc/ietf/blocks.rb', line 212

def admonition_parse(node, out)
  type = node["type"]
  name = admonition_name(node, type)
  out.aside anchor: node["id"] do |t|
    admonition_name_parse(node, t, name) if name
    node.children.each { |n| parse(n, t) unless n.name == "name" }
  end
end

#annex(isoxml, out) ⇒ Object 



172
173
174
175
176
 
# File 'lib/isodoc/ietf/section.rb', line 172

def annex(isoxml, out)
  isoxml.xpath(ns("//annex")).each do |c|
    clause_parse(c, out)
  end
end

#annotation_cleanup(docxml) ⇒ Object 



198
199
200
201
202
203
204
205
 
# File 'lib/isodoc/ietf/cleanup.rb', line 198

def annotation_cleanup(docxml)
  docxml.xpath("//reference").each do |r|
    while r.next_element&.name == "aside"
      annotation_cleanup1(r)
    end
  end
  docxml.xpath("//references/aside").each(&:remove)
end

#annotation_cleanup1(ref) ⇒ Object 



207
208
209
210
211
212
213
214
 
# File 'lib/isodoc/ietf/cleanup.rb', line 207

def annotation_cleanup1(ref)
  aside = ref.next_element
  aside.name = "annotation"
  aside.traverse do |n|
    n.name == "t" and n.replace(n.children)
  end
  ref << aside
end

#annotation_parse(node, out) ⇒ Object 



139
140
141
142
143
144
145
146
147
148
 
# File 'lib/isodoc/ietf/blocks.rb', line 139

def annotation_parse(node, out)
  @sourcecode = false
  node.at(ns("./annotation")) or return
  out.t { |p| p << @i18n.key }
  out.dl do |dl|
    node.xpath(ns("./annotation")).each do |a|
      annotation_parse1(a, dl)
    end
  end
end

#annotation_parse1(ann, dlist) ⇒ Object 



150
151
152
153
154
155
 
# File 'lib/isodoc/ietf/blocks.rb', line 150

def annotation_parse1(ann, dlist)
  dlist.dt ann.at(ns("//callout[@target='#{ann['id']}']")).text
  dlist.dd do |dd|
    ann.children.each { |n| parse(n, dd) }
  end
end

#area(_isoxml, front) ⇒ Object 



205
206
207
208
209
 
# File 'lib/isodoc/ietf/front.rb', line 205

def area(_isoxml, front)
  @meta.get[:areas].each do |w|
    front.area w
  end
end

#aside_cleanup(docxml) ⇒ Object 



239
240
241
242
243
244
245
246
247
248
 
# File 'lib/isodoc/ietf/cleanup.rb', line 239

def aside_cleanup(docxml)
  docxml.xpath("//*[aside]").each do |p|
    %w(section).include?(p.name) and next
    insert = p
    p.xpath("./aside").each do |a|
      insert.next = a.remove
      insert = insert.next_element
    end
  end
end

#author(isoxml, front) ⇒ Object 



71
72
73
74
75
76
77
78
 
# File 'lib/isodoc/ietf/front.rb', line 71

def author(isoxml, front)
  isoxml.xpath(("//xmlns:bibdata/xmlns:contributor[xmlns:role/@type = " \
    "'author' or xmlns:role/@type = 'editor']")).each do |c|
    role = c.at(ns("./role/@type")).text == "editor" ? "editor" : nil
    (c.at("./organization") and org_author(c, role, front)) or
      person_author(c, role, front)
  end
end

#bcp14_parse(node, out) ⇒ Object 



34
35
36
37
38
 
# File 'lib/isodoc/ietf/inline.rb', line 34

def bcp14_parse(node, out)
  out.bcp14 do |e|
    node.children.each { |n| parse(n, e) }
  end
end

#bibitem_render(ref, bib) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/isodoc/ietf/references.rb', line 64

def bibitem_render(ref, bib)
  bib1 = bib.clone
  @isodoc.prep_for_rendering(bib1)
  bib1.namespace = nil
  ret = @bibrenderer.render(bib1.to_xml, embedded: true)
  ref << if bib1.at(ns("./formattedref")) && !bib1.at(ns("./title"))
           "<front><title>#{ret}</title></front>"
         else
           ret
         end
end

#biblio_abstract_cleanup(xmldoc) ⇒ Object 



43
44
45
46
47
48
49
50
51
 
# File 'lib/isodoc/ietf/cleanup.rb', line 43

def biblio_abstract_cleanup(xmldoc)
  xmldoc.xpath("//abstract[@cleanme]").each do |a|
    a.delete("cleanme")
    ret = reparse_abstract(a)
    a.children = if a.at("./p") then ret
                 else "<t>#{ret}</t>"
                 end
  end
end

#biblio_cleanup(xmldoc) ⇒ Object 



23
24
25
26
27
28
 
# File 'lib/isodoc/ietf/cleanup.rb', line 23

def biblio_cleanup(xmldoc)
  biblio_abstract_cleanup(xmldoc)
  biblio_date_cleanup(xmldoc)
  biblio_refcontent_cleanup(xmldoc)
  annotation_cleanup(xmldoc)
end

#biblio_date_cleanup(xmldoc) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/isodoc/ietf/cleanup.rb', line 30

def biblio_date_cleanup(xmldoc)
  xmldoc.xpath("//date[@cleanme]").each do |a|
    a.delete("cleanme")
    d = @c.decode(a.text).gsub(/–/, "-").sub(/-\d\d\d\d.*$/, "")
    if attrs = date_attr(d)
      attrs.each do |k, v|
        a[k] = v
      end
      a.children.remove
    else a.remove end
  end
end

#biblio_list(node, div, _biblio) ⇒ Object 



41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/isodoc/ietf/references.rb', line 41

def biblio_list(node, div, _biblio)
  i = 0
  node.xpath(ns("./bibitem | ./note")).each do |b|
    next if implicit_reference(b)

    i += 1 if b.name == "bibitem"
    if b.name == "note" then note_parse(b, div)
    else
      ietf_bibitem(div, b, i)
    end
  end
end

#biblio_refcontent_cleanup(xmldoc) ⇒ Object 



53
54
55
56
57
58
59
60
 
# File 'lib/isodoc/ietf/cleanup.rb', line 53

def biblio_refcontent_cleanup(xmldoc)
  xmldoc.xpath("//refcontent").each do |a|
    val = a.text.strip
    if val.empty? then a.remove
    else a.children = val
    end
  end
end

#bibliography(docxml, out) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
 
# File 'lib/isodoc/ietf/references.rb', line 6

def bibliography(docxml, out)
  bibliography_prep(docxml)
  docxml.xpath(ns("//bibliography/references | " \
                  "//bibliography/clause[.//references] | " \
                  "//annex/clause[.//references] | " \
                  "//annex/references | " \
                  "//sections/clause[.//references]")).each do |f|
    bibliography1(f, out)
  end
end

#bibliography1(node, out) ⇒ Object 



26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/isodoc/ietf/references.rb', line 26

def bibliography1(node, out)
  out.references **attr_code(anchor: node["id"]) do |div|
    title = node.at(ns("./title")) and div.name do |name|
      title.children.each { |n| parse(n, name) }
    end
    node.elements.select do |e|
      %w(references clause).include? e.name
    end.each { |e| bibliography1(e, out) }
    node.elements.reject do |e|
      %w(references title bibitem note).include? e.name
    end.each { |e| parse(e, div) }
    biblio_list(node, div, true)
  end
end

#bibliography_prep(docxml) ⇒ Object 



17
18
19
20
21
22
23
24
 
# File 'lib/isodoc/ietf/references.rb', line 17

def bibliography_prep(docxml)
  docxml.xpath(ns("//references/bibitem/docidentifier")).each do |i|
    i.children = docid_prefix(i["type"], i.text)
  end
  @bibrenderer =
    ::Relaton::Render::Ietf::General.new(language: @lang,
                                         i18nhash: @i18n.get)
end

#boilerplate(isoxml, front) ⇒ Object 



245
 
# File 'lib/isodoc/ietf/front.rb', line 245

def boilerplate(isoxml, front); end

#bookmark_cleanup(docxml) ⇒ Object 



60
61
62
 
# File 'lib/isodoc/ietf/cleanup_inline.rb', line 60

def bookmark_cleanup(docxml)
  docxml.xpath("//bookmark").each(&:remove)
end

#bookmark_parse(node, out) ⇒ Object 



170
171
172
 
# File 'lib/isodoc/ietf/inline.rb', line 170

def bookmark_parse(node, out)
  out.bookmark nil, **attr_code(anchor: node["id"])
end

#br_parse(_node, out) ⇒ Object 



72
73
74
 
# File 'lib/isodoc/ietf/inline.rb', line 72

def br_parse(_node, out)
  out.br
end

#clause(isoxml, out) ⇒ Object 



161
162
163
164
165
166
167
168
169
170
 
# File 'lib/isodoc/ietf/section.rb', line 161

def clause(isoxml, out)
  isoxml.xpath("//xmlns:preface/child::*" \
               "[not(name() = 'abstract' or name() = 'foreword')] " \
               "| //xmlns:sections/child::*").each do |c|
    # cdup = c.dup
    # cdup.xpath(ns(".//references")).each { |r| r.remove }
    # cdup.at("./*[local-name() != 'title'][normalize-space(text()) != '']") or next
    clause_parse(c, out)
  end
end

#clause_parse(node, out) ⇒ Object 



147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/isodoc/ietf/section.rb', line 147

def clause_parse(node, out)
  return if node.at(ns(".//references"))

  out.section **attr_code(
    anchor: node["id"], numbered: node["numbered"],
    removeInRFC: node["removeInRFC"], toc: node["toc"]
  ) do |div|
    clause_parse_title(node, div, node.at(ns("./title")), out)
    node.children.reject { |c1| c1.name == "title" }.each do |c1|
      parse(c1, div)
    end
  end
end

#clause_parse_title(_node, div, clause, _out, _heading_attrs = {}) ⇒ Object 



139
140
141
142
143
144
145
 
# File 'lib/isodoc/ietf/section.rb', line 139

def clause_parse_title(_node, div, clause, _out, _heading_attrs = {})
  return unless clause

  div.name do |n|
    clause&.children&.each { |c2| parse(c2, n) }
  end
end

#cleanup(docxml) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/isodoc/ietf/cleanup.rb', line 6

def cleanup(docxml)
  image_cleanup(docxml)
  figure_cleanup(docxml)
  table_cleanup(docxml)
  footnote_cleanup(docxml)
  sourcecode_cleanup(docxml)
  li_cleanup(docxml)
  deflist_cleanup(docxml)
  bookmark_cleanup(docxml)
  cref_cleanup(docxml)
  front_cleanup(docxml)
  u_cleanup(docxml)
  biblio_cleanup(docxml) # feeds aside
  aside_cleanup(docxml)
  docxml
end

#common_rfc_pis(node) ⇒ Object 



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/isodoc/ietf/section.rb', line 4

def common_rfc_pis(node)
  rfc_pis = {
    artworkdelimiter: node&.at(ns("//pi/artworkdelimiter"))&.text,
    artworklines: node&.at(ns("//pi/artworklines"))&.text,
    authorship: node&.at(ns("//pi/authorship"))&.text,
    autobreaks: node&.at(ns("//pi/autobreaks"))&.text,
    background: node&.at(ns("//pi/background"))&.text,
    colonspace: node&.at(ns("//pi/colonspace"))&.text,
    comments: node&.at(ns("//pi/comments"))&.text,
    docmapping: node&.at(ns("//pi/docmapping"))&.text,
    editing: node&.at(ns("//pi/editing"))&.text,
    emoticonic: node&.at(ns("//pi/emoticonic"))&.text,
    footer: node&.at(ns("//pi/footer"))&.text,
    header: node&.at(ns("//pi/header"))&.text,
    inline: node&.at(ns("//pi/inline"))&.text,
    iprnotified: node&.at(ns("//pi/iprnotified"))&.text,
    linkmailto: node&.at(ns("//pi/linkmailto"))&.text,
    linefile: node&.at(ns("//pi/linefile"))&.text,
    notedraftinprogress: node&.at(ns("//pi/notedraftinprogress"))&.text,
    private: node&.at(ns("//pi/private"))&.text,
    refparent: node&.at(ns("//pi/refparent"))&.text,
    rfcedstyle: node&.at(ns("//pi/rfcedstyle"))&.text,
    slides: node&.at(ns("//pi/slides"))&.text,
    "text-list-symbols": node&.at(ns("//pi/text-list-symbols"))&.text,
    tocappendix: node&.at(ns("//pi/tocappendix"))&.text,
    tocindent: node&.at(ns("//pi/tocindent"))&.text,
    tocnarrow: node&.at(ns("//pi/tocnarrow"))&.text,
    tocompact: node&.at(ns("//pi/tocompact"))&.text,
    topblock: node&.at(ns("//pi/topblock"))&.text,
    useobject: node&.at(ns("//pi/useobject"))&.text,
    strict: node&.at(ns("//pi/strict"))&.text || "yes",
    compact: node&.at(ns("//pi/compact"))&.text || "yes",
    subcompact: node&.at(ns("//pi/subcompact"))&.text || "no",
    toc: node&.at(ns("//pi/tocinclude"))&.text,
    tocdepth: node&.at(ns("//pi/toc-depth"))&.text || "4",
    symrefs: node&.at(ns("//pi/sym-refs"))&.text || "yes",
    sortrefs: node&.at(ns("//pi/sort-refs"))&.text || "yes",
  }
  attr_code(rfc_pis)
end

#concept_parse(node, out) ⇒ Object 



49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/isodoc/ietf/terms.rb', line 49

def concept_parse(node, out)
  if d = node.at(ns("./renderterm"))
    out.em do |em|
      d.children.each { |n| parse(n, em) }
    end
    out << " "
  end
  out << "[term defined in "
  r = node.at(ns("./xref | ./eref | ./termref"))
  parse(r, out)
  out << "]"
end

#content_validate(xml, filename) ⇒ Object 



18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
# File 'lib/isodoc/ietf/validation.rb', line 18

def content_validate(xml, filename)
  #return
  err = []
  err += numbered_sections_check(xml)
  err += toc_sections_check(xml)
  err += references_check(xml)
  err += xref_check(xml)
  err += metadata_check(xml)
  return if err.empty?

  FileUtils.mv(filename, "#{filename}.err")
  err.each { |e| warn "RFC XML: #{e}" }
  warn "Cannot continue processing"
end

#convert1(docxml, _filename, _dir) ⇒ Object 



19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/isodoc/ietf/rfc_convert.rb', line 19

def convert1(docxml, _filename, _dir)
  document_preprocess(docxml)
  ret = noko do |xml|
    xml.rfc **attr_code(rfc_attributes(docxml)) do |html|
      make_link(html, docxml)
      make_front(html, docxml)
      make_middle(html, docxml)
      make_back(html, docxml)
    end
  end.join("\n").sub(/<!DOCTYPE[^>]+>\n/, "")
  set_pis(docxml, Nokogiri::XML(ret))
end

#cref_cleanup(docxml) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
 
# File 'lib/isodoc/ietf/cleanup_inline.rb', line 64

def cref_cleanup(docxml)
  docxml.xpath("//cref").each do |c|
    c.xpath("./t").each do |t|
      t.replace(t.children)
    end
    next unless %w(section abstract).include? c.parent.name

    c.wrap("<t></t>")
  end
end

#date(_isoxml, front) ⇒ Object 



180
181
182
183
184
185
 
# File 'lib/isodoc/ietf/front.rb', line 180

def date(_isoxml, front)
  date = @meta.get[:publisheddate] || @meta.get[:circulateddate] || return
  date = date.gsub(/T.*$/, "")
  attr = date_attr(date) || return
  front.date **attr_code(attr)
end

#date_attr(date) ⇒ Object 



187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
 
# File 'lib/isodoc/ietf/front.rb', line 187

def date_attr(date)
  return nil if date.nil?

  if date.length == 4 && date =~ /^\d\d\d\d$/ then { year: date }
  elsif /^\d\d\d\d-?\d\d$/.match?(date)
    m = /^(?<year>\d\d\d\d)-(?<month>\d\d)$/.match date
    { month: Date::MONTHNAMES[(m[:month]).to_i], year: m[:year] }
  else
    begin
      d = Date.iso8601 date
      { day: d.day.to_s.gsub(/^0/, ""), year: d.year,
        month: Date::MONTHNAMES[d.month] }
    rescue StandardError
      nil
    end
  end
end

#dd_cleanup(docxml) ⇒ Object 



232
233
234
235
236
237
 
# File 'lib/isodoc/ietf/cleanup.rb', line 232

def dd_cleanup(docxml)
  docxml.xpath("//dd").each do |d|
    d&.first_element_child&.name == "bookmark" and
      d["anchor"] ||= d.first_element_child["anchor"]
  end
end

#definition_parse(node, out) ⇒ Object 



4
5
6
 
# File 'lib/isodoc/ietf/terms.rb', line 4

def definition_parse(node, out)
  node.children.each { |n| parse(n, out) }
end

#deflist_cleanup(docxml) ⇒ Object 



216
217
218
219
 
# File 'lib/isodoc/ietf/cleanup.rb', line 216

def deflist_cleanup(docxml)
  dt_cleanup(docxml)
  dd_cleanup(docxml)
end

#deprecated_term_parse(node, out) ⇒ Object 



14
15
16
17
18
19
20
 
# File 'lib/isodoc/ietf/terms.rb', line 14

def deprecated_term_parse(node, out)
  name = node.at(ns(".//name"))
  out.t do |p|
    p << l10n("#{@i18n.deprecated}: ")
    name.children.each { |c| parse(c, p) }
  end
end

#div_parse(node, out) ⇒ Object 



29
30
31
32
33
 
# File 'lib/isodoc/ietf/reqt.rb', line 29

def div_parse(node, out)
  node.children.each do |n|
    parse(n, out)
  end
end

#dl_attrs(node) ⇒ Object 



60
61
62
63
64
65
 
# File 'lib/isodoc/ietf/blocks.rb', line 60

def dl_attrs(node)
  attr_code(anchor: node["id"],
            newline: node["newline"],
            indent: node["indent"],
            spacing: node["spacing"])
end

#document_preprocess(docxml) ⇒ Object 



32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/isodoc/ietf/rfc_convert.rb', line 32

def document_preprocess(docxml)
  @isodoc.reqt_models = Metanorma::Requirements
    .new({ default: "default", lang: @lang, script: @script,
           locale: @locale, labels: @i18n.get })
  info docxml, nil
  @xrefs.parse docxml
  @isodoc.xrefs = @xrefs
  @isodoc.permission(docxml)
  @isodoc.requirement(docxml)
  @isodoc.recommendation(docxml)
  @isodoc.requirement_render(docxml)
  @xrefs.parse docxml
end

#dt_cleanup(docxml) ⇒ Object 



221
222
223
224
225
226
227
228
229
230
 
# File 'lib/isodoc/ietf/cleanup.rb', line 221

def dt_cleanup(docxml)
  docxml.xpath("//dt").each do |d|
    d.first_element_child&.name == "bookmark" and
      d["anchor"] ||= d.first_element_child["anchor"]
    d.xpath(".//t").each do |t|
      d["anchor"] ||= t["anchor"]
      t.replace(t.children)
    end
  end
end

#dt_parse(dterm, term) ⇒ Object 



67
68
69
70
71
72
73
 
# File 'lib/isodoc/ietf/blocks.rb', line 67

def dt_parse(dterm, term)
  if dterm.elements.empty?
    term << dterm.text
  else
    dterm.children.each { |n| parse(n, term) }
  end
end

#em_parse(node, out) ⇒ Object 



4
5
6
7
8
 
# File 'lib/isodoc/ietf/inline.rb', line 4

def em_parse(node, out)
  out.em do |e|
    node.children.each { |n| parse(n, e) }
  end
end

#email(email, out) ⇒ Object 



174
175
176
177
178
 
# File 'lib/isodoc/ietf/front.rb', line 174

def email(email, out)
  ascii = email.text.transliterate
  out.email email.text,
            **attr_code(ascii: ascii == email.text ? nil : ascii)
end

#eref_parse(node, out) ⇒ Object 



131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/isodoc/ietf/inline.rb', line 131

def eref_parse(node, out)
  linkend = node.children.reject do |c|
    %w{locality localityStack}.include? c.name
  end
  # section = "" unless relative.empty?
  out.relref **attr_code(target: node["bibitemid"],
                         section: eref_section(node),
                         relative: eref_relative(node),
                         displayFormat: node["displayFormat"]) do |l|
                           linkend.each { |n| parse(n, l) }
                         end
end

#eref_relative(node) ⇒ Object 



144
145
146
147
 
# File 'lib/isodoc/ietf/inline.rb', line 144

def eref_relative(node)
  node["relative"] ||
    node.at(ns(".//locality[@type = 'anchor']/referenceFrom"))&.text || ""
end

#eref_section(node) ⇒ Object 



149
150
151
152
153
154
 
# File 'lib/isodoc/ietf/inline.rb', line 149

def eref_section(node)
  @isodoc.eref_localities(
    node.xpath(ns("./locality | ./localityStack")), nil, node
  )&.sub(/^,/, "")&.sub(/^\s*(Sections?|Clauses?)/, "")&.strip
    &.sub(/,$/, "") || ""
end

#error_parse(node, out) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/isodoc/ietf/rfc_convert.rb', line 65

def error_parse(node, out)
  case node.name
  when "bcp14" then bcp14_parse(node, out)
  when "concept" then concept_parse(node, out)
  when "verbal-definition", "non-verbal-representation"
    node.elements.each { |n| parse(n, out) }
  else
    text = node.to_xml.gsub(/</, "&lt;").gsub(/>/, "&gt;")
    out.t { |p| p << text }
  end
end

#example_label(node, div, name) ⇒ Object 



101
102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/isodoc/ietf/blocks.rb', line 101

def example_label(node, div, name)
  n = @xrefs.get[node["id"]]
  div.t **attr_code(anchor: node["id"], keepWithNext: "true") do |p|
    lbl = if n.nil? || n[:label].nil? || n[:label].empty?
            @i18n.example
          else
            l10n("#{@i18n.example} #{n[:label]}")
          end
    p << lbl
    name and !lbl.nil? and p << ": "
    name&.children&.each { |e| parse(e, p) }
  end
end

#example_parse(node, out) ⇒ Object 



96
97
98
99
 
# File 'lib/isodoc/ietf/blocks.rb', line 96

def example_parse(node, out)
  example_label(node, out, node.at(ns("./name")))
  node.elements.each { |n| parse(n, out) unless n.name == "name" }
end

#extract_delims(text) ⇒ Object 



54
55
56
57
58
59
60
61
62
63
 
# File 'lib/isodoc/ietf/rfc_convert.rb', line 54

def extract_delims(text)
  @openmathdelim = "$$"
  @closemathdelim = "$$"
  while %r{#{Regexp.escape(@openmathdelim)}}m.match(text) ||
      %r{#{Regexp.escape(@closemathdelim)}}m.match(text)
    @openmathdelim += "$"
    @closemathdelim += "$"
  end
  [@openmathdelim, @closemathdelim]
end

#figure_cleanup(docxml) ⇒ Object 



106
107
108
109
110
111
 
# File 'lib/isodoc/ietf/cleanup.rb', line 106

def figure_cleanup(docxml)
  figure_postamble(docxml)
  figure_unnest(docxml)
  figure_footnote_cleanup(docxml)
  figure_data_uri(docxml)
end

#figure_data_uri(docxml) ⇒ Object 



113
114
115
116
117
118
119
120
 
# File 'lib/isodoc/ietf/cleanup.rb', line 113

def figure_data_uri(docxml)
  docxml.xpath("//artwork").each do |a|
    %r{^data:image/svg\+xml;base64}.match?(a["src"]) or next
    f = Vectory::Utils::save_dataimage(a["src"])
    a.delete("src")
    a.children = File.read(f).sub(%r{<\?.+\?>}, "")
  end
end

#figure_footnote_cleanup(docxml) ⇒ Object 



94
95
96
97
98
99
100
 
# File 'lib/isodoc/ietf/cleanup.rb', line 94

def figure_footnote_cleanup(docxml)
  docxml.xpath("//figure[descendant::fn]").each do |t|
    t.xpath(".//fn").each do |a|
      t << "<aside>#{a.remove.children}</aside>"
    end
  end
end

#figure_name_parse(_node, div, name) ⇒ Object 



232
233
234
235
236
237
238
 
# File 'lib/isodoc/ietf/blocks.rb', line 232

def figure_name_parse(_node, div, name)
  return if name.nil?

  div.name do |_n|
    name.children.each { |n| parse(n, div) }
  end
end

#figure_parse(node, out) ⇒ Object 



244
245
246
247
248
249
250
251
252
253
254
255
256
 
# File 'lib/isodoc/ietf/blocks.rb', line 244

def figure_parse(node, out)
  return pseudocode_parse(node, out) if node["class"] == "pseudocode" ||
    node["type"] == "pseudocode"

  @in_figure = true
  out.figure **attr_code(anchor: node["id"]) do |div|
    figure_name_parse(node, div, node.at(ns("./name")))
    node.children.each do |n|
      parse(n, div) unless n.name == "name"
    end
  end
  @in_figure = false
end

#figure_postamble(docxml) ⇒ Object 



134
135
136
137
138
 
# File 'lib/isodoc/ietf/cleanup.rb', line 134

def figure_postamble(docxml)
  make_postamble(docxml)
  move_postamble(docxml)
  move_preamble(docxml)
end

#figure_unnest(docxml) ⇒ Object 



122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/isodoc/ietf/cleanup.rb', line 122

def figure_unnest(docxml)
  docxml.xpath("//figure[descendant::figure]").each do |f|
    insert = f
    f.xpath(".//figure").each do |a|
      title = f.at("./name") and a.children.first.previous = title.remove
      insert.next = a.remove
      insert = insert.next_element
    end
    f.remove
  end
end

#footnote_cleanup(docxml) ⇒ Object 



14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/isodoc/ietf/cleanup_inline.rb', line 14

def footnote_cleanup(docxml)
  fn = footnote_refs_cleanup(docxml)
  endnotes = make_endnotes(docxml)
  docxml.xpath("//section[descendant::fn] | " \
               "//abstract[descendant::fn]").each do |s|
    s.xpath(".//fn").each do |f|
      ref = f.at(".//ref") and ref.replace("[#{fn[ref.text]}] ")
      endnotes << f.remove.children
    end
  end
end

#footnote_parse(node, out) ⇒ Object 



3
4
5
6
7
8
9
 
# File 'lib/isodoc/ietf/footnotes.rb', line 3

def footnote_parse(node, out)
  return table_footnote_parse(node, out) if @in_table || @in_figure

  fn = node["reference"]
  out.fnref fn
  make_local_footnote(node, fn, out)
end

#footnote_refs_cleanup(docxml) ⇒ Object 



26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/isodoc/ietf/cleanup_inline.rb', line 26

def footnote_refs_cleanup(docxml)
  i = 0
  fn = {}
  docxml.xpath("//fnref").each do |f|
    unless fn[f.text]
      i = i + 1
      fn[f.text] = i.to_s
    end
    f.replace(" [#{fn[f.text]}]")
  end
  fn
end

#formula_parse(node, out) ⇒ Object 



173
174
175
176
177
178
179
180
181
 
# File 'lib/isodoc/ietf/blocks.rb', line 173

def formula_parse(node, out)
  formula_parse1(node, out)
  formula_where(node.at(ns("./dl")), out)
  node.children.each do |n|
    next if %w(stem dl).include? n.name

    parse(n, out)
  end
end

#formula_parse1(node, out) ⇒ Object 



164
165
166
167
168
169
170
171
 
# File 'lib/isodoc/ietf/blocks.rb', line 164

def formula_parse1(node, out)
  out.t **attr_code(anchor: node["id"]) do |p|
    parse(node.at(ns("./stem")), p)
    lbl = @xrefs.anchor(node["id"], :label, false)
    lbl.nil? or
      p << "    (#{lbl})"
  end
end

#formula_where(dlist, out) ⇒ Object 



157
158
159
160
161
162
 
# File 'lib/isodoc/ietf/blocks.rb', line 157

def formula_where(dlist, out)
  return unless dlist

  out.t { |p| p << @i18n.where }
  parse(dlist, out)
end

#front_cleanup(xmldoc) ⇒ Object 



78
79
80
81
82
83
84
 
# File 'lib/isodoc/ietf/cleanup.rb', line 78

def front_cleanup(xmldoc)
  xmldoc.xpath("//title").each { |s| s.children = s.text }
  xmldoc.xpath("//reference/front[not(author)]").each do |f|
    insert = f.at("./seriesInfo[last()]") || f.at("./title")
    insert.next = "<author surname='Unknown'/>"
  end
end

#get_linkend(node) ⇒ Object 



121
122
123
124
125
126
127
128
129
 
# File 'lib/isodoc/ietf/inline.rb', line 121

def get_linkend(node)
  no_loc_contents = node.children.reject do |c|
    %w{locality localityStack location}.include? c.name
  end
  contents = no_loc_contents.select { |c| !c.text? || /\S/.match(c) }
  !contents.empty? and
    return to_xml(Nokogiri::XML::NodeSet.new(node.document, contents))
  ""
end

#get_table_ancestor_id(node) ⇒ Object 



67
68
69
70
71
72
 
# File 'lib/isodoc/ietf/footnotes.rb', line 67

def get_table_ancestor_id(node)
  table = node.ancestors("table") || node.ancestors("figure")
  return UUIDTools::UUID.random_create.to_s if table.empty?

  table.last["id"]
end

#hr_parse(node, out) ⇒ Object 



76
 
# File 'lib/isodoc/ietf/inline.rb', line 76

def hr_parse(node, out); end

#id_seriesinfo(isoxml, front) ⇒ Object 



62
63
64
65
66
67
68
69
 
# File 'lib/isodoc/ietf/front.rb', line 62

def id_seriesinfo(isoxml, front)
  front.seriesInfo nil,
                   **seriesinfo_attr(isoxml)
                     .merge({ name: "Internet-Draft",
                              asciiName: "Internet-Draft" })
  i = isoxml&.at(ns("//bibdata/series[@type = 'intended']/title"))&.text and
    front.seriesInfo **attr_code(name: "", value: "", status: i)
end

#ietf_bibitem(list, bib, _ordinal) ⇒ Object 



54
55
56
57
58
59
60
61
62
 
# File 'lib/isodoc/ietf/references.rb', line 54

def ietf_bibitem(list, bib, _ordinal)
  uris = bib.xpath(ns("./uri"))
  target = nil
  uris&.each { |u| target = u.text if u["type"] == "src" }
  list.reference **attr_code(target: target,
                             anchor: bib["id"]) do |r|
                               bibitem_render(r, bib)
                             end
end

#image_cleanup(docxml) ⇒ Object 



49
50
51
52
53
54
55
56
57
58
 
# File 'lib/isodoc/ietf/cleanup_inline.rb', line 49

def image_cleanup(docxml)
  docxml.xpath("//t[descendant::artwork]").each do |t|
    insert = t
    t.xpath(".//artwork").each_with_index do |a, i|
      insert.next = a.dup
      insert = insert.next
      a.replace("[IMAGE #{i + 1}]")
    end
  end
end

#image_parse(node, out, caption) ⇒ Object 



91
92
93
94
 
# File 'lib/isodoc/ietf/inline.rb', line 91

def image_parse(node, out, caption)
  out.artwork **attr_code(image_parse_attrs(node))
  image_title_parse(out, caption)
end

#image_parse_attrs(node) ⇒ Object 



84
85
86
87
88
89
 
# File 'lib/isodoc/ietf/inline.rb', line 84

def image_parse_attrs(node)
  { src: node["src"], title: node["title"],
    align: node["align"], name: node["filename"],
    anchor: node["id"], type: "svg",
    alt: node["alt"] }
end

#image_title_parse(out, caption) ⇒ Object 



96
97
98
99
100
101
102
 
# File 'lib/isodoc/ietf/inline.rb', line 96

def image_title_parse(out, caption)
  unless caption.nil?
    out.t align: "center", keepWithPrevious: "true" do |p|
      p << caption.to_s
    end
  end
end

#index_parse(node, out) ⇒ Object 



164
165
166
167
168
 
# File 'lib/isodoc/ietf/inline.rb', line 164

def index_parse(node, out)
  out.iref nil, **attr_code(item: node.at(ns("./primary")).text,
                            primary: node["primary"],
                            subitem: node&.at(ns("./secondary"))&.text)
end

#info(isoxml, out) ⇒ Object 



21
22
23
24
 
# File 'lib/isodoc/ietf/front.rb', line 21

def info(isoxml, out)
  @meta.areas isoxml, out
  super
end

#init_file(filename, debug) ⇒ Object 



97
98
99
100
 
# File 'lib/isodoc/ietf/rfc_convert.rb', line 97

def init_file(filename, debug)
  filename = filename.sub(/\.rfc\.xml$/, ".rfc")
  super
end

#ipr_check(xml) ⇒ Object

5.4.2.3. “Copyright Notice” Insertion



192
193
194
195
196
197
198
199
 
# File 'lib/isodoc/ietf/validation.rb', line 192

def ipr_check(xml)
  xml.root["ipr"] or
    return ["Missing ipr attribute on <rfc> element (:ipr:)"]
  /trust200902$/.match(xml.root["ipr"]) or
    return ["Unknown ipr attribute on <rfc> element (:ipr:): " \
            "#{xml.root['ipr']}"]
  []
end

#keyword(_isoxml, front) ⇒ Object 



217
218
219
220
221
 
# File 'lib/isodoc/ietf/front.rb', line 217

def keyword(_isoxml, front)
  @meta.get[:keywords].each do |kw|
    front.keyword kw
  end
end

#keyword_parse(node, out) ⇒ Object 



48
49
50
 
# File 'lib/isodoc/ietf/inline.rb', line 48

def keyword_parse(node, out)
  node.children.each { |n| parse(n, out) }
end

#label(sect) ⇒ Object 



33
34
35
36
 
# File 'lib/isodoc/ietf/validation.rb', line 33

def label(sect)
  sect&.at("./name")&.text ||
    sect["name"] || sect["anchor"]
end

#li_cleanup(xmldoc) ⇒ Object 



70
71
72
73
74
75
76
 
# File 'lib/isodoc/ietf/cleanup.rb', line 70

def li_cleanup(xmldoc)
  xmldoc.xpath("//li[t]").each do |li|
    next unless li.elements.size == 1

    li.children = li.elements[0].children
  end
end

#link_check(xml) ⇒ Object

5.6.3. <link> Processing



165
166
167
168
169
170
171
172
 
# File 'lib/isodoc/ietf/validation.rb', line 165

def link_check(xml)
  l = xml&.at("//link[@rel = 'convertedFrom']")&.text
  !l || %r{^https://datatracker\.ietf\.org/doc/draft-}.match(l) or
    return ["<link rel='convertedFrom'> (:derived-from: document " \
            "attribute) must start with " \
            "https://datatracker.ietf.org/doc/draft-"]
  []
end

#link_parse(node, out) ⇒ Object 



78
79
80
81
82
 
# File 'lib/isodoc/ietf/inline.rb', line 78

def link_parse(node, out)
  out.eref **attr_code(target: node["target"]) do |l|
    node.children.each { |n| parse(n, l) }
  end
end

#make_back(out, isoxml) ⇒ Object 



132
133
134
135
136
137
 
# File 'lib/isodoc/ietf/section.rb', line 132

def make_back(out, isoxml)
  out.back do |back|
    bibliography isoxml, back
    annex isoxml, back
  end
end

#make_endnotes(docxml) ⇒ Object 



39
40
41
42
43
44
45
46
47
 
# File 'lib/isodoc/ietf/cleanup_inline.rb', line 39

def make_endnotes(docxml)
  return unless docxml.at("//fn")

  unless endnotes = docxml.at("//back")
    docxml << "<back/>" and endnotes = docxml.at("//back")
  end
  endnotes << "<section><name>Endnotes</name></section>"
  docxml.at("//back/section[last()]")
end

#make_front(out, isoxml) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
# File 'lib/isodoc/ietf/front.rb', line 5

def make_front(out, isoxml)
  info(isoxml, out)
  out.front do |front|
    title isoxml, front
    seriesinfo isoxml, front
    author isoxml, front
    date isoxml, front
    area isoxml, front
    workgroup isoxml, front
    keyword isoxml, front
    abstract isoxml, front
    note isoxml, front
    boilerplate isoxml, front
  end
end

#make_generic_footnote_text(node, fnref) ⇒ Object 



20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/isodoc/ietf/footnotes.rb', line 20

def make_generic_footnote_text(node, fnref)
  first = node.first_element_child
  noko do |xml|
    xml.fn do |_div|
      xml.t **attr_code(anchor: first ? first["id"] : nil) do |div|
        div.ref fnref
        first.name == "p" and first.children.each { |n| parse(n, div) }
      end
      (first.name == "p" and
        node.elements.drop(1).each { |n| parse(n, xml) }) or
        node.children.each { |n| parse(n, xml) }
    end
  end.join
end

#make_link(out, isoxml) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
 
# File 'lib/isodoc/ietf/section.rb', line 104

def make_link(out, isoxml)
  links = isoxml
    .xpath(ns("//bibdata/relation[@type = 'includedIn' or " \
              "@type = 'describedBy' or @type = 'derivedFrom' or " \
              "@type = 'instanceOf']")) || return
  links.each do |l|
    out.link href: l&.at(ns("./bibitem/docidentifier"))&.text,
             rel: rel2iana(l["type"])
  end
end

#make_local_footnote(node, fn, out) ⇒ Object 



11
12
13
14
15
16
17
18
 
# File 'lib/isodoc/ietf/footnotes.rb', line 11

def make_local_footnote(node, fn, out)
  return if @seen_footnote.include?(fn)

  @in_footnote = true
  out << make_generic_footnote_text(node, fn)
  @in_footnote = false
  @seen_footnote << fn
end

#make_middle(out, isoxml) ⇒ Object 



126
127
128
129
130
 
# File 'lib/isodoc/ietf/section.rb', line 126

def make_middle(out, isoxml)
  out.middle do |middle|
    clause isoxml, middle
  end
end

#make_postamble(docxml) ⇒ Object 



140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/isodoc/ietf/cleanup.rb', line 140

def make_postamble(docxml)
  docxml.xpath("//figure").each do |f|
    a = f.at("./artwork | ./sourcecode") || next
    name = f.at("./name")&.remove
    b = a.xpath("./preceding-sibling::*")&.remove
    c = a.xpath("./following-sibling::*")&.remove
    a = a.remove
    name and f << name
    b.empty? or f << "<preamble>#{to_xml(b)}</preamble>"
    a and f << a
    c.empty? or f << "<postamble>#{to_xml(c)}</postamble>"
  end
end

#make_table_footnote_link(out, _fnid, fnref) ⇒ Object 



50
51
52
 
# File 'lib/isodoc/ietf/footnotes.rb', line 50

def make_table_footnote_link(out, _fnid, fnref)
  out << " [#{fnref}]"
end

#make_table_footnote_text(node, _fnid, fnref) ⇒ Object 



54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/isodoc/ietf/footnotes.rb', line 54

def make_table_footnote_text(node, _fnid, fnref)
  first = node.first_element_child
  noko do |xml|
    xml.t **attr_code(anchor: first ? first["id"] : nil) do |div|
      div << "[#{fnref}]  "
      first.name == "p" and first.children.each { |n| parse(n, div) }
    end
    (first.name == "p" and
      node.elements.drop(1).each { |n| parse(n, xml) }) or
      node.children.each { |n| parse(n, xml) }
  end.join
end

#make_tr_attr(cell, _row, _totalrows, _header) ⇒ Object 



44
45
46
47
 
# File 'lib/isodoc/ietf/table.rb', line 44

def make_tr_attr(cell, _row, _totalrows, _header)
  attr_code(rowspan: cell["rowspan"], colspan: cell["colspan"],
            align: cell["align"])
end

#metadata_check(xml) ⇒ Object 



156
157
158
159
160
161
162
 
# File 'lib/isodoc/ietf/validation.rb', line 156

def metadata_check(xml)
  ret = []
  ret += link_check(xml)
  ret += seriesInfo_check(xml)
  ret += ipr_check(xml)
  ret
end

#metadata_init(lang, script, locale, i18n) ⇒ Object 



46
47
48
 
# File 'lib/isodoc/ietf/rfc_convert.rb', line 46

def metadata_init(lang, script, locale, i18n)
  @meta = Metadata.new(lang, script, locale, i18n)
end

#modification_parse(node, out) ⇒ Object 



8
9
10
11
12
 
# File 'lib/isodoc/ietf/terms.rb', line 8

def modification_parse(node, out)
  para = node.at(ns("./p"))
  out << " -- "
  para.children.each { |n| parse(n, out) }
end

#move_postamble(docxml) ⇒ Object 



154
155
156
157
158
159
160
161
162
 
# File 'lib/isodoc/ietf/cleanup.rb', line 154

def move_postamble(docxml)
  docxml.xpath("//postamble").each do |p|
    insert = p.parent
    p.remove.elements.each do |e|
      insert.next = e
      insert = insert.next_element
    end
  end
end

#move_preamble(docxml) ⇒ Object 



164
165
166
167
168
169
170
171
 
# File 'lib/isodoc/ietf/cleanup.rb', line 164

def move_preamble(docxml)
  docxml.xpath("//preamble").each do |p|
    insert = p.parent
    p.remove.elements.each do |e|
      insert.previous = e
    end
  end
end

#note(isoxml, front) ⇒ Object 



232
233
234
235
236
237
238
239
240
241
242
243
 
# File 'lib/isodoc/ietf/front.rb', line 232

def note(isoxml, front)
  a = isoxml.at(ns("//preface/abstract/note | //preface/foreword/note")) or
    return
  front.note **attr_code(removeInRFC: a["removeInRFC"]) do |n|
    title = a.at(ns("./name")) and n.name do |t|
      title.children.each { |tt| parse(tt, t) }
    end
    a.children.reject { |c1| c1.name == "name" }.each do |c1|
      parse(c1, n)
    end
  end
end

#note_label(node) ⇒ Object 



75
76
77
78
79
80
81
 
# File 'lib/isodoc/ietf/blocks.rb', line 75

def note_label(node)
  n = @xrefs.get[node["id"]]
  return l10n("#{@i18n.note}: ") if n.nil? || n[:label].nil? ||
    n[:label].empty?

  l10n("#{@i18n.note} #{n[:label]}: ")
end

#note_parse(node, out) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/isodoc/ietf/blocks.rb', line 83

def note_parse(node, out)
  first = node.first_element_child
  out.aside **attr_code(anchor: node["id"] || first["id"]) do |a|
    a.t do |p|
      p << note_label(node)
      first.name == "p" and first.children.each { |n| parse(n, p) }
    end
    (first.name == "p" and
      node.elements.drop(1).each { |n| parse(n, out) }) or
      node.children.each { |n| parse(n, out) }
  end
end

#numbered_sections_check(xml) ⇒ Object

2.46.2. “numbered” Attribute



39
40
41
42
43
44
45
46
 
# File 'lib/isodoc/ietf/validation.rb', line 39

def numbered_sections_check(xml)
  ret = []
  xml.xpath("//section[@numbered = 'false']").each do |s1|
    ret += numbered_sections_check1(s1)
    ret += numbered_sections_check2(s1)
  end
  ret
end

#numbered_sections_check1(section) ⇒ Object 



48
49
50
51
52
53
54
 
# File 'lib/isodoc/ietf/validation.rb', line 48

def numbered_sections_check1(section)
  section.xpath("./section[not(@numbered) or @numbered = 'true']")
    .each_with_object([]) do |s2, m|
    m << "Numbered section #{label(s2)} under unnumbered section " \
         "#{label(section)}"
  end
end

#numbered_sections_check2(section) ⇒ Object 



56
57
58
59
60
61
62
63
 
# File 'lib/isodoc/ietf/validation.rb', line 56

def numbered_sections_check2(section)
  section.xpath("./following-sibling::*[name() = 'section']" \
                "[not(@numbered) or @numbered = 'true']")
    .each_with_object([]) do |s2, m|
    m << "Numbered section #{label(s2)} following unnumbered " \
         "section #{label(section)}"
  end
end

#ol_attrs(node) ⇒ Object 



46
47
48
49
50
51
52
 
# File 'lib/isodoc/ietf/blocks.rb', line 46

def ol_attrs(node)
  { anchor: node["id"],
    spacing: node["spacing"],
    type: ol_style(node["type"]),
    group: node["group"],
    start: node["start"] }
end

#ol_parse(node, out) ⇒ Object 



54
55
56
57
58
 
# File 'lib/isodoc/ietf/blocks.rb', line 54

def ol_parse(node, out)
  out.ol **attr_code(ol_attrs(node)) do |ol|
    node.children.each { |n| parse(n, ol) }
  end
end

#ol_style(type) ⇒ Object 



42
43
44
 
# File 'lib/isodoc/ietf/blocks.rb', line 42

def ol_style(type)
  OL_STYLE[type&.to_sym] || type
end

#omit_docid_prefix(prefix) ⇒ Object 



77
78
79
80
81
 
# File 'lib/isodoc/ietf/rfc_convert.rb', line 77

def omit_docid_prefix(prefix)
  return true if %w(IETF RFC).include?(prefix)

  super
end

#org_author(contrib, role, front) ⇒ Object 



115
116
117
118
119
120
121
122
123
124
 
# File 'lib/isodoc/ietf/front.rb', line 115

def org_author(contrib, role, front)
  front.author **attr_code(role: role) do |a|
    organization(contrib.at(ns("./organization")), a,
                 contrib.document.at(ns("//showOnFrontPage")))
    address(contrib.at(ns(".//address")),
            contrib.at(ns(".//phone[not(@type = 'fax')]")),
            contrib.at(ns(".//phone[@type = 'fax']")),
            contrib.at(ns(".//email")), contrib.at(ns(".//uri")), a)
  end
end

#organization(org, out, show) ⇒ Object 



126
127
128
129
130
131
132
133
 
# File 'lib/isodoc/ietf/front.rb', line 126

def organization(org, out, show)
  name = org.at(ns("./name"))&.text
  out.organization name, **attr_code(
    showOnFrontPage: show&.text, ascii: output_if_translit(name),
    asciiAbbrev: output_if_translit(org.at(ns("./abbreviation"))),
    abbrev: org.at(ns("./abbreviation"))
  )
end

#origin_parse(node, out) ⇒ Object 



156
157
158
159
160
161
162
 
# File 'lib/isodoc/ietf/inline.rb', line 156

def origin_parse(node, out)
  if t = node.at(ns("./termref"))
    termrefelem_parse(t, out)
  else
    eref_parse(node, out)
  end
end

#output_if_translit(text) ⇒ Object 



26
27
28
29
30
 
# File 'lib/isodoc/ietf/front.rb', line 26

def output_if_translit(text)
  return nil if text.nil?

  text.transliterate == text ? nil : text.transliterate
end

#page_break(_out) ⇒ Object 



68
 
# File 'lib/isodoc/ietf/inline.rb', line 68

def page_break(_out); end

#pagebreak_parse(_node, _out) ⇒ Object 



70
 
# File 'lib/isodoc/ietf/inline.rb', line 70

def pagebreak_parse(_node, _out); end

#para_attrs(node) ⇒ Object 



4
5
6
7
8
 
# File 'lib/isodoc/ietf/blocks.rb', line 4

def para_attrs(node)
  { keepWithNext: node["keep-with-next"],
    keepWithPrevious: node["keep-with-previous"],
    anchor: node["id"] }
end

#para_parse(node, out) ⇒ Object 



10
11
12
13
14
15
16
17
18
19
 
# File 'lib/isodoc/ietf/blocks.rb', line 10

def para_parse(node, out)
  out.t **attr_code(para_attrs(node)) do |p|
    unless @termdomain.empty?
      p << "&lt;#{@termdomain}&gt; "
      @termdomain = ""
    end
    node.children.each { |n| parse(n, p) unless n.name == "note" }
  end
  node.xpath(ns("./note")).each { |n| parse(n, out) }
end

#permission_parse(node, out) ⇒ Object 



25
26
27
 
# File 'lib/isodoc/ietf/reqt.rb', line 25

def permission_parse(node, out)
  recommendation_parse1(node, out)
end

#pers_author_attrs1(ret, full, init, contrib) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
 
# File 'lib/isodoc/ietf/front.rb', line 92

def pers_author_attrs1(ret, full, init, contrib)
  full and ret.merge!(
    attr_code(
      asciiFullname: output_if_translit(full),
      asciiInitials: output_if_translit(init),
      asciiSurname: output_if_translit(contrib&.at(ns("./surname"))),
    ),
  )
  ret
end

#person_author(contrib, role, front) ⇒ Object 



103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/isodoc/ietf/front.rb', line 103

def person_author(contrib, role, front)
  attrs = person_author_attrs(contrib.at(ns("./person/name")), role)
  front.author **attrs do |a|
    org = contrib.at(ns("./person/affiliation/organization")) and
      organization(org, a, contrib.document.at(ns("//showOnFrontPage")))
    address(contrib.xpath(ns(".//address")),
            contrib.at(ns(".//phone[not(@type = 'fax')]")),
            contrib.at(ns(".//phone[@type = 'fax']")),
            contrib.xpath(ns(".//email")), contrib.xpath(ns(".//uri")), a)
  end
end

#person_author_attrs(contrib, role) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/isodoc/ietf/front.rb', line 80

def person_author_attrs(contrib, role)
  return {} if contrib.nil?

  full = contrib&.at(ns("./completename"))&.text
  init = contrib&.at(ns("./initial"))&.text ||
    contrib&.xpath(ns("./forename"))&.map { |n| n.text[0] }&.join(".")
  init = nil if init.empty?
  ret = attr_code(role: role, fullname: full, initials: init,
                  surname: contrib&.at(ns("./surname"))&.text)
  pers_author_attrs1(ret, full, init, contrib)
end

#postal(addr, out) ⇒ Object 



147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/isodoc/ietf/front.rb', line 147

def postal(addr, out)
  out.postal do |p|
    if line = addr.at(ns("./formattedAddress"))
      line.xpath(ns(".//br")).each { |br| br.replace("\n") }
      line.text.split("\n").each do |l|
        p.postalLine l, **attr_code(ascii: l.transliterate)
      end
    else
      postal_detailed(addr, p)
    end
  end
end

#postal_detailed(addr, out) ⇒ Object 



160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/isodoc/ietf/front.rb', line 160

def postal_detailed(addr, out)
  addr.xpath(ns("./street")).each do |s|
    out.street s.text, **attr_code(ascii: s.text.transliterate)
  end
  s = addr.at(ns("./city")) and
    out.city s.text, **attr_code(ascii: s.text.transliterate)
  s = addr.at(ns("./state")) and
    out.region s.text, **attr_code(ascii: s.text.transliterate)
  s = addr.at(ns("./country")) and
    out.country s.text, **attr_code(ascii: s.text.transliterate)
  s = addr.at(ns("./postcode")) and
    out.code s.text, **attr_code(ascii: s.text.transliterate)
end

#postprocess(result, filename, _dir) ⇒ Object 



87
88
89
90
91
92
93
94
95
 
# File 'lib/isodoc/ietf/rfc_convert.rb', line 87

def postprocess(result, filename, _dir)
  result = from_xhtml(cleanup(to_xhtml(textcleanup(result))))
    .sub(/<!DOCTYPE[^>]+>\n/, "")
    .sub(/(<rfc[^<]+? )lang="[^"]+"/, "\\1")
  File.open(filename, "w:UTF-8") { |f| f.write(result) }
  schema_validate(filename)
  @files_to_delete.each { |f| FileUtils.rm_rf f }
  content_validate(to_xhtml(result), filename)
end

#pre_parse(node, out) ⇒ Object 



132
133
134
135
136
137
 
# File 'lib/isodoc/ietf/blocks.rb', line 132

def pre_parse(node, out)
  out.artwork **attr_code(anchor: node["id"], align: node["align"],
                          alt: node["alt"], type: "ascii-art") do |s|
    s.cdata node.text.sub(/^\n/, "").gsub(/\t/, "    ")
  end
end

#preprocess_termref(elem) ⇒ Object 



77
78
79
80
81
82
83
84
 
# File 'lib/isodoc/ietf/terms.rb', line 77

def preprocess_termref(elem)
  origin = elem.at(ns("./origin"))
  s = termsource_status(elem["status"]) and origin.next = l10n(", #{s}")
  termsource_add_modification_text(elem.at(ns("./modification")))
  while elem&.next_element&.name == "termsource"
    elem << "; #{to_xml(elem.next_element.remove.children)}"
  end
end

#pseudocode_parse(node, out) ⇒ Object 



240
241
242
 
# File 'lib/isodoc/ietf/blocks.rb', line 240

def pseudocode_parse(node, out)
  sourcecode_parse(node, out)
end

#quote_attribution(node) ⇒ Object 



183
184
185
186
187
 
# File 'lib/isodoc/ietf/blocks.rb', line 183

def quote_attribution(node)
  author = node&.at(ns("./author"))&.text
  source = node&.at(ns("./source/@uri"))&.text
  attr_code(quotedFrom: author, cite: source)
end

#quote_parse(node, out) ⇒ Object 



189
190
191
192
193
194
195
 
# File 'lib/isodoc/ietf/blocks.rb', line 189

def quote_parse(node, out)
  out.blockquote **quote_attribution(node) do |p|
    node.children.each do |n|
      parse(n, p) unless ["author", "source"].include? n.name
    end
  end
end

#recommendation_name(node, out) ⇒ Object 



4
5
6
7
8
 
# File 'lib/isodoc/ietf/reqt.rb', line 4

def recommendation_name(node, out)
  out.t **{ keepWithNext: "true" } do |p|
    node.children.each { |n| parse(n, p) }
  end
end

#recommendation_parse(node, out) ⇒ Object 



10
11
12
 
# File 'lib/isodoc/ietf/reqt.rb', line 10

def recommendation_parse(node, out)
  recommendation_parse1(node, out)
end

#recommendation_parse1(node, out) ⇒ Object 



14
15
16
17
18
19
 
# File 'lib/isodoc/ietf/reqt.rb', line 14

def recommendation_parse1(node, out)
  recommendation_name(node.at(ns("./name")), out)
  node.children.each do |n|
    parse(n, out) unless n.name == "name"
  end
end

#references_check(xml) ⇒ Object

5.4.3 <reference> “target” Insertion

5.4.2.4  "Table of Contents" Insertion



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/isodoc/ietf/validation.rb', line 79

def references_check(xml)
  ret = []
  xml.xpath("//reference[not(@target)]").each do |s|
    s.xpath(".//seriesInfo[@name = 'RFC' or @name = 'Internet-Draft' " \
            "or @name = 'DOI'][not(@value)]").each do |s1|
      ret << "for reference #{s['anchor']}, the seriesInfo with " \
             "name=#{s1['name']} has been given no value"
    end
  end
  xml.xpath("//references | //section").each do |s|
    s.at("./name") or ret << "Cannot generate table of contents entry " \
                             "for #{label(s)}, as it has no title"
  end
  ret
end

#rel2iana(type) ⇒ Object 



115
116
117
118
119
120
121
122
123
124
 
# File 'lib/isodoc/ietf/section.rb', line 115

def rel2iana(type)
  case type
  when "includedIn" then "item"
  when "describedBy" then "describedby"
  when "derivedFrom" then "convertedfrom"
  when "instanceOf" then "alternate"
  else
    "alternate"
  end
end

#reparse_abstract(abstract) ⇒ Object 



62
63
64
65
66
67
68
 
# File 'lib/isodoc/ietf/cleanup.rb', line 62

def reparse_abstract(abstract)
  a1 = Nokogiri::XML(abstract.dup.to_xml
    .sub("<abstract>", "<abstract xmlns='http://www.example.com'>")).root
  noko do |xml|
    a1.children.each { |n| parse(n, xml) }
  end.join
end

#requirement_parse(node, out) ⇒ Object 



21
22
23
 
# File 'lib/isodoc/ietf/reqt.rb', line 21

def requirement_parse(node, out)
  recommendation_parse1(node, out)
end

#review_note_parse(node, out) ⇒ Object 



221
222
223
224
225
226
227
228
229
230
 
# File 'lib/isodoc/ietf/blocks.rb', line 221

def review_note_parse(node, out)
  out.cref **attr_code(anchor: node["id"], display: node["display"],
                       source: node["reviewer"]) do |c|
    if name = node.at(ns("./name"))
      name.children.each { |n| parse(n, c) }
      c << " "
    end
    node.children.each { |n| parse(n, c) unless n.name == "name" }
  end
end

#rfc_attributes(docxml) ⇒ Object 



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/isodoc/ietf/section.rb', line 55

def rfc_attributes(docxml)
  # t = Time.now.getutc
  obs = xpath_comma(docxml
    .xpath(ns("//bibdata/relation[@type = 'obsoletes']/bibitem/docidentifier")))
  upd = xpath_comma(docxml
    .xpath(ns("//bibdata/relation[@type = 'updates']/bibitem/docidentifier")))
  {
    docName: @meta.get[:doctype] == "Internet Draft" ? @meta.get[:docnumber] : nil,
    number: @meta.get[:doctype].casecmp?("rfc") ? @meta.get[:docnumber] : nil,
    category: series2category(
      docxml&.at(ns("//bibdata/series[@type = 'intended']/title"))&.text,
    ),
    ipr: docxml&.at(ns("//bibdata/ext/ipr"))&.text,
    consensus: docxml&.at(ns("//bibdata/ext/consensus"))&.text,
    obsoletes: obs,
    updates: upd,
    indexInclude: docxml&.at(ns("//bibdata/ext/indexInclude"))&.text,
    iprExtract: docxml&.at(ns("//bibdata/ext/iprExtract"))&.text,
    sortRefs: docxml&.at(ns("//bibdata/ext/sortRefs"))&.text,
    symRefs: docxml&.at(ns("//bibdata/ext/symRefs"))&.text,
    tocInclude: docxml&.at(ns("//bibdata/ext/tocInclude"))&.text,
    tocDepth: docxml&.at(ns("//bibdata/ext/tocDepth"))&.text,
    submissionType: docxml&.at(ns(
      "//bibdata/series[@type = 'stream']/title",
    ))&.text || "IETF",
    "xml:lang": docxml&.at(ns("//bibdata/language"))&.text,
    version: "3",
    "xmlns:xi": "http://www.w3.org/2001/XInclude",
  }
end

#rfc_seriesinfo(isoxml, front) ⇒ Object 



52
53
54
55
56
57
58
59
60
 
# File 'lib/isodoc/ietf/front.rb', line 52

def rfc_seriesinfo(isoxml, front)
  front.seriesInfo **seriesinfo_attr(isoxml).merge({ name: "RFC",
                                                     asciiName: "RFC" })
  i = isoxml&.at(ns("//bibdata/series[@type = 'intended']")) and
    front.seriesInfo nil,
                     **attr_code(name: "",
                                 status: i&.at(ns("./title"))&.text,
                                 value: i&.at(ns("./number"))&.text || "")
end

#schema_validate(filename) ⇒ Object 



7
8
9
10
11
12
13
14
15
16
 
# File 'lib/isodoc/ietf/validation.rb', line 7

def schema_validate(filename)
  errors = Jing.new(File.join(File.dirname(__FILE__), "v3.rng"))
    .validate(filename)
  errors.each do |error|
    warn "RFC XML: Line #{'%06d' % error[:line]}:#{error[:column]} " \
         "#{error[:message]}"
  end
rescue Jing::Error => e
  abort "Jing failed with error: #{e}"
end

#series2category(series) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/isodoc/ietf/section.rb', line 86

def series2category(series)
  case series&.downcase
  when "standard", "std", "full-standard" then "std"
  when "informational", "info", "fyi" then "info"
  when "experimental", "exp" then "exp"
  when "bcp" then "bcp"
  when "historic" then "historic"
  else
    "std"
  end
end

#seriesinfo(isoxml, front) ⇒ Object 



39
40
41
42
 
# File 'lib/isodoc/ietf/front.rb', line 39

def seriesinfo(isoxml, front)
  rfc_seriesinfo(isoxml, front) if @meta.get[:doctype] == "Rfc"
  id_seriesinfo(isoxml, front) if @meta.get[:doctype] == "Internet Draft"
end

#seriesinfo_attr(isoxml) ⇒ Object 



44
45
46
47
48
49
50
 
# File 'lib/isodoc/ietf/front.rb', line 44

def seriesinfo_attr(isoxml)
  attr_code(value: @meta.get[:docnumber] || "",
            asciiValue: output_if_translit(@meta.get[:docnumber]),
            status: @meta.get[:stage],
            stream: isoxml&.at(ns("//bibdata/series[@type = 'stream']/" \
                                  "title"))&.text)
end

#seriesInfo_check(xml) ⇒ Object

5.2.2. “seriesInfo” Insertion



175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/isodoc/ietf/validation.rb', line 175

def seriesInfo_check(xml)
  ret = []
  xml.root["ipr"] == "none" and return []
  rfcinfo = xml.at("//front//seriesInfo[@name = 'RFC']")
  rfcnumber = xml.root["number"]
  rfcinfo && rfcnumber && rfcnumber != rfcinfo["value"] and
    ret << "Mismatch between <rfc number='#{rfcnumber}'> " \
           "(:docnumber: NUMBER) " \
           "and <seriesInfo name='RFC' value='#{rfcinfo['value']}'> " \
           "(:intended-series: TYPE NUMBER)"
  rfcinfo && !/^\d+$/.match(rfcnumber) and
    ret << "RFC identifier <rfc number='#{rfcnumber}'> " \
           "(:docnumber: NUMBER) must be a number"
  ret
end

#set_pis(node, doc) ⇒ Object 



45
46
47
48
49
50
51
52
53
 
# File 'lib/isodoc/ietf/section.rb', line 45

def set_pis(node, doc)
  rfc_pis = common_rfc_pis(node)
  rfc_pis.each_pair do |k, v|
    pi = Nokogiri::XML::ProcessingInstruction.new(doc, "rfc",
                                                  "#{k}=\"#{v}\"")
    doc.root.add_previous_sibling(pi)
  end
  doc.to_xml
end

#smallcap_parse(node, out) ⇒ Object 



44
45
46
 
# File 'lib/isodoc/ietf/inline.rb', line 44

def smallcap_parse(node, out)
  node.children.each { |n| parse(n, out) }
end

#source_parse(node, out) ⇒ Object 



115
116
117
 
# File 'lib/isodoc/ietf/blocks.rb', line 115

def source_parse(node, out)
  termref_parse(node, out)
end

#sourcecode_cleanup(docxml) ⇒ Object

for markup in pseudocode



174
175
176
177
178
179
180
181
182
 
# File 'lib/isodoc/ietf/cleanup.rb', line 174

def sourcecode_cleanup(docxml)
  docxml.xpath("//sourcecode").each do |s|
    s.children = to_xml(s.children).gsub(%r{<br/>\n}, "\n")
      .gsub(%r{\s+(<t[ >])}, "\\1").gsub(%r{</t>\s+}, "</t>")
    sourcecode_remove_markup(s)
    s.children = "<![CDATA[#{HTMLEntities.new.decode(to_xml(s
  .children).sub(/\A\n+/, ''))}]]>"
  end
end

#sourcecode_parse(node, out) ⇒ Object 



119
120
121
122
123
124
125
126
127
128
129
130
 
# File 'lib/isodoc/ietf/blocks.rb', line 119

def sourcecode_parse(node, out)
  out.sourcecode **attr_code(
    anchor: node["id"], type: node["lang"], name: node["filename"],
    markers: node["markers"], src: node["src"]
  ) do |s|
    node.children.each do |x|
      %w(name dl).include?(x.name) and next
      parse(x, s)
    end
  end
  annotation_parse(node, out)
end

#sourcecode_remove_markup(node) ⇒ Object 



184
185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/isodoc/ietf/cleanup.rb', line 184

def sourcecode_remove_markup(node)
  node.traverse do |n|
    next if n.text?
    next if %w(name callout annotation note sourcecode).include? n.name

    case n.name
    when "br" then n.replace("\n")
    when "t" then n.replace("\n\n#{n.children}")
    else
      n.replace(n.children)
    end
  end
end

#stem_parse(node, out) ⇒ Object 



59
60
61
62
63
64
65
66
 
# File 'lib/isodoc/ietf/inline.rb', line 59

def stem_parse(node, out)
  stem = case node["type"]
         when "MathML" then Plurimath::Math
           .parse(node.children.to_xml, "mathml").to_asciimath
         else HTMLEntities.new.encode(node.text)
         end
  out << "#{@openmathdelim} #{stem} #{@closemathdelim}"
end

#strike_parse(node, out) ⇒ Object 



40
41
42
 
# File 'lib/isodoc/ietf/inline.rb', line 40

def strike_parse(node, out)
  node.children.each { |n| parse(n, out) }
end

#strong_parse(node, out) ⇒ Object 



28
29
30
31
32
 
# File 'lib/isodoc/ietf/inline.rb', line 28

def strong_parse(node, out)
  out.strong do |e|
    node.children.each { |n| parse(n, e) }
  end
end

#sub_parse(node, out) ⇒ Object 



16
17
18
19
20
 
# File 'lib/isodoc/ietf/inline.rb', line 16

def sub_parse(node, out)
  out.sub do |e|
    node.children.each { |n| parse(n, e) }
  end
end

#sup_parse(node, out) ⇒ Object 



10
11
12
13
14
 
# File 'lib/isodoc/ietf/inline.rb', line 10

def sup_parse(node, out)
  out.sup do |e|
    node.children.each { |n| parse(n, e) }
  end
end

#svg_parse(node, out) ⇒ Object 



104
105
106
107
108
109
110
111
112
 
# File 'lib/isodoc/ietf/inline.rb', line 104

def svg_parse(node, out)
  if node.parent.name == "image" then super
  else
    out.artwork **attr_code(image_parse_attrs(node)) do |x|
      out = x
      super
    end
  end
end

#table_attrs(node) ⇒ Object 



4
5
6
 
# File 'lib/isodoc/ietf/table.rb', line 4

def table_attrs(node)
  attr_code(anchor: node["id"], align: node["align"])
end

#table_cleanup(docxml) ⇒ Object 



102
103
104
 
# File 'lib/isodoc/ietf/cleanup.rb', line 102

def table_cleanup(docxml)
  table_footnote_cleanup(docxml)
end

#table_footnote_cleanup(docxml) ⇒ Object 



86
87
88
89
90
91
92
 
# File 'lib/isodoc/ietf/cleanup.rb', line 86

def table_footnote_cleanup(docxml)
  docxml.xpath("//table[descendant::fn]").each do |t|
    t.xpath(".//fn").each do |a|
      t << "<aside>#{a.remove.children}</aside>"
    end
  end
end

#table_footnote_parse(node, out) ⇒ Object 



35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/isodoc/ietf/footnotes.rb', line 35

def table_footnote_parse(node, out)
  fn = node["reference"]
  tid = get_table_ancestor_id(node)
  make_table_footnote_link(out, tid + fn, fn)
  # do not output footnote text if we have already seen it for this table
  return if @seen_footnote.include?(tid + fn)

  @in_footnote = true
  out.fn do |a|
    a << make_table_footnote_text(node, tid + fn, fn)
  end
  @in_footnote = false
  @seen_footnote << (tid + fn)
end

#table_parse(node, out) ⇒ Object 



8
9
10
11
12
13
14
15
16
17
18
 
# File 'lib/isodoc/ietf/table.rb', line 8

def table_parse(node, out)
  @in_table = true
  out.table **table_attrs(node) do |t|
    table_title_parse(node, t)
    thead_parse(node, t)
    tbody_parse(node, t)
    tfoot_parse(node, t)
  end
  table_parse_tail(node, out)
  @in_table = false
end

#table_parse_tail(node, out) ⇒ Object 



20
21
22
23
24
 
# File 'lib/isodoc/ietf/table.rb', line 20

def table_parse_tail(node, out)
  (dl = node.at(ns("./dl"))) && parse(dl, out)
  node.xpath(ns("./source")).each { |n| parse(n, out) }
  node.xpath(ns("./note")).each { |n| parse(n, out) }
end

#table_title_parse(node, out) ⇒ Object 



26
27
28
29
30
31
 
# File 'lib/isodoc/ietf/table.rb', line 26

def table_title_parse(node, out)
  name = node.at(ns("./name")) || return
  out.name do |p|
    name.children.each { |n| parse(n, p) }
  end
end

#term_parse(node, out) ⇒ Object 



29
30
31
32
33
34
 
# File 'lib/isodoc/ietf/terms.rb', line 29

def term_parse(node, out)
  name = node.at(ns(".//name"))
  out.name do |p|
    name.children.each { |n| parse(n, p) }
  end
end

#termdef_parse(node, out) ⇒ Object 



40
41
42
43
44
45
 
# File 'lib/isodoc/ietf/terms.rb', line 40

def termdef_parse(node, out)
  set_termdomain("")
  node.xpath(ns("./definition")).size > 1 and
    @isodoc.multidef(node)
  clause_parse(node, out)
end

#termdocsource_parse(_node, _out) ⇒ Object 



47
 
# File 'lib/isodoc/ietf/terms.rb', line 47

def termdocsource_parse(_node, _out); end

#termnote_parse(node, out) ⇒ Object 



36
37
38
 
# File 'lib/isodoc/ietf/terms.rb', line 36

def termnote_parse(node, out)
  note_parse(node, out)
end

#termref_parse(elem, out) ⇒ Object 



86
87
88
89
90
91
92
 
# File 'lib/isodoc/ietf/terms.rb', line 86

def termref_parse(elem, out)
  preprocess_termref(elem)
  elem.children = l10n("[#{@i18n.source}: #{to_xml(elem.children).strip}]")
  out.t do |p|
    elem.children.each { |n| parse(n, p) }
  end
end

#termsource_add_modification_text(mod) ⇒ Object 



69
70
71
72
73
74
75
 
# File 'lib/isodoc/ietf/terms.rb', line 69

def termsource_add_modification_text(mod)
  mod or return
  mod.text.strip.empty? or mod.previous = " &#x2013; "
  mod.elements.size == 1 and
    mod.elements[0].replace(mod.elements[0].children)
  mod.replace(mod.children)
end

#termsource_status(status) ⇒ Object 



62
63
64
65
66
67
 
# File 'lib/isodoc/ietf/terms.rb', line 62

def termsource_status(status)
  case status
  when "modified" then @i18n.modified
  when "adapted" then @i18n.adapted
  end
end

#text_parse(node, out) ⇒ Object 



52
53
54
55
56
57
 
# File 'lib/isodoc/ietf/inline.rb', line 52

def text_parse(node, out)
  return if node.nil? || node.text.nil?

  text = node.to_s
  out << text
end

#textcleanup(docxml) ⇒ Object 



83
84
85
 
# File 'lib/isodoc/ietf/rfc_convert.rb', line 83

def textcleanup(docxml)
  passthrough_cleanup(docxml)
end

#title(_isoxml, front) ⇒ Object 



32
33
34
35
36
37
 
# File 'lib/isodoc/ietf/front.rb', line 32

def title(_isoxml, front)
  title = @meta.get[:doctitle] or return
  front.title title, **attr_code(abbrev: @meta.get[:docabbrev],
                                 ascii: (@meta.get[:docascii] ||
                                 output_if_translit(title)))
end

#toc_parse(_node, _out) ⇒ Object 



258
 
# File 'lib/isodoc/ietf/blocks.rb', line 258

def toc_parse(_node, _out); end

#toc_sections_check(xml) ⇒ Object

5.2.7. Section “toc” attribute



66
67
68
69
70
71
72
73
74
75
 
# File 'lib/isodoc/ietf/validation.rb', line 66

def toc_sections_check(xml)
  ret = []
  xml.xpath("//section[@toc = 'exclude']").each do |s1|
    s1.xpath(".//section[@toc = 'include']").each do |s2|
      ret << "Section #{label(s2)} with toc=include is included in " \
             "section #{label(s1)} with toc=exclude"
    end
  end
  ret
end

#tr_parse(node, out, ord, totalrows, header) ⇒ Object 



33
34
35
36
37
38
39
40
41
42
 
# File 'lib/isodoc/ietf/table.rb', line 33

def tr_parse(node, out, ord, totalrows, header)
  out.tr do |r|
    node.elements.each do |td|
      attrs = make_tr_attr(td, ord, totalrows - 1, header)
      r.send td.name, **attrs do |entry|
        td.children.each { |n| parse(n, entry) }
      end
    end
  end
end

#tt_parse(node, out) ⇒ Object 



22
23
24
25
26
 
# File 'lib/isodoc/ietf/inline.rb', line 22

def tt_parse(node, out)
  out.tt do |e|
    node.children.each { |n| parse(n, e) }
  end
end

#u_cleanup(xmldoc) ⇒ Object 



4
5
6
7
8
9
10
11
12
 
# File 'lib/isodoc/ietf/cleanup_inline.rb', line 4

def u_cleanup(xmldoc)
  xmldoc.traverse do |n|
    next unless n.text?
    next unless %w(t blockquote li dd preamble td th annotation)
      .include? n.parent.name

    n.replace(n.text.gsub(/[\u0080-\uffff]/, "<u>\\0</u>"))
  end
end

#ul_attrs(node) ⇒ Object

NOTE ignoring “bare” attribute, which is tantamount to “empty”



22
23
24
25
26
 
# File 'lib/isodoc/ietf/blocks.rb', line 22

def ul_attrs(node)
  { anchor: node["id"],
    empty: node["nobullet"],
    spacing: node["spacing"] }
end

#ul_parse(node, out) ⇒ Object 



28
29
30
31
32
 
# File 'lib/isodoc/ietf/blocks.rb', line 28

def ul_parse(node, out)
  out.ul **attr_code(ul_attrs(node)) do |ul|
    node.children.each { |n| parse(n, ul) }
  end
end

#workgroup(_isoxml, front) ⇒ Object 



211
212
213
214
215
 
# File 'lib/isodoc/ietf/front.rb', line 211

def workgroup(_isoxml, front)
  @meta.get[:wg].each do |w|
    front.workgroup w
  end
end

#xpath_comma(xpath) ⇒ Object 



98
99
100
101
102
 
# File 'lib/isodoc/ietf/section.rb', line 98

def xpath_comma(xpath)
  return nil if xpath.empty?

  xpath.map(&:text).join(", ")
end

#xref_check(xml) ⇒ Object

5.4.8.2. “derivedContent” Insertion (without Content)



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/isodoc/ietf/validation.rb', line 96

def xref_check(xml)
  ret = []
  xml.xpath("//xref | //relref").each do |x|
    t = xml.at(".//*[@anchor = '#{x['target']}']") ||
      xml.at(".//*[@pn = '#{x['target']}']") or
      ret << "#{x.name} target #{x['target']} does not exist in the document"
    next unless t

    x.delete("relative") if x["relative"] && x["relative"].empty?
    x.delete("section") if x["section"] && x["section"].empty?
    if x["format"] == "title" && t.name == "reference"
      t.at("./front/title") or
        ret << "reference #{t['anchor']} has been referenced by #{x.name} " \
               "with format=title, but the reference has no title"
    end
    if x["format"] == "counter" && !%w(section table figure li
                                       reference references t dt).include?(t.name)
      ret << "#{x.to_xml} with format=counter is only allowed for " \
             "clauses, tables, figures, list entries, definition terms, " \
             "paragraphs, bibliographies, and bibliographic entries"
    end
    if x["format"] == "counter" && t.name == "reference" && !x["section"]
      ret << "reference #{t['anchor']} has been referenced by xref " \
             "#{x.to_xml} with format=counter, which requires a " \
             "section attribute"
    end
    if x["format"] == "counter" && t.name == "li" && t.parent.name != "ol"
      ret << "#{x.to_xml} with format=counter refers to an unnumbered " \
             "list entry"
    end
    if x["format"] == "title" && %w(u author contact).include?(t.name)
      ret << "#{x.to_xml} with format=title cannot reference a " \
             "<#{t.name}> element"
    end
    if x["relative"] && !x["section"]
      ret << "#{x.to_xml} with relative attribute requires a section " \
             "attribute"
    end
    if (x["section"]) && t.name != "reference"
      ret << "#{x.to_xml} has a section attribute, but #{x['target']} " \
             "points to a #{t.name}"
    end
    if (x["relative"]) && t.name != "reference"
      ret << "#{x.to_xml} has a relative attribute, but #{x['target']} " \
             "points to a #{t.name}"
    end
    if !x["relative"] && x["section"] && !t.at(".//seriesInfo[@name = 'RFC' or @name = " \
                                               "'Internet-Draft']")
      ret << "#{x.to_xml} must use a relative attribute, " \
             "since it does not point to a RFC or Internet-Draft reference"
    end
    if x["relative"] && !(t.at(".//seriesInfo[@name = 'RFC' or @name = " \
                               "'Internet-Draft']") || t["target"])
      ret << "need an explicit target= URL attribute in the reference " \
             "pointed to by #{x.to_xml}"
    end
  end
  ret
end

#xref_init(lang, script, klass, i18n, options) ⇒ Object 



50
51
52
 
# File 'lib/isodoc/ietf/rfc_convert.rb', line 50

def xref_init(lang, script, klass, i18n, options)
  @xrefs = Xref.new(lang, script, klass, i18n, options)
end

#xref_parse(node, out) ⇒ Object 



114
115
116
117
118
119
 
# File 'lib/isodoc/ietf/inline.rb', line 114

def xref_parse(node, out)
  out.xref **attr_code(target: node["target"], format: node["format"],
                       relative: node["relative"]) do |l|
                         l << get_linkend(node)
                       end
end