metanorma-release 0.2.25 → 0.2.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d042d82fb6c1175f03ccb4534e040db56ca33378c116e316937a873c275c2219
-  data.tar.gz: cefa7d75ac920f733ad39c5161557baf40533f21660b2341d0a95a76a678e32a
+  metadata.gz: edbfe878db6e725d2335b5361abd3ab85a5c9e01bca54e4465235ea66c14b62b
+  data.tar.gz: f14879f8a6e09373db94081064af2fd96e7ca1e650df42bbdabbeea98af77f1c
 SHA512:
-  metadata.gz: ae3fe6c644f91c61fb4e8192ff312a42d94fe0c52e08701d5d54edb73de7048837ba06e3e77757ff96eba3a0a9ac93222c18a8aec7b8bbd23abe966f18a5b1be
-  data.tar.gz: 052b5bdb91acdaaa8a98248f734f534408cfea074ca4a819fc2bad003a1f076b26a9ac25819df2e0949b48b681192772c2efa81264dafe40d686468f9a24f2d1
+  metadata.gz: e44a4bd8f2d81326a395779f1df4cf4626edd9f8ef15bce4f528b1f9d94d4c5d7c92d1913c80258d80dc386894869375b4cd4e2c2198a7bf5efddfb80b7dbc08
+  data.tar.gz: f3748555ca6418d71c8c045c35d81d3499fafa215a97c1a7361fc4dac9db4fc2e36c105e5fa9d7cbce31e830aaad4a5ac9f10f951705542d9f7e74ece3525141

data/README.adoc

@@ -109,7 +109,7 @@ metanorma-release aggregate
 [source,ruby]
 ----
 # Discover publications from compiled RXL files
-publications = Metanorma::Release::Publication.discover("_site")
+publications = Metanorma::Release::RxlExtractor.discover("_site")
 
 pub = publications.first
 pub.identifier  # => "CC 18011:2018"
@@ -243,7 +243,7 @@ You can also route by stage or doctype instead of pattern:
 [source,yaml]
 ----
 documents:
-  - stages: ["20", "30"]
+  - stage: ["20", "30"]
     channels: [internal]
   - doctypes: [standard, specification]
     channels: [public/standards]
@@ -342,6 +342,18 @@ github:
 
 CLI flags override config file values.
 
+=== Global options
+
+All commands accept these options:
+
+[cols="1m,3",options="header"]
+|===
+|Option |Description
+|`--verbose` |Enable debug-level logging
+|`--quiet` |Suppress warnings (only errors shown)
+|`--help` |Show command help
+|===
+
 == Concepts
 
 === Channels

data/lib/metanorma/release/aggregation_pipeline.rb

@@ -2,10 +2,21 @@
 
 module Metanorma
   module Release
-    FetchResult = Struct.new(:releases, :etag, :unchanged?, keyword_init: true)
+    # failed?: the release listing itself failed (rate limit, network) —
+    # distinct from an empty result. A failed listing must never be
+    # treated as "all releases deleted".
+    FetchResult = Struct.new(:releases, :etag, :unchanged?, :failed?,
+                             keyword_init: true) do
+      def initialize(releases:, etag:, **flags)
+        super(releases: releases, etag: etag,
+              unchanged?: flags.fetch(:unchanged?, false),
+              failed?: flags.fetch(:failed?, false))
+      end
+    end
     RepoReport  = Struct.new(:releases, :included, :skipped, :reason, :errors,
                              keyword_init: true)
     RepoError   = Struct.new(:tag, :message, keyword_init: true)
+    Collision   = Struct.new(:path, :claimed_by, keyword_init: true)
 
     class AggregationPipeline
       Dependencies = Struct.new(
@@ -39,9 +50,14 @@ module Metanorma
 
       Result = Struct.new(
         :publications, :repo_count, :channels_found,
-        :report, :failed_repos,
+        :report, :failed_repos, :collisions,
         keyword_init: true
-      )
+      ) do
+        def initialize(publications:, repo_count:, channels_found:, report:,
+                       failed_repos:, collisions: [])
+          super
+        end
+      end
 
       def initialize(deps)
         @deps = deps
@@ -67,9 +83,25 @@ module Metanorma
           channels_found: publications.flat_map(&:channels).uniq.sort,
           report: reports,
           failed_repos: failed_repos,
+          collisions: detect_collisions(publications),
         )
       end
 
