metanorma-release 0.2.24 → 0.2.26

data/lib/metanorma/release/publication.rb

@@ -1,12 +1,5 @@
 # frozen_string_literal: true
 
-begin
-  require "relaton/bib"
-rescue LoadError
-  raise LoadError,
-        "The relaton-bib gem is required. Add `gem 'relaton-bib'` to your Gemfile."
-end
-
 require "json"
 
 module Metanorma
@@ -67,6 +60,11 @@ module Metanorma
     class Publication
       METADATA_VERSION = 1
 
+      DRAFT_STAGES = %w[
+        20 30 40 50
+        working-draft committee-draft draft-standard final-draft
+      ].freeze
+
       attr_reader :identifier, :slug, :title, :edition, :stage, :doctype,
                   :revdate, :files, :channels, :source
 
@@ -94,14 +92,23 @@ module Metanorma
         files.any? ? File.dirname(files.first.path) : "."
       end
 
-      def content_hash
-        ContentHash.of_directory(base_dir, base: slug)
+      def content_hash(from_directory: nil)
+        dir = if from_directory && base_dir == "."
+                from_directory
+              else
+                base_dir
+              end
+        ContentHash.of_directory(dir, base: slug)
       end
 
       def file?(format)
         formats.include?(format)
       end
 
+      def draft?
+        DRAFT_STAGES.include?(stage.to_s)
+      end
+
       def eql?(other)
         other.is_a?(self.class) && identifier == other.identifier &&
           edition == other.edition && stage == other.stage
@@ -154,40 +161,26 @@ module Metanorma
       end
 
       def to_release_body
-        "<!-- mn-release-metadata\n#{JSON.generate(metadata_hash)}\n-->"
+        PublicationSerializer.to_release_body(self)
       end
 
       def to_json(*_args)
-        JSON.generate(metadata_hash)
-      end
-
-      def self.from_json(json_string)
-        data = JSON.parse(json_string)
-        raise ArgumentError, "Missing required field: id" unless data["id"]
-        unless data["title"]
-          raise ArgumentError,
-                "Missing required field: title"
-        end
-
-        from_metadata_hash(data)
+        PublicationSerializer.to_json(self)
       end
 
       def self.from_release_body(body)
-        return nil if body.nil? || body.empty?
-
-        match = body.match(/<!--\s*mn-release-metadata\s*\n(.*?)\n-->/m)
-        return nil unless match
+        PublicationSerializer.from_release_body(body)
+      end
 
-        from_json(match[1])
-      rescue JSON::ParserError
-        nil
+      def self.from_json(json_string)
+        PublicationSerializer.from_json(json_string)
       end
 
       def self.from_metadata_hash(data)
         ident = data["identifier"] || data["id"]
         new(
           identifier: ident,
-          slug: slug_from_identifier(ident),
+          slug: SlugStrategy.slug_from_identifier(ident),
           title: data["title"],
           edition: data["edition"],
           stage: data["stage"],
@@ -199,137 +192,6 @@ module Metanorma
           metadata_formats: data["formats"],
         )
       end
