metanorma-standoc 0.0.1

data/lib/asciidoctor/standoc/table.rb

@@ -0,0 +1,61 @@
+module Asciidoctor
+  module Standoc
+    module Table
+      def table_attrs(node)
+        { id: Utils::anchor_or_uuid(node),
+          headerrows: node.attr("headerrows") }
+      end
+
+      def table(node)
+        @table_fn_number = "a"
+        noko do |xml|
+          xml.table **attr_code(table_attrs(node)) do |xml_table|
+            table_name(node, xml_table)
+            %i(head body foot).reject do |tblsec|
+              node.rows[tblsec].empty?
+            end
+            table_head_body_and_foot node, xml_table
+          end
+        end
+      end
+
+      private
+
+      def table_name(node, xml_table)
+        if node.title?
+          xml_table.name node.title
+        end
+      end
+
+      def table_cell1(cell, thd)
+        if cell.style == :asciidoc
+          thd << cell.content
+        else
+          thd << cell.text
+        end
+      end
+
+      def table_cell(c, xml_tr, tblsec)
+        cell_attributes = { id: c.id, colspan: c.colspan,
+                            rowspan: c.rowspan, align: c.attr("halign") }
+        cell_tag = "td"
+        cell_tag = "th" if tblsec == :head || c.style == :header
+        xml_tr.send cell_tag, **attr_code(cell_attributes) do |thd|
+          table_cell1(c, thd)
+        end
+      end
+
+      def table_head_body_and_foot(node, xml)
+        %i(head body foot).reject { |s| node.rows[s].empty? }.each do |s|
+          xml.send "t#{s}" do |xml_tblsec|
+            node.rows[s].each do |row|
+              xml_tblsec.tr do |xml_tr|
+                row.each { |cell| table_cell(cell, xml_tr, s) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/utils.rb

@@ -0,0 +1,121 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "json"
+require "pathname"
+require "open-uri"
+require "uuidtools"
+require "pp"
+
+module Asciidoctor
+  module Standoc
+    module Utils
+      class << self
+        def anchor_or_uuid(node = nil)
+          uuid = UUIDTools::UUID.random_create
+          node.nil? || node.id.nil? || node.id.empty? ? "_" + uuid : node.id
+        end
+
+        def current_location(n)
+          return "Line #{n.lineno}" if n.respond_to?(:lineno) &&
+            !n.lineno.nil? && !n.lineno.empty?
+          return "Line #{n.line}" if n.respond_to?(:line) &&
+            !n.line.nil?
+          return "ID #{n.id}" if n.respond_to?(:id) && !n.id.nil?
+          while !n.nil? &&
+              (!n.respond_to?(:level) || n.level.positive?) &&
+              (!n.respond_to?(:context) || n.context != :section)
+            n = n.parent
+            return "Section: #{n.title}" if n&.respond_to?(:context) &&
+              n&.context == :section
+          end
+          "??"
+        end
+
+        def warning(node, msg, text)
+          return if @novalid
+          warntext = "asciidoctor: WARNING"\
+            "(#{current_location(node)}): #{msg}"
+          warntext += ": #{text}" if text
+          warn warntext
+        end
+
+        def flatten_rawtext_lines(node, result)
+          node.lines.each do |x|
+            if node.respond_to?(:context) && (node.context == :literal ||
+                node.context == :listing)
+              result << x.gsub(/</, "&lt;").gsub(/>/, "&gt;")
+            else
+              # strip not only HTML <tag>, and Asciidoc xrefs <<xref>>
+              result << x.gsub(/<[^>]*>+/, "")
+            end
+          end
+          result
+        end
+
+        # if node contains blocks, flatten them into a single line;
+        # and extract only raw text
+        def flatten_rawtext(node)
+          result = []
+          if node.respond_to?(:blocks) && node.blocks?
+            node.blocks.each { |b| result << flatten_rawtext(b) }
+          elsif node.respond_to?(:lines)
+            result = flatten_rawtext_lines(node, result)
+          elsif node.respond_to?(:text)
+            result << node.text.gsub(/<[^>]*>+/, "")
+          else
+            result << node.content.gsub(/<[^>]*>+/, "")
+          end
+          result.reject(&:empty?)
+        end
+      end
+
+      def convert(node, transform = nil, opts = {})
+        transform ||= node.node_name
+        opts.empty? ? (send transform, node) : (send transform, node, opts)
+      end
+
+      def document_ns_attributes(_doc)
+        nil
+      end
+
+      NOKOHEAD = <<~HERE.freeze
+          <!DOCTYPE html SYSTEM
+          "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+          <html xmlns="http://www.w3.org/1999/xhtml">
+          <head> <title></title> <meta charset="UTF-8" /> </head>
+          <body> </body> </html>
+      HERE
+
+      # block for processing XML document fragments as XHTML,
+      # to allow for HTMLentities
+      def noko(&block)
+        doc = ::Nokogiri::XML.parse(NOKOHEAD)
+        fragment = doc.fragment("")
+        ::Nokogiri::XML::Builder.with fragment, &block
+        fragment.to_xml(encoding: "US-ASCII").lines.map do |l|
+          l.gsub(/\s*\n/, "")
+        end
+      end
+
+      def attr_code(attributes)
+        attributes = attributes.reject { |_, val| val.nil? }.map
+        attributes.map do |k, v|
+          [k, (v.is_a? String) ? HTMLEntities.new.decode(v) : v]
+        end.to_h
+      end
+
+      # if the contents of node are blocks, output them to out;
+      # else, wrap them in <p>
+      def wrap_in_para(node, out)
+        if node.blocks? then out << node.content
+        else
+          out.p { |p| p << node.content }
+        end
+      end
+
+      SUBCLAUSE_XPATH = "//clause[ancestor::clause or ancestor::annex or "\
+        "ancestor::introduction]".freeze
+    end
+  end
+end

data/lib/asciidoctor/standoc/validate.rb

@@ -0,0 +1,65 @@
+require "asciidoctor/standoc/utils"
+require_relative "./validate_section.rb"
+require "nokogiri"
+require "jing"
+require "pp"
+require "iev"
+
+module Asciidoctor
+  module Standoc
+    module Validate
+
+      SOURCELOCALITY = ".//locality[@type = 'clause']/referenceFrom".freeze
+
+      def iev_validate(xmldoc)
+        xmldoc.xpath("//term").each do |t|
+          /^IEV($|\s|:)/.match(t&.at(".//origin/@citeas")&.text) or next
+          pref = t.xpath("./preferred").inject([]) { |m, x| m << x&.text&.downcase }
+          locality = t.xpath(SOURCELOCALITY)&.text or next
+          iev = @iev.fetch(locality, xmldoc&.at("//language")&.text || "en") or next
+          pref.include?(iev.downcase) or
+            warn %(Term "#{pref[0]}" does not match IEV #{locality} "#{iev}")
+        end
+      end
+
+      def content_validate(doc)
+        section_validate(doc)
+        iev_validate(doc.root)
+      end
+
+      def schema_validate(doc, filename)
+        File.open(".tmp.xml", "w:UTF-8") { |f| f.write(doc.to_xml) }
+        begin
+          errors = Jing.new(filename).validate(".tmp.xml")
+        rescue Jing::Error => e
+          abort "what what what #{e}"
+        end
+        warn "Valid!" if errors.none?
+        errors.each do |error|
+          warn "#{error[:message]} @ #{error[:line]}:#{error[:column]}"
+        end
+      end
+
+      # RelaxNG cannot cope well with wildcard attributes. So we strip
+      # any attributes from FormattedString instances (which can contain
+      # xs:any markup, and are signalled with @format) before validation.
+      def formattedstr_strip(doc)
+        doc.xpath("//*[@format]").each do |n|
+          n.elements.each do |e|
+            e.traverse do |e1|
+              next unless e1.element?
+              e1.each { |k, _v| e.delete(k) }
+            end
+          end
+        end
+        doc
+      end
+
+      def validate(doc)
+        content_validate(doc)
+        schema_validate(formattedstr_strip(doc.dup),
+                        File.join(File.dirname(__FILE__), "isodoc.rng"))
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/validate_section.rb

@@ -0,0 +1,42 @@
+require "nokogiri"
+
+module Asciidoctor
+  module Standoc
+    module Validate
+      def section_validate(doc)
+        sourcecode_style(doc.root)
+        asset_style(doc.root)
+      end
+
+      def sourcecode_style(root)
+        root.xpath("//sourcecode").each do |x|
+          callouts = x.elements.select { |e| e.name == "callout" }
+          annotations = x.elements.select { |e| e.name == "annotation" }
+          if callouts.size != annotations.size
+            warn "#{x['id']}: mismatch of callouts and annotations"
+          end
+        end
+      end
+
+      def style_warning(node, msg, text)
+        return if @novalid
+        w = "ISO style: WARNING (#{Utils::current_location(node)}): #{msg}"
+        w += ": #{text}" if text
+        warn w
+      end
+
+      def asset_title_style(root)
+        root.xpath("//figure[image][not(title)]").each do |node|
+          style_warning(node, "Figure should have title", nil)
+        end
+        root.xpath("//table[not(title)]").each do |node|
+          style_warning(node, "Table should have title", nil)
+        end
+      end
+
+      def asset_style(root)
+        asset_title_style(root)
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/version.rb

@@ -0,0 +1,5 @@
+module Metanorma
+  module Standoc
+    VERSION = "0.0.1".freeze
+  end
+end

data/lib/metanorma-standoc.rb

@@ -0,0 +1,9 @@
+require "asciidoctor" unless defined? Asciidoctor::Converter
+require_relative "asciidoctor/standoc/converter"
+require_relative "asciidoctor/standoc/version"
+require "asciidoctor/extensions"
+
+if defined? Metanorma
+  require_relative "metanorma/standoc"
+  Metanorma::Registry.instance.register(Metanorma::Standoc::Processor)
+end

data/lib/metanorma/standoc.rb

@@ -0,0 +1,7 @@
+require_relative "./standoc/processor"
+
+module Metanorma
+  module Standoc
+
+  end
+end

data/lib/metanorma/standoc/processor.rb

@@ -0,0 +1,40 @@
+require "metanorma/processor"
+
+module Metanorma
+  module Standoc
+    class Processor < Metanorma::Processor
+
+      def initialize
+        @short = :standoc
+        @input_format = :asciidoc
+        @asciidoctor_backend = :standoc
+      end
+
+      def output_formats
+        super.merge(
+          html: "html",
+          doc: "doc"
+        )
+      end
+
+      def version
+        "Asciidoctor::Standoc #{Metanorma::Standoc::VERSION}/IsoDoc #{IsoDoc::VERSION}"
+      end
+
+      def input_to_isodoc(file)
+        Metanorma::Input::Asciidoc.new.process(file, @asciidoctor_backend)
+      end
+
+      def output(isodoc_node, outname, format, options={})
+        case format
+        when :html
+          IsoDoc::HtmlConvert.new(options).convert(outname, isodoc_node)
+        when :doc
+          IsoDoc::WordConvert.new(options).convert(outname, isodoc_node)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/metanorma-standoc.gemspec

@@ -0,0 +1,47 @@
+# coding: utf-8
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "asciidoctor/standoc/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "metanorma-standoc"
+  spec.version       = Metanorma::Standoc::VERSION
+  spec.authors       = ["Ribose Inc."]
+  spec.email         = ["open.source@ribose.com"]
+
+  spec.summary       = "metanorma-standoc realises standards following the Metanorma standoc model"
+  spec.description   = <<~DESCRIPTION
+    metanorma-standoc realises standards following the Metanorma standoc model
+
+    This gem is in active development.
+  DESCRIPTION
+
+  spec.homepage      = "https://github.com/riboseinc/metanorma-standoc"
+  spec.license       = "BSD-2-Clause"
+
+  spec.bindir        = "bin"
+  spec.require_paths = ["lib"]
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.add_dependency "asciidoctor", "~> 1.5.7"
+  spec.add_dependency "ruby-jing"
+  spec.add_dependency "isodoc", ">= 0.8"
+  spec.add_dependency "iev", "~> 0.2.0"
+  spec.add_dependency "relaton", "~> 0.1.3"
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "equivalent-xml", "~> 0.6"
+  spec.add_development_dependency "guard", "~> 2.14"
+  spec.add_development_dependency "guard-rspec", "~> 4.7"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "rspec", "~> 3.6"
+  spec.add_development_dependency "rubocop", "~> 0.50"
+  spec.add_development_dependency "simplecov", "~> 0.15"
+  spec.add_development_dependency "timecop", "~> 0.9"
+  spec.add_development_dependency "metanorma", "~> 0.2.6"
+  spec.add_development_dependency "isobib", "~> 0.2.0"
+end

data/spec/asciidoctor-standoc/base_spec.rb

@@ -0,0 +1,271 @@
+require "spec_helper"
+
+RSpec.describe Asciidoctor::Standoc do
+  it "has a version number" do
+    expect(Metanorma::Standoc::VERSION).not_to be nil
+  end
+
+  it "processes a blank document" do
+    expect(Asciidoctor.convert(<<~"INPUT", backend: :standoc, header_footer: true)).to be_equivalent_to <<~"OUTPUT"
+    #{ASCIIDOC_BLANK_HDR}
+    INPUT
+    #{BLANK_HDR}
+<sections/>
+</standard-document>
+    OUTPUT
+  end
+
+  it "converts a blank document" do
+    system "rm -f test.doc"
+    expect(Asciidoctor.convert(<<~"INPUT", backend: :standoc, header_footer: true)).to be_equivalent_to <<~"OUTPUT"
+      = Document title
+      Author
+      :docfile: test.adoc
+      :novalid:
+    INPUT
+    #{BLANK_HDR}
+<sections/>
+</standard-document>
+    OUTPUT
+    expect(File.exist?("test.doc")).to be true
+    expect(File.exist?("htmlstyle.css")).to be false
+  end
+
+  it "processes default metadata" do
+    expect(Asciidoctor.convert(<<~"INPUT", backend: :standoc, header_footer: true)).to be_equivalent_to <<~'OUTPUT'
+      = Document title
+      Author
+      :docfile: test.adoc
+      :nodoc:
+      :novalid:
+      :docnumber: 1000
+      :partnumber: 1
+      :edition: 2
+      :revdate: 2000-01-01
+      :draft: 3.4
+      :technical-committee: TC
+      :technical-committee-number: 1
+      :technical-committee-type: A
+      :subcommittee: SC
+      :subcommittee-number: 2
+      :subcommittee-type: B
+      :workgroup: WG
+      :workgroup-number: 3
+      :workgroup-type: C
+      :secretariat: SECRETARIAT
+      :copyright-year: 2001
+      :docstage: 10
+      :docsubstage: 20
+      :iteration: 3
+      :language: en
+      :title-intro-en: Introduction
+      :title-main-en: Main Title -- Title
+      :title-part-en: Title Part
+      :title-intro-fr: Introduction Française
+      :title-main-fr: Titre Principal
+      :title-part-fr: Part du Titre
+      :library-ics: 1,2,3
+    INPUT
+    <?xml version="1.0" encoding="UTF-8"?>
+<standard-document xmlns="http://riboseinc.com/isoxml">
+<bibdata type="article">
+
+  <docidentifier>
+    <project-number part="1"> 1000</project-number>
+  </docidentifier>
+  <language>en</language>
+  <script>Latn</script>
+  <status format="plain">published</status>
+  <copyright>
+    <from>2001</from>
+  </copyright>
+  <editorialgroup>
+    <technical-committee number="1" type="A">TC</technical-committee>
+  </editorialgroup>
+  <ics>
+    <code>1</code>
+  </ics>
+  <ics>
+    <code>2</code>
+  </ics>
+  <ics>
+    <code>3</code>
+  </ics>
+</bibdata><version>
+  <edition>2</edition>
+  <revision-date>2000-01-01</revision-date>
+  <draft>3.4</draft>
+</version>
+<sections/>
+</standard-document>
+    OUTPUT
+  end
+
+
+  it "processes complex metadata" do
+    expect(Asciidoctor.convert(<<~"INPUT", backend: :standoc, header_footer: true)).to be_equivalent_to <<~'OUTPUT'
+      = Document title
+      Author
+      :docfile: test.adoc
+      :nodoc:
+      :novalid:
+      :docnumber: 1000
+      :partnumber: 1-1
+      :tc-docnumber: 2000
+      :language: el
+      :script: Grek
+      :publisher: IEC,IETF,ISO
+    INPUT
+           <?xml version="1.0" encoding="UTF-8"?>
+       <standard-document xmlns="http://riboseinc.com/isoxml">
+       <bibdata type="article">
+
+         <docidentifier>
+           <project-number part="1" subpart="1">ISO/IEC/IETF 1000</project-number>
+         </docidentifier>
+         <contributor>
+           <role type="author"/>
+           <organization>
+             <name>IEC</name>
+           </organization>
+         </contributor>
+         <contributor>
+           <role type="author"/>
+           <organization>
+             <name>IETF</name>
+           </organization>
+         </contributor>
+         <contributor>
+           <role type="author"/>
+           <organization>
+             <name>ISO</name>
+           </organization>
+         </contributor>
+         <contributor>
+           <role type="publisher"/>
+           <organization>
+             <name>IEC</name>
+           </organization>
+         </contributor>
+         <contributor>
+           <role type="publisher"/>
+           <organization>
+             <name>IETF</name>
+           </organization>
+         </contributor>
+         <contributor>
+           <role type="publisher"/>
+           <organization>
+             <name>ISO</name>
+           </organization>
+         </contributor>
+         <language>el</language>
+         <script>Grek</script>
+         <status format="plain">published</status>
+         <copyright>
+           <from>2018</from>
+           <owner>
+             <organization>
+               <name>IEC</name>
+             </organization>
+           </owner>
+         </copyright>
+         <copyright>
+           <from>2018</from>
+           <owner>
+             <organization>
+               <name>IETF</name>
+             </organization>
+           </owner>
+         </copyright>
+         <copyright>
+           <from>2018</from>
+           <owner>
+             <organization>
+               <name>ISO</name>
+             </organization>
+           </owner>
+         </copyright>
+         <editorialgroup>
+           <technical-committee/>
+         </editorialgroup>
+       </bibdata>
+       <sections/>
+       </standard-document>
+    OUTPUT
+  end
+
+  it "reads scripts into blank HTML document" do
+    system "rm -f test.html"
+    Asciidoctor.convert(<<~"INPUT", backend: :standoc, header_footer: true)
+      = Document title
+      Author
+      :docfile: test.adoc
+      :novalid:
+    INPUT
+    html = File.read("test.html", encoding: "utf-8")
+    expect(html).to match(%r{<script>})
+  end
+
+  it "uses default fonts" do
+    system "rm -f test.html"
+    Asciidoctor.convert(<<~"INPUT", backend: :standoc, header_footer: true)
+      = Document title
+      Author
+      :docfile: test.adoc
+      :novalid:
+    INPUT
+    html = File.read("test.html", encoding: "utf-8")
+    expect(html).to match(%r[\.Sourcecode[^{]+\{[^{]+font-family: "Courier New", monospace;]m)
+    expect(html).to match(%r[blockquote[^{]+\{[^{]+font-family: "Cambria", serif;]m)
+    expect(html).to match(%r[\.h2Annex[^{]+\{[^{]+font-family: "Cambria", serif;]m)
+  end
+
+  it "uses default fonts for alt doc" do
+    system "rm -f test_alt.html"
+    Asciidoctor.convert(<<~"INPUT", backend: :standoc, header_footer: true)
+      = Document title
+      Author
+      :docfile: test.adoc
+      :novalid:
+    INPUT
+    html = File.read("test_alt.html", encoding: "utf-8")
+    expect(html).to match(%r[\.Sourcecode[^{]+\{[^{]+font-family: "Space Mono", monospace;]m)
+    expect(html).to match(%r[blockquote[^{]+\{[^{]+font-family: "Lato", sans-serif;]m)
+    expect(html).to match(%r[\.h2Annex[^{]+\{[^{]+font-family: "Lato", sans-serif;]m)
+  end
+
+  it "uses Chinese fonts" do
+    system "rm -f test.html"
+    Asciidoctor.convert(<<~"INPUT", backend: :standoc, header_footer: true)
+      = Document title
+      Author
+      :docfile: test.adoc
+      :novalid:
+      :script: Hans
+    INPUT
+    html = File.read("test.html", encoding: "utf-8")
+    expect(html).to match(%r[\.Sourcecode[^{]+\{[^{]+font-family: "Courier New", monospace;]m)
+    expect(html).to match(%r[blockquote[^{]+\{[^{]+font-family: "SimSun", serif;]m)
+    expect(html).to match(%r[\.h2Annex[^{]+\{[^{]+font-family: "SimHei", sans-serif;]m)
+  end
+
+  it "uses specified fonts" do
+    system "rm -f test.html"
+    Asciidoctor.convert(<<~"INPUT", backend: :standoc, header_footer: true)
+      = Document title
+      Author
+      :docfile: test.adoc
+      :novalid:
+      :script: Hans
+      :body-font: Zapf Chancery
+      :header-font: Comic Sans
+      :monospace-font: Andale Mono
+    INPUT
+    html = File.read("test.html", encoding: "utf-8")
+    expect(html).to match(%r[\.Sourcecode[^{]+\{[^{]+font-family: Andale Mono;]m)
+    expect(html).to match(%r[blockquote[^{]+\{[^{]+font-family: Zapf Chancery;]m)
+    expect(html).to match(%r[\.h2Annex[^{]+\{[^{]+font-family: Comic Sans;]m)
+  end
+
+end