metanorma-mko 1.0.0

data/lib/metanorma/mko/units.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "unitsml/model"
+
+module Metanorma
+  module Mko
+    # Units register (#55 GAP-1): every unit the document uses, carried
+    # by the model's typed UnitsML classes (or parsed from raw container
+    # XML). Emitted as unitsml.jsonl — one entry per line — and
+    # referenced by id from formula payloads and table columns.
+    # Consumers compare on quantity kinds, never unit strings.
+    module Units
+      Entry = Struct.new(:id, :symbol, :name, :quantity_kind, :dimension,
+                         :dimension_url, :si_to, :si_expression,
+                         keyword_init: true)
+
+      # SI base-quantity symbols in canonical vector order: L M T I Θ N J
+      # plus plane angle. Shared by the XML parser and the model
+      # projection so both compose identical vectors.
+      BASE_QUANTITY_SYMBOLS = {
+        "Length" => "L", "Mass" => "M", "Time" => "T",
+        "ElectricCurrent" => "I", "ThermodynamicTemperature" => "Θ",
+        "AmountOfSubstance" => "N", "LuminousIntensity" => "J",
+        "PlaneAngle" => "φ"
+      }.freeze
+
+      class << self
+        # unitsml_xml: the <UnitsML> container XML (or the inner
+        # <UnitSet>). Returns [Entry].
+        def parse(unitsml_xml)
+          require "nokogiri"
+          doc = Nokogiri::XML(unitsml_xml)
+          units = doc.remove_namespaces!
+                     .xpath("//UnitSet/Unit").map do |node|
+            wrap_unit(node)
+          end
+          dimensions = parse_dimensions(doc)
+          units.each do |u|
+            dim = dimensions[u.dimension_url]
+            u.dimension = dim if dim
+          end
+          units
+        end
+
+        # Write unitsml.jsonl into a bundle; returns the entry list.
+        def write(entries, dir)
+          path = File.join(dir, "unitsml.jsonl")
+          File.write(path,
+                     entries.map { |e| JSON.generate(entry_hash(e)) }
+                       .join("\n") + "\n")
+          entries
+        end
+
+        def entry_hash(entry)
+          {
+            "id" => entry.id,
+            "symbol" => entry.symbol,
+            "name" => entry.name,
+            "quantity_kind" => entry.quantity_kind,
+            "dimension" => entry.dimension,
+            "si_conversion" => entry.si_to || entry.si_expression ? {
+              "to" => entry.si_to,
+              "expression" => entry.si_expression,
+            } : nil,
+          }.compact
+        end
+
+        # SI base-quantity vector from (symbol, powerNumerator,
+        # powerDenominator) triples: "M·L^2·T^-2", "Θ", ...
+        def vectorize(parts)
+          parts.filter_map do |sym, n, d|
+            next sym if n.nil? || (n == 1 && (d.nil? || d == 1))
+
+            exp = d && d != 1 ? "#{n || 1}/#{d}" : n.to_s
+            "#{sym}^#{exp}"
+          end.join("·")
+        end
+
+        private
+
+        def wrap_unit(node)
+          Entry.new(
+            id: node["id"],
+            symbol: node.xpath(".//UnitSymbol/text()").map(&:text).join,
+            name: node.xpath(".//UnitName/text()").map(&:text).join,
+            quantity_kind: nil,
+            dimension_url: node["dimensionURL"]&.sub("#", ""),
+          )
+        end
+
+        def parse_dimensions(doc)
+          doc.xpath("//Dimension").each_with_object({}) do |d, h|
+            h[d["id"]] = dimension_vector(d)
+          end
+        end
+
+        # SI base-quantity vector: L M T I Θ N J + plane angle
+        def dimension_vector(dim)
+          parts = BASE_QUANTITY_SYMBOLS.map do |el, sym|
+            node = dim.xpath("./#{el}").first or next
+            [sym, node["powerNumerator"]&.to_i,
+             node["powerDenominator"]&.to_i]
+          end
+          vectorize(parts)
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/mko/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mko
+    # Gem version — kept dependency-free so gemspecs can read it
+    # without activating the model stack. Tracks the MN 116 schema
+    # version: the wire contract and the gem release together.
+    VERSION = "1.0.0"
+  end
+end