-
-      private
-
-      def metadata_hash
-        {
-          "version" => METADATA_VERSION,
-          "id" => slug,
-          "identifier" => identifier,
-          "title" => title,
-          "edition" => edition,
-          "stage" => stage,
-          "doctype" => doctype,
-          "revdate" => revdate,
-          "formats" => formats,
-          "channels" => channels,
-          "publisher" => Publication.publisher_from_identifier(identifier),
-        }
-      end
-
-      def self.slug_from_identifier(identifier)
-        identifier.to_s.strip
-          .gsub(/\s+/, "-")
-          .gsub(/:+/, "-")
-          .downcase
-          .gsub(/--+/, "-")
-          .gsub(/[-.]+$/, "")
-      end
-
-      def self.publisher_from_identifier(identifier)
-        return nil if identifier.nil? || identifier.strip.empty?
-
-        identifier.strip.split(/[\s-]/).first&.downcase
-      end
-
-      # -- RXL extraction --
-
-      def self.discover(output_dir)
-        Dir.glob(File.join(output_dir, "**", "*.rxl")).filter_map do |path|
-          from_rxl(path)
-        rescue StandardError => e
-          warn "Warning: Skipping #{path}: #{e.message}"
-          nil
-        end
-      end
-
-      def self.from_rxl(rxl_path)
-        unless File.exist?(rxl_path)
-          raise ArgumentError,
-                "RXL file not found: #{rxl_path}"
-        end
-
-        content = File.read(rxl_path)
-        bib = Relaton::Bib::Item.from_xml(content)
-        build_from_bib(bib, rxl_path)
-      rescue StandardError => e
-        warn "Warning: Failed to parse RXL #{rxl_path}: #{e.message}"
-        fallback_from_rxl(rxl_path)
-      end
-
-      class << self
-        private
-
-        def build_from_bib(bib, rxl_path)
-          identifier = bib.docidentifier&.first&.content || ""
-          slug = slug_from_identifier(identifier)
-          output_dir = File.dirname(rxl_path)
-          base_name = File.basename(rxl_path, ".rxl")
-
-          new(
-            identifier: identifier, slug: slug,
-            title: bib.title&.first&.content || "",
-            edition: extract_edition(bib),
-            stage: extract_stage(bib),
-            doctype: extract_doctype(bib),
-            revdate: extract_revdate(bib),
-            files: discover_files(output_dir, base_name),
-            channels: [], source: nil
-          )
-        end
-
-        def extract_edition(bib)
-          ed = bib.edition
-          return "1" unless ed
-
-          ed.respond_to?(:content) ? ed.content.to_s : ed.to_s
-        end
-
-        def extract_stage(bib)
-          stage = bib.status&.stage
-          return "" unless stage
-
-          stage.respond_to?(:content) ? stage.content.to_s : stage.to_s
-        end
-
-        def extract_doctype(bib)
-          doctype = bib.ext&.doctype
-          return "" unless doctype
-
-          doctype.respond_to?(:content) ? doctype.content.to_s : doctype.to_s
-        end
-
-        def extract_revdate(bib)
-          date = bib.date&.find { |d| d.type == "published" } || bib.date&.first
-          return nil unless date
-
-          val = date.at
-          val ? val.to_s : nil
-        rescue StandardError
-          nil
-        end
-
-        def discover_files(output_dir, base_name)
-          Dir.glob(File.join(output_dir, "#{base_name}.*")).filter_map do |path|
-            next if File.directory?(path)
-
-            name = File.basename(path)
-            ext = File.extname(name).delete_prefix(".")
-            PublicationFile.new(format: ext, name: name, path: name)
-          end
-        end
-
-        def fallback_from_rxl(rxl_path)
-          base_name = File.basename(rxl_path, ".rxl")
-          slug = slug_from_identifier(base_name)
-          new(
-            identifier: base_name, slug: slug, title: "",
-            edition: "0", stage: "", doctype: "",
-            revdate: nil, files: [], channels: [], source: nil
-          )
-        end
-      end
     end
   end
 end

data/lib/metanorma/release/publication_serializer.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module PublicationSerializer
+      METADATA_COMMENT_PATTERN = /<!--\s*mn-release-metadata\s*\n(.*?)\n-->/m
+
+      def self.to_release_body(publication)
+        "<!-- mn-release-metadata\n#{JSON.generate(metadata_hash(publication))}\n-->"
+      end
+
+      def self.from_release_body(body)
+        return nil if body.nil? || body.empty?
+
+        match = body.match(METADATA_COMMENT_PATTERN)
+        return nil unless match
+
+        from_json(match[1])
+      rescue JSON::ParserError
+        nil
+      end
+
+      def self.to_json(publication)
+        JSON.generate(metadata_hash(publication))
+      end
+
+      def self.from_json(json_string)
+        data = JSON.parse(json_string)
+        raise ArgumentError, "Missing required field: id" unless data["id"]
+        unless data["title"]
+          raise ArgumentError,
+                "Missing required field: title"
+        end
+
+        Publication.from_metadata_hash(data)
+      end
+
+      class << self
+        private
+
+        def metadata_hash(publication)
+          {
+            "version" => Publication::METADATA_VERSION,
+            "id" => publication.slug,
+            "identifier" => publication.identifier,
+            "title" => publication.title,
+            "edition" => publication.edition,
+            "stage" => publication.stage,
+            "doctype" => publication.doctype,
+            "revdate" => publication.revdate,
+            "formats" => publication.formats,
+            "channels" => publication.channels,
+            "publisher" => SlugStrategy.publisher_from_identifier(publication.identifier),
+          }
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/release/release_pipeline.rb

