metanorma-document 0.5.1 → 0.5.2.pre.alpha.1

data/lib/metanorma/html/templates/_agency_cover.html.liquid

@@ -0,0 +1,30 @@
+<div class="title-section">
+{% if cover.cover_security or cover.cover_recipient %}
+  {% comment %} Agency layout: title band, docinfo table. {% endcomment %}
+  {% if title %}
+    <div class="cover-title"><span>{{ title | escape }}</span></div>
+  {% endif %}
+  {% if cover.cover_stage_display %}
+    <p class="cover-stage">{{ cover.cover_stage_display | escape }}</p>
+  {% endif %}
+  {% if cover.cover_publisher_name %}
+    <p class="cover-publisher">{{ cover.cover_publisher_name | escape }}</p>
+  {% endif %}
+  <p class="cover-band">{{ cover.cover_doctype_label | escape }} • {{ cover.cover_primary_docidentifier | escape }} {{ title | escape }} {{ cover.cover_publisher_name | escape }}</p>
+  <p class="cover-doc-year">{{ cover.cover_copyright_year | escape }}</p>
+  <p class="cover-committee">{{ cover.cover_committee_name | escape }}</p>
+  <p class="cover-publisher">{{ cover.cover_publisher_name | escape }}</p>
+  <div class="cover-docinfo">
+    <p>{{ cover.cover_doctype_label | escape }}</p>
+    <p>{{ cover.cover_stage_display | escape }}</p>
+    <p>{{ cover.revdate | escape }}</p>
+    <p>Classification: {{ cover.cover_security | escape }}</p>
+    <p>Recipient: {{ cover.cover_recipient | escape }}</p>
+    <p>© {{ cover.cover_copyright_owner | escape }} {{ cover.cover_copyright_year | escape }}</p>
+  </div>
+{% else %}
+  {% comment %} Publisher layout: title, doctype label, docid, stage. {% endcomment %}
+  <p class="cover-docid-band">{{ title | escape }} • {{ title | escape }} {{ cover.cover_doctype_label | escape }} : {{ cover.cover_primary_docidentifier | escape }} - {{ cover.cover_stage_display | escape }}</p>
+{% endif %}
+</div>
+<hr class="cover-separator" />

data/lib/metanorma/html/templates/_columnbreak.html.liquid

@@ -0,0 +1 @@
+<span class="column-break"></span>

data/lib/metanorma/html/templates/_cover.html.liquid

@@ -7,5 +7,8 @@
     <span class="subtitle">{{ title | escape }}</span>
   </div></div>
 {% endif %}
+{% if tc_html %}{{ tc_html }}{% endif %}
+{% if stage_html %}{{ stage_html }}{% endif %}
 </div>
+{% if dates_html %}<div class="coverpage-dates">{{ dates_html }}</div>{% endif %}
 <hr class="cover-separator" />

data/lib/metanorma/html/templates/_main_content.html.liquid

@@ -1 +1 @@
-<main class="main-section">{{ content }}</main>
+<main class="main-section"><button onclick="topFunction()" id="myBtn" title="Go to top">Top</button>{{ content }}</main>

data/lib/metanorma/html/templates/_ruby.html.liquid

@@ -0,0 +1 @@
+<ruby{% if id %} id="{{ id }}"{% endif %}>{{ base }}{% if annotation %}<rt>{{ annotation }}</rt>{% endif %}</ruby>

data/lib/metanorma/html/templates/_sourcecode.html.liquid

@@ -1,4 +1,5 @@
-<div{% if block.id %} id="{{ block.id }}"{% endif %} class="{{ block.css_class }}">
-{% if block.name_html %}<p class="code-name">{{ block.name_html }}</p>{% endif %}
+<figure{% if block.id %} id="{{ block.id }}"{% endif %} class="{{ block.css_class }}" spellcheck="false" translation="no">
 <pre><code{% if block.lang %} lang="{{ block.lang }}"{% endif %}>{{ block.code_html }}</code></pre>