data/lib/metanorma/mko/writer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mko
+    # Maps a projection Result onto a bundle directory (or zip). The
+    # on-disk mechanics live in Bundle; this class only decides which
+    # components a document projection produces.
+    module Writer
+      class << self
+        def write(result, to:, zip: false)
+          bundle = Bundle.open(result.document.ids.short, to)
+          bundle.flavor = result.flavor
+          add_components(bundle, result)
+          bundle.write_manifest
+          zip ? bundle.zip! : bundle.dir
+        end
+
+        private
+
+        def add_components(bundle, result)
+          bundle.add_json("document", "document.json", result.document)
+          # bibdata/glossary/identifiers carry the NATIVE object-model
+          # serializations (Relaton::Bib, Glossarist::Concept, Pubid),
+          # produced by Document::NativeModels at the model layer.
+          if result.bibdata
+            bundle.add_json("bibdata", "bibdata.json", result.bibdata)
+          end
+          bundle.add_json("identifiers", "identifiers.json", result.identifiers)
+          bundle.add_json("glossary", "glossary.json",
+                          { "concepts" => result.glossary.map do |c|
+                            JSON.parse(c.to_json)
+                          end })
+          # bibliography.jsonl: every cited document as native objects —
+          # Relaton item + pubid parse — keyed to its reference unit.
+          bib_lines = result.bibliography.map do |e|
+            {
+              "unit" => "u:#{e.key}",
+              "citeas" => e.citeas,
+              "pubid" => e.pubid && JSON.parse(e.pubid.to_json),
+              "pubid_render" => e.pubid&.to_s,
+              "bibitem" => e.item && JSON.parse(e.item.to_json),
+            }
+          end
+          bundle.add_lines("bibliography", "bibliography.jsonl", bib_lines) do |l|
+            JSON.generate(l)
+          end
+          bundle.add_lines("units", "units.jsonl", result.units)
+          bundle.add_lines("edges", "edges.jsonl", result.edges)
+          # unitsml.jsonl: the units register, referenced by id from
+          # formula payloads and table columns (#55). Absent when the
+          # source carries no UnitsML container.
+          unless result.unitsml.empty?
+            bundle.add_lines("unitsml", "unitsml.jsonl", result.unitsml) do |e|
+              JSON.generate(Units.entry_hash(e))
+            end
+          end
+          result.assets.each { |entry| bundle.add_asset(entry) }
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/mko.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require "json"
+require "digest"
+
+module Metanorma
+  # Metanorma Knowledge Objects (MKO, MN 116) — the machine
+  # serialization of a Metanorma document as a bundle of typed,
+  # addressable knowledge objects (metanorma/metanorma#592). A derived
+  # projection over a typed document model: like a rendering, never a
+  # source format.
+  #
+  # This gem owns the FORMAT (the MN 116 contract): wire schema,
+  # bundle layout + manifest verification, assets, alignment, diffs,
+  # the generated JSON Schemas, and the reference MCP server.
+  # metanorma-document reopens this module with the MODEL side — the
+  # projection walk, collection orchestration, flavor resolution — and
+  # composes this gem to export.
+  module Mko
+    autoload :VERSION, "metanorma/mko/version"
+    autoload :Schema, "metanorma/mko/schema"
+    autoload :Bundle, "metanorma/mko/bundle"
+    autoload :Writer, "metanorma/mko/writer"
+    autoload :Export, "metanorma/mko/export"
+    autoload :Result, "metanorma/mko/result"
+    autoload :Assets, "metanorma/mko/assets"
+    autoload :Alignment, "metanorma/mko/alignment"
+    autoload :Diff, "metanorma/mko/diff"
+    autoload :Mcp, "metanorma/mko/mcp"
+    autoload :Units, "metanorma/mko/units"
+
+    autoload :VERSION, "metanorma/mko/version"
+
+    SCHEMA = "metanorma-mko"
+    SCHEMA_VERSION = VERSION
+
+    class << self
+      # The published wire contract, generated from the schema classes
+      # (single source of truth): name => JSON Schema draft 2020-12.
+      def json_schemas
+        Schema::JsonSchema.all
+      end
+
+      # Canonical short-id derivation (one rule, documents and
+      # collections alike).
+      def slug(canonical)
+        canonical.to_s.tr(" ", "-").gsub(/[^A-Za-z0-9.\-]/, "")
+                 .squeeze("-").downcase
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: metanorma-mko
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Ribose Inc.
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lutaml-model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: unitsml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: 'The MN 116 wire contract as code: typed unit schema, bundle layout with
+  manifest verification, hash-addressed assets, edition diffs, interlingual alignment,
+  generated JSON Schemas, and the reference MCP server. metanorma-document composes
+  this gem to export; polyglot consumers validate against the published schemas.'
+email:
+- open.source@ribose.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.adoc
+- lib/metanorma/mko.rb
+- lib/metanorma/mko/alignment.rb
+- lib/metanorma/mko/assets.rb
+- lib/metanorma/mko/bundle.rb
+- lib/metanorma/mko/diff.rb
+- lib/metanorma/mko/export.rb
+- lib/metanorma/mko/mcp.rb
+- lib/metanorma/mko/result.rb
+- lib/metanorma/mko/schema.rb
+- lib/metanorma/mko/schema/collection.rb
+- lib/metanorma/mko/schema/document.rb
+- lib/metanorma/mko/schema/edge.rb
+- lib/metanorma/mko/schema/identifiers.rb
+- lib/metanorma/mko/schema/json_schema.rb
+- lib/metanorma/mko/schema/manifest.rb
+- lib/metanorma/mko/schema/unit.rb
+- lib/metanorma/mko/units.rb
+- lib/metanorma/mko/version.rb
+- lib/metanorma/mko/writer.rb
+homepage: https://github.com/metanorma/metanorma-mko
+licenses:
+- BSD-2-Clause
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Metanorma Knowledge Objects (MN 116) — the machine serialization format
+test_files: []