+      # Two releases extracting to the same path (same slug from
+      # different repos, or same-year editions under flat routing)
+      # silently overwrite each other. Surface them so callers can
+      # disambiguate in source repos or fail loudly.
+      def detect_collisions(publications)
+        claims = Hash.new { |h, k| h[k] = [] }
+        publications.each do |pub|
+          owner = pub.source ? "#{pub.source.repo_key}@#{pub.source.tag}" : pub.slug
+          pub.files.each { |file| claims[file.path] << owner }
+        end
+        claims.select { |_path, owners| owners.uniq.length > 1 }.map do |path, owners|
+          Collision.new(path: path, claimed_by: owners.uniq)
+        end
+      end
+
       private
 
       def run_sequential(repos, output_dir, config)
@@ -130,6 +162,17 @@ module Metanorma
         etag = @deps.delta_state.etag(repo_key)
         fetch_result = @deps.fetcher.fetch(repo, etag: etag)
 
+        if fetch_result.failed?
+          # The listing failed (rate limit, network) — this is NOT "the
+          # releases are gone". Keep the existing extracted files and
+          # delta state untouched so a later run can reconcile.
+          return [], RepoReport.new(
+            releases: 0, included: 0, skipped: 0,
+            reason: "fetch failed — existing state kept",
+            errors: [RepoError.new(tag: nil, message: "release listing failed")]
+          )
+        end
+
         if fetch_result.unchanged?
           return [], RepoReport.new(releases: 0, included: 0, skipped: 0,
                                     reason: "etag unchanged", errors: [])
@@ -150,21 +193,25 @@ module Metanorma
           tag = release.tag_name
           current_tags << tag
 
+          zip_asset = find_zip_asset(release)
+          fingerprint = release_fingerprint(release, zip_asset)
           cached_files = @deps.delta_state.release_files(repo_key, tag)
-          if cached_files.any? && cached_files.all? do |f|
-            File.exist?(File.join(output_dir, f))
-          end
+          cached_fingerprint = @deps.delta_state.release_fingerprint(repo_key, tag)
+          if fingerprint &&
+             cached_files.any? &&
+             cached_fingerprint == fingerprint &&
+             cached_files.all? { |f| File.exist?(File.join(output_dir, f)) }
             publications << build_publication(metadata, cached_files, release,
                                               repo)
             next
           end
 
-          zip_asset = find_zip_asset(release)
           next unless zip_asset
 
           result = @deps.asset_processor.process(zip_asset.data, metadata_h)
           @deps.delta_state.mark_processed(repo_key, tag, nil,
-                                           result.files.map(&:path))
+                                           result.files.map(&:path),
+                                           fingerprint: fingerprint)
           publications << build_publication(metadata, result.files.map(&:path),
                                             release, repo)
         rescue StandardError => e
@@ -191,6 +238,17 @@ module Metanorma
 
         release.assets.find { |a| a.name.end_with?(".zip") }
       end
+
+      # Identity of a release's CONTENT from listing data alone (no
+      # downloads): a force-recreated release gets a new timestamp and
+      # asset, so a fingerprint mismatch means the cached extraction is
+      # stale even though the tag (and the on-disk files) still exist.
+      def release_fingerprint(release, zip_asset)
+        return nil if zip_asset.nil?
+
+        size = zip_asset.respond_to?(:size) ? zip_asset.size : nil
+        [release.published_at, zip_asset.name, size].join("|")
+      end
     end
   end
 end

data/lib/metanorma/release/asset_processor.rb

@@ -35,7 +35,9 @@ module Metanorma
               dest_path = File.join(@output_dir, relative_path)
 
               FileUtils.mkdir_p(File.dirname(dest_path))