-</div>
+{% if block.annotations_html %}<pre class="sourcecode"><div class="figdl"><p class="ListTitle">Key</p><dl>{{ block.annotations_html }}</dl></div></pre>{% endif %}
+{% if block.name_html %}<figcaption>{{ block.name_html }}</figcaption>{% endif %}
+</figure>

data/lib/metanorma/html/templates/_standard_cover.html.liquid

@@ -14,17 +14,68 @@
 {% if pub_date %}
   <p class="cover-date">{{ pub_date | escape }}</p>
 {% endif %}
+{% comment %} Cover identity block, laid out like the isodoc titlepage.
+  The flavor passes its bibdata model as `cover`; the model's lutaml-model
+  auto-Drop (plus its `liquid` mappings) serves every fact. The title
+  precedes the identity lines so the cover reads like the native
+  "title • docnumber (draft …) edition Date: …" sequence. {% endcomment %}
+{% if title %}
+  <div class="cover-title"><span>{{ title | escape }}</span></div>
+{% endif %}
+{% if cover.tc_docnumber.size > 0 %}
+  {% for num in cover.tc_docnumber %}
+  <p class="cover-doc-id">{{ num | escape }}</p>
+  {% endfor %}
+{% else %}
+  {% if cover.docnumber_undated %}
+  <p class="cover-doc-id">{{ cover.docnumber_undated | escape }}{% if cover.draftinfo %} {{ cover.draftinfo | escape }}{% endif %}</p>
+  {% elsif cover.draftinfo %}
+  <p class="cover-doc-id">{{ cover.draftinfo | escape }}</p>
+  {% endif %}
+{% endif %}
+{% if cover.edition_display %}
+  <p class="cover-doc-id">{{ cover.edition_display | escape }}</p>
+{% endif %}
+{% if cover.revdate %}
+  <p class="cover-doc-id">Date: {{ cover.revdate | escape }}</p>
+{% endif %}
+{% if cover.tc_docnumber.size > 0 %}
+  {% if cover.docnumber_undated %}
+  <p class="cover-doc-id">{{ cover.docnumber_undated | escape }}{% if cover.draftinfo %} {{ cover.draftinfo | escape }}{% endif %}</p>
+  {% elsif cover.draftinfo %}
+  <p class="cover-doc-id">{{ cover.draftinfo | escape }}</p>
+  {% endif %}
+{% endif %}
+{% if cover.editorialgroup %}
+  <p class="cover-doc-id">{{ cover.editorialgroup | escape }}</p>
+{% endif %}
+{% if cover.secretariat %}
+  <p class="cover-doc-id">Secretariat: {{ cover.secretariat | escape }}</p>
+{% endif %}
 </div>
 <div class="cover-body">
-{% if doctype %}
-  <p class="cover-doctype">{{ doctype | escape }}</p>
-{% endif %}
+{% comment %} Native titlepage order: display title, French title,
+  stage line, then ICS last. The doctype identity labels close the
+  column so they never split the native "… Date: <revdate> TC <title>
+  ICS:" cover band. {% endcomment %}
 {% if title %}
   <div class="cover-title"><span>{{ title | escape }}</span></div>
 {% endif %}
+{% if title_fr %}
+  <div class="cover-title-fr"><span>{{ title_fr | escape }}</span></div>
+{% endif %}
 {% if stage %}
   <div class="cover-stage"><p>{{ stage | escape }}</p></div>
 {% endif %}
+{% if cover.ics %}
+  <p class="cover-ics"><strong>ICS:</strong> {{ cover.ics | escape }}</p>
+{% endif %}
+{% if doctype %}
+  <p class="cover-doctype">{{ doctype | escape }}</p>
+{% endif %}
+{% if cover.ext.subdoctype %}
+  <p class="cover-docsubtype">Document subtype: {{ cover.ext.subdoctype | capitalize | escape }}</p>
+{% endif %}
 </div>
 </div>
 </div>

