metanorma-release 0.2.2 → 0.2.3

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

@@ -7,8 +7,9 @@ module Metanorma
         class Publisher
           include Metanorma::Release::Publisher
 
-          def publish(tag, _artifact, _metadata, channels:, force_replace: false)
-            PublishResult.new(tag: tag.to_s, url: 'null://', created?: true)
+          def publish(tag, _artifact, _metadata, channels:,
+force_replace: false)
+            PublishResult.new(tag: tag.to_s, url: "null://", created?: true)
           end
         end
       end

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

@@ -4,7 +4,7 @@ module Metanorma
   module Release
     module Platform
       module Null
-        autoload :Publisher, 'metanorma/release/platform/null/publisher'
+        autoload :Publisher, "metanorma/release/platform/null/publisher"
       end
     end
   end

data/lib/metanorma/release/platform.rb

@@ -3,9 +3,9 @@
 module Metanorma
   module Release
     module Platform
-      autoload :GitHub, 'metanorma/release/platform/github'
-      autoload :Local, 'metanorma/release/platform/local'
-      autoload :Null, 'metanorma/release/platform/null'
+      autoload :GitHub, "metanorma/release/platform/github"
+      autoload :Local, "metanorma/release/platform/local"
+      autoload :Null, "metanorma/release/platform/null"
     end
   end
 end

data/lib/metanorma/release/platform_factory.rb

@@ -4,59 +4,77 @@ module Metanorma
   module Release
     module PlatformFactory
       PUBLISHER_REGISTRY = {
-        'null' => ->(_opts) { Platform::Null::Publisher.new },
-        'local' => ->(opts) { Platform::Local::Publisher.new(output_dir: opts[:output_dir]) }
-      }.freeze
+        "null" => ->(_opts) { Platform::Null::Publisher.new },
+        "local" => ->(opts) {
+          Platform::Local::Publisher.new(output_dir: opts[:output_dir])
+        },
+      }.dup
 
       AGGREGATION_REGISTRY = {
-        'local' => lambda { |opts, _token|
-          path = opts[:source].sub('local:', '')
+        "local" => lambda { |opts, _token|
+          path = opts[:source].sub("local:", "")
           {
             discoverer: Platform::Local::DirectoryDiscoverer.new(base_path: path),
-            fetcher: Platform::Local::Fetcher.new(base_path: path)
+            fetcher: Platform::Local::Fetcher.new(base_path: path),
           }
-        }
-      }.freeze
+        },
+        "github" => lambda { |opts, token|
+          require "octokit"
+          client = build_github_client(token)
+
+          discoverer = if opts[:repos]
+                         repos = opts[:repos].map { |r| RepoRef.from_string(r) }
+                         StaticDiscoverer.new(repos: repos)
+                       else
+                         Platform::GitHub::TopicDiscoverer.new(
+                           client: client, organizations: opts[:organizations], topic: opts[:topic],
+                         )
+                       end
+
+          {
+            discoverer: discoverer,
+            fetcher: Platform::GitHub::ReleaseFetcher.new(client: client),
+            manifest_reader: Platform::GitHub::ManifestReader.new(client: client),
+          }
+        },
+      }.dup
 
       def self.build_publisher(platform, options)
         factory = PUBLISHER_REGISTRY[platform]
-        raise ArgumentError, "Unknown platform: #{platform}. Available: #{PUBLISHER_REGISTRY.keys.join(', ')}" unless factory
+        unless factory
+          raise ArgumentError,
+                "Unknown platform: #{platform}. Available: #{PUBLISHER_REGISTRY.keys.join(', ')}"
+        end
 
         factory.call(options)
       end
 
       def self.build_aggregation_adapters(options)
         source = options[:source]
-        if source.start_with?('local:')
-          adapters = AGGREGATION_REGISTRY['local'].call(options, options[:token])
+
+        if source.start_with?("local:")
+          adapters = AGGREGATION_REGISTRY["local"].call(options,
+                                                        options[:token])
           adapters[:manifest_reader] = NullManifestReader.new
           return adapters
         end
 
