metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/metadata.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require_relative './metadata_date'
+
+module IsoDoc
+  class Metadata
+    DATETYPES = %w{published accessed created implemented obsoleted confirmed
+                   updated issued received transmitted copied unchanged
+                   circulated vote-started
+                   vote-ended}.freeze
+
+    attr_accessor :fonts_options
+
+    def ns(xpath)
+      Common::ns(xpath)
+    end
+
+    def l10n(a, b, c)
+      @i18n.l10n(a, b, c)
+    end
+
+    def initialize(lang, script, i18n, fonts_options = {})
+      @metadata = {}
+      DATETYPES.each { |w| @metadata["#{w.gsub(/-/, '_')}date".to_sym] = 'XXX' }
+      @lang = lang
+      @script = script
+      @c = HTMLEntities.new
+      @i18n = i18n
+      @labels = @i18n.get
+      @fonts_options = fonts_options
+    end
+
+    def get
+      @metadata
+    end
+
+    def labels
+      @labels
+    end
+
+    def set(key, value)
+      @metadata[key] = value
+    end
+
+    def extract_person_names(authors)
+      authors.reduce([]) do |ret, a|
+        if a.at(ns('./name/completename'))
+          ret << a.at(ns('./name/completename')).text
+        else
+          fn = []
+          forenames = a.xpath(ns('./name/forename'))
+          forenames.each { |f| fn << f.text }
+          surname = a&.at(ns('./name/surname'))&.text
+          ret << fn.join(' ') + ' ' + surname
+        end
+      end
+    end
+
+    def extract_person_affiliations(authors)
+      authors.reduce([]) do |m, a|
+        name = a&.at(ns('./affiliation/organization/name'))&.text
+        location = a&.at(ns('./affiliation/organization/address/'\
+                            'formattedAddress'))&.text
+        m << (!name.nil? && !location.nil? ? "#{name}, #{location}" :
+          (name || location || ''))
+        m
+      end
+    end
+
+    def extract_person_names_affiliations(authors)
+      names = extract_person_names(authors)
+      affils = extract_person_affiliations(authors)
+      ret = {}
+      affils.each_with_index do |a, i|
+        ret[a] ||= []
+        ret[a] << names[i]
+      end
+      ret
+    end
+
+    def personal_authors(isoxml)
+      authors = isoxml.xpath(ns("//bibdata/contributor[role/@type = 'author' "\
+                                "or xmlns:role/@type = 'editor']/person"))
+      set(:authors, extract_person_names(authors))
+      set(:authors_affiliations, extract_person_names_affiliations(authors))
+    end
+
+    def author(xml, _out)
+      personal_authors(xml)
+      agency(xml)
+    end
+
+    def bibdate(isoxml, _out)
+      isoxml.xpath(ns('//bibdata/date')).each do |d|
+        set("#{d['type'].gsub(/-/, '_')}date".to_sym, Common::date_range(d))
+      end
+    end
+
+    def doctype(isoxml, _out)
+      b = isoxml&.at(ns('//bibdata/ext/doctype'))&.text || return
+      t = b.split(/[- ]/).map(&:capitalize).join(' ')
+      set(:doctype, t)
+    end
+
+    def iso?(org)
+      name = org&.at(ns('./name'))&.text
+      abbrev = org&.at(ns('./abbreviation'))&.text
+      (abbrev == 'ISO' ||
+       name == 'International Organization for Standardization')
+    end
+
+    def agency(xml)
+      agency = ''
+      publisher = []
+      xml.xpath(ns("//bibdata/contributor[xmlns:role/@type = 'publisher']/"\
+                   'organization')).each do |org|
+        name = org&.at(ns('./name'))&.text
+        agency1 = org&.at(ns('./abbreviation'))&.text || name
+        publisher << name if name
+        agency = iso?(org) ? "ISO/#{agency}" : "#{agency}#{agency1}/"
+      end
+      set(:agency, agency.sub(%r{/$}, ''))
+      set(:publisher, multiple_and(publisher, @labels['and']))
+    end
+
+    def multiple_and(names, andword)
+      return '' if names.empty?
+      return names[0] if names.length == 1
+      (names.length == 2) &&
+        (return l10n("#{names[0]} #{andword} #{names[1]}", @lang, @script))
+      l10n(names[0..-2].join(', ') + " #{andword} #{names[-1]}", @lang, @script)
+    end
+
+    def docstatus(isoxml, _out)
+      docstatus = isoxml.at(ns('//bibdata/status/stage'))
+      set(:unpublished, true)
+      if docstatus
+        set(:stage, status_print(docstatus.text))
+        (i = isoxml&.at(ns('//bibdata/status/substage'))&.text) &&
+          set(:substage, i)
+        (i = isoxml&.at(ns('//bibdata/status/iteration'))&.text) &&
+          set(:iteration, i)
+        set(:unpublished, unpublished(docstatus.text))
+        unpublished(docstatus.text) &&
+          set(:stageabbr, stage_abbr(docstatus.text))
+      end
+    end
+
+    def stage_abbr(docstatus)
+      status_print(docstatus).split(/ /)
+                             .map { |s| s[0].upcase }.join('')
+    end
+
+    def unpublished(status)
+      !status.casecmp('published').zero?
+    end
+
+    def status_print(status)
+      status.split(/-/).map(&:capitalize).join(' ')
+    end
+
+    def docid(isoxml, _out)
+      dn = isoxml.at(ns('//bibdata/docidentifier'))
+      set(:docnumber, dn&.text)
+    end
+
+    def docnumeric(isoxml, _out)
+      dn = isoxml.at(ns('//bibdata/docnumber'))
+      set(:docnumeric, dn&.text)
+    end
+
+    def draftinfo(draft, revdate)
+      draftinfo = ''
+      if draft
+        draftinfo = " (#{@labels['draft_label']} #{draft}"
+        draftinfo += ", #{revdate}" if revdate
+        draftinfo += ')'
+      end
+      l10n(draftinfo, @lang, @script)
+    end
+
+    def version(isoxml, _out)
+      set(:edition, isoxml&.at(ns('//bibdata/edition'))&.text)
+      set(:docyear, isoxml&.at(ns('//bibdata/copyright/from'))&.text)
+      set(:draft, isoxml&.at(ns('//version/draft'))&.text)
+      revdate = isoxml&.at(ns('//version/revision-date'))&.text
+      set(:revdate, revdate)
+      set(:revdate_monthyear, monthyr(revdate))
+      set(:draftinfo,
+          draftinfo(get[:draft], get[:revdate]))
+    end
+
+    def title(isoxml, _out)
+      main = isoxml&.at(ns("//bibdata/title[@language='en']"))&.text
+      set(:doctitle, main)
+    end
+
+    def subtitle(_isoxml, _out)
+      nil
+    end
+
+    def relations(isoxml, _out)
+      relations_obsoletes(isoxml)
+      relations_partof(isoxml)
+    end
+
+    def relations_partof(isoxml)
+      std = isoxml.at(ns("//bibdata/relation[@type = 'partOf']")) || return
+      id = std.at(ns('.//docidentifier'))
+      set(:partof, id.text) if id
+    end
+
+    def relations_obsoletes(isoxml)
+      std = isoxml.at(ns("//bibdata/relation[@type = 'obsoletes']")) || return
+      locality = std.at(ns('.//locality'))
+      id = std.at(ns('.//docidentifier'))
+      set(:obsoletes, id.text) if id
+      set(:obsoletes_part, locality.text) if locality
+    end
+
+    def url(xml, _out)
+      (a = xml.at(ns('//bibdata/uri[not(@type)]'))) && set(:url, a.text)
+      (a = xml.at(ns("//bibdata/uri[@type = 'html']"))) && set(:html, a.text)
+      (a = xml.at(ns("//bibdata/uri[@type = 'xml']"))) && set(:xml, a.text)
+      (a = xml.at(ns("//bibdata/uri[@type = 'pdf']"))) && set(:pdf, a.text)
+      (a = xml.at(ns("//bibdata/uri[@type = 'doc']"))) && set(:doc, a.text)
+    end
+
+    def keywords(isoxml, _out)
+      ret = []
+      isoxml.xpath(ns('//bibdata/keyword')).each { |kw| ret << kw.text }
+      set(:keywords, ret)
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/metadata_date.rb