data/lib/metanorma/html.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "liquid"
+require "metanorma-core"
 require "nokogiri"
 
 module Metanorma
@@ -14,8 +15,7 @@ module Metanorma
     end
 
     autoload :BaseRenderer, "metanorma/html/base_renderer"
-    autoload :Flavor, "metanorma/html/flavor"
-    autoload :FlavorRegistry, "metanorma/html/flavor_registry"
+    autoload :Concerns, "metanorma/html/concerns"
     autoload :Generator, "metanorma/html/generator"
     autoload :RendererDelegation, "metanorma/html/renderer_delegation"
     autoload :Theme, "metanorma/html/theme"
@@ -23,18 +23,33 @@ module Metanorma
     autoload :Component, "metanorma/html/component"
     autoload :Drops, "metanorma/html/drops"
     autoload :StandardRenderer, "metanorma/html/standard_renderer"
-    autoload :IsoRenderer, "metanorma/html/iso_renderer"
-    autoload :BipmRenderer, "metanorma/html/bipm_renderer"
-    autoload :CcRenderer, "metanorma/html/cc_renderer"
-    autoload :CsaRenderer, "metanorma/html/csa_renderer"
-    autoload :IccRenderer, "metanorma/html/icc_renderer"
-    autoload :PdfaRenderer, "metanorma/html/pdfa_renderer"
-    autoload :IecRenderer, "metanorma/html/iec_renderer"
-    autoload :IeeeRenderer, "metanorma/html/ieee_renderer"
-    autoload :IetfRenderer, "metanorma/html/ietf_renderer"
-    autoload :IhoRenderer, "metanorma/html/iho_renderer"
-    autoload :ItuRenderer, "metanorma/html/itu_renderer"
-    autoload :OgcRenderer, "metanorma/html/ogc_renderer"
-    autoload :RiboseRenderer, "metanorma/html/ribose_renderer"
+
+    # This module is a pure format adapter over the central flavor
+    # registry (Metanorma.flavors). It contributes the HTML renderers
+    # for the two model trees the harness ships — that is the extent of
+    # its registration. Flavor gems register their own entries from
+    # their load paths; nothing here knows a flavor.
+    #
+    # Lazy: the registry exists only on the flavor-table line of
+    # metanorma-core. Requiring this gem must never depend on it —
+    # seeds on first render, no-op without it.
+    module_function
+
+    def seed_flavors!
+      return unless defined?(Metanorma::Core::Flavors)
+      return if @flavors_seeded
+
+      @flavors_seeded = true
+      Metanorma::Core::Flavors.register(Metanorma::Core::Flavor.new(
+                                          name: :document,
+                                          model_root: Metanorma::Document::Root,
+                                          renderers: { html: BaseRenderer },
+                                        ))
+      Metanorma::Core::Flavors.register(Metanorma::Core::Flavor.new(
+                                          name: :standoc,
+                                          model_root: "Metanorma::Standoc::Document::Root",
+                                          renderers: { html: StandardRenderer },
+                                        ))
+    end
   end
 end