-              entry.extract(dest_path) { true }
+              entry.extract(File.basename(dest_path),
+                            destination_directory:
+                              File.dirname(dest_path)) { true }
 
               ext = File.extname(file_name).delete_prefix(".")
               files << PublicationFile.new(format: ext, name: file_name,

data/lib/metanorma/release/cli.rb

@@ -88,8 +88,8 @@ module Metanorma
       option :repos, type: :array, desc: "Explicit repo list"
       option :channels, type: :array, default: [],
                         desc: "Filter channels"
-      option :output_dir, type: :string, default: "_site/cc",
-                          desc: "Output directory"
+      option :output_dir, type: :string,
+                          desc: "Output directory (default: config file, or _site/cc)"
       option :file_routing, type: :string,
                             desc: "File routing (by-document|flat|by-format)"
       option :cache_dir, type: :string, desc: "Cache directory"

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

@@ -72,7 +72,7 @@ module Metanorma
           topic: cli_options[:topic] || gh["topic"],
           repos: cli_options[:repos] || file_data["repos"],
           channels: cli_options[:channels].any? ? cli_options[:channels] : Array(file_data["channels"]),
-          output_dir: cli_options[:output_dir] || file_data["output_dir"],
+          output_dir: cli_options[:output_dir] || file_data["output_dir"] || "_site/cc",
           file_routing: cli_options[:file_routing] || file_data["file_routing"] || "by-document",
           cache_dir: cli_options[:cache_dir] || file_data["cache_dir"],
           data_dir: cli_options[:data_dir] || file_data["data_dir"],

data/lib/metanorma/release/delta_state.rb

@@ -29,6 +29,10 @@ module Metanorma
         raise NotImplementedError, "#{self.class} must implement #release_files"
       end
 
+      def release_fingerprint(repo_key, tag)
+        raise NotImplementedError, "#{self.class} must implement #release_fingerprint"
+      end
+
       def mark_processed(repo_key, tag, content_hash, files)
         raise NotImplementedError,
               "#{self.class} must implement #mark_processed"
@@ -85,11 +89,20 @@ module Metanorma
         releases[tag]["files"] || []
       end
 
-      def mark_processed(repo_key, tag, content_hash, files)
+      def release_fingerprint(repo_key, tag)
+        releases = repo_state(repo_key)["releases"]
+        return nil unless releases.key?(tag)
+
+        releases[tag]["fingerprint"]
+      end
+
+      def mark_processed(repo_key, tag, content_hash, files,
+                         fingerprint: nil)
         repo = ensure_repo(repo_key)
         repo["releases"][tag] = {
           "content_hash" => content_hash.to_s,
           "files" => files,
+          "fingerprint" => fingerprint,
         }
       end
 
@@ -138,6 +151,7 @@ module Metanorma
       def set_etag(_repo_key, _etag) = nil
       def processed?(*_args) = false
       def release_files(*_args) = []
+      def release_fingerprint(*_args) = nil
       def mark_processed(*_args); end
       def cleanup_stale(*_args) = 0
     end

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

@@ -15,14 +15,16 @@ module Metanorma
           end
 
           def fetch(repo, etag: nil)
-            releases = paginate_releases(repo.to_s)
+            releases, failed = paginate_releases(repo.to_s)
             parsed = releases.map { |r| parse_release(r) }
             FetchResult.new(releases: parsed, etag: "etag-#{repo}",
-                            unchanged?: false)
+                            unchanged?: false, failed?: failed)
           end
 
           private
 
+          # Returns [releases, failed] — failed is true when the listing
+          # errored, which callers must not treat as an empty release set.
           def paginate_releases(repo_slug)
             all = []
             page = 1
@@ -35,10 +37,10 @@ module Metanorma
 
               page += 1
             end
-            all
+            [all, false]
           rescue StandardError => e
             Metanorma::Release.logger.warn "Failed to fetch releases for #{repo_slug}: #{e.message}"
-            []
+            [[], true]
           end
 
           def parse_release(r)

data/lib/metanorma/release/site.rb

@@ -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)
 

data/lib/metanorma/release/version.rb

@@ -2,6 +2,6 @@
 
 module Metanorma
   module Release
-    VERSION = "0.2.25"
+    VERSION = "0.2.26"
   end
 end

data/lib/metanorma/release/zip_packager.rb

@@ -35,7 +35,7 @@ module Metanorma
 
         zip_path = File.join(dir, "#{canonical_base}.zip")
         FileUtils.rm_f(zip_path)
-        Zip::File.open(zip_path, Zip::File::CREATE) do |zipfile|
+        Zip::File.open(zip_path, create: true) do |zipfile|
           files.each do |file|
             ext = File.extname(file)
             entry_name = "#{canonical_base}#{ext}"

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-release
 version: !ruby/object:Gem::Version
-  version: 0.2.25
+  version: 0.2.26
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-01 00:00:00.000000000 Z
+date: 2026-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: relaton-bib
+  name: relaton
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: 3.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: 3.1.1
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement