Class: IsoDoc::Ieee::PresentationXMLConvert

Inherits:
PresentationXMLConvert
  • Object
show all
Includes:
Init
Defined in:
lib/isodoc/ieee/presentation_ref.rb,
lib/isodoc/ieee/presentation_terms.rb,
lib/isodoc/ieee/presentation_bibdata.rb,
lib/isodoc/ieee/presentation_xml_convert.rb

Constant Summary collapse

KEEP_BIBRENDER_XPATH = 
"./docidentifier | ./uri | ./note | ./title | ./biblio-tag".freeze

Instance Method Summary collapse

Methods included from Init

#bibrenderer, #fileloc, #i18n_init, #metadata_init, #std_docid_sdo, #std_docid_semantic, #std_docid_semantic1, #std_docid_semantic_full, #xref_init

Constructor Details

#initialize(options) ⇒ PresentationXMLConvert

Returns a new instance of PresentationXMLConvert.



10
11
12
13
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 10

def initialize(options)
  @hierarchical_assets = options[:hierarchicalassets]
  super
end

Instance Method Details



213
214
215
216
217
218
219
220
221
222
223
224
225
226
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 213

def admitted_to_related(docxml)
  docxml.xpath(ns("//term")).each do |t|
    t.xpath(ns("./fmt-admitted/semx | ./fmt-preferred/semx")).each_with_index do |a, i|
      orig = semx_orig(a)
      (i.zero? ||
       orig.at(ns("./abbreviation-type | ./graphical-symbol"))) and next
      out = t.at(ns("./fmt-related")) || t.at(ns("./definition")).before("<fmt-related/>").previous
      admitted_to_related1(a, t.at(ns("./fmt-preferred/semx")), out)
      a.parent.name == "fmt-preferred" and a.remove
    end
    t.at(ns("./fmt-admitted"))&.remove
  end
  #term_reorder(docxml)
end

#admitted_to_related1(adm, pref, out) ⇒ Object 



228
229
230
231
232
233
234
235
236
237
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 228

def admitted_to_related1(adm, pref, out)
  new = adm.dup
  adm["type"] = "equivalent"
  adm.name = "related"
  adm.children = "<preferred>#{to_xml(adm.children)}</preferred>"
  adm.parent.next = <<~TERM
    <term><preferred>#{to_xml(new.children)}</preferred>
    <related type='see'><preferred>#{to_xml(pref.children)}</preferred></related></term>
  TERM
end

#affiliation_header(clause) ⇒ Object 



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

def affiliation_header(clause)
  clause.xpath(ns(".//p[@type = 'officeorgrepmember']")).each do |p|
    prev = p.previous_element
    prev && prev.name == "p" &&
      prev["type"] == "officeorgrepmember" and next
    p.previous = <<~HDR
      <p type='officeorgrepmemberhdr'><em>Organization
      Represented</em><tab/><em>Name of Representative</em></p>
    HDR
  end
end

#amend1(elem) ⇒ Object 



119
120
121
122
123
124
125
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 119

def amend1(elem)
  elem.xpath(ns("./description/p")).each do |p|
    p.children = to_xml(p.children).strip
    amend_format(p)
  end
  super
end

#amend_format(para) ⇒ Object 



127
128
129
130
131
132
133
134
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 127

def amend_format(para)
  2.times do
    para.children.size == 1 &&
      %(em strong).include?(para.children.first.name) and
      para.children = para.elements.first.children
  end
  para.children = "<strong><em>#{to_xml(para.children)}</em></strong>"
end

#anchor_linkend(node, linkend) ⇒ Object

Style manual 19



7
8
9
10
11
12
13
 
# File 'lib/isodoc/ieee/presentation_ref.rb', line 7

def anchor_linkend(node, linkend)
  @bibanchors ||= biblio_ids_titles(node.document)
  if node["citeas"] && i = @bibanchors[node["bibitemid"]]
    biblio_anchor_linkend(node, i)
  else super
  end
end

#anchor_linkend1(node) ⇒ Object 



56
57
58
59
60
61
62
63
64
65
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 56

def anchor_linkend1(node)
  linkend = @xrefs.anchor(node["target"], :xref)
  @xrefs.anchor(node["target"], :type) == "clause" &&
    @xrefs.anchor(node["target"], :level) > 1 &&
    !start_of_sentence(node) and
    linkend = strip_initial_clause(linkend)
  container = @xrefs.anchor(node["target"], :container, false)
  linkend = prefix_container(container, linkend, node, node["target"])
  capitalise_xref(node, linkend, anchor_value(node["target"]))
end

#annex1(elem) ⇒ Object 



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

def annex1(elem)
  if @doctype == "whitepaper"
    annex1_whitepaper(elem)
  else
    super
  end
end

#annex1_default(elem) ⇒ Object

KILL



111
112
113
114
115
116
117
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 111