data/tasks/flavors.rake

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "rbconfig"
+
+desc "Audit flavor repos: parse + HTML-generate presentation fixtures"
+task :flavors_audit do
+  flavors = (ENV["FLAVORS"] ||
+    "iso itu ogc iec iho bipm cc ribose bsi nist jis gb")
+    .split(/[\s,]+/).reject(&:empty?)
+  home = Dir.home
+  results = {}
+
+  flavors.each do |flavor|
+    dir = File.join(home, "src/mn/metanorma-#{flavor}")
+    results[flavor] = audit_flavor(flavor, dir)
+  end
+
+  results.each do |flavor, lines|
+    puts "== #{flavor}"
+    Array(lines).each { |l| puts "  #{l}" }
+  end
+end
+
+def audit_flavor(flavor, dir)
+  return ["NO_CHECKOUT #{dir}"] unless File.file?(File.join(dir, "Gemfile"))
+
+  fixtures = (Dir[File.join(dir, "spec/fixtures/**/*presentation*.xml")] +
+              Dir[File.join(dir, "**/*presentation*.xml")].reject do |f|
+                f.include?("spec/fixtures") || f.include?("node_modules")
+              end).uniq.first(2)
+  return ["NO_PRESENTATION_FIXTURE"] if fixtures.empty?
+
+  script = flavor_probe_script(flavor, dir, fixtures)
+  # The target repo's bundle is its own resolution: make sure it is
+  # installed, then run the probe through it.
+  gemfile = File.join(dir, "Gemfile")
+  # Scrub EVERY BUNDLE*/BUNDLER* var the invoking context leaks —
+  # BUNDLE_LOCKFILE/BUNDLER_VERSION silently hijack nested installs.
+  scrub = ["env",
+           *ENV.keys.select { |k| k.start_with?("BUNDLE") }
+             .flat_map { |k| ["-u", k] },
+           "-u", "RUBYOPT", "-u", "RUBYLIB",
+           "BUNDLE_GEMFILE=#{gemfile}"]
+  install_out, install_st = Open3.capture2e(*scrub, "bundle", "install",
+                                            chdir: dir)
+  unless install_st.success?
+    return ["BUNDLE_INSTALL_FAIL",
+            *install_out.lines.map(&:strip).reject(&:empty?).last(3)]
+  end
+  out, _st = Open3.capture2e(*scrub, "bundle", "exec", RbConfig.ruby,
+                             "-e", script, chdir: dir)
+  out.lines.map(&:strip).reject(&:empty?)
+rescue StandardError => e
+  ["PROBE_ERROR #{e.class}: #{e.message[0, 100]}"]
+end
+
+def flavor_probe_script(flavor, dir, fixtures)
+  <<~RUBY
+    flavor = #{flavor.inspect}
+    dir = #{dir.inspect}
+    require "metanorma-core"
+    begin
+      require "metanorma/\#{flavor}"
+    rescue LoadError => e
+      puts "LOAD_FAIL \#{e.message[0, 100]}"; exit 2
+    end
+    require "metanorma/html/generator"
+    require "timeout"
+    root = nil
+    # Older metanorma-core resolutions predate the Flavors table; the
+    # constant lookup then falls through to the Root convention below.
+    flavors_mod = Object.const_defined?("Metanorma::Core::Flavors") ? Metanorma::Core::Flavors : nil
+    [flavors_mod].compact.each do |mod|
+      mod.table.reverse_each do |entry|
+        next if entry.respond_to?(:taste?) && entry.taste?
+        next unless entry.name.to_s == "\#{flavor}"
+        mc = entry.model_root_class rescue nil
+        root = mc if mc
+      end
+    end
+    begin
+      root ||= Object.const_get("Metanorma::#{flavor.capitalize}::Document::Root")
+    rescue NameError
+      root = nil
+    end
+    unless root
+      puts "NO_ROOT"; exit 3
+    end
+    #{fixtures.inspect}.each do |fx|
+      label = fx.sub("\#{dir}/", "")
+      begin
+        model = Timeout.timeout(120) { root.from_xml(File.read(fx, encoding: "utf-8")) }
+        puts "PARSE_OK \#{label}"
+        begin
+          html = Timeout.timeout(120) { Metanorma::Html::Generator.generate(model) }
+          require "nokogiri"
+          page = Nokogiri::HTML(html)
+          page.css("header, nav, .header-actions, button, kbd").remove
+          p_count = page.css("p").size
+          verdict = p_count.positive? ? "CONTENT" : "EMPTY_SHELL"
+          puts "HTML_\#{verdict} \#{label} p=\#{p_count}"
+        rescue Timeout::Error
+          puts "HTML_TIMEOUT \#{label}"
+        rescue StandardError => e
+          puts "HTML_FAIL \#{label} \#{e.class}: \#{e.message[0, 100]}"
+        end
+      rescue Timeout::Error
+        puts "PARSE_TIMEOUT \#{label}"
+      rescue StandardError => e
+        puts "PARSE_FAIL \#{label} \#{e.class}: \#{e.message[0, 100]}"
+      end
+    end
+  RUBY
+end