-        require 'octokit'
-        client = build_github_client(options[:token])
-
-        discoverer = if options[:repos]
-                       repos = options[:repos].map { |r| RepoRef.from_string(r) }
-                       StaticDiscoverer.new(repos: repos)
-                     else
-                       Platform::GitHub::TopicDiscoverer.new(
-                         client: client, organizations: options[:organizations], topic: options[:topic]
-                       )
-                     end
-
-        {
-          discoverer: discoverer,
-          fetcher: Platform::GitHub::ReleaseFetcher.new(client: client),
-          manifest_reader: Platform::GitHub::ManifestReader.new(client: client)
-        }
+        AGGREGATION_REGISTRY["github"].call(options, options[:token])
       end
 
       def self.build_github_client(token)
-        require 'octokit'
+        require "octokit"
         token ? Octokit::Client.new(access_token: token) : Octokit::Client.new
       end
 
+      def self.register_publisher(name, factory)
+        PUBLISHER_REGISTRY[name] = factory
+      end
+
+      def self.register_aggregation(name, factory)
+        AGGREGATION_REGISTRY[name] = factory
+      end
+
       class StaticDiscoverer
         include RepoDiscoverer
 
@@ -71,6 +89,7 @@ module Metanorma
 
       class NullManifestReader
         include Metanorma::Release::ManifestReader
+
         def read(_repo) = nil
       end
     end

data/lib/metanorma/release/publication.rb