def annex1_default(elem)
  lbl = @xrefs.anchor(elem["id"], :label)
  if t = elem.at(ns("./title"))
    t.children = "<strong>#{to_xml(t.children)}</strong>"
  end
  prefix_name(elem, { caption: "<br/>" }, lbl, "title")
end

#annex1_whitepaper(elem) ⇒ Object 



94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 94

def annex1_whitepaper(elem)
  lbl = @xrefs.anchor(elem["id"], :label)
  if t = elem.at(ns("./title"))
    d = t.dup
    # TODO fmt-variant-title
    d.name = "variant-title"
    d["type"] = "sub"
    t.next = d
  end
  elem.add_first_child "<fmt-title>#{lbl}</fmt-title>"
end

#annex_delim(_elem) ⇒ Object 



106
107
108
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 106

def annex_delim(_elem)
  "<br/>"
end

#asciimath_dup(node) ⇒ Object 



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

def asciimath_dup(node)
  @suppressasciimathdup and return
  super
  node.parent.at(ns("./latexmath")) and return
  math = node.to_xml.gsub(/ xmlns=["'][^"']+["']/, "")
    .gsub(%r{<[^:/]+:}, "<").gsub(%r{</[^:/]+:}, "</")
  ret = Plurimath::Math.parse(math, "mathml").to_latex
  ret = HTMLEntities.new.encode(ret, :basic)
  node.next = "<latexmath>#{ret}</latexmath>"
rescue StandardError => e
  warn "Failure to convert MathML to LaTeX\n#{node.parent.to_xml}\n#{e}"
end

#author_date(xml, renderings) ⇒ Object 



60
61
62
63
64
65
66
 
# File 'lib/isodoc/ieee/presentation_ref.rb', line 60

def author_date(xml, renderings)
  author_date?(xml) or return
  cit = renderings[xml["id"]][:citation]
  xml << "<docidentifier type='metanorma'>#{cit}</docidentifier>"
  xml.at(ns("./biblio-tag"))&.remove
  xml << "<biblio-tag>#{cit}, </biblio-tag>"
end

#author_date?(xml) ⇒ Boolean

Returns:

  • (Boolean) 


68
69
70
71
72
73
74
75
76
 
# File 'lib/isodoc/ieee/presentation_ref.rb', line 68

def author_date?(xml)
  ret = !xml["type"]
  ret ||= %w(standard techreport website webresource)
    .include?(xml["type"])
  ret ||= xml.at(".//ancestor::xmlns:references[@normative = 'false']")
  ret ||= xml.at(ns("./docidentifier[@type = 'metanorma']"))
  ret and return false
  true
end

#availability_note(bib) ⇒ Object 



112
113
114
115
116
 
# File 'lib/isodoc/ieee/presentation_ref.rb', line 112

def availability_note(bib)
  note = bib.at(ns("./note[@type = 'Availability']")) or return ""
  id = UUIDTools::UUID.random_create.to_s
  "<fn reference='#{id}'><p>#{note.content}</p></fn>"
end

#bibdata_dates(bib) ⇒ Object 



9
10
11
12
13
14
15
16
17
 
# File 'lib/isodoc/ieee/presentation_bibdata.rb', line 9

def bibdata_dates(bib)
  bib.xpath(ns("./date")).each do |d|
    d.next = d.dup
    d.next["format"] = "ddMMMyyyy"
    d.next.xpath(ns("./from | ./to | ./on")).each do |x|
      x.children = ddMMMyyyy(x.text)
    end
  end
end

#bibdata_i18n(bib) ⇒ Object 



4
5
6
7
 
# File 'lib/isodoc/ieee/presentation_bibdata.rb', line 4

def bibdata_i18n(bib)
  super
  bibdata_dates(bib)
end

#biblio_anchor_linkend(node, bib) ⇒ Object 



15
16
17
18
19
20
21
22
23
 
# File 'lib/isodoc/ieee/presentation_ref.rb', line 15

def biblio_anchor_linkend(node, bib)
  if %w(techreport standard).include?(bib[:type])
    [node["citeas"], bib[:ord]].compact.join(" ")
  elsif bib[:author]
    "#{bib[:author]} " + node["citeas"]
  else
    node["citeas"]
  end
end

#biblio_ids_titles(xmldoc) ⇒ Object 



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

def biblio_ids_titles(xmldoc)
  xmldoc.xpath(ns("//references[@normative = 'false']/bibitem"))
    .each_with_object({}) do |b, m|
    m[b["id"]] =
      { docid: pref_ref_code(b), type: b["type"],
        title: (b.at(ns("./title")) ||
               b.at(ns("./formattedref")))&.text,
        author: @author[b["id"]] || (b.at(ns("./title")) ||
               b.at(ns("./formattedref")))&.text,
        ord: b.at(ns("./docidentifier[@type = 'metanorma' or " \
                     "@type = 'metanorma-ordinal']"))&.text }
  end
end

#bibliography_bibitem_number1(bibitem, idx, normative) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/isodoc/ieee/presentation_ref.rb', line 89