data/tasks/grammar.rake

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+desc "Diff the grammar-coverage vocabulary against standoc-models"
+task :grammar_coverage do
+  require_relative "../lib/metanorma/document/grammar_vocabulary"
+
+  dir = ENV["STANDOC_MODELS"] ||
+    File.expand_path("~/src/mn/standoc-models/grammars")
+  abort <<~MSG unless File.directory?(dir)
+    standoc-models grammars not found at #{dir}
+    Clone metanorma/standoc-models or point STANDOC_MODELS at its grammars/ dir.
+  MSG
+
+  fresh = Metanorma::Document::GrammarVocabulary.scan(dir)
+  spec = {
+    semantic: Metanorma::Document::GrammarVocabulary::SEMANTIC_ELEMENTS,
+    presentation: Metanorma::Document::GrammarVocabulary::PRESENTATION_ELEMENTS,
+  }
+
+  %i[semantic presentation].each do |kind|
+    added = fresh[kind] - spec[kind]
+    stale = spec[kind] - fresh[kind]
+    puts "== #{kind}: grammar #{fresh[kind].size} vs spec #{spec[kind].size}"
+    puts "  new in grammar (classify: map, delegate, or gap): #{added.join(' ')}" unless added.empty?
+    puts "  gone from grammar (stale spec entries): #{stale.join(' ')}" unless stale.empty?
+    puts "  in sync" if added.empty? && stale.empty?
+  end
+end

data/tasks/roundtrip_samples.rake

@@ -35,26 +35,42 @@ module RoundtripSamples
 
   HTTP_TIMEOUT = 30
 
-  # Maps mn-samples-* repo name to the model class for round-tripping.
-  # nil means no document model exists yet — reported as "no_model".
+  # Maps mn-samples-* repo name to the model class name for
+  # round-tripping. Resolved lazily: the flavor trees moved to their
+  # gems (Phase 5), and this task must not require every flavor gem at
+  # load time — missing constants resolve to nil ("no_model").
   # OIML moved to the metanorma-oiml gem — its roundtrip lives there.
   FLAVOR_MODEL_MAP = {
-    "iso"     => Metanorma::IsoDocument::Root,
-    "iec"     => Metanorma::IecDocument::Root,
-    "ieee"    => Metanorma::IeeeDocument::Root,
-    "iho"     => Metanorma::IhoDocument::Root,
-    "cc"      => Metanorma::CcDocument::Root,
-    "bipm"    => Metanorma::BipmDocument::Root,
-    "itu"     => Metanorma::ItuDocument::Root,
-    "ogc"     => Metanorma::OgcDocument::Root,
-    "ribose"  => Metanorma::RiboseDocument::Root,
-    "ietf"    => Metanorma::IetfDocument::Root,
-    "csa"     => Metanorma::CsaDocument::Root,
+    "iso"     => "Metanorma::Iso::Document::Root",
+    "iec"     => "Metanorma::Iec::Document::Root",
+    "ieee"    => "Metanorma::Ieee::Document::Root",
+    "iho"     => "Metanorma::Iho::Document::Root",
+    "cc"      => "Metanorma::Cc::Document::Root",
+    "bipm"    => "Metanorma::Bipm::Document::Root",
+    "itu"     => "Metanorma::Itu::Document::Root",
+    "ogc"     => "Metanorma::Ogc::Document::Root",
+    "ribose"  => "Metanorma::Ribose::Document::Root",
+    "ietf"    => "Metanorma::Ietf::Document::Root",
+    "csa"     => "Metanorma::Csa::Document::Root",
     "un"      => nil,
   }.freeze
 
   module_function
 