@@ -15,6 +15,8 @@ module Metanorma
         :manifest, :channel_override, :config,
         keyword_init: true
       ) do
+        include DependencyValidation
+
         def initialize(**kwargs)
           super
           validate_types!
@@ -23,9 +25,9 @@ module Metanorma
         private
 
         def validate_types!
-          unless extractor.respond_to?(:discover)
+          unless extractor.is_a?(Class) && extractor.singleton_class.ancestors.include?(Extractor)
             raise ArgumentError,
-                  "extractor must respond to #discover, got #{extractor.class}"
+                  "extractor must extend Extractor, got #{extractor}"
           end
 
           validate_interface!(change_detector, ChangeDetector,
@@ -33,21 +35,11 @@ module Metanorma
           validate_interface!(packager, Packager, "packager")
           validate_interface!(publisher, Publisher, "publisher")
         end
-
-        def validate_interface!(obj, mod, name)
-          return if obj.is_a?(mod) || begin
-            obj.class.ancestors.include?(mod)
-          rescue StandardError
-            false
-          end
-
-          raise ArgumentError, "#{name} must include #{mod}, got #{obj.class}"
-        end
       end
 
       Config = Struct.new(
-        :output_dir, :manifest_path, :force, :force_replace_patterns,
-        :concurrency, :default_visibility,
+        :output_dir, :force, :force_replace_patterns,
+        :concurrency,
         keyword_init: true
       )
 
@@ -72,7 +64,7 @@ module Metanorma
 
       def phase_one(publications, config)
         publications.map do |pub|
-          publisher = Publication.publisher_from_identifier(pub.identifier)
+          publisher = SlugStrategy.publisher_from_identifier(pub.identifier)
           strategy = @deps.slug_registry.resolve(publisher)
           tag_info = strategy.compute_tag(pub)
           canonical_base = strategy.compute_asset_name(pub).sub(/\.zip$/, "")

data/lib/metanorma/release/rxl_extractor.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    class RxlExtractor
+      extend Extractor
+
+      def self.discover(output_dir)
+        require "relaton/bib"
+        Dir.glob(File.join(output_dir, "**", "*.rxl")).filter_map do |path|
+          from_rxl(path)
+        rescue StandardError => e
+          Metanorma::Release.logger.warn "Skipping #{path}: #{e.message}"
+          nil
+        end
+      end
+
+      def self.from_rxl(rxl_path)
+        unless File.exist?(rxl_path)
+          raise ArgumentError,
+                "RXL file not found: #{rxl_path}"
+        end
+
+        content = File.read(rxl_path)
+        bib = Relaton::Bib::Item.from_xml(content)
+        build_from_bib(bib, rxl_path)
+      rescue StandardError => e
+        Metanorma::Release.logger.warn "Failed to parse RXL #{rxl_path}: #{e.message}"
+        fallback_from_rxl(rxl_path)
+      end
+
+      class << self
+        private
+
+        def build_from_bib(bib, rxl_path)
+          identifier = bib.docidentifier&.first&.content || ""
+          slug = SlugStrategy.slug_from_identifier(identifier)
+          output_dir = File.dirname(rxl_path)
+          base_name = File.basename(rxl_path, ".rxl")
+
+          Publication.new(
+            identifier: identifier, slug: slug,
+            title: bib.title&.first&.content || "",
+            edition: extract_edition(bib),
+            stage: extract_stage(bib),
+            doctype: extract_doctype(bib),
+            revdate: extract_revdate(bib),
+            files: discover_files(output_dir, base_name),
+            channels: [], source: nil
+          )
+        end
+
+        def extract_edition(bib)
+          ed = bib.edition
+          return "1" unless ed
+
+          ed.is_a?(String) ? ed : ed.content.to_s
+        end
+
+        def extract_stage(bib)
+          stage = bib.status&.stage
+          return "" unless stage
+
+          stage.is_a?(String) ? stage : stage.content.to_s
+        end
+
+        def extract_doctype(bib)
+          doctype = bib.ext&.doctype
+          return "" unless doctype
+
+          doctype.is_a?(String) ? doctype : doctype.content.to_s
+        end
+
+        def extract_revdate(bib)
+          date = bib.date&.find { |d| d.type == "published" } || bib.date&.first
+          return nil unless date
+
+          val = date.at
+          val&.to_s
+        rescue StandardError
+          nil
+        end
+
+        def discover_files(output_dir, base_name)
+          Dir.glob(File.join(output_dir, "#{base_name}.*")).filter_map do |path|
+            next if File.directory?(path)
+
+            name = File.basename(path)
+            ext = File.extname(name).delete_prefix(".")
+            PublicationFile.new(format: ext, name: name, path: name)
+          end
+        end
+
+        def fallback_from_rxl(rxl_path)
+          base_name = File.basename(rxl_path, ".rxl")
+          slug = SlugStrategy.slug_from_identifier(base_name)
+          Publication.new(
+            identifier: base_name, slug: slug, title: "",
+            edition: "0", stage: "", doctype: "",
+            revdate: nil, files: [], channels: [], source: nil
+          )
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/release/site.rb

@@ -13,7 +13,7 @@ module Metanorma
         @index = index
         @output_dir = output_dir
         @data_dir = data_dir
-        @display_categories = display_categories || []
+        @flattener = DocumentFlattener.new(display_categories: display_categories)
       end
 
       def write!
@@ -33,7 +33,7 @@ module Metanorma
         require "zip"
 
         path = zip_path || "#{output_dir}.zip"
-        Zip::File.open(path, Zip::File::CREATE) do |zipfile|
+        Zip::File.open(path, create: true) do |zipfile|
           Dir.glob("#{output_dir}/**/*").each do |file|
             next if File.directory?(file)
 
@@ -50,12 +50,13 @@ module Metanorma
         index.publications.map do |pub|
           enrich_publication(pub)
         rescue StandardError => e
-          warn "  Skip #{pub.identifier}: #{e.message}"
+          Metanorma::Release.logger.warn "Skip #{pub.identifier}: #{e.message}"
           pub.to_h
         end
       end
 
       def enrich_publication(pub)
+        require "relaton/bib"
         rxl_file = pub.files.find { |f| f.format == "rxl" }
         return pub.to_h unless rxl_file
 
@@ -78,171 +79,10 @@ module Metanorma
 
       def write_data_file(documents)
         FileUtils.mkdir_p(@data_dir)
-        items = documents.compact.map { |doc| flatten_for_site(doc) }
+        items = documents.compact.map { |doc| @flattener.flatten(doc) }
         File.write(File.join(@data_dir, "documents.json"),
                    JSON.pretty_generate({ "items" => items }))
       end
-
-      def flatten_for_site(doc)
-        bib = doc["bibliographic"] || {}
-        doctype = extract_doctype(bib) || doc.fetch("doctype", "")
-        formats = doc["formats"] || []
-        base = {
-          "slug" => doc["id"],
-          "id" => resolve_doc_id(bib, doc),
-          "title" => doc["title"].to_s,
-          "abstract" => extract_abstract(bib),
-          "stage" => (doc["stage"] || "published").to_s.downcase,
-          "doctype" => doctype,
-          "edition" => doc["edition"],
-          "date" => extract_date(doc),
-          "channels" => doc["channels"] || [],
-          "formats" => formats,
-          "files" => doc["files"] || [],
-          "bibliographic" => bib,
-        }
-        add_format_flags(base, formats)
-        add_display_category(base, doctype)
-        add_contributors(base, bib)
-        base
-      end
-
-      def add_format_flags(hash, formats)
-        hash["has_html"] = formats.include?("html")
-        hash["has_pdf"] = formats.include?("pdf")
-        hash["has_xml"] = formats.include?("xml")
-        hash["has_rxl"] = formats.include?("rxl")
-
-        files = hash["files"]
-        html_file = files.find { |f| f["format"] == "html" }
-        hash["html_path"] = html_file["path"] if html_file
-        pdf_file = files.find { |f| f["format"] == "pdf" }
-        hash["pdf_path"] = pdf_file["path"] if pdf_file
-        xml_file = files.find { |f| f["format"] == "xml" }
-        hash["xml_path"] = xml_file["path"] if xml_file
-        rxl_file = files.find { |f| f["format"] == "rxl" }
-        hash["rxl_path"] = rxl_file["path"] if rxl_file
-      end
-
-      def add_display_category(hash, doctype)
-        cat = resolve_display_category(doctype)
-        hash["stage_css"] = hash["stage"].gsub(/\s+/, "-")
-        hash["doctype_class"] = "type-#{doctype.downcase}"
-        hash["display_category"] = cat&.fetch("name", nil)
-        hash["display_category_slug"] = cat&.fetch("slug", nil)
-      end
-
-      def resolve_doc_id(bib, doc)
-        extract_primary_id(bib) || doc["identifier"] || doc["id"]
-      end
-
-      def extract_primary_id(bib)
-        ids = bib["docidentifier"]
-        return nil unless ids&.any?
-
-        primary = ids.find { |di| di["primary"] == true } || ids.first
-        primary["content"]
-      end
-
-      def extract_doctype(bib)
-        bib.dig("ext", "doctype", "content")
-      end
-
-      def extract_abstract(bib)
-        abstracts = bib["abstract"]
-        return nil unless abstracts&.any?
-
-        abstracts.first["content"]
-      end
-
-      def extract_date(doc)
-        bib_date = extract_bib_date(doc["bibliographic"])
-        return bib_date if bib_date
-
-        release_date = doc.dig("source", "releaseDate")
-        return nil unless release_date
-
-        release_date.to_s.split(/[T ]/).first
-      end
-
-      def extract_bib_date(bib)
-        return nil unless bib
-
-        dates = bib["date"]
-        return nil if dates.nil? || dates.empty?
-
-        published = dates.find { |d| d["type"] == "published" }
-        entry = published || dates.first
-        at = entry["at"]
-        at ? at.to_s.split(/[T ]/).first : nil
-      end
-
-      def resolve_display_category(doctype)
-        return nil if doctype.nil? || doctype.empty?
-
-        @display_categories.each do |cat|
-          doctypes = cat["doctypes"] || []
-          return { "name" => cat["name"], "slug" => cat["slug"] } if doctypes.include?(doctype)
-        end
-        nil
-      end
-
-      def add_contributors(hash, bib)
-        contribs = bib["contributor"] || []
-        persons, committees = partition_contributors(contribs)
-        hash["authors"] = persons
-        hash["committee"] = committees.first
-      end
-
-      def partition_contributors(contribs)
-        persons = contribs.filter_map { |c| parse_person(c) }
-        committees = contribs.filter_map { |c| parse_committee(c) }
-        [persons, committees]
-      end
-
-      def parse_person(contrib)
-        return nil unless contrib["person"]
-
-        name = extract_person_name(contrib["person"])
-        return nil unless name
-
-        role = (contrib["role"] || []).first&.fetch("type", nil)
-        { "name" => name, "role" => role }
-      end
-
-      def parse_committee(contrib)
-        return nil unless contrib["organization"]
-
-        extract_org_subdivision(contrib["organization"])
-      end
-
-      def extract_person_name(person)
-        n = person["name"] || {}
-        complete = n["completename"]
-        return complete["content"] if complete.is_a?(Hash) && complete["content"]
-        return complete if complete.is_a?(String)
-
-        surname = n["surname"]
-        given = n["given"]
-        given_str = given.is_a?(Hash) ? given["content"].to_s : given.to_s
-        parts = [given_str, surname].compact
-        parts.empty? ? nil : parts.join(" ")
-      end
-
-      def extract_org_subdivision(org)
-        subs = org["subdivision"]
-        return nil unless subs&.any?
-
-        sd = subs.first
-        sd_name = sd["name"]
-        if sd_name.is_a?(Array)
-          sd_name.first&.dig("content")
-        elsif sd_name.is_a?(Hash)
-          sd_name["content"]
-        else
-          sd_name.to_s
-        end
-      end
     end
   end
 end