def bibliography_bibitem_number1(bibitem, idx, normative)
  bibitem.xpath(ns(".//docidentifier[@type = 'metanorma' or " \
                   "@type = 'metanorma-ordinal']")).each do |mn|
    /^\[?B?\d\]?$/.match?(mn&.text) and mn.remove
  end
  unless bibliography_bibitem_number_skip(bibitem) || normative
    idx += 1
    docidentifier_insert_pt(bibitem).next =
      "<docidentifier type='metanorma-ordinal'>[B#{idx}]</docidentifier>"
  end
  idx
end

#bibrender_relaton(xml, renderings) ⇒ Object 



51
52
53
54
55
56
57
58
 
# File 'lib/isodoc/ieee/presentation_ref.rb', line 51

def bibrender_relaton(xml, renderings)
  f = renderings[xml["id"]][:formattedref]
  fn = availability_note(xml)
  f &&= "<formattedref>#{f}#{fn}</formattedref>"
  xml.children = "#{f}#{xml.xpath(ns(KEEP_BIBRENDER_XPATH)).to_xml}"
  author_date(xml, renderings)
  @author[xml["id"]] = renderings[xml["id"]][:author]
end

#block_delim ⇒ Object 



78
79
80
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 78

def block_delim
  "&#x2014;"
end

#boilerplate(docxml) ⇒ Object 



31
32
33
34
35
36
37
38
 
# File 'lib/isodoc/ieee/presentation_bibdata.rb', line 31

def boilerplate(docxml)
  docxml.xpath(ns("//clause[@id = 'boilerplate-participants']/" \
                  "clause/title")).each(&:remove)
  docxml.xpath(ns("//clause[@id = 'boilerplate-participants']/clause"))
    .each do |clause|
    participants(clause)
  end
end

#bracket_if_num(num) ⇒ Object 



123
124
125
126
127
128
129
130
 
# File 'lib/isodoc/ieee/presentation_ref.rb', line 123

def bracket_if_num(num)
  return nil if num.nil?

  num = num.text.sub(/^\[/, "").sub(/\]$/, "")
  return "[#{num}]" if /^B?\d+$/.match?(num)

  num
end

#citestyle ⇒ Object 



39
40
41
 
# File 'lib/isodoc/ieee/presentation_ref.rb', line 39

def citestyle
  "author-date"
end

#collapse_term(docxml) ⇒ Object 



291
292
293
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 291

def collapse_term(docxml)
  docxml.xpath(ns("//term")).each { |t| collapse_term1(t) }
end

#collapse_term1(term) ⇒ Object 



295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 295

def collapse_term1(term)
  #pref = term.xpath(ns("./fmt-preferred//semx")).each_with_index.with_object([]) do |(a, i), m|
      #orig = semx_orig(a, term)
#if i.zero? || orig.at(ns("./abbreviation-type | ./graphical-symbol"))
  #m << a
#end
  #end

  ret = collapse_term_template(
    pref: term.at(ns("./fmt-preferred")),
    def: term.at(ns("./fmt-definition")),
    rels: term.at(ns("./fmt-related"))&.remove,
    source: term.at(ns("./fmt-termsource"))&.remove,
  )
  term.at(ns("./fmt-preferred"))&.remove
  term.at(ns("./fmt-admitted"))&.remove
  ins = term.at(ns("./fmt-definition")) and
    ins.children = ret
end

#collapse_term_pref(opt) ⇒ Object 



362
363
364
365
366
367
368
369
370
371
372
373
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 362

def collapse_term_pref(opt)
  p = opt[:pref]
  p.text.strip.empty? and return "**TERM NOT FOUND**"
  s = p.xpath(ns(".//semx[@element = 'termsource']"))
  unless s.empty?
    s[0].previous = " ("
    s[-1].next = ")"
  end
  p.xpath(ns(".//fmt-termsource")).each { |x| x.replace(x.children) }
  to_xml(p.children).strip

end

#collapse_term_related(rels) ⇒ Object 



315
316
317
318
319
320
321
322
323
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 315

def collapse_term_related(rels)
  ret = rels.map do |r|
    p = r.at(ns("./preferred"))
    rel = p ? to_xml(p.children) : "**RELATED TERM NOT FOUND**"
    "<em>#{@i18n.relatedterms[r['type']]}:</em> #{rel}"
  end.join(". ")
  ret += "." unless ret.empty?
  ret
end

#collapse_term_template(opt) ⇒ Object 



341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 341

def collapse_term_template(opt)
  defn, multiblock = collapse_unwrap_definition(opt[:def])
  #require "debug"; binding.b
  src = nil
  opt[:source] and src = "(#{to_xml(opt[:source].remove.children).strip})"
  t = collapse_term_pref(opt)
  #require "debug"; opt[:pref].nil? and binding.b
  #require "debug"; opt[:rels].empty? or binding.b
  tail = "#{collapse_term_related(opt[:rels])} #{src}"
  if multiblock
    tail = tail.strip.empty? ? "" : "<p>#{tail}</p>"
  <<~TERM
    <p>#{t}:</p> #{defn}#{tail}
  TERM
  else
  <<~TERM
    <p>#{t}: #{defn} #{tail}</p>
  TERM
  end
