asciidoctor-iso 0.0.1 → 0.6.0

data/lib/asciidoctor/iso/isostandard_diff.rnc

@@ -0,0 +1,295 @@
+default namespace = "http://riboseinc.com/isoxml"
+
+# grammar {
+
+start = iso-standard
+
+iso-standard = 
+  element iso-standard {
+    title+,
+    status,
+    creator,
+    language,
+    script,
+    type,
+    id,
+    version?,
+    copyright,
+    sections
+  }
+
+language =
+  element language { ( "en" | "fr" ) }
+
+script =
+  element script { "latn" }
+
+# draft into isodoc? To replace version/version?
+version =
+  element version {
+    edition?,
+    revision-date?,
+    draft?
+  }
+
+draft = element draft {text}
+
+copyright = 
+  element copyright {
+    from, owner
+}
+
+owner = 
+  element owner {
+    owner-affiliation  
+}
+
+owner-affiliation = element affiliation { "ISO" }
+
+id =
+  element id {
+    documentnumber,
+    tc-documentnumber?
+  }
+
+creator =
+  element creator { 
+    attribute role { text },
+    technical-committee,
+    subcommittee?,
+    workgroup?,
+    secretariat?
+  }
+
+type =
+  element type {
+     ( "international-standard" | "technical-specification" | 
+       "technical-report" | "publicly-available-specification" | 
+        "international-workshop-agreement" | "guide" )
+  }
+
+status =
+  element status {
+     stage,
+     substage?
+  }
+
+stage = 
+  element stage {
+    ("00" | "10" | "20" | "30" | "40" | "50" | "60" | "90" | "95" )
+  }
+
+substage = 
+  element substage {
+    ("00" | "20" | "60" | "90" | "92" | "93" | "98" | "99" )
+  }
+
+documentnumber = 
+  element project-number { 
+    attribute part { xsd:int }?,
+    xsd:int 
+   }
+
+tc-documentnumber = 
+  element tc-document-number { 
+    xsd:int 
+   }
+
+technical-committee =
+  element technical-committee {
+    attribute number { xsd:int }?,
+    text
+  }
+
+subcommittee =
+  element subcommittee {
+    attribute number { xsd:int }?,
+    text
+  }
+
+workgroup =
+  element workgroup {
+    attribute number { xsd:int }?,
+    text
+  }
+
+secretariat =
+  element secretariat { text }
+
+title = 
+  element title { 
+    attribute language { text }, 
+    title-intro?, title-main, title-part? 
+}
+
+title-intro =
+  element title-intro { text }
+
+title-main =
+  element title-main { text }
+
+title-part =
+  element title-part { text }
+
+sections =
+  element sections {
+    content, content?, 
+    clause, references, terms, clause+, 
+    annex*, references?
+  }
+
+references =
+  element references {
+    attribute id { xsd:ID }?,
+    section-title?,
+    bibitem*,
+    references*
+}
+
+terms = 
+  element terms { 
+    attribute id { xsd:ID }?,
+    section-title?,
+    # boilerplate
+    paragraph-with-footnote*, ul?,
+    (term+ | terms? )
+  }
+
+term = 
+  element term { 
+    attribute id { xsd:ID }?,
+    preferred, admitted*, deprecates*,
+    termdomain?, definition, termnote*, termexample*, termsource* 
+  }
+
+definition =
+  element definition {
+    ( paragraph | figure | formula )+
+  }
+
+origin =
+  element origin { 
+    attribute citeas { text },
+    CitationType 
+}
+
+clause-hanging-paragraph-with-footnote =
+  element subsection {
+    attribute id { xsd:ID }?,
+    attribute  inline-header  {   xsd:boolean  } ? ,
+    section-title?,
+    # allow hanging paragraphs in annexes: they introduce lists
+    BasicBlock*,
+    clause-hanging-paragraph-with-footnote*
+  }
+
+annex =
+  element annex { 
+    attribute id { xsd:ID }?,
+    attribute inline-header { xsd:boolean }?,
+    attribute subtype { "normative" | "informative" }?,
+    section-title?,
+    # allow hanging paragraps in annexes: they introduce lists
+    #( paragraph-with-footnote | table | note | formula | admonition | ol | ul | dl | figure | quote | sourcecode | review | example )*,
+    BasicBlock*,
+    clause-hanging-paragraph-with-footnote*
+  }
+
+figure = 
+  element figure {
+    attribute id { xsd:ID },
+    tname?,
+    ( image | figure+ ),
+    fn*,
+    dl?,
+    note*
+  }
+
+li =
+  element li {
+    #( paragraph-with-footnote | table | note | formula | admonition | ol | ul | dl | quote | sourcecode | review | example )+
+    BasicBlock+
+    # exclude figures?
+  }
+
+dd =
+  element dd {
+    #( paragraph-with-footnote | table | note | formula | admonition | ol | ul | dl | quote | sourcecode | review | example )*
+    # exclude figures?
+    BasicBlock
+  }
+
+admonition =
+  element admonition { 
+    attribute id { xsd:ID },
+    attribute type { 
+     ( "danger" | "caution" | "warning" | "important" | "safety precautions" )},
+    paragraph-with-footnote+ 
+  }
+
+xref =
+  element xref { 
+    attribute target { xsd:IDREF },
+    text
+  }
+
+hyperlink =
+  element link {
+    attribute target {xsd:anyURI},
+    text
+}
+
+thead =
+  element thead { tr+ }
+
+td =
+  element td {
+    attribute colspan { text }?,
+    attribute rowspan { text }?,
+    attribute align { "left" | "right" | "center" }?,
+    (
+      (TextElement | fn | review )* |
+      paragraph-with-footnote+
+    )
+}
+
+th =
+  element th {
+    attribute colspan { text }?,
+    attribute rowspan { text }?,
+    attribute align { "left" | "right" | "center" }?,
+    (
+      (TextElement | fn | review )* |
+      paragraph-with-footnote+
+    )
+}
+
+table-note = element note {
+    attribute id { xsd:ID }?,
+ paragraph
+}
+
+
+Clause-Section =
+    attribute id { xsd:ID }?,
+    attribute inline-header { xsd:boolean }?,
+    section-title?,
+    (
+      BasicBlock+ |
+       clause-subsection+
+    )
+
+
+BibliographicItem =
+     attribute id { xsd:ID },
+     attribute type { "article" | "book" | "booklet" | "conference" | "manual" |
+                      "proceedings" | "presentation" | "thesis" | "techreport" |
+                      "standard" | "unpublished" }?,
+    (bname | formatted), source?, publishdate?, docidentifier*, accesseddate?, creator*,
+    publisher*, edition?,
+    biblionote*, partof*, creationdate?, language*, script*, abstract?
+
+
+# }
+
+