+
+  # Flavor gems load on demand; a missing gem resolves to nil
+  # ("no_model"), never a load-time NameError.
+  def resolve_flavor_model(repo_name)
+    name = FLAVOR_MODEL_MAP[repo_name]
+    name && safe_const(name)
+  end
+
+  def safe_const(name)
+    Object.const_get(name)
+  rescue NameError
+    nil
+  end
+
   # --- Entry Points ---
 
   def run_site(site_url, repo_name)
@@ -249,31 +265,31 @@ module RoundtripSamples
 
   # Maps root element names to model classes for auto-detection
   ROOT_MODEL_MAP = {
-    "iso-standard"       => -> { Metanorma::IsoDocument::Root },
-    "iec-standard"       => -> { Metanorma::IecDocument::Root },
-    "ieee-standard"      => -> { Metanorma::IeeeDocument::Root },
-    "ogc-standard"       => -> { Metanorma::OgcDocument::Root },
-    "itu-standard"       => -> { Metanorma::ItuDocument::Root },
-    "bipm-standard"      => -> { Metanorma::BipmDocument::Root },
-    "nist-standard"      => -> { Metanorma::IsoDocument::Root },
-    "iho-standard"       => -> { Metanorma::IhoDocument::Root },
-    "rsd-standard"       => -> { Metanorma::RiboseDocument::Root },
-    "ietf-standard"      => -> { Metanorma::IetfDocument::Root },
-    "cc-standard"        => -> { Metanorma::CcDocument::Root },
-    "metanorma"          => -> { Metanorma::IsoDocument::Root },
-    "metanorma-collection" => -> { Metanorma::Collection::Root },
-    "m3d-standard"        => -> { Metanorma::IsoDocument::Root },
+    "iso-standard"       => "Metanorma::Iso::Document::Root",
+    "iec-standard"       => "Metanorma::Iec::Document::Root",
+    "ieee-standard"      => "Metanorma::Ieee::Document::Root",
+    "ogc-standard"       => "Metanorma::Ogc::Document::Root",
+    "itu-standard"       => "Metanorma::Itu::Document::Root",
+    "bipm-standard"      => "Metanorma::Bipm::Document::Root",
+    "nist-standard"      => "Metanorma::Iso::Document::Root",
+    "iho-standard"       => "Metanorma::Iho::Document::Root",
+    "rsd-standard"       => "Metanorma::Ribose::Document::Root",
+    "ietf-standard"      => "Metanorma::Ietf::Document::Root",
+    "cc-standard"        => "Metanorma::Cc::Document::Root",
+    "metanorma"          => "Metanorma::Iso::Document::Root",
+    "metanorma-collection" => "Metanorma::Collection::Root",
+    "m3d-standard"        => "Metanorma::Iso::Document::Root",
   }.freeze
 
   def resolve_model(xml, repo_name)
     if repo_name
-      model = FLAVOR_MODEL_MAP[repo_name]
+      model = resolve_flavor_model(repo_name)
       return model if model
     end
 
     # Auto-detect from XML root element or metanorma/@flavor
     if xml.include?("<metanorma-collection")
-      return Metanorma::Collection::Root
+      return safe_const("Metanorma::Collection::Root")
     end
 
     root_name = extract_root_name(xml)
@@ -281,15 +297,13 @@ module RoundtripSamples
     # Check for <metanorma flavor="...">
     if xml =~ /<metanorma[^>]*flavor="([^"]*)"/
       flavor = Regexp.last_match(1)
-      model = FLAVOR_MODEL_MAP[flavor]
+      model = resolve_flavor_model(flavor)
       return model if model
     end
 
     # Fallback: map root element name
-    factory = ROOT_MODEL_MAP[root_name]
-    return factory.call if factory
-
-    nil
+    name = ROOT_MODEL_MAP[root_name]
+    name && safe_const(name)
   end
 
   def extract_root_name(xml)