end

#collapse_unwrap_definition(defn) ⇒ Object 



375
376
377
378
379
380
381
382
383
384
385
386
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 375

def collapse_unwrap_definition(defn)
  #require "debug"; binding.b
  defn.nil? and return nil, nil
  s = defn.xpath(ns(".//fmt-termsource"))
  p = defn.at(ns(".//p"))
  !s.empty? && p and p << s.map(&:remove).map(&:children)
    .map { |x| to_xml(x) }.join
  # fmt-definition/semx/p
  elems = defn.at(ns("./semx")) || defn
  multiblock = elems.at(ns("./table | ./formula | ./dl | ./ol | ./ul")) || elems.xpath(ns("./p")).size > 1
  [defn.elements, multiblock]
end

#concept1(node) ⇒ Object 



470
471
472
473
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 470

def concept1(node)
  concept_render(node, ital: "false", ref: "false", bold: "false",
                 linkref: "false", linkmention: "false")
end

#creatornames(bibitem) ⇒ Object 



78
79
80
81
82
83
84
85
86
87
 
# File 'lib/isodoc/ieee/presentation_ref.rb', line 78

def creatornames(bibitem)
  ::Relaton::Render::Ieee::General
    .new(language: @lang, i18nhash: @i18n.get,
         # template: { (bibitem["type"] || "misc").to_sym =>
         # "{{ creatornames }}" },
         template: "{{ creatornames }}",
         extenttemplate: { (bibitem["type"] || "misc").to_sym => "{{page}}" },
         sizetemplate: { (bibitem["type"] || "misc").to_sym => "{{data}}" })
    .render1(RelatonBib::XMLParser.from_xml(bibitem.to_xml))
end

#ddMMMyyyy(isodate) ⇒ Object 



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

def ddMMMyyyy(isodate)
  isodate.nil? and return nil
  arr = isodate.split("-")
  if arr.size == 1 && (/^\d+$/.match isodate)
    Date.new(*arr.map(&:to_i)).strftime("%Y")
  elsif arr.size == 2
    Date.new(*arr.map(&:to_i)).strftime("%b %Y")
  else
    Date.parse(isodate).strftime("%d %b %Y")
  end
end

#deprecates(desgn) ⇒ Object 



58
59
60
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 58

def deprecates(desgn)
  desgn.remove
end

#designation(docxml) ⇒ Object

def unwrap_definition(elem)

  elem.xpath(ns("./definition")).each do |d|
    %w(verbal-definition non-verbal-representation).each do |e|
      v = d&.at(ns("./#{e}"))
      v&.replace(v.children)
    end
  end
end

to

  def unwrap_definition(_elem, fmt_defn)
  fmt_defn.xpath(ns(".//semx[@element = 'definition']")).each do |d|
    %w(verbal-definition non-verbal-representation).each do |e|
      v = d&.at(ns("./#{e}"))
      v&.replace(v.children)
    end
  end
en



54
55
56
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 54

def designation(docxml)
  super
end

#designation_boldface(desgn) ⇒ Object 



62
63
64
65
66
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 62

def designation_boldface(desgn)
  #desgn["element"] == "preferred" or return
  name = desgn.at(ns("./expression/name | ./letter-symbol/name")) or return
  name.children = "<strong>#{name.children}</strong>"
end

#designation_field(desgn, name, orig) ⇒ Object 



415
416
417
418
419
420
421
422
423
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 415

def designation_field(desgn, name, orig)
  if desgn["element"] == "preferred"
    f = orig.parent.xpath(ns("./domain | ./subject"))
      .map { |u| to_xml(semx_fmt_dup(u)) }.join(", ")
    #require 'debug'; binding.b
    name << "<span class='fmt-designation-field'>, &#x3c;#{f}&#x3e;</span>" unless f.empty?
  end
  super
end

#docidentifier_insert_pt(bibitem) ⇒ Object 



102
103
104
105
106
 
# File 'lib/isodoc/ieee/presentation_ref.rb', line 102

def docidentifier_insert_pt(bibitem)
  bibitem.at(ns(".//docidentifier"))&.previous ||
    bibitem.at(ns(".//title")) ||
    bibitem.at(ns(".//formattedref"))
end

#eref_localities1(opt) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 42

def eref_localities1(opt)
  opt[:type] == "anchor" and return nil
  opt[:type].downcase!
  opt[:lang] == "zh" and return l10n(eref_localities1_zh(opt))
  ret = ""
  opt[:node]["droploc"] != "true" &&
    !subclause?(opt[:target], opt[:type], opt[:from]) and
    ret = eref_locality_populate(opt[:type], opt[:node], opt[:number])
  ret += " #{opt[:from]}" if opt[:from]
  ret += "&#x2013;#{opt[:upto]}" if opt[:upto]
  ret += ")" if opt[:type] == "list"
  l10n(ret)