data/lib/asciidoctor/iso/lists.rb

@@ -2,156 +2,199 @@ require "pp"
 module Asciidoctor
   module ISO
     module Lists
+      def li(xml_ul, item)
+        xml_ul.li do |xml_li|
+          style(item, item.text)
+          if item.blocks?
+            xml_li.p **id_attr(item) do |t|
+              t << item.text 
+            end
+            xml_li << item.content
+          else
+            xml_li.p **id_attr(item) do |p|
+              p << item.text 
+            end
+          end
+        end
+      end
+
       def ulist(node)
-        return norm_ref(node) if $norm_ref
-        return biblio_ref(node) if $biblio
+        return reference(node, true) if in_norm_ref
+        return reference(node, false) if in_biblio
         noko do |xml|
-          xml.ul **attr_code(anchor: node.id) do |xml_ul|
+          xml.ul **id_attr(node) do |xml_ul|
             node.items.each do |item|
-              xml_ul.li **attr_code(anchor: item.id) do |xml_li|
-                if item.blocks?
-                  xml_li.p { |t| t << item.text }
-                  xml_li << item.content
-                else
-                  xml_li.p { |p| p << item.text }
-                end
-              end
+              li(xml_ul, item)
             end
           end
-        end.join
+        end.join("\n")
+      end
+
+      def iso_publisher(t)
+        t.publisher **{ role: "publisher" } do |p|
+          p.affiliation do |aff|
+            aff.name "ISO"
+          end
+        end
       end
 
       def isorefmatches(xml, matched)
-        ref_attributes = {
-          anchor: matched[:anchor],
-        }
-        xml.iso_ref_title **attr_code(ref_attributes) do |t|
-          t.isocode matched[:code]
-          t.isodate matched[:year] if matched[:year]
-          t.isotitle { |i| i << ref_normalise(matched[:text]) }
+        ref_attributes = { id: matched[:anchor], type: "standard" }
+        xml.bibitem **attr_code(ref_attributes) do |t|
+          t.name { |i| i << ref_normalise(matched[:text]) }
+          t.publishDate matched[:year] if matched[:year]
+          t.docidentifier matched[:code]
+          iso_publisher(t)
         end
       end
 
