metanorma-release 0.2.23 → 0.2.25

data/lib/metanorma/release/platform/null.rb

@@ -5,6 +5,8 @@ module Metanorma
     module Platform
       module Null
         autoload :Publisher, "metanorma/release/platform/null/publisher"
+        autoload :ManifestReader,
+                 "metanorma/release/platform/null/manifest_reader"
       end
     end
   end

data/lib/metanorma/release/platform/static_discoverer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module Platform
+      class StaticDiscoverer
+        include RepoDiscoverer
+
+        def initialize(repos:)
+          @repos = repos
+        end
+
+        def discover
+          @repos
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/release/platform.rb

@@ -6,6 +6,7 @@ module Metanorma
       autoload :GitHub, "metanorma/release/platform/github"
       autoload :Local, "metanorma/release/platform/local"
       autoload :Null, "metanorma/release/platform/null"
+      autoload :StaticDiscoverer, "metanorma/release/platform/static_discoverer"
     end
   end
 end

data/lib/metanorma/release/platform_factory.rb

@@ -24,14 +24,17 @@ module Metanorma
 
           discoverer = if opts[:repos]
                          repos = opts[:repos].map { |r| RepoRef.from_string(r) }
-                         StaticDiscoverer.new(repos: repos)
+                         Platform::StaticDiscoverer.new(repos: repos)
                        else
                          Platform::GitHub::TopicDiscoverer.new(
                            client: client, organizations: opts[:organizations], topic: opts[:topic],
                          )
                        end
 
-          download_cache = opts[:cache_dir] ? File.join(opts[:cache_dir], "downloads") : nil
+          download_cache = if opts[:cache_dir]
+                             File.join(opts[:cache_dir],
+                                       "downloads")
+                           end
 
           {
             discoverer: discoverer,
@@ -58,7 +61,7 @@ module Metanorma
         if source.start_with?("local:")
           adapters = AGGREGATION_REGISTRY["local"].call(options,
                                                         options[:token])
-          adapters[:manifest_reader] = NullManifestReader.new
+          adapters[:manifest_reader] = Platform::Null::ManifestReader.new
           return adapters
         end
 
@@ -78,24 +81,6 @@ module Metanorma
       def self.register_aggregation(name, factory)
         AGGREGATION_REGISTRY[name] = factory
       end
-
-      class StaticDiscoverer
-        include RepoDiscoverer
-
-        def initialize(repos:)
-          @repos = repos
-        end
-
-        def discover
-          @repos
-        end
-      end
-
-      class NullManifestReader
-        include Metanorma::Release::ManifestReader
-
-        def read(_repo) = nil
-      end
     end
   end
 end

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