metanorma-mko 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 999fff00e42607cc53980cc815a00b38047a06c67de5145ce84f2766b7923314
-  data.tar.gz: aef9dd8137535a06dcc602f160a29ba66693d554285e1216e62ac947bfed5d4d
+  metadata.gz: 4e612f1678371d2e5f3ab58ef00e80918dcf419346ae7140244e5baa15b24c3e
+  data.tar.gz: 41519e76b5470d19f8823554386bbfac62c7e688ccaf5d263fe0f75a79f5a722
 SHA512:
-  metadata.gz: 1a07c7907caa16a1430bcd3f671460ad7787ccc28efa2f8f067febc0d1112646ea9b4cdcd26c88e22f0b1dbdc93cc838d02f3a010e159f75739aeaa698c637b5
-  data.tar.gz: 4dbb3da76cf6616078c7c6522c63917b86b63d6619cfd139df504435c8e072e6d22473d77c654ac9beb42c3b17473c0d9cab04ce6d9dbdf5960b0e8c78f1f473
+  metadata.gz: 84a2bb13c2ac8f215785e613cce14810c8873fc86d8de11c77e3dee9f7f419fe0943d8fb8597cf8af0d59f785d6e57a7fedeef514561e5b71ab782c072feef4f
+  data.tar.gz: c9c724166f850ed54b8ef85a744d7a22c7b51290dec4f39db72f4de349239f4958d2c11d9f2736030355d8678e37df9914a44f2293ee9e1884494375f62c0b20

data/lib/metanorma/mko/bundle.rb

@@ -68,7 +68,7 @@ module Metanorma
       def zip!
         require "zip"
         zip_path = "#{dir}.zip"
-        Zip::File.open(zip_path, Zip::File::CREATE) do |zipfile|
+        Zip::File.open(zip_path, create: true) do |zipfile|
           Dir[File.join(dir, "**", "*")].each do |f|
             next if File.directory?(f)
 

data/lib/metanorma/mko/model/collection.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Metanorma
+  module Mko
+    # Collection export (MN 116 §collections): a metanorma
+    # collection.yml declares a document family (OIML R 60 parts,
+    # amendments, R 129/138/144). Every member document exports as its
+    # own bundle (the document bundle is the unit of truth); the
+    # collection adds one small bundle with the membership contract:
+    # collection.json and the cross-document part_of edges binding the
+    # members to the family. Member identity comes from each member's
+    # exported document.json — the collection yml's identifiers are
+    # reference labels only.
+    class Collection
+      Member = Struct.new(:fileref, :xml_path, :identifier,
+                          :bundle_path, :result, :skipped,
+                          keyword_init: true)
+
+      class Result
+        attr_reader :collection_bundle, :members
+
+        def initialize(collection_bundle:, members:)
+          @collection_bundle = collection_bundle
+          @members = members
+        end
+
+        def skipped
+          members.select(&:skipped)
+        end
+      end
+
+      class << self
+        def export(yml, to:, assets_from: nil, zip: false)
+          new(yml, to: to, assets_from: assets_from, zip: zip).export
+        end
+      end
+
+      def initialize(yml, to:, assets_from: nil, zip: false)
+        @yml = if yml.is_a?(Hash)
+                 yml
+               elsif File.exist?(yml.to_s)
+                 YAML.safe_load_file(yml)
+               else
+                 YAML.safe_load(yml)
+               end
+        @base = File.exist?(yml.to_s) ? File.dirname(File.expand_path(yml.to_s)) : Dir.pwd
+        @to = to
+        @assets_from = assets_from
+        @zip = zip
+      end
+
+      def export
+        members = docrefs.filter_map do |ref|
+          member = resolve_member(ref)
+          next member if member.skipped
+
+          export = Mko.export(
+            File.read(member.xml_path), to: @to,
+                                        presentation_xml: presentation_for(member.xml_path),
+                                        assets_from: @assets_from || File.dirname(member.xml_path)
+          )
+          member.bundle_path = export.path
+          member.result = export.result
+          member
+        end
+        Result.new(collection_bundle: write_collection_bundle(members),
+                   members: members)
+      end
+
+      private
+
+      def docrefs
+        manifest = @yml["manifest"]
+        manifest = manifest.first if manifest.is_a?(Array)
+        Array(manifest.is_a?(Hash) ? manifest["docref"] : nil)
+      rescue StandardError
+        []
+      end
+
+      # The yml points members at .adoc sources; the compiled semantic
+      # XML sits beside them. Direct .xml filerefs work too.
+      def resolve_member(ref)
+        fileref = ref["fileref"].to_s
+        xml = fileref.end_with?(".xml") ? fileref : fileref.sub(/\.adoc$/, ".xml")
+        path = File.expand_path(xml, @base)
+        if File.file?(path)
+          Member.new(fileref: fileref, xml_path: path,
+                     identifier: ref["identifier"])
+        else
+          Member.new(fileref: fileref, xml_path: path,
+                     identifier: ref["identifier"], skipped: true)
+        end
+      end
+
+      def presentation_for(xml_path)
+        pres = xml_path.sub(/\.xml$/, ".presentation.xml")
+        File.file?(pres) ? File.read(pres) : nil
+      end
+
+      def canonical
+        docid = @yml.dig("bibdata", "docid")
+        docid = docid.first if docid.is_a?(Array)
+        docid.is_a?(Hash) ? docid["id"].to_s : docid.to_s
+      end
+
+      def title
+        t = @yml.dig("bibdata", "title")
+        t = t.first if t.is_a?(Array)
+        t.is_a?(Hash) ? t["content"].to_s : t.to_s
+      end
+
+      def collection_short
+        Mko.slug(canonical.empty? ? "collection" : canonical)
+      end
+
+      # Member identity from the export's own Result — the same truth
+      # the bundle was written from, never a read-back of our output.
+      def member_data(member)
+        document = member.result.document
+        { "bundle" => "#{document.ids.short}.mko",
+          "docidentifier" => document.ids.canonical,
+          "identifier" => member.identifier,
+          "title" => document.titles.first&.text,
+          "edition" => document.edition }
+      rescue StandardError
+        nil
+      end
+
+      def collection_member(member)
+        data = member_data(member) or return nil
+
+        Schema::CollectionMember.new(
+          bundle: data["bundle"], docidentifier: data["docidentifier"],
+          identifier: data["identifier"], title: data["title"],
+          edition: data["edition"]
+        )
+      end
+
+      def write_collection_bundle(members)
+        collection = Schema::Collection.new(
+          canonical: canonical, short: collection_short, title: title,
+          edition: @yml.dig("bibdata", "edition"),
+          members: members.filter_map { |m| collection_member(m) }
+        )
+        # A member whose identity collides with the family (e.g. a
+        # stale amendment bibdata — mn-samples-oiml#66) would emit a
+        # self-edge; skip those, they say nothing.
+        edges = collection.members.reject do |m|
+          m.docidentifier.to_s.empty? || m.docidentifier == collection.canonical
+        end.map do |m|
+          { "from" => "doc:#{m.docidentifier}",
+            "to" => "doc:#{collection.canonical}",
+            "kind" => "part_of" }
+        end
+        bundle = Bundle.open(collection_short, @to)
+        bundle.flavor = nil
+        bundle.add_json("collection", "collection.json", collection)
+        bundle.add_lines("edges", "edges.jsonl", edges) do |edge|
+          JSON.generate(edge)
+        end
+        bundle.write_manifest
+        @zip ? bundle.zip! : bundle.dir
+      end
+    end
+  end
+end

data/lib/metanorma/mko/model/exporter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mko
+    # Registry-facing exporter: quacks like a renderer (generate_full_document)
+    # so the Core::Flavors format table and the compile pipeline can select
+    # mko like any output format.
+    class Exporter
+      def generate_full_document(document, **options)
+        output = options[:output] || options[:output_filename] || "."
+        to = File.directory?(output) ? output : File.dirname(output)
+        Mko.export(document, to: to,
+                             presentation_xml: options[:presentation_xml])
+      end
+    end
+  end
+end