-      def isorefmatches2(xml, matched2)
-        ref_attributes = {
-          anchor: matched2[:anchor],
-        }
-        xml.iso_ref_title **attr_code(ref_attributes) do |t|
-          t.isocode matched2[:code]
-          t.isodate "--"
-          t.date_footnote matched2[:fn]
-          t.isotitle { |i| i << ref_normalise(matched2[:text]) }
+      def isorefmatches2(xml, matched)
+        ref_attributes = { id: matched[:anchor], type: "standard" }
+        xml.bibitem **attr_code(ref_attributes) do |t|
+          t.name { |i| i << ref_normalise(matched[:text]) }
+          t.publishDate "--"
+          t.docidentifier matched[:code]
+          iso_publisher(t)
+          t.note { |p| p << "ISO DATE: #{matched[:fn]}" }
+        end
+      end
+
+      def isorefmatches3(xml, matched)
+        ref_attributes = { id: matched[:anchor], type: "standard" }
+        xml.bibitem **attr_code(ref_attributes) do |t|
+          t.name { |i| i << ref_normalise(matched[:text]) }
+          t.publishDate matched[:year] if matched[:year]
+          t.docidentifier "#{matched[:code]}:All Parts"
+          iso_publisher(t)
+        end
+      end
+
+      def refitem(xml, item, node)
+        m = NON_ISO_REF.match item
+        if m.nil? then Utils::warning(node, "no anchor on reference", item)
+        else
+          xml.bibitem **attr_code(id: m[:anchor]) do |t|
+            t.formatted { |i| i << ref_normalise_no_format(m[:text]) }
+            code = m[:code]
+            code = "[#{code}]" if /^\d+$?/.match? code
+            t.docidentifier code
+          end
         end
       end
 
       def ref_normalise(ref)
-        ref.gsub(/&#8201;&#8212;&#8201;/, " -- ").
+        ref.
+          # gsub(/&#8201;&#8212;&#8201;/, " -- ").
+          gsub(/&amp;amp;/, "&amp;").
+          gsub(%r{^<em>(.*)</em>}, "\\1")
+      end
+
+      def ref_normalise_no_format(ref)
+        ref.
+          # gsub(/&#8201;&#8212;&#8201;/, " -- ").
           gsub(/&amp;amp;/, "&amp;")
       end
 
-      def norm_ref(node)
-        noko do |xml|
-          node.items.each do |item|
-            matched = %r{^<ref\sanchor="(?<anchor>[^"]+)">
-            \[ISO\s(?<code>[0-9-]+)(:(?<year>[0-9]+))?\]</ref>,?\s
-            (?<text>.*)$}x.match item.text
-            matched2 = %r{^<ref\sanchor="(?<anchor>[^"]+)">
-            \[ISO\s(?<code>[0-9-]+):--\]</ref>,?\s?
-            <fn>(?<fn>[^\]]+)</fn>,?\s?(?<text>.*)$}x.match item.text
-            if matched2.nil?
-              if matched.nil?
-                warn %(asciidoctor: WARNING (#{current_location(node)}): normative reference not in expected format: #{item.text})
-              else
-                isorefmatches(xml, matched)
-              end
-            else
-              isorefmatches2(xml, matched2)
-            end
-          end
-        end.join
+      ISO_REF = %r{^<ref\sid="(?<anchor>[^"]+)">
+      \[ISO\s(?<code>[0-9-]+)(:(?<year>[0-9]+))?\]</ref>,?\s
+      (?<text>.*)$}xm
+
+      ISO_REF_NO_YEAR = %r{^<ref\sid="(?<anchor>[^"]+)">
+      \[ISO\s(?<code>[0-9-]+):--\]</ref>,?\s?
+      <fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>,?\s?(?<text>.*)$}xm
+
+      ISO_REF_ALL_PARTS = %r{^<ref\sid="(?<anchor>[^"]+)">
+      \[ISO\s(?<code>[0-9]+)\s\(all\sparts\)\]</ref>(<p>)?,?\s?
+      (?<text>.*)(</p>)?$}xm
+
+      NON_ISO_REF = %r{^<ref\sid="(?<anchor>[^"]+)">
+      \[(?<code>[^\]]+)\]</ref>,?\s
+      (?<text>.*)$}xm
+
+      def reference1(node, item, xml, normative)
+        matched = ISO_REF.match item
+        matched2 = ISO_REF_NO_YEAR.match item
+        matched3 = ISO_REF_ALL_PARTS.match item
+        if matched3.nil? && matched2.nil? && matched.nil?
+          refitem(xml, item, node)
+        elsif !matched.nil? then isorefmatches(xml, matched)
+        elsif !matched2.nil? then isorefmatches2(xml, matched2)
+        elsif !matched3.nil? then isorefmatches3(xml, matched3)
+        end
+        if matched3.nil? && matched2.nil? && matched.nil? && normative
+          Utils::warning(node, 
+                         "non-ISO/IEC reference not expected as normative",
+                         item)
+        end
       end
 
