metanorma-release 0.2.23 → 0.2.25

data/lib/metanorma/release/change_detector.rb

@@ -8,12 +8,13 @@ module Metanorma
     class ContentHashChangeDetector
       include ChangeDetector
 
-      def initialize(previous_releases:)
+      def initialize(previous_releases:, output_dir: ".")
         @previous_releases = previous_releases
+        @output_dir = output_dir
       end
 
       def detect(publication, tag, force: false)
-        current = publication.content_hash
+        current = publication.content_hash(from_directory: @output_dir)
         previous = @previous_releases[tag.to_s]
         changed = force || previous.nil? || !current.eql?(previous)
         ChangeResult.new(changed?: changed, current_hash: current,

data/lib/metanorma/release/cli.rb

@@ -11,6 +11,17 @@ module Metanorma
 
       class PipelineError < Thor::Error; end
 
+      desc "version", "Print version"
+      def version
+        puts "metanorma-release #{VERSION}"
+      end
+      map %w[--version -v] => :version
+
+      class_option :verbose, type: :boolean, default: false,
+                             desc: "Verbose output"
+      class_option :quiet, type: :boolean, default: false,
+                           desc: "Suppress warnings"
+
       desc "package", "Package compiled documents"
       option :output_dir, type: :string, default: "_site",
                           desc: "Compiled docs directory"
@@ -21,6 +32,7 @@ module Metanorma
       option :config, type: :string, desc: "Config file"
 
       def package
+        configure_logging
         config = PackageCommand::Config.new(
           output_dir: options[:output_dir],
           dest: options[:dest],
@@ -49,6 +61,7 @@ module Metanorma
       option :config, type: :string, desc: "Config file"
 
       def release
+        configure_logging
         config = ReleaseCommand::Config.new(
           output_dir: options[:output_dir],
           platform: options[:platform],
@@ -80,16 +93,19 @@ module Metanorma
       option :file_routing, type: :string,
                             desc: "File routing (by-document|flat|by-format)"
       option :cache_dir, type: :string, desc: "Cache directory"
-      option :data_dir, type: :string, desc: "Write flattened documents.json for site generators"
+      option :data_dir, type: :string,
+                        desc: "Write flattened documents.json for site generators"
       option :include_drafts, type: :boolean, default: false,
                               desc: "Include draft releases"
       option :concurrency, type: :numeric, default: 4
       option :min_documents, type: :numeric, default: 0,
                              desc: "Minimum required documents"
       option :token, type: :string, desc: "Platform auth token"
-      option :config, type: :string, desc: "Config file (default: metanorma.aggregate.yml)"
+      option :config, type: :string,
+                      desc: "Config file (default: metanorma.aggregate.yml)"
 
       def aggregate
+        configure_logging
         config = AggregateCommand.build_config(
           source: options[:source],
           organizations: options[:organizations],
@@ -123,6 +139,14 @@ module Metanorma
 
       private
 
+      def configure_logging
+        if options[:verbose]
+          Metanorma::Release.logger.level = Logger::DEBUG
+        elsif options[:quiet]
+          Metanorma::Release.logger.level = Logger::ERROR
+        end
+      end
+
       def print_package_result(result, dest)
         released = result.released
         puts "Packaged #{released.length} documents → #{dest}/"

data/lib/metanorma/release/commands/aggregate.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "base64"
 require "yaml"
 
 module Metanorma
@@ -33,7 +32,6 @@ module Metanorma
         site.enrich!
         site.package! if @config.create_zip
 
-        stamp_primary_identifiers(index)
         result
       end
 
@@ -151,20 +149,6 @@ module Metanorma
           output_dir: @config.output_dir,
         )
       end
-
-      def stamp_primary_identifiers(index)
-        index.publications.each do |pub|
-          next unless pub.to_h["bibliographic"]
-
-          ids = pub.to_h.dig("bibliographic", "docidentifier")
-          next unless ids&.any?
-
-          primary = ids.find { |di| di["primary"] == true } || ids.first
-          pub.to_h.merge("primary_identifier" => primary["content"])
-        end
-      rescue LoadError
-        warn "  (relaton gem not available — bibliography skipped)"
-      end
     end
   end
 end

data/lib/metanorma/release/commands/package.rb

@@ -3,6 +3,8 @@
 module Metanorma
   module Release
     class PackageCommand
+      extend ConfigLoader
+
       Config = Struct.new(
         :output_dir, :dest, :manifest, :config_source,
         keyword_init: true
@@ -13,11 +15,15 @@ module Metanorma
       end
 
       def call
-        config = load_config
+        config = self.class.load_config(
+          config_source: @config.config_source,
+          manifest: @config.manifest,
+        )
         deps = ReleasePipeline::Dependencies.new(
-          extractor: Publication,
+          extractor: RxlExtractor,
           filters: [],
-          change_detector: ContentHashChangeDetector.new(previous_releases: {}),
+          change_detector: ContentHashChangeDetector.new(previous_releases: {},
+                                                         output_dir: @config.output_dir),
           packager: ZipPackager.new(output_dir: @config.output_dir),
           publisher: PlatformFactory.build_publisher("null", {}),
           slug_registry: SlugRegistry.from_config(config),
@@ -28,27 +34,13 @@ module Metanorma
 
         pipeline_config = ReleasePipeline::Config.new(
           output_dir: @config.output_dir,
-          manifest_path: @config.manifest,
           force: false,
           force_replace_patterns: nil,
           concurrency: 4,
-          default_visibility: "public",
         )
 
         ReleasePipeline.new(deps).run(pipeline_config)
       end
-
-      private
-
-      def load_config
-        if @config.config_source && File.exist?(@config.config_source)
-          Metanorma::Release::Config.from_file(@config.config_source)
-        elsif @config.manifest && File.exist?(@config.manifest)
-          Metanorma::Release::Config.from_file(@config.manifest)
-        else
-          Metanorma::Release::Config.defaults
-        end
-      end
     end
   end
 end

data/lib/metanorma/release/commands/release_command.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require "yaml"
-
 module Metanorma
   module Release
     class ReleaseCommand
+      extend ConfigLoader
+
       Config = Struct.new(
         :output_dir, :platform, :manifest, :force,
         :force_replace, :channels, :concurrency, :token, :config_source,
@@ -16,15 +16,20 @@ module Metanorma
       end
 
       def call
-        config = load_config
+        config = self.class.load_config(
+          config_source: @config.config_source,
+          manifest: @config.manifest,
+        )
         options = { token: @config.token }
         publisher = PlatformFactory.build_publisher(@config.platform, options)
         channel_override = Channel.parse_list(@config.channels) if @config.channels
 
+        previous_releases = build_previous_releases
         deps = ReleasePipeline::Dependencies.new(
-          extractor: Publication,
+          extractor: RxlExtractor,
           filters: [],
-          change_detector: ContentHashChangeDetector.new(previous_releases: {}),
+          change_detector: ContentHashChangeDetector.new(previous_releases: previous_releases,
+                                                         output_dir: @config.output_dir),
           packager: ZipPackager.new(output_dir: @config.output_dir),
           publisher: publisher,
           slug_registry: SlugRegistry.from_config(config),
@@ -35,11 +40,9 @@ module Metanorma
 
         pipeline_config = ReleasePipeline::Config.new(
           output_dir: @config.output_dir,
-          manifest_path: @config.manifest,
           force: @config.force,
           force_replace_patterns: @config.force_replace && !@config.force_replace.empty? ? @config.force_replace : nil,
           concurrency: @config.concurrency,
-          default_visibility: "public",
         )
 
         ReleasePipeline.new(deps).run(pipeline_config)
@@ -47,13 +50,15 @@ module Metanorma
 
       private
 
-      def load_config
-        if @config.config_source && File.exist?(@config.config_source)
-          Metanorma::Release::Config.from_file(@config.config_source)
-        elsif @config.manifest && File.exist?(@config.manifest)
-          Metanorma::Release::Config.from_file(@config.manifest)
-        else
-          Metanorma::Release::Config.defaults
+      def build_previous_releases
+        pubs = RxlExtractor.discover(@config.output_dir)
+        pubs.each_with_object({}) do |pub, map|
+          pub.slug
+          registry = SlugRegistry.default
+          strategy = registry.resolve(SlugStrategy.publisher_from_identifier(pub.identifier))
+          tag_info = strategy.compute_tag(pub)
+          content_hash = pub.content_hash(from_directory: @config.output_dir)
+          map[tag_info[:tag]] = content_hash if content_hash
         end
       end
     end

data/lib/metanorma/release/config.rb

@@ -60,13 +60,26 @@ module Metanorma
       end
     end
 
-    # Single routing entry — matches by any combination of pattern, source,
+    # Shared config resolution logic for CLI commands.
+    module ConfigLoader
+      def load_config(config_source:, manifest:)
+        if config_source && File.exist?(config_source)
+          Config.from_file(config_source)
+        elsif manifest && File.exist?(manifest)
+          Config.from_file(manifest)
+        else
+          Config.defaults
+        end
+      end
+    end
+
+    # Single routing entry — matches by any combination of pattern,
     # stage, and doctype. An entry with no criteria matches everything (catch-all).
-    DocumentEntry = Struct.new(:pattern, :source, :stages, :doctypes, :channels, keyword_init: true) do
+    DocumentEntry = Struct.new(:pattern, :stages, :doctypes,
+                               :channels, keyword_init: true) do
       def initialize(data)
         super(
           pattern: data["pattern"],
-          source: data["source"],
           stages: Array(data["stage"]).map(&:to_s),
           doctypes: Array(data["doctype"]).map(&:to_s),
           channels: Array(data["channels"]).map(&:to_s),
@@ -80,10 +93,6 @@ module Metanorma
           return false
         end
 
-        if source && !(publication.source_path&.end_with?(source) || false)
-          return false
-        end
-
         if !stages.empty? && !stages.include?(publication.stage.to_s)
           return false
         end

data/lib/metanorma/release/dependency_validation.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module DependencyValidation
+      private
+
+      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
+  end
+end

data/lib/metanorma/release/document_flattener.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    class DocumentFlattener
+      def initialize(display_categories: [])
+        @display_categories = display_categories || []
+      end
+
+      def flatten(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
+
+      private
+
+      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"]
+        %w[html pdf xml rxl].each do |fmt|
+          file = files.find { |f| f["format"] == fmt }
+          hash["#{fmt}_path"] = file["path"] if file
+        end
+      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_display_category(doctype)
+        return nil if doctype.nil? || doctype.empty?
+
+        @display_categories.each do |cat|
+          doctypes = cat["doctypes"] || []
+          if doctypes.include?(doctype)
+            return { "name" => cat["name"],
+                     "slug" => cat["slug"] }
+          end
+        end
+        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 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

data/lib/metanorma/release/index.rb

@@ -51,7 +51,7 @@ module Metanorma
       end
 
       def to_json(*_args)
-        JSON.generate(to_h)
+        JSON.pretty_generate(to_h)
       end
 
       def write(path)

data/lib/metanorma/release/interfaces.rb

@@ -2,6 +2,18 @@
 
 module Metanorma
   module Release
+    module Extractor
+      def discover(output_dir)
+        raise NotImplementedError, "#{self} must implement .discover"
+      end
+    end
+
+    Release = Struct.new(:tag_name, :body, :prerelease, :draft,
+                         :html_url, :published_at, :created_at,
+                         :assets, keyword_init: true)
+    Asset = Struct.new(:name, :browser_download_url, :size, :data,
+                       keyword_init: true)
+
     module Filter
       def apply(documents)
         raise NotImplementedError, "#{self.class} must implement #apply"

data/lib/metanorma/release/platform/github/manifest_reader.rb

@@ -22,7 +22,9 @@ module Metanorma
             return nil unless parsed.is_a?(Hash)
 
             channels = Array(parsed["channels"])
-            Array(parsed["documents"]).each { |doc| channels.concat(Array(doc["channels"])) }
+            Array(parsed["documents"]).each do |doc|
+              channels.concat(Array(doc["channels"]))
+            end
             channels.map(&:to_s).uniq
           rescue StandardError
             nil

data/lib/metanorma/release/platform/github/release_fetcher.rb

@@ -6,12 +6,6 @@ module Metanorma
   module Release
     module Platform
       module GitHub
-        GitHubRelease = Struct.new(:tag_name, :body, :prerelease, :draft,
-                                   :html_url, :published_at, :created_at,
-                                   :assets, keyword_init: true)
-        GitHubAsset = Struct.new(:name, :browser_download_url, :size, :data,
-                                 keyword_init: true)
-
         class ReleaseFetcher
           include Metanorma::Release::ReleaseFetcher
 
@@ -43,21 +37,21 @@ module Metanorma
             end
             all
           rescue StandardError => e
-            warn "Warning: Failed to fetch releases for #{repo_slug}: #{e.message}"
+            Metanorma::Release.logger.warn "Failed to fetch releases for #{repo_slug}: #{e.message}"
             []
           end
 
           def parse_release(r)
             assets = (r[:assets] || []).map do |a|
               data = download_asset(a[:url]) if a[:name].end_with?(".zip")
-              GitHubAsset.new(
+              Asset.new(
                 name: a[:name],
                 browser_download_url: a[:browser_download_url],
                 size: a[:size],
                 data: data,
               )
             end
-            GitHubRelease.new(
+            Release.new(
               tag_name: r[:tag_name],
               body: r[:body],
               prerelease: r[:prerelease],
@@ -82,7 +76,7 @@ module Metanorma
             end
             data
           rescue StandardError => e
-            warn "Warning: Failed to download asset #{url}: #{e.message}"
+            Metanorma::Release.logger.warn "Failed to download asset #{url}: #{e.message}"
             nil
           end
 

data/lib/metanorma/release/platform/github/topic_discoverer.rb

@@ -20,7 +20,7 @@ module Metanorma
               page = 1
               loop do
                 results = @client.search_repositories(query, per_page: 100,
-                                                      page: page)
+                                                             page: page)
                 items = results[:items]
                 break if items.nil? || items.empty?
 

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

@@ -18,10 +18,6 @@ module Metanorma
                  "metanorma/release/platform/github/release_fetcher"
         autoload :ManifestReader,
                  "metanorma/release/platform/github/manifest_reader"
-
-        def self.cache_store(cache_dir:)
-          FileCacheStore.new(cache_dir)
-        end
       end
     end
   end

data/lib/metanorma/release/platform/local/fetcher.rb

@@ -6,12 +6,6 @@ module Metanorma
   module Release
     module Platform
       module Local
-        LocalRelease = Struct.new(:tag_name, :body, :prerelease, :draft,
-                                  :html_url, :published_at, :created_at,
-                                  :assets, keyword_init: true)
-        LocalAsset = Struct.new(:name, :browser_download_url, :size, :data,
-                                keyword_init: true)
-
         class Fetcher
           include Metanorma::Release::ReleaseFetcher
 
@@ -42,22 +36,22 @@ module Metanorma
             zip_path = File.join(dir, "#{base}.zip")
 
             unless File.exist?(zip_path)
-              warn "Warning: Missing zip for #{meta_path}, skipping"
+              Metanorma::Release.logger.warn "Missing zip for #{meta_path}, skipping"
               return nil
             end
 
             metadata = Publication.from_metadata_hash(data)
-            asset = LocalAsset.new(
+            asset = Asset.new(
               name: "#{base}.zip",
               browser_download_url: "file://#{File.expand_path(zip_path)}",
               size: File.size(zip_path),
               data: File.binread(zip_path),
             )
 
-            LocalRelease.new(
+            Release.new(
               tag_name: "#{metadata.slug}/#{metadata.edition || '1'}",
               body: metadata.to_release_body,
-              prerelease: prerelease?(metadata),
+              prerelease: metadata.draft?,
               draft: false,
               html_url: "file://#{File.expand_path(dir)}",
               published_at: File.mtime(zip_path).iso8601,
@@ -65,15 +59,9 @@ module Metanorma
               assets: [asset],
             )
           rescue JSON::ParserError
-            warn "Warning: Invalid metadata JSON in #{meta_path}, skipping"
+            Metanorma::Release.logger.warn "Invalid metadata JSON in #{meta_path}, skipping"
             nil
           end
-
-          def prerelease?(metadata)
-            stage = metadata.stage.to_s
-            %w[working-draft committee-draft draft-standard
-               final-draft].include?(stage)
-          end
         end
       end
     end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module Platform
+      module Null
+        class ManifestReader
+          include Metanorma::Release::ManifestReader
+
+          def read(_repo) = nil
+        end
+      end
+    end
+  end
+end

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

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