metanorma-release 0.2.5 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb0e65e7f0e9f70aa92db6b778aced4b069a8de152db5227088569988fa691e3
-  data.tar.gz: 6482d90ac0568c9b2e8cda7b62b051981c14649d5eb7c3761ac62945ecbeafc9
+  metadata.gz: 33318ed83e806c7f0f7e4d16c3095762cf64f3558214a6775549c2dd5bd74302
+  data.tar.gz: 3d72e6618afb935951e22b19284299dad2adc3c7940cd87735fb47bb3f13b650
 SHA512:
-  metadata.gz: 7fb10367dbc5b804eea4f9c4f8ef4ca14108c9c735952887028f943411a67586a49411309ff6ac049a7ca0ab6b801082801cecbd92761690a9b3321564effe62
-  data.tar.gz: f0c46507af66c462bfc5d8caa3a4c13642688da1a05a29312c98700fed51693319e2bf19f174866b67fff9b009e0ee1bb80b432f832ed3645dae9d3f35ca473f
+  metadata.gz: eff37e2e0d375443613b578fabf7f47a51b007557ff602995105c020fe8a67034b755514d5f75d9e915189b8a189b1b32b3439ea632e478413556bd2bebc4575
+  data.tar.gz: fa1201421381243f2e7b1ef363c621afe636b4d684493a29b53a333f44417093f32bae0cc1ee0c99a4a9f6722177b28e6e457811909680ca631dd871d4ac0143

data/lib/metanorma/release/channel.rb

@@ -23,7 +23,10 @@ module Metanorma
       end
 
       def matches?(filter_channels)
-        filter_channels.any? { |c| eql?(Channel.new(c)) }
+        filter_channels.any? do |c|
+          fc = Channel.new(c)
+          eql?(fc) || @name.start_with?("#{fc.name}/")
+        end
       end
 
       def self.parse(channel_string)

data/lib/metanorma/release/channel_filter.rb

@@ -18,7 +18,7 @@ module Metanorma
         return true if @all_channels
 
         parsed = manifest_channels.map { |c| Channel.new(c) }
-        parsed.any? { |mc| @channels.any? { |fc| fc.eql?(mc) } }
+        parsed.any? { |mc| mc.matches?(@channels) }
       end
 
       private
@@ -29,7 +29,7 @@ module Metanorma
         release_channels = (release_metadata["channels"] || []).map do |c|
           Channel.new(c)
         end
-        release_channels.any? { |rc| @channels.any? { |fc| fc.eql?(rc) } }
+        release_channels.any? { |rc| rc.matches?(@channels) }
       end
 
       def stage_match?(release_metadata)

data/lib/metanorma/release/cli.rb

@@ -82,6 +82,7 @@ module Metanorma
       option :file_routing, type: :string, default: "by-document",
                             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 :include_drafts, type: :boolean, default: false,
                               desc: "Include draft releases"
       option :concurrency, type: :numeric, default: 4
@@ -101,6 +102,7 @@ module Metanorma
           output_dir: options[:output_dir],
           file_routing: options[:file_routing],
           cache_dir: options[:cache_dir],
+          data_dir: options[:data_dir],
           include_drafts: options[:include_drafts],
           concurrency: options[:concurrency],
           min_documents: options[:min_documents],

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

@@ -8,7 +8,8 @@ module Metanorma
       Config = Struct.new(
         :source, :organizations, :topic, :repos, :repo_pattern, :local_path,
         :channels, :stages, :output_dir, :file_routing, :cache_dir,
-        :include_drafts, :concurrency, :min_documents, :token, :create_zip,
+        :data_dir, :include_drafts, :concurrency, :min_documents, :token,
+        :create_zip, :org,
         keyword_init: true
       )
 
@@ -17,14 +18,17 @@ module Metanorma
 
       def initialize(config)
         @config = config
+        @org_config = nil
       end
 
       def call
+        load_org_config
         result = run_aggregation
         return result unless result.publications.any?
 
         index = build_index(result)
-        site = Site.new(index: index, output_dir: @config.output_dir)
+        site = Site.new(index: index, output_dir: @config.output_dir,
+                        data_dir: @config.data_dir)
         site.write!
         site.enrich!
         site.package! if @config.create_zip
@@ -46,11 +50,13 @@ module Metanorma
           output_dir: merged[:output_dir],
           file_routing: merged[:file_routing],
           cache_dir: merged[:cache_dir] || DEFAULT_CACHE_DIR,
+          data_dir: merged[:data_dir],
           include_drafts: merged[:include_drafts],
           concurrency: merged[:concurrency],
           min_documents: merged[:min_documents],
           token: merged[:token],
           create_zip: merged[:create_zip],
+          org: merged[:org],
         )
       end
 
@@ -73,11 +79,13 @@ module Metanorma
           output_dir: cli_options[:output_dir] || file_data["output_dir"],
           file_routing: cli_options[:file_routing] || file_data["file_routing"],
           cache_dir: cli_options[:cache_dir] || file_data["cache_dir"],
+          data_dir: cli_options[:data_dir] || file_data["data_dir"],
           include_drafts: cli_options[:include_drafts] || file_data["include_drafts"],
           concurrency: cli_options[:concurrency] || file_data["concurrency"],
           min_documents: cli_options[:min_documents] || file_data["min_documents"],
           token: cli_options[:token],
           create_zip: cli_options[:create_zip],
+          org: file_data["org"],
         }
       end
 
@@ -159,6 +167,27 @@ module Metanorma
       rescue LoadError
         warn "  (relaton gem not available — bibliography skipped)"
       end
+
+      def load_org_config
+        return unless @config.org
+
+        ref = OrgConfig.parse_ref(@config.org)
+        local_path = OrgConfig.remote_path(ref)
+        @org_config = File.exist?(local_path) ? OrgConfig.from_file(local_path) : fetch_org_config_from_github(ref)
+      end
+
+      def fetch_org_config_from_github(ref)
+        require "octokit"
+        token = @config.token || ENV.fetch("GITHUB_TOKEN", nil)
+        client = token ? Octokit::Client.new(access_token: token) : Octokit::Client.new
+        remote = OrgConfig.remote_path(ref)
+        contents = client.contents("#{ref.owner}/#{ref.repo}", path: remote)
+        decoded = Base64.decode64(contents[:content])
+        OrgConfig.from_yaml(decoded)
+      rescue StandardError => e
+        warn "  (org config not loaded from #{ref.owner}/#{ref.repo}: #{e.message})"
+        OrgConfig.defaults
+      end
     end
   end
 end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "yaml"
+
 module Metanorma
   module Release
     class ReleaseCommand
@@ -14,7 +16,8 @@ module Metanorma
       end
 
       def call
-        config = load_config
+        org_config = load_org_config
+        config = load_config(org_config: org_config)
         options = { token: @config.token }
         publisher = PlatformFactory.build_publisher(@config.platform, options)
         channel_override = Channel.parse_list(@config.channels) if @config.channels
@@ -45,15 +48,59 @@ module Metanorma
 
       private
 
-      def load_config
+      def load_config(org_config: nil)
         if @config.config_source && File.exist?(@config.config_source)
-          Metanorma::Release::Config.from_file(@config.config_source)
+          Metanorma::Release::Config.from_file(@config.config_source, org_config: org_config)
         elsif @config.manifest && File.exist?(@config.manifest)
-          Metanorma::Release::Config.from_file(@config.manifest)
+          Metanorma::Release::Config.from_file(@config.manifest, org_config: org_config)
         else
-          Metanorma::Release::Config.defaults
+          Metanorma::Release::Config.defaults(org_config: org_config)
         end
       end
+
+      def load_org_config
+        path = find_config_path
+        return nil unless path
+
+        org_ref = extract_org_ref(path)
+        return nil unless org_ref
+
+        resolve_org_config(org_ref)
+      end
+
+      def find_config_path
+        if @config.config_source && File.exist?(@config.config_source)
+          @config.config_source
+        elsif @config.manifest && File.exist?(@config.manifest)
+          @config.manifest
+        end
+      end
+
+      def extract_org_ref(path)
+        raw = YAML.safe_load_file(path, permitted_classes: [Symbol]) || {}
+        raw["org"]
+      end
+
+      def resolve_org_config(org_ref)
+        ref = OrgConfig.parse_ref(org_ref)
+        local_path = OrgConfig.remote_path(ref)
+        return OrgConfig.from_file(local_path) if File.exist?(local_path)
+
+        fetch_org_config_from_github(ref)
+      end
+
+      def fetch_org_config_from_github(ref)
+        require "octokit"
+        token = @config.token || ENV.fetch("GITHUB_TOKEN", nil)
+        client = token ? Octokit::Client.new(access_token: token) : Octokit::Client.new
+        remote = OrgConfig.remote_path(ref)
+        contents = client.contents("#{ref.owner}/#{ref.repo}", path: remote)
+        decoded = Base64.decode64(contents[:content])
+        OrgConfig.from_yaml(decoded)
+      rescue StandardError => e
+        warn "  (org config not loaded from #{ref.owner}/#{ref.repo}: #{e.message})"
+        OrgConfig.defaults
+      end
     end
   end
 end

data/lib/metanorma/release/config.rb

@@ -5,26 +5,31 @@ require "yaml"
 module Metanorma
   module Release
     class Config
-      def self.from_yaml(yaml_string)
+      def self.from_yaml(yaml_string, org_config: nil)
         data = YAML.safe_load(yaml_string, permitted_classes: [Symbol])
-        new(data || {})
+        new(data || {}, org_config: org_config)
       end
 
-      def self.from_file(path)
+      def self.from_file(path, org_config: nil)
         unless File.exist?(path)
           raise ArgumentError,
                 "Config file not found: #{path}"
         end
 
-        from_yaml(File.read(path))
+        from_yaml(File.read(path), org_config: org_config)
       end
 
-      def self.defaults
-        new({})
+      def self.defaults(org_config: nil)
+        new({}, org_config: org_config)
       end
 
-      def initialize(data)
+      def initialize(data, org_config: nil)
         @data = data
+        @org_config = org_config
+      end
+
+      def org
+        @data["org"]
       end
 
       def channels
@@ -77,6 +82,15 @@ module Metanorma
         rule_channels = resolve_routing_rules(publication)
         return rule_channels if rule_channels
 
+        org_rule_channels = resolve_org_routing_rules(publication)
+        return org_rule_channels if org_rule_channels
+
+        local_default = routing_default
+        return local_default unless local_default == ["public"] && @org_config
+
+        org_default = @org_config&.routing_default
+        return org_default unless org_default.nil? || org_default.empty?
+
         default_channels
       end
 
@@ -99,6 +113,18 @@ module Metanorma
         end
         nil
       end
+
+      def resolve_org_routing_rules(publication)
+        return nil unless @org_config
+
+        @org_config.routing_rules.each do |rule|
+          match = true
+          match &&= Array(rule["stage"]).map(&:to_s).include?(publication.stage.to_s) if rule["stage"]
+          match &&= Array(rule["doctype"]).map(&:to_s).include?(publication.doctype.to_s) if rule["doctype"]
+          return rule["channels"] if match && rule["channels"]
+        end
+        nil
+      end
     end
   end
 end

data/lib/metanorma/release/org_config.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Metanorma
+  module Release
+    class OrgConfig
+      Ref = Struct.new(:owner, :repo, :name, keyword_init: true)
+
+      def self.parse_ref(org_string)
+        parts = org_string.to_s.split("#", 2)
+        slug = parts[0].to_s.strip
+        segments = slug.split("/", 2)
+        raise ArgumentError, "Invalid org reference: #{org_string}" unless segments.length == 2
+
+        Ref.new(owner: segments[0], repo: segments[1], name: parts[1]&.strip)
+      end
+
+      def self.default_config_name
+        "channels"
+      end
+
+      def self.remote_path(ref)
+        name = ref.name || default_config_name
+        ".metanorma/#{name}.yml"
+      end
+
+      def self.from_yaml(yaml_string)
+        data = YAML.safe_load(yaml_string, permitted_classes: [Symbol])
+        new(data || {})
+      end
+
+      def self.from_file(path)
+        raise ArgumentError, "Org config file not found: #{path}" unless File.exist?(path)
+
+        from_yaml(File.read(path))
+      end
+
+      def self.defaults
+        new({})
+      end
+
+      def initialize(data)
+        @data = data
+      end
+
+      def channels
+        @data.fetch("channels", [])
+      end
+
+      def routing_default
+        dig_defaults_routing("default") || []
+      end
+
+      def routing_rules
+        dig_defaults_routing("rules") || []
+      end
+
+      def valid_channel?(name)
+        return true if channels.empty?
+
+        ch = Channel.new(name)
+        channels.any? do |valid|
+          valid_ch = Channel.new(valid)
+          ch.eql?(valid_ch) || ch.name.start_with?("#{valid_ch.name}/") || valid_ch.name.start_with?("#{ch.name}/")
+        end
+      end
+
+      private
+
+      def dig_defaults_routing(key)
+        @data.dig("defaults", "routing", key)
+      end
+    end
+  end
+end

data/lib/metanorma/release/site.rb

@@ -9,9 +9,10 @@ module Metanorma
     class Site
       attr_reader :index, :output_dir
 
-      def initialize(index:, output_dir:)
+      def initialize(index:, output_dir:, data_dir: nil)
         @index = index
         @output_dir = output_dir
+        @data_dir = data_dir
       end
 
       def write!
@@ -22,22 +23,49 @@ module Metanorma
       def enrich!
         return if index.empty?
 
-        documents = index.publications.map do |pub|
-          rxl_file = pub.files.find { |f| f.format == "rxl" }
-          next pub.to_h unless rxl_file
+        documents = enrich_documents
+        write_relaton_index(documents)
+        write_data_file(documents) if @data_dir
+      end
+
+      def package!(zip_path: nil)
+        require "zip"
 
-          rxl_path = File.join(output_dir, rxl_file.path)
-          next pub.to_h unless File.exist?(rxl_path)
+        path = zip_path || "#{output_dir}.zip"
+        Zip::File.open(path, Zip::File::CREATE) do |zipfile|
+          Dir.glob("#{output_dir}/**/*").each do |file|
+            next if File.directory?(file)
 
-          bib = Relaton::Bib::Item.from_xml(File.read(rxl_path))
-          enriched = pub.to_h
-          enriched["bibliographic"] = bib.to_h
-          enriched
+            entry_name = file.sub("#{File.dirname(output_dir)}/", "")
+            zipfile.add(entry_name, file)
+          end
+        end
+        path
+      end
+
+      private
+
+      def enrich_documents
+        index.publications.map do |pub|
+          enrich_publication(pub)
         rescue StandardError => e
           warn "  Skip #{pub.identifier}: #{e.message}"
           pub.to_h
         end
+      end
+
+      def enrich_publication(pub)
+        rxl_file = pub.files.find { |f| f.format == "rxl" }
+        return pub.to_h unless rxl_file
 
+        rxl_path = File.join(output_dir, rxl_file.path)
+        return pub.to_h unless File.exist?(rxl_path)
+
+        bib = Relaton::Bib::Item.from_xml(File.read(rxl_path))
+        pub.to_h.merge("bibliographic" => bib.to_h)
+      end
+
+      def write_relaton_index(documents)
         dest = File.join(output_dir, "relaton")
         FileUtils.mkdir_p(dest)
         index_data = { "root" => { "title" => "Document Registry",
@@ -47,19 +75,59 @@ module Metanorma
         File.write(File.join(dest, "index.yaml"), YAML.dump(index_data))
       end
 
-      def package!(zip_path: nil)
-        require "zip"
+      def write_data_file(documents)
+        FileUtils.mkdir_p(@data_dir)
+        items = documents.compact.map { |doc| flatten_for_site(doc) }
+        File.write(File.join(@data_dir, "documents.json"),
+                   JSON.pretty_generate({ "items" => items }))
+      end
 
-        path = zip_path || "#{output_dir}.zip"
-        Zip::File.open(path, Zip::File::CREATE) do |zipfile|
-          Dir.glob("#{output_dir}/**/*").each do |file|
-            next if File.directory?(file)
+      def flatten_for_site(doc)
+        bib = doc["bibliographic"] || {}
+        doc_id = resolve_doc_id(bib, doc)
+        {
+          "slug" => doc["id"],
+          "id" => doc_id,
+          "title" => doc["title"].to_s,
+          "abstract" => extract_abstract(bib),
+          "stage" => (doc["stage"] || "published").to_s.downcase,
+          "doctype" => extract_doctype(bib) || doc.fetch("doctype", ""),
+          "edition" => doc["edition"],
+          "date" => extract_date(doc),
+          "channels" => doc["channels"] || [],
+          "formats" => doc["formats"] || [],
+          "files" => doc["files"] || [],
+        }
+      end
 
-            entry_name = file.sub("#{File.dirname(output_dir)}/", "")
-            zipfile.add(entry_name, file)
-          end
-        end
-        path
+      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)
+        release_date = doc.dig("source", "releaseDate")
+        return nil unless release_date
+
+        release_date.to_s.split(/[T ]/).first
       end
     end
   end

data/lib/metanorma/release/version.rb

@@ -2,6 +2,6 @@
 
 module Metanorma
   module Release
-    VERSION = "0.2.5"
+    VERSION = "0.2.8"
   end
 end

data/lib/metanorma/release.rb

@@ -11,6 +11,7 @@ module Metanorma
     autoload :Index,             "metanorma/release/index"
     autoload :Site,              "metanorma/release/site"
     autoload :Channel,           "metanorma/release/channel"
+    autoload :OrgConfig,         "metanorma/release/org_config"
     autoload :Config,            "metanorma/release/config"
     autoload :ContentHash,       "metanorma/release/content_hash"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-release
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.8
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-17 00:00:00.000000000 Z
+date: 2026-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: relaton-bib
@@ -102,6 +102,7 @@ files:
 - lib/metanorma/release/file_routing.rb
 - lib/metanorma/release/index.rb
 - lib/metanorma/release/interfaces.rb
+- lib/metanorma/release/org_config.rb
 - lib/metanorma/release/platform.rb
 - lib/metanorma/release/platform/github.rb
 - lib/metanorma/release/platform/github/manifest_reader.rb