-      def biblio_ref(node)
+      def reference(node, normative)
         noko do |xml|
           node.items.each do |item|
-            matched = %r{^<ref\sanchor="(?<anchor>[^"]+)">
-            \[ISO\s(?<code>[0-9-]+)(:(?<year>[0-9]+))?\]</ref>,?\s
-            (?<text>.*)$}.match item.text
-            matched2 = %r{^<ref\sanchor="(?<anchor>[^"]+)">
-            \[ISO\s(?<code>[0-9-]+):--\]</ref>,?\s?
-            <fn>(?<fn>[^\]]+)</fn>,?\s?(?<text>.*)$}.match item.text
-            if matched2.nil?
-              if matched.nil?
-                xml.reference do |t|
-                  t.p { |p| p << ref_normalise(item.text) }
-                end
-              else
-                isorefmatches(xml, matched)
-              end
-            else
-              isorefmatches2(xml, matched2)
-            end
+            reference1(node, item.text, xml, normative)
           end
-        end.join
+        end.join("\n")
+      end
+
+      def olist_style(style)
+        return "alphabet" if style == "loweralpha"
+        return "roman" if style == "lowerroman"
+        return "roman_upper" if style == "upperroman"
+        return "alphabet_upper" if style == "upperalpha"
+        return style
       end
 
       def olist(node)
         noko do |xml|
-          xml.ol **attr_code(anchor: node.id, type: node.style) do |xml_ol|
-            node.items.each do |item|
-              xml_ol.li **attr_code(anchor: item.id) do |xml_li|
-                if item.blocks?
-                  xml_li.p { |t| t << item.text }
-                  xml_li << item.content
-                else
-                  xml_li.p { |p| p << item.text }
-                end
-              end
-            end
+          xml.ol **attr_code(id: Utils::anchor_or_uuid(node),
+                             type: olist_style(node.style)) do |xml_ol|
+            node.items.each { |item| li(xml_ol, item) }
+          end
+        end.join("\n")
+      end
+
+      def dt(terms, xml_dl)
+        terms.each_with_index do |dt, idx|
+          style(dt, dt.text)
+          xml_dl.dt { |xml_dt| xml_dt << dt.text }
+          if idx < terms.size - 1
+            xml_dl.dd
           end
-        end.join
+        end
+      end
+
+      def dd(dd, xml_dl)
+        if dd.nil?
+          xml_dl.dd
+          return
+        end
+        xml_dl.dd do |xml_dd|
+          style(dd, dd.text)
+          xml_dd.p { |t| t << dd.text } if dd.text?
+          xml_dd << dd.content if dd.blocks?
+        end
       end
 
       def dlist(node)
         noko do |xml|
-          xml.dl **attr_code(anchor: node.id) do |xml_dl|
+          xml.dl **id_attr(node) do |xml_dl|
             node.items.each do |terms, dd|
-              terms.each_with_index do |dt, idx|
-                xml_dl.dt { |xml_dt| xml_dt << dt.text }
-                if idx < terms.size - 1
-                  xml_dl.dd
-                end
-              end
-
-              if dd.nil?
-                xml_dl.dd
-              else
-                xml_dl.dd do |xml_dd|
-                  if dd.blocks?
-                    if dd.text?
-                      xml_dd.p { |t| t << dd.text }
-                    end
-                    xml_dd << dd.content
-                  else
-                    xml_dd.p { |t| t << dd.text }
-                  end
-                end
-              end
+              dt(terms, xml_dl)
+              dd(dd, xml_dl)
             end
           end
-        end.join
+        end.join("\n")
       end
 
       def colist(node)
         noko do |xml|
-          xml.colist **attr_code(anchor: node.id) do |xml_ul|
-            node.items.each_with_index do |item, i|
-              xml_ul.annotation **attr_code(id: i + 1) do |xml_li|
-                xml_li << item.text
-              end
+          node.items.each_with_index do |item, i|
+            xml_ul.annotation **attr_code(id: i + 1) do |xml_li|
+              style(item, item.text)
+              xml_li.p { |p| p << item.text }
             end
           end
-        end.join
+        end.join("\n")
       end
     end
   end