end

#eref_localities_conflated(refs, target, node) ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 15

def eref_localities_conflated(refs, target, node)
  droploc = node["droploc"]
  node["droploc"] = true
  ret = resolve_eref_connectives(eref_locality_stacks(refs, target,
                                                      node))
  node["droploc"] = droploc
  p = prefix_clause(target, refs.first.at(ns("./locality")))
  eref_localities1({ target: target, number: "pl",
                     type: p,
                     from: l10n(ret[1..-1].join), node: node,
                     lang: @lang })
end

#eref_locality_populate(type, node, number) ⇒ Object 



73
74
75
76
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 73

def eref_locality_populate(type, node, number)
  type == "page" and return ""
  super
end

#example1(elem) ⇒ Object 



229
230
231
232
233
234
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 229

def example1(elem)
  super
  n = elem.at(ns("./fmt-name")) or return
  n << l10n("<span class='fmt-caption-delim'>:</span>")
  n.children.wrap("<em></em>")
end

#expand_citeas(text) ⇒ Object 



108
109
110
 
# File 'lib/isodoc/ieee/presentation_ref.rb', line 108

def expand_citeas(text)
  std_docid_semantic(super)
end

#formula_where(dlist) ⇒ Object 



154
155
156
157
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 154

def formula_where(dlist)
  dlist or return
  dlist["class"] = "formula_dl"
end

#insert_related_type(docxml) ⇒ Object

temporarily insert related/@type to fmt-related/semx, for sorting



118
119
120
121
122
123
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 118

def insert_related_type(docxml)
  docxml.xpath(ns("//fmt-related/semx")).each do |r|
    orig = semx_orig(r)
    r["type"] = orig["type"]
  end
end

#merge_second_preferred(term) ⇒ Object 



425
426
427
428
429
430
431
432
433
434
435
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 425

def merge_second_preferred(term)
  pref =
    term.at(ns("./preferred[not(abbreviation-type)]/expression/name"))
  x = term.xpath(ns("./preferred[expression/name][abbreviation-type] | " \
                    "./admitted[expression/name][abbreviation-type]"))
  (pref && !x.empty?) or return
  tail = x.map do |p|
    to_xml(p.remove.at(ns("./expression/name")).children).strip
  end.join(", ")
  pref << " (#{tail})"
end

#middle_title(docxml) ⇒ Object 



195
196
197
198
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 195

def middle_title(docxml)
  s = middle_title_insert(docxml) or return
  s.previous = middle_title_body
end

#middle_title_body ⇒ Object 



200
201
202
203
204
205
206
207
208
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 200

def middle_title_body
  ret = "<p class='zzSTDTitle1'>#{@meta.get[:full_doctitle]}"
  @meta.get[:amd] || @meta.get[:corr] and ret += "<br/>"
  @meta.get[:amd] and ret += "Amendment #{@meta.get[:amd]}"
  @meta.get[:amd] && @meta.get[:corr] and ret += " "
  @meta.get[:corr] and ret += "Corrigenda #{@meta.get[:corr]}"
  ret += "</p>"
  ret
end

#middle_title_insert(docxml) ⇒ Object 



210
211
212
213
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 210

def middle_title_insert(docxml)
  s = docxml.at(ns("//sections")) or return
  s.children.first
end

#move_abstract(doc) ⇒ Object 



220
221
222
223
224
225
226
227
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 220

def move_abstract(doc)
  doc.at(ns("//bibdata/ext/doctype"))&.text == "whitepaper" or return
  source = doc.at(ns("//preface/abstract")) or return
  dest = doc.at(ns("//sections")) ||
    doc.at(ns("//preface")).after("<sections> </sections>").next_element
  dest.children.empty? and dest.children = " "
  dest.children.first.next = source
end

#multidef(elem, defn, fmt_defn) ⇒ Object 



4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 4

def multidef(elem, defn, fmt_defn)
  ctr = IsoDoc::XrefGen::Counter.new("@")
  coll = defn.each_with_object([]) do |d, m|
    ctr.increment(d)
    ret = semx_fmt_dup(d)
    ret.at(ns("./verbal-definition | ./non-verbal-definition")).elements
      .first.add_first_child("<strong>(#{ctr.print})</strong>&#xa0;")
    m << ret
  end
  #require "debug"; binding.b
  fmt_defn << coll.map { |c| to_xml(c) }.join(" ")
  #coll.each { |x| unwrap_definition1(x) }
  #fmt_defn << unwrap_multidef(coll)
end

#note_delim(_elem) ⇒ Object 



82
83
84
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 82

def note_delim(_elem)
  "&#x2014;"
end

#ol(docxml) ⇒ Object 



159
160
161
162
163
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 159

def ol(docxml)
  ol_numbering(docxml)
  @xrefs.list_anchor_names(docxml.xpath(ns(@xrefs.sections_xpath)))
  docxml.xpath(ns("//ol/li")).each { |f| ol_label(f) }