@@ -0,0 +1,335 @@
+# 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
+  module Release
+    class PublicationFile
+      attr_reader :format, :name, :path
+
+      def initialize(format:, name:, path:)
+        @format = format
+        @name = name
+        @path = path
+        freeze
+      end
+
+      def eql?(other)
+        other.is_a?(self.class) && format == other.format && path == other.path
+      end
+
+      def hash
+        [format, path].hash
+      end
+
+      def to_h
+        { "format" => format, "name" => name, "path" => path }
+      end
+    end
+
+    class PublicationSource
+      attr_reader :owner, :repo, :tag, :url, :date
+
+      def initialize(owner:, repo:, tag:, url:, date:)
+        @owner = owner
+        @repo = repo
+        @tag = tag
+        @url = url
+        @date = date
+        freeze
+      end
+
+      def repo_key
+        "#{owner}/#{repo}"
+      end
+
+      def eql?(other)
+        other.is_a?(self.class) && owner == other.owner && repo == other.repo && tag == other.tag
+      end
+
+      def hash
+        [owner, repo, tag].hash
+      end
+
+      def to_h
+        { "owner" => owner, "repo" => repo, "tag" => tag,
+          "releaseUrl" => url, "releaseDate" => date }
+      end
+    end
+
+    class Publication
+      METADATA_VERSION = 1
+
+      attr_reader :identifier, :slug, :title, :edition, :stage, :doctype,
+                  :revdate, :files, :channels, :source
+
+      def initialize(identifier:, slug:, title:, edition:, stage:, doctype:,
+                     revdate:, files:, channels:, source: nil, metadata_formats: nil)
+        @identifier = identifier
+        @slug = slug
+        @title = title
+        @edition = edition
+        @stage = stage
+        @doctype = doctype
+        @revdate = revdate
+        @files = files.freeze
+        @channels = channels.freeze
+        @source = source
+        @metadata_formats = metadata_formats
+        freeze
+      end
+
+      def formats
+        @metadata_formats || files.map(&:format)
+      end
+
+      def base_dir
+        files.any? ? File.dirname(files.first.path) : "."
+      end
+
+      def content_hash
+        ContentHash.of_directory(base_dir, base: slug)
+      end
+
+      def file?(format)
+        formats.include?(format)
+      end
+
+      def eql?(other)
+        other.is_a?(self.class) && identifier == other.identifier &&
+          edition == other.edition && stage == other.stage
+      end
+
+      def hash
+        [identifier, edition, stage].hash
+      end
+
+      def to_h
+        h = {
+          "id" => slug, "identifier" => identifier, "title" => title,
+          "edition" => edition, "stage" => stage, "doctype" => doctype,
+          "channels" => channels, "formats" => formats,
+          "revdate" => revdate
+        }
+        h["source"] = source.to_h if source
+        h["files"] = files.map(&:to_h) unless files.empty?
+        h
+      end
+
+      def with_channels(new_channels)
+        self.class.new(
+          identifier: identifier, slug: slug, title: title,
+          edition: edition, stage: stage, doctype: doctype,
+          revdate: revdate, files: files,
+          channels: new_channels, source: source,
+          metadata_formats: @metadata_formats
+        )
+      end
+
+      def with_files_and_source(new_files, release, repo)
+        source = PublicationSource.new(
+          owner: repo.owner, repo: repo.repo,
+          tag: release.tag_name,
+          url: release.html_url,
+          date: release.published_at
+        )
+        pub_files = new_files.map do |f|
+          name = File.basename(f)
+          ext = File.extname(name).delete_prefix(".")
+          PublicationFile.new(format: ext, name: name, path: f)
+        end
+        self.class.new(
+          identifier: identifier, slug: slug, title: title,
+          edition: edition, stage: stage, doctype: doctype,
+          revdate: revdate, files: pub_files,
+          channels: channels, source: source
+        )
+      end
+
+      def to_release_body
+        "<!-- mn-release-metadata\n#{JSON.generate(metadata_hash)}\n-->"
+      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)
+      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
+
+        from_json(match[1])
+      rescue JSON::ParserError
+        nil
+      end
+
+      def self.from_metadata_hash(data)
+        ident = data["identifier"] || data["id"]
+        new(
+          identifier: ident,
+          slug: slug_from_identifier(ident),
+          title: data["title"],
+          edition: data["edition"],
+          stage: data["stage"],
+          doctype: data["doctype"],
+          revdate: data["revdate"],
+          files: [],
+          channels: data["channels"] || [],
+          source: nil,
+          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
+
+          on = date.on
+          on.respond_to?(:content) ? on.content.to_s : on.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 = 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/release_pipeline.rb

@@ -2,13 +2,48 @@
 
 module Metanorma
   module Release
+    PublishResult = Struct.new(:tag, :url, :created?, keyword_init: true)
+    ReleasedArtifact = Struct.new(:id, :tag, :url, :channels,
+                                  keyword_init: true)
+    ReleaseResult = Struct.new(:released, :skipped, :failed,
+                               :released_artifacts, keyword_init: true)
+
     class ReleasePipeline
       Dependencies = Struct.new(
         :extractor, :filters, :change_detector,
-        :packager, :publisher, :naming_registry,
-        :manifest, :channel_override, :channel_config,
+        :packager, :publisher, :slug_registry,
+        :manifest, :channel_override, :config,
         keyword_init: true
-      )
+      ) do
+        def initialize(**kwargs)
+          super
+          validate_types!
+        end
+
+        private
+
+        def validate_types!
+          unless extractor.respond_to?(:discover)
+            raise ArgumentError,
+                  "extractor must respond to #discover, got #{extractor.class}"
+          end
+
+          validate_interface!(change_detector, ChangeDetector,
+                              "change_detector")
+          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,
@@ -21,29 +56,31 @@ module Metanorma
       end
 
       def run(config)
-        documents = @deps.extractor.discover(config.output_dir)
-        filtered = apply_filters(documents)
+        publications = @deps.extractor.discover(config.output_dir)
+        filtered = apply_filters(publications)
         results = phase_one(filtered, config)
         phase_two(results, config)
       end
 
       private
 
-      def apply_filters(documents)
-        return documents unless @deps.filters && !@deps.filters.empty?
+      def apply_filters(publications)
+        return publications unless @deps.filters && !@deps.filters.empty?
 
-        @deps.filters.reduce(documents) { |docs, filter| filter.apply(docs) }
+        @deps.filters.reduce(publications) { |docs, filter| filter.apply(docs) }
       end
 
