metanorma-release 0.2.6 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd5a3df2d9c64ed9d7d70d8f4c3fd3646d8c932a4cbffc39c07490e0276e37d9
-  data.tar.gz: f688bc55c1dff3751cdc1903e420e64c7503f7716710655c123e034dd0a3a3fb
+  metadata.gz: 33318ed83e806c7f0f7e4d16c3095762cf64f3558214a6775549c2dd5bd74302
+  data.tar.gz: 3d72e6618afb935951e22b19284299dad2adc3c7940cd87735fb47bb3f13b650
 SHA512:
-  metadata.gz: 8127051648875b3ea36b988542c9ae82954bf68caf4ad91b785543d8ff6518ef95e1caa7d55334a777c22567806fbfa6cd32014812e6b2885388f42997f881d1
-  data.tar.gz: 77c9e3f867de101f3e962d674c8ddcabc630b9ba45557afe4c6338af0669a572dee37432b8231887cde7964f143817ea4ee1b50c9549bf2875dcdc76542152fe
+  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/commands/aggregate.rb

@@ -9,7 +9,7 @@ module Metanorma
         :source, :organizations, :topic, :repos, :repo_pattern, :local_path,
         :channels, :stages, :output_dir, :file_routing, :cache_dir,
         :data_dir, :include_drafts, :concurrency, :min_documents, :token,
-        :create_zip,
+        :create_zip, :org,
         keyword_init: true
       )
 
@@ -18,9 +18,11 @@ 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?
 
@@ -54,6 +56,7 @@ module Metanorma
           min_documents: merged[:min_documents],
           token: merged[:token],
           create_zip: merged[:create_zip],
+          org: merged[:org],
         )
       end
 
@@ -82,6 +85,7 @@ module Metanorma
           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
 
@@ -163,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/version.rb

@@ -2,6 +2,6 @@
 
 module Metanorma
   module Release
-    VERSION = "0.2.6"
+    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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-release
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.8
 platform: ruby
 authors:
 - Ribose Inc.
@@ -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