end

#ol_depth_rotate(node, idx) ⇒ Object 



187
188
189
190
191
192
193
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 187

def ol_depth_rotate(node, idx)
  depth = node.ancestors("ol").size + idx
  type = :alphabet
  type = :arabic if [2, 5, 8].include? depth
  type = :roman if [3, 6, 9].include? depth
  type
end

#ol_numbering(docxml) ⇒ Object 



165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 165

def ol_numbering(docxml)
  p = "//clause | //annex | //foreword | //acknowledgements | " \
      "//introduction | //preface/abstract | //appendix | //terms | " \
      "//term | //definitions | //references | //colophon"
  docxml.xpath(ns(p)).each do |c|
    (c.xpath(ns(".//ol")) -
    c.xpath(ns("./clause//ol | ./appendix//ol | ./term//ol | " \
               "./terms//ol | ./definitions//ol | " \
               "/references//ol | ./colophon//ol")))
      .each_with_index do |o, i|
      ol_numbering1(o, i)
    end
  end
end

#ol_numbering1(elem, idx) ⇒ Object 



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

def ol_numbering1(elem, idx)
  elem["type"] = ol_depth_rotate(elem, idx).to_s
  elem.xpath(ns("./li")).each do |li|
    li["id"] ||= "_#{UUIDTools::UUID.random_create}"
  end
end

#omit_docid_prefix(prefix) ⇒ Object 



118
119
120
121
 
# File 'lib/isodoc/ieee/presentation_ref.rb', line 118

def omit_docid_prefix(prefix)
  prefix == "DOI" and return true
  super
end

#participant_member_para(map, name, _idx) ⇒ Object 



84
85
86
87
88
89
90
91
 
# File 'lib/isodoc/ieee/presentation_bibdata.rb', line 84

def participant_member_para(map, name, _idx)
  if map["company"] && (map["name"] || map["surname"])
    pers = map["name"] || "#{map['given']} #{map['surname']}"
    "<p type='officeorgrepmember'>#{name}<tab/>#{pers}</p>"
  elsif map["company"] then "<p type='officeorgmember'>#{name}</p>"
  else "<p type='officemember'>#{name}</p>"
  end
end

#participant_name(map) ⇒ Object 



100
101
102
 
# File 'lib/isodoc/ieee/presentation_bibdata.rb', line 100

def participant_name(map)
  map["company"] || map["name"] || "#{map['given']} #{map['surname']}"
end

#participant_officeholder_para(map, name, idx) ⇒ Object 



93
94
95
96
97
98
 
# File 'lib/isodoc/ieee/presentation_bibdata.rb', line 93

def participant_officeholder_para(map, name, idx)
  name = "<strong>#{name}</strong>" if idx.zero?
  br = map["role"].size > 30 ? "<br/>" : ""
  "<p type='officeholder' align='center'>#{name}, #{br}" \
    "<em><span class='au_role'>#{map['role']}</span></em></p>"
end

#participant_para(map, idx) ⇒ Object 



75
76
77
78
79
80
81
82
 
# File 'lib/isodoc/ieee/presentation_bibdata.rb', line 75

def participant_para(map, idx)
  name = participant_name(map)
  if map["role"]&.casecmp("member")&.zero?
    participant_member_para(map, name, idx)
  else
    participant_officeholder_para(map, name, idx)
  end
end

#participants(clause) ⇒ Object 



40
41
42
43
44
45
46
 
# File 'lib/isodoc/ieee/presentation_bibdata.rb', line 40

def participants(clause)
  clause.xpath(ns(".//ul")).each_with_index do |ulist, idx|
    ulist.xpath(ns("./li")).each { |list| participants1(list, idx) }
    ulist.replace(ulist.children)
  end
  affiliation_header(clause)
end

#participants1(list, idx) ⇒ Object 



60
61
62
63
64
65
66
67
68
 
# File 'lib/isodoc/ieee/presentation_bibdata.rb', line 60

def participants1(list, idx)
  key = ""
  map = list.xpath(ns(".//dt | .//dd")).each_with_object({}) do |dtd, m|
    (dtd.name == "dt" and key = dtd.text) or
      m[key] = text_from_paras(dtd)
        .gsub(/\*/, "<span class='cite_fn'>*</span>")
  end
  list.replace(participant_para(map, idx))
end

#preface_rearrange(doc) ⇒ Object 



215
216
217
218
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 215

def preface_rearrange(doc)
  move_abstract(doc)
  super
end

#prefix_clause(target, loc) ⇒ Object 



28
29
30
31
32
33
34
35
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 28

def prefix_clause(target, loc)
  loc["type"] == "clause" or return loc["type"]
  if subclause?(target, loc["type"],
                loc&.at(ns("./referenceFrom"))&.text)
    ""
  else "clause"
  end
end

#references_render(docxml) ⇒ Object 



43
44
45
46
 