@@ -0,0 +1,39 @@
+module IsoDoc
+  class Metadata
+    def months
+    {
+        "01": @labels["month_january"],
+        "02": @labels["month_february"],
+        "03": @labels["month_march"],
+        "04": @labels["month_april"],
+        "05": @labels["month_may"],
+        "06": @labels["month_june"],
+        "07": @labels["month_july"],
+        "08": @labels["month_august"],
+        "09": @labels["month_september"],
+        "10": @labels["month_october"],
+        "11": @labels["month_november"],
+        "12": @labels["month_december"],
+    }
+    end
+
+    def monthyr(isodate)
+      m = /(?<yr>\d\d\d\d)-(?<mo>\d\d)/.match isodate
+      return isodate unless m && m[:yr] && m[:mo]
+      l10n("#{months[m[:mo].to_sym]} #{m[:yr]}",
+                                   @lang, @script)
+    end
+
+    def MMMddyyyy(isodate)
+      return nil if isodate.nil?
+      arr = isodate.split("-")
+      date = if arr.size == 1 and (/^\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("%B %d, %Y")
+             end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/pdf_convert.rb

@@ -0,0 +1,50 @@
+require_relative "html_function/comments.rb"
+require_relative "html_function/footnotes.rb"
+require_relative "html_function/html.rb"
+require "metanorma"
+
+module IsoDoc
+  class PdfConvert < ::IsoDoc::Convert
+
+    include HtmlFunction::Comments
+    include HtmlFunction::Footnotes
+    include HtmlFunction::Html
+
+    def initialize(options)
+      @standardstylesheet = nil
+      super
+      @scripts = @scripts_pdf if @scripts_pdf
+      @maxwidth = 500
+      @maxheight = 800
+    end
+
+    def tmpimagedir_suffix
+      "_pdfimages"
+    end
+
+    def initialize(options)
+      @format = :pdf
+      @suffix = "pdf"
+      super
+    end
+
+    def convert(input_filename, file = nil, debug = false, output_filename = nil)
+      file = File.read(input_filename, encoding: "utf-8") if file.nil?
+      @openmathdelim, @closemathdelim = extract_delims(file)
+      docxml, filename, dir = convert_init(file, input_filename, debug)
+      result = convert1(docxml, filename, dir)
+      return result if debug
+      postprocess(result, filename + ".tmp.html", dir)
+      FileUtils.rm_rf dir
+      ::Metanorma::Output::Pdf.new.convert("#{filename}.tmp.html",
+                                           output_filename || "#{filename}.#{@suffix}")
+      FileUtils.rm_rf ["#{filename}.tmp.html", tmpimagedir]
+    end
+
+    def xref_parse(node, out)
+      target = /#/.match(node["target"]) ? node["target"].sub(/#/, ".pdf#") :
+        "##{node["target"]}"
+      out.a(**{ "href": target }) { |l| l << get_linkend(node) }
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/presentation_function/block.rb

@@ -0,0 +1,138 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    def figure(docxml)
+      docxml.xpath(ns("//figure")).each do |f|
+        figure1(f)
+      end
+    end
+
+    def figure1(f)
+      return sourcecode1(f) if f["class"] == "pseudocode" ||
+        f["type"] == "pseudocode"
+      return if labelled_ancestor(f) && f.ancestors("figure").empty?
+      return if f.at(ns("./figure")) and !f.at(ns("./name"))
+      lbl = @xrefs.anchor(f['id'], :label, false) or return
+      prefix_name(f, "&nbsp;&mdash; ", l10n("#{@i18n.figure} #{lbl}"), "name")
+    end
+
+    def prefix_name(f, delim, number, elem)
+      return if number.nil? || number.empty?
+      unless name = f.at(ns("./#{elem}"))
+        f.children.empty? and f.add_child("<#{elem}></#{elem}>") or
+          f.children.first.previous = "<#{elem}></#{elem}>"
+          name = f.children.first
+      end
+      name.children.empty? ? name.add_child(number) :
+        ( name.children.first.previous = "#{number}#{delim}" )
+    end
+
+    def sourcecode(docxml)
+      docxml.xpath(ns("//sourcecode")).each do |f|
+        sourcecode1(f)
+      end
+    end
+
+    def sourcecode1(f)
+      return if labelled_ancestor(f)
+      return unless f.ancestors("example").empty?
+      lbl = @xrefs.anchor(f['id'], :label, false) or return
+      prefix_name(f, "&nbsp;&mdash; ", l10n("#{@i18n.figure} #{lbl}"), "name")
+    end
+
+    def formula(docxml)
+      docxml.xpath(ns("//formula")).each do |f|
+        formula1(f)
+      end
+    end
+
+    # introduce name element
+    def formula1(f)
+      lbl = @xrefs.anchor(f['id'], :label, false)
+      prefix_name(f, "", lbl, "name")
+    end
+
+    def example(docxml)
+      docxml.xpath(ns("//example")).each do |f|
+        example1(f)
+      end
+    end
+
+    def termexample(docxml)
+      docxml.xpath(ns("//termexample")).each do |f|
+        example1(f)
+      end
+    end
+
+    def example1(f)
+      n = @xrefs.get[f["id"]]
+      lbl = (n.nil? || n[:label].nil? || n[:label].empty?) ? @i18n.example :
+        l10n("#{@i18n.example} #{n[:label]}")
+      prefix_name(f, "&nbsp;&mdash; ", lbl, "name")
+    end
+
+    def note(docxml)
+      docxml.xpath(ns("//note")).each do |f|
+        note1(f)
+      end
+    end
+
+    # introduce name element
+    def note1(f)
+      return if f.parent.name == "bibitem"
+      n = @xrefs.get[f["id"]]
+      lbl = (@i18n.note if n.nil? || n[:label].nil? || n[:label].empty?) ?
+        @i18n.note : l10n("#{@i18n.note} #{n[:label]}")
+      prefix_name(f, "", lbl, "name")
+    end
+
+    def termnote(docxml)
+      docxml.xpath(ns("//termnote")).each do |f|
+        termnote1(f)
+      end
+    end
+
+    # introduce name element
+    def termnote1(f)
+      lbl = l10n(@xrefs.anchor(f['id'], :label) || '???')
+      prefix_name(f, "", lbl, "name")
+    end
+
+    def recommendation(docxml)
+      docxml.xpath(ns("//recommendation")).each do |f|
+        recommendation1(f, @i18n.recommendation)
+      end
+    end
+
+    def requirement(docxml)
+      docxml.xpath(ns("//requirement")).each do |f|
+        recommendation1(f, @i18n.requirement)
+      end
+    end
+
+    def permission(docxml)
+      docxml.xpath(ns("//permission")).each do |f|
+        recommendation1(f, @i18n.permission)
+      end
+    end
+
+    # introduce name element
+    def recommendation1(f, type)
+      n = @xrefs.anchor(f['id'], :label, false)
+      lbl = (n.nil? ? type : l10n("#{type} #{n}"))
+      prefix_name(f, "", lbl, "name")
+    end
+
+    def table(docxml)
+      docxml.xpath(ns("//table")).each do |f|
+        table1(f)
+      end
+    end
+
+    def table1(f)
+      return if labelled_ancestor(f)
+      return if f["unnumbered"] && !f.at(ns("./name"))
+      n = @xrefs.anchor(f['id'], :label, false)
+      prefix_name(f, "&nbsp;&mdash; ", l10n("#{@i18n.table} #{n}"), "name")
+    end
+  end
+end