-      def phase_one(documents, config)
-        documents.map do |doc|
-          strategy = @deps.naming_registry.resolve(doc.document_type)
-          tag = strategy.compute_tag(doc.id.to_s, doc.version)
-          canonical_base = strategy.compute_canonical_base(doc.id.to_s, doc.version)
-          change = @deps.change_detector.detect(doc, tag, force: config.force)
-
-          { document: doc, tag: tag, canonical_base: canonical_base,
-            changed: change.changed?, change_result: change }
+      def phase_one(publications, config)
+        publications.map do |pub|
+          publisher = Publication.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$/, "")
+          change = @deps.change_detector.detect(pub, tag_info[:tag],
+                                                force: config.force)
+
+          { publication: pub, tag: tag_info[:tag], pre_release: tag_info[:pre_release],
+            canonical_base: canonical_base, changed: change.changed?, change_result: change }
         end
       end
 
@@ -54,34 +91,38 @@ module Metanorma
         released_artifacts = []
 
         candidates.each do |candidate|
-          doc = candidate[:document]
+          pub = candidate[:publication]
           tag = candidate[:tag]
 
           unless candidate[:changed]
-            skipped << doc
+            skipped << pub
             next
           end
 
           begin
-            policy = resolve_policy(doc, config)
-            unless policy.release?
-              skipped << doc
+            channels = resolve_channels(pub)
+            if channels.empty?
+              skipped << pub
               next
             end
 
-            artifact = @deps.packager.package(doc, canonical_base: candidate[:canonical_base])
-            channels = resolve_channels(doc, policy)
-            metadata_json = ReleaseMetadata.from_document(doc, channels: channels)
-            force = config.force_replace_patterns&.any? { |p| File.fnmatch?(p, doc.id.to_s) } || false
-
-            result = @deps.publisher.publish(tag, artifact, metadata_json, channels: channels, force_replace: force)
-            released << doc
+            artifact = @deps.packager.package(pub,
+                                              canonical_base: candidate[:canonical_base])
+            channel_objects = channels.map { |c| Channel.new(c) }
+            pub_for_release = pub.with_channels(channels)
+            force = config.force_replace_patterns&.any? do |p|
+              File.fnmatch?(p, pub.slug)
+            end || false
+
+            result = @deps.publisher.publish(tag, artifact, pub_for_release,
+                                             channels: channel_objects, force_replace: force)
+            released << pub
             released_artifacts << ReleasedArtifact.new(
-              id: doc.id.to_s, tag: tag.to_s,
-              url: result.url, channels: channels.map(&:to_s)
+              id: pub.slug, tag: tag.to_s,
+              url: result.url, channels: channels
             )
           rescue StandardError => e
-            failed << { document: doc, error: e.message }
+            failed << { document: pub, error: e.message }
           end
         end
 
@@ -89,26 +130,18 @@ module Metanorma
                           released_artifacts: released_artifacts)
       end
 
-      def resolve_policy(doc, _config)
-        return @deps.manifest.resolve(doc) if @deps.manifest
-
-        DocumentReleasePolicy.from_defaults('public', [Channel.public('default')])
-      end
-
-      def resolve_channels(_doc, policy)
-        channels = if @deps.channel_override && !@deps.channel_override.empty?
-                     @deps.channel_override
-                   else
-                     policy.channels
-                   end
-
-        validate_channels(channels)
-      end
-
-      def validate_channels(channels)
-        return channels unless @deps.channel_config
-
-        channels.select { |ch| @deps.channel_config.registry.valid?(ch) }
+      def resolve_channels(pub)
+        override = @deps.channel_override
+        return override if override && !override.empty?
+
+        if @deps.config
+          @deps.config.resolve_channels(pub)
+        elsif @deps.manifest
+          policy = @deps.manifest.resolve(pub)
+          policy&.channels&.map(&:to_s) || ["public"]
+        else
+          ["public"]
+        end
       end
     end
   end

data/lib/metanorma/release/repo_ref.rb

@@ -6,8 +6,11 @@ module Metanorma
       attr_reader :owner, :repo
 
       def self.from_string(str)
-        parts = str.split('/', 2)
-        raise ArgumentError, "Invalid repo reference: #{str}" unless parts.length == 2
+        parts = str.split("/", 2)
+        unless parts.length == 2
+          raise ArgumentError,
+                "Invalid repo reference: #{str}"
+        end
 
         new(owner: parts[0], repo: parts[1])
       end