# File 'lib/isodoc/ieee/presentation_ref.rb', line 43

def references_render(docxml)
  @author = {}
  super
end

#related(docxml) ⇒ Object 



110
111
112
113
114
115
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 110

def related(docxml)
  insert_related_type(docxml)
  admitted_to_related docxml
  term_reorder(docxml)
  docxml.xpath(ns("//term[fmt-related/semx]")).each { |f| related_term(f) }
end

#related1(node) ⇒ Object

KILL



253
254
255
256
257
258
259
260
261
262
263
264
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 253

def related1(node)
   require "debug"; binding.b
  p, ref, orig = related1_prep(node)
  label = @i18n.relatedterms[orig["type"]].upcase
  if p
    node.children =(l10n("<p><strong>#{label}:</strong> " \
                      "<em>#{to_xml(p)}</em></p>"))
  else
    node.children = (l10n("<p><strong>#{label}:</strong> " \
                      "<strong>**RELATED TERM NOT FOUND**</strong></p>"))
  end
end

#related_designation1(desgn) ⇒ Object 



106
107
108
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 106

def related_designation1(desgn)
  super
end

#related_term(term) ⇒ Object 



125
126
127
128
129
130
131
132
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 125

def related_term(term)
  #require "debug"; binding.b
  #coll = term_related_reorder(term.xpath(ns("./fmt-related/semx")))
  r = term.at(ns("./fmt-related"))
  r.xpath(ns(".//xref | .//eref | .//termref")).each(&:remove)
  coll = sort_related(r.xpath(ns("./semx")))
  r.children = term_related_collapse(coll)
end

#section(docxml) ⇒ Object 



136
137
138
139
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 136

def section(docxml)
  boilerplate(docxml)
  super
end

#sort_related(coll) ⇒ Object 



190
191
192
193
194
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 190

def sort_related(coll)
  coll.sort do |a, b|
    sort_related_key(a) <=> sort_related_key(b)
  end
end

#sort_related_key(related) ⇒ Object 



196
197
198
199
200
201
202
203
204
205
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 196

def sort_related_key(related)
  type = case related["type"]
         when "contrast" then 1
         when "equivalent" then 2
         when "see" then 3
         when "seealso" then 4
         else "5-#{related['type']}"
         end
  "#{type} :: #{sort_terms_key(related)}"
end

#sort_terms(terms) ⇒ Object 



278
279
280
281
282
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 278

def sort_terms(terms)
  terms.sort do |a, b|
    sort_terms_key(a) <=> sort_terms_key(b)
  end
end

#sort_terms_key(term) ⇒ Object 



164
165
166
167
168
169
170
171
172
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 164

def sort_terms_key(term)
  d = term.at(ns("./preferred/expression/name | " \
                 "./preferred/letter-symbol/name | " \
                 "./preferred/graphical-symbol/figure/name | " \
                 "./preferred/graphical-symbol/figure/@id | " \
                 "./preferred | ./fmt-preferred//semx"))
  f = term.at(ns("./field-of-application")) || term.at(ns("./domain"))
  @c.decode("#{sort_terms_key1(d)} :: #{sort_terms_key1(f)}")
end

#sort_terms_key1(elem) ⇒ Object 



174
175
176
177
178
179
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 174

def sort_terms_key1(elem)
  elem.nil? and return "zzzz"
  dup = elem.dup
  dup.xpath(ns(".//asciimath | .//latexmath")).each(&:remove)
  dup.text&.strip&.downcase || "zzzz"
end

#strip_initial_clause(linkend) ⇒ Object 



67
68
69
70
71
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 67

def strip_initial_clause(linkend)
  x = Nokogiri::XML("<a>#{linkend}</a>")
  x.at(".//span[@class = 'fmt-element-name']")&.remove
  to_xml(x.elements.first.children).strip
end

#subclause?(target, type, from) ⇒ Boolean

Returns:

  • (Boolean) 


37
38
39
40
 
# File 'lib/isodoc/ieee/presentation_xml_convert.rb', line 37

def subclause?(target, type, from)
  (from&.match?(/\./) && type == "clause") ||
    target&.gsub(/<[^<>]+>/, "")&.match?(/^IEV$|^IEC 60050-/)
end

#term(docxml) ⇒ Object 



468
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 468

def term(docxml); end

#term_related_collapse(coll) ⇒ Object 



134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 134

def term_related_collapse(coll)
  prev = 0
  coll[0].wrap("<p></p>")
  coll[1..-1].each_with_index do |r, i|
    if coll[prev]["type"] != r["type"]
      prev = i
      r.wrap("<p></p>")
      next
    end

    #coll[prev].at(ns("./preferred")) << "; #{to_xml(r.at(ns('./preferred'))
    #.children)}"
    coll[prev] << "; #{to_xml(r)}"
    r.remove
  end
end

#term_related_reorder(coll) ⇒ Object

KILL



182
183
184
185
186
187
188
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 182

def term_related_reorder(coll)
  ins = coll.first.previous_element
  ret = sort_related(coll)
  coll.each(&:remove)
  ret.reverse_each { |t| ins.next = t }
  ins.parent.xpath(ns("./related"))
end

#term_reorder(xmldoc) ⇒ Object 



266
267
268
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 266

def term_reorder(xmldoc)
  xmldoc.xpath(ns("//terms")).each { |t| term_reorder1(t) }
end

#term_reorder1(terms) ⇒ Object 



270
271
272
273
274
275
276
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 270

def term_reorder1(terms)
  ins = terms.at(ns("./term"))&.previous_element or return
  coll = terms.xpath(ns("./term"))
  ret = sort_terms(coll)
  coll.each(&:remove)
  ret.reverse_each { |t| ins.next = t }
end

#termcleanup(docxml) ⇒ Object 



207
208
209
210
211
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 207

def termcleanup(docxml)
  collapse_term docxml
  docxml.xpath(ns("//term//semx[@type]")).each { |x| x.delete("type") } # temp attribute from insert_related_type
  super
end

#termcontainers(docxml) ⇒ Object 



284
285
286
287
288
289
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 284

def termcontainers(docxml)
  super
  docxml.xpath(ns("//term[not(./fmt-definition)]")).each do |t|
    t << "<fmt-definition></fmt-definition>"
  end
end

#termdomain(elem, domain) ⇒ Object

domain is rendered in designation_field instead



410
411
412
413
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 410

def termdomain(elem, domain)
  #d = elem.at(ns(".//domain")) or return
  #d["hidden"] = "true"
end

#termnote1(elem) ⇒ Object 



458
459
460
461
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 458

def termnote1(elem)
  lbl = termnote_label(elem)
  prefix_name(elem, { label: block_delim }, lower2cap(lbl), "name")
end

#termnote_label(elem) ⇒ Object 



463
464
465
466
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 463

def termnote_label(elem)
  lbl = l10n(@xrefs.anchor(elem["id"], :label)&.strip || "???")
  l10n lbl
end

#termsource1xx(elem) ⇒ Object

KILL



389
390
391
392
393
394
395
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 389

def termsource1xx(elem)
  while elem&.next_element&.name == "termsource"
    elem << "; #{to_xml(elem.next_element.remove.children)}"
  end
  adapt = termsource_adapt(elem["status"]) and
    elem.children = l10n("#{adapt}#{to_xml(elem.children).strip}")
end

#termsource_adapt(status) ⇒ Object 



403
404
405
406
407
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 403

def termsource_adapt(status)
  case status
  when "adapted" then @i18n.adapted_from
  end
end

#termsource_label(elem, sources) ⇒ Object 



397
398
399
400
401
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 397

def termsource_label(elem, sources)
  adapt = termsource_adapt(elem["status"]) and
    sources = "#{adapt}#{sources}"
  elem.replace(l10n(sources))
end

#text_from_paras(node) ⇒ Object 



70
71
72
73
 
# File 'lib/isodoc/ieee/presentation_bibdata.rb', line 70

def text_from_paras(node)
  r = node.at(ns("./p")) and node = r
  node.children.to_xml.strip
end

#unwrap_definition(_elem, fmt_defn) ⇒ Object 



68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 68

def unwrap_definition(docxml)
  docxml.xpath(ns(".//definition/verbal-definition")).each do |v|
    v.elements.all? { |e| %w(termsource p).include?(e.name) } or next
    p = v.xpath(ns("./p"))
    s = v.xpath(ns('./termsource'))
    s.empty? or s = " (#{s.map { |x| to_xml(x) }.join("\n")})"
    v.children =
      "<p>#{p.map(&:children).map { |x| to_xml(x) }.join("\n")}#{s}</p>"
  end
  super
end

#unwrap_definition1(d) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/isodoc/ieee/presentation_terms.rb', line 86

def unwrap_definition1(d)
    %w(verbal-definition non-verbal-representation).each do |e|
      v = d.at(ns("./#{e}")) or next
      if v.elements.all? { |e| %w(termsource p).include?(e.name) }
        p = v.xpath(ns("./p"))
        s = v.xpath(ns('./termsource'))
        s.empty? or s = " (#{s.map { |x| to_xml(x) }.join()})"
        v.children =
          "#{p.map(&:children).map { |x| to_xml(x) }.join("\n")}#{s}"
      else
        s = v.xpath(ns('./termsource'))
        unless s.empty?
          s[0].previous = " ("
          s[-1].next = ")"
        end
      end
      v.replace(v.children)
    end
end

#unwrap_multidef(coll) ⇒ Object 



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

def unwrap_multidef(coll)
  if coll.all? do |c|
    c.elements.size == 1 && c.elements.first.name == "p"
  end
  ret = coll.map do |c|
    c.children = c.elements.first.children
  end
  return "<p>#{ret.map { |x| to_xml(x) }.join}</p>"
  end
  coll.map { |c| to_xml(c.children) }.join(" ")
end