metanorma-release 0.2.21 → 0.2.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 870b32feb3cf51fae8f217ca433e725d783904cd986947264f886e16bc30e03b
-  data.tar.gz: f37c695d3ed8bd4becde735a1eb7f0d598ac2e1c946a047c3574d910eff08596
+  metadata.gz: fcbd94afb53b355f5637604bd713ec156adaf4e061c49dda44c1cf6cf777938a
+  data.tar.gz: 6dfa4f1d17e6aa4bac1bccc991510d9ac3856012d2205c9ce46644aa045d1ede
 SHA512:
-  metadata.gz: 8d3292688c6e9043a2c05c75704fc3362e07344285c2d928e2aa85b3e48592aed79ed573424c36ca583e977e745640d44609887849511bb5853d093c38ae40e3
-  data.tar.gz: 20c61ff249f15acc7022c24acf13206dfc4d08193168a9597d96a4c32df98166e54c1ab7f1a339e894f1bd43fc42d9e2fca43cbb11544551c3629002267d1010
+  metadata.gz: 5acb0eb4eaaa919c5a5f5f5a868aea80cc0d1de643fc9377d4497e0148f6b84171dee1208832f037b3dcab9ab285e8e7fdcba600cb0db99a2169ed4da484f50d
+  data.tar.gz: 9e55e666c20c4e5c93a2545ff5d8927328721878f83ae8f4affdbbe40bc31d94f021f796ce437d3389297eeecca802875dc2f3174545db67f2d586218f10156c

data/TODO.cleanups/01-channel-resolver-ocp.md

@@ -0,0 +1,28 @@
+# 01 — Extract routing domain model (OCP / model-driven)
+
+## Problem
+`Config` mixes data access with routing behavior. Matching logic for pattern,
+source, stage, and doctype is embedded as private methods using raw hashes.
+This violates OCP — adding a new routing criterion requires modifying Config.
+
+## Solution
+Extract value objects that encapsulate matching logic:
+
+- `DocumentEntry` — matches by `pattern` (slug glob) or `source` (file path)
+- `RoutingRule` — matches by `stage` and/or `doctype`
+- `ChannelResolver` — composes strategies, resolves channels for a Publication
+
+Config becomes a pure data reader. ChannelResolver owns the behavior.
+New routing criteria = new value object + register in resolver, no existing code changes.
+
+## Files
+- Create `lib/metanorma/release/channel_resolver.rb`
+- Update `lib/metanorma/release/config.rb` — remove private routing methods
+- Update `lib/metanorma/release/release_pipeline.rb` — use ChannelResolver
+- Update `lib/metanorma/release.rb` — add autoload
+- Update `spec/domain/config_spec.rb` — move routing specs
+- Create `spec/domain/channel_resolver_spec.rb`
+
+## Status
+- [x] Implement — DocumentEntry merged with RoutingRule, single `documents` list
+- [x] Specs pass — 234 examples, 0 failures

data/TODO.cleanups/02-documentation.md

@@ -0,0 +1,31 @@
+# 02 — Update metanorma.org documentation
+
+## Problem
+Three documentation files still reference the old three-file architecture
+(org config repo, per-repo channels.yml, org: key).
+
+## Files to update
+
+### `_pages/install/publication-setup.adoc`
+- Remove org config repo section and channels.yml schema
+- Remove `org:` key from config examples
+- Remove `.metanorma/channels.yml` from file checklist
+- Move `display_categories` into aggregator config schema
+- Document two-file architecture: release manifest + aggregate config
+
+### `_posts/2026-05-13-channel-based-publication.adoc`
+- Remove `.metanorma/channels.yml` sections (lines 64-77, 124-130, 238-242)
+- Remove CalConnect/.metanorma references (line 504)
+- Update `display_category` reference (line 449) — now in aggregator config
+- Reflect two-file architecture throughout
+
+### `_pages/install/cicd.adoc`
+- Remove "Channel discovery manifest" subsection (lines 476-483)
+- Remove `channels.yml` from file tree (line 224)
+- Remove `.metanorma/channels.yml` section (line 243)
+- Remove org config references (lines 408-432)
+
+## Status
+- [x] publication-setup.adoc
+- [x] blog post
+- [x] cicd.adoc

data/TODO.cleanups/03-cleanup-repos.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+# Delete .metanorma/channels.yml (and .metanorma/ dir) from CalConnect repos.
+# Usage: bash TODO.cleanups/03-cleanup-repos.sh [--dry-run]
+#
+# This removes dead config files — the gem never reads per-repo channels.yml.
+
+set -uo pipefail
+
+DRY_RUN=false
+[[ "${1:-}" == "--dry-run" ]] && DRY_RUN=true
+
+BRANCH="chore/remove-dead-channels-yml"
+COMMIT_MSG="chore: remove dead .metanorma/channels.yml
+
+The metanorma-release gem never reads per-repo .metanorma/channels.yml.
+Channel routing is configured in metanorma.release.yml via documents[]
+entries. This file was dead code that created confusion about the
+architecture."
+
+count=0
+skipped=0
+
+for channels_file in $(find /Users/mulgogi/src/calconnect -maxdepth 3 -name "channels.yml" -path "*/.metanorma/*" 2>/dev/null | sort); do
+  metanorma_dir=$(dirname "$channels_file")
+  repo_dir=$(dirname "$metanorma_dir")
+  repo_name=$(basename "$repo_dir")
+
+  # Skip the org config repo
+  if [[ "$repo_name" == "dot-metanorma" ]]; then
+    echo "SKIP: $repo_name (org config repo — handle separately)"
+    skipped=$((skipped + 1))
+    continue
+  fi
+
+  count=$((count + 1))
+
+  if $DRY_RUN; then
+    echo "DRY: $repo_name — would remove $channels_file"
+    continue
+  fi
+
+  cd "$repo_dir"
+
+  # Check for uncommitted changes
+  if ! git diff --quiet HEAD 2>/dev/null; then
+    echo "SKIP: $repo_name — uncommitted changes"
+    continue
+  fi
+
+  # Create branch from main
+  git checkout main -q 2>/dev/null
+  git pull -q 2>/dev/null || true
+  git checkout -b "$BRANCH" -q 2>/dev/null || git checkout "$BRANCH" -q
+
+  # Remove the file and directory
+  rm -rf "$metanorma_dir"
+
+  # Commit and push
+  git add -A
+  if git diff --cached --quiet; then
+    echo "SKIP: $repo_name — no changes (already removed?)"
+    git checkout main -q 2>/dev/null
+    continue
+  fi
+
+  git commit -m "$COMMIT_MSG" -q
+  git push -u origin "$BRANCH" -q 2>/dev/null
+
+  # Create PR
+  gh pr create \
+    --title "chore: remove dead .metanorma/channels.yml" \
+    --body "$COMMIT_MSG" \
+    --base main \
+    --head "$BRANCH" \
+    2>/dev/null || echo "WARN: $repo_name — PR creation failed (may already exist)"
+
+  git checkout main -q 2>/dev/null
+
+  echo "DONE: $repo_name"
+done
+
+echo ""
+echo "Processed: $count repos, skipped: $skipped"
+if $DRY_RUN; then
+  echo "(dry run — no changes made)"
+fi

data/TODO.cleanups/03-repo-channels-yml-cleanup.md

@@ -0,0 +1,20 @@
+# 03 — Delete .metanorma/channels.yml from 55 CalConnect repos
+
+## Problem
+55 CalConnect repos have `.metanorma/channels.yml` that is dead code.
+The gem never reads these files. They create confusion about the architecture.
+
+## Approach
+Script-based cleanup via GitHub API:
+1. Find all repos with `.metanorma/channels.yml`
+2. Create branch `chore/remove-dead-channels-yml`
+3. Delete `.metanorma/channels.yml` (and `.metanorma/` dir if empty)
+4. Commit, push, create PR
+
+## Repo list (55 repos)
+Found via: `find /Users/mulgogi/src/calconnect -maxdepth 3 -name "channels.yml"`
+
+## Status
+- [x] Script written — `03-cleanup-repos.sh`
+- [x] Dry run verified — 54 repos found
+- [x] Run on all repos — 53 branches pushed, 53 PRs created, all 53 rebase-merged

data/TODO.cleanups/04-version-bump.md

@@ -0,0 +1,13 @@
+# 04 — Version bump
+
+## Problem
+Breaking changes require a version bump. Removed OrgConfig class, stages filter,
+and org: key support. Added pattern-based routing, display_categories in
+aggregator config.
+
+## Changes
+- Bump version in `lib/metanorma/release/version.rb`
+- Update CHANGELOG if present
+
+## Status
+- [x] Bumped to 0.2.21

data/lib/metanorma/release/aggregation_pipeline.rb

@@ -84,7 +84,7 @@ module Metanorma
 
       private
 
-      def process_repo(repo, _output_dir, config)
+      def process_repo(repo, output_dir, config)
         repo_key = repo.to_s
 
         manifest_channels = @deps.manifest_reader.read(repo)
@@ -120,9 +120,11 @@ module Metanorma
 
           if @deps.delta_state.processed?(repo_key, tag, content_hash)
             files = @deps.delta_state.release_files(repo_key, tag)
-            publications << build_publication(metadata, files, content_hash,
-                                              release, repo)
-            next
+            if files.all? { |f| File.exist?(File.join(output_dir, f)) }
+              publications << build_publication(metadata, files, content_hash,
+                                                release, repo)
+              next
+            end
           end
 
           zip_asset = find_zip_asset(release)

data/lib/metanorma/release/channel_filter.rb

@@ -3,15 +3,13 @@
 module Metanorma
   module Release
     class MetadataFilter
-      def initialize(channels: [], stages: [])
+      def initialize(channels: [])
         @channels = channels.map { |c| Channel.new(c) }
-        @stages = Set.new(stages.map(&:downcase))
         @all_channels = @channels.empty?
-        @all_stages = @stages.empty?
       end
 
       def matches?(release_metadata)
-        channel_match?(release_metadata) && stage_match?(release_metadata)
+        channel_match?(release_metadata)
       end
 
       def overlaps?(manifest_channels)
@@ -31,12 +29,6 @@ module Metanorma
         end
         release_channels.any? { |rc| rc.matches?(@channels) }
       end
-
-      def stage_match?(release_metadata)
-        return true if @all_stages
-
-        @stages.include?(release_metadata["stage"].to_s.downcase)
-      end
     end
   end
 end

data/lib/metanorma/release/cli.rb

@@ -75,8 +75,6 @@ module Metanorma
       option :repos, type: :array, desc: "Explicit repo list"
       option :channels, type: :array, default: [],
                         desc: "Filter channels"
-      option :stages, type: :array, default: [],
-                      desc: "Filter stages"
       option :output_dir, type: :string, default: "_site/cc",
                           desc: "Output directory"
       option :file_routing, type: :string,
@@ -98,7 +96,6 @@ module Metanorma
           topic: options[:topic],
           repos: options[:repos],
           channels: options[:channels],
-          stages: options[:stages],
           output_dir: options[:output_dir],
           file_routing: options[:file_routing],
           cache_dir: options[:cache_dir],

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

@@ -8,9 +8,9 @@ module Metanorma
     class AggregateCommand
       Config = Struct.new(
         :source, :organizations, :topic, :repos, :repo_pattern, :local_path,
-        :channels, :stages, :output_dir, :file_routing, :cache_dir,
+        :channels, :output_dir, :file_routing, :cache_dir,
         :data_dir, :include_drafts, :concurrency, :min_documents, :token,
-        :create_zip, :org,
+        :create_zip, :display_categories,
         keyword_init: true
       )
 
@@ -19,17 +19,16 @@ 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,
-                        data_dir: @config.data_dir, org_config: @org_config)
+                        data_dir: @config.data_dir,
+                        display_categories: @config.display_categories)
         site.write!
         site.enrich!
         site.package! if @config.create_zip
@@ -47,7 +46,6 @@ module Metanorma
           topic: merged[:topic],
           repos: merged[:repos],
           channels: merged[:channels],
-          stages: merged[:stages],
           output_dir: merged[:output_dir],
           file_routing: merged[:file_routing],
           cache_dir: merged[:cache_dir] || DEFAULT_CACHE_DIR,
@@ -57,7 +55,7 @@ module Metanorma
           min_documents: merged[:min_documents],
           token: merged[:token],
           create_zip: merged[:create_zip],
-          org: merged[:org],
+          display_categories: merged[:display_categories],
         )
       end
 
@@ -76,7 +74,6 @@ 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"]),
-          stages: cli_options[:stages].any? ? cli_options[:stages] : Array(file_data["stages"]),
           output_dir: cli_options[:output_dir] || file_data["output_dir"],
           file_routing: cli_options[:file_routing] || file_data["file_routing"] || "by-document",
           cache_dir: cli_options[:cache_dir] || file_data["cache_dir"],
@@ -86,7 +83,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"],
+          display_categories: file_data["display_categories"] || [],
         }
       end
 
@@ -104,7 +101,6 @@ module Metanorma
 
         metadata_filter = MetadataFilter.new(
           channels: Channel.parse_list(@config.channels),
-          stages: @config.stages || [],
         )
         routing = FileRoutingFactory.from_name(@config.file_routing)
         asset_processor = AssetProcessor.new(
@@ -169,27 +165,6 @@ 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,6 +1,5 @@
 # frozen_string_literal: true
 
-require "base64"
 require "yaml"
 
 module Metanorma
@@ -17,8 +16,7 @@ module Metanorma
       end
 
       def call
-        org_config = load_org_config
-        config = load_config(org_config: org_config)
+        config = load_config
         options = { token: @config.token }
         publisher = PlatformFactory.build_publisher(@config.platform, options)
         channel_override = Channel.parse_list(@config.channels) if @config.channels
@@ -49,59 +47,15 @@ module Metanorma
 
       private
 
-      def load_config(org_config: nil)
+      def load_config
         if @config.config_source && File.exist?(@config.config_source)
-          Metanorma::Release::Config.from_file(@config.config_source, org_config: org_config)
+          Metanorma::Release::Config.from_file(@config.config_source)
         elsif @config.manifest && File.exist?(@config.manifest)
-          Metanorma::Release::Config.from_file(@config.manifest, org_config: org_config)
+          Metanorma::Release::Config.from_file(@config.manifest)
         else
-          Metanorma::Release::Config.defaults(org_config: org_config)
+          Metanorma::Release::Config.defaults
         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,27 +5,26 @@ require "yaml"
 module Metanorma
   module Release
     class Config
-      def self.from_yaml(yaml_string, org_config: nil)
+      def self.from_yaml(yaml_string)
         data = YAML.safe_load(yaml_string, permitted_classes: [Symbol])
-        new(data || {}, org_config: org_config)
+        new(data || {})
       end
 
-      def self.from_file(path, org_config: nil)
+      def self.from_file(path)
         unless File.exist?(path)
           raise ArgumentError,
                 "Config file not found: #{path}"
         end
 
-        from_yaml(File.read(path), org_config: org_config)
+        from_yaml(File.read(path))
       end
 
-      def self.defaults(org_config: nil)
-        new({}, org_config: org_config)
+      def self.defaults
+        new({})
       end
 
-      def initialize(data, org_config: nil)
+      def initialize(data)
         @data = data
-        @org_config = org_config
       end
 
       def org
@@ -36,18 +35,6 @@ module Metanorma
         @data.fetch("channels", [])
       end
 
-      def routing
-        @data.fetch("routing", {})
-      end
-
-      def routing_default
-        routing.fetch("default", ["public"])
-      end
-
-      def routing_rules
-        routing.fetch("rules", [])
-      end
-
       def slug_config
         @data.fetch("slug", {})
       end
@@ -64,66 +51,60 @@ module Metanorma
         @data.fetch("documents", [])
       end
 
-      def defaults
-        @data.fetch("defaults", {})
-      end
-
-      def default_channels
-        list = defaults.fetch("channels", nil)
-        return ["public"] unless list
-
-        list
+      def document_entries
+        @document_entries ||= documents.map { |d| DocumentEntry.new(d) }
       end
 
       def resolve_channels(publication)
-        manifest_channels = resolve_manifest_channels(publication)
-        return manifest_channels if manifest_channels
-
-        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
+        ChannelResolver.resolve(publication, self)
+      end
+    end
 
-        local_default = routing_default
-        return local_default unless local_default == ["public"] && @org_config
+    # Single routing entry — matches by any combination of pattern, source,
+    # stage, and doctype. An entry with no criteria matches everything (catch-all).
+    DocumentEntry = Struct.new(:pattern, :source, :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),
+        )
+      end
 
-        org_default = @org_config&.routing_default
-        return org_default unless org_default.nil? || org_default.empty?
+      def matches?(publication)
+        return false if channels.empty?
 
-        default_channels
-      end
+        if pattern && !File.fnmatch?(pattern, publication.slug)
+          return false
+        end
 
-      private
+        if source && !(publication.source_path&.end_with?(source) || false)
+          return false
+        end
 
-      def resolve_manifest_channels(publication)
-        documents.each do |entry|
-          next unless entry["source"] && publication.source_path&.end_with?(entry["source"])
-          return entry["channels"] if entry["channels"]
+        if !stages.empty? && !stages.include?(publication.stage.to_s)
+          return false
         end
-        nil
-      end
 
-      def resolve_routing_rules(publication)
-        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"]
+        if !doctypes.empty? && !doctypes.include?(publication.doctype.to_s)
+          return false
         end
-        nil
+
+        true
       end
+    end
 
-      def resolve_org_routing_rules(publication)
-        return nil unless @org_config
+    # Iterates document entries: first match wins. Falls back to ["public"].
+    class ChannelResolver
+      FALLBACK = ["public"].freeze
 
-        @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"]
+      def self.resolve(publication, config)
+        config.document_entries.each do |entry|
+          return entry.channels if entry.matches?(publication)
         end
-        nil
+        FALLBACK
       end
     end
   end

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

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

data/lib/metanorma/release/site.rb

@@ -9,11 +9,11 @@ module Metanorma
     class Site
       attr_reader :index, :output_dir
 
-      def initialize(index:, output_dir:, data_dir: nil, org_config: nil)
+      def initialize(index:, output_dir:, data_dir: nil, display_categories: [])
         @index = index
         @output_dir = output_dir
         @data_dir = data_dir
-        @org_config = org_config
+        @display_categories = display_categories || []
       end
 
       def write!
@@ -168,9 +168,13 @@ module Metanorma
       end
 
       def resolve_display_category(doctype)
-        return nil unless @org_config
+        return nil if doctype.nil? || doctype.empty?
 
-        @org_config.display_category_for(doctype)
+        @display_categories.each do |cat|
+          doctypes = cat["doctypes"] || []
+          return { "name" => cat["name"], "slug" => cat["slug"] } if doctypes.include?(doctype)
+        end
+        nil
       end
 
       def add_contributors(hash, bib)

data/lib/metanorma/release/version.rb

@@ -2,6 +2,6 @@
 
 module Metanorma
   module Release
-    VERSION = "0.2.21"
+    VERSION = "0.2.23"
   end
 end

data/lib/metanorma/release.rb

@@ -11,8 +11,9 @@ 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 :DocumentEntry,     "metanorma/release/config"
+    autoload :ChannelResolver,   "metanorma/release/config"
     autoload :ContentHash,       "metanorma/release/content_hash"
 
     # Strategies

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-release
 version: !ruby/object:Gem::Version
-  version: 0.2.21
+  version: 0.2.23
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-20 00:00:00.000000000 Z
+date: 2026-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: relaton-bib
@@ -84,6 +84,11 @@ files:
 - PROMPT.md
 - README.adoc
 - Rakefile
+- TODO.cleanups/01-channel-resolver-ocp.md
+- TODO.cleanups/02-documentation.md
+- TODO.cleanups/03-cleanup-repos.sh
+- TODO.cleanups/03-repo-channels-yml-cleanup.md
+- TODO.cleanups/04-version-bump.md
 - exe/metanorma-release
 - lib/metanorma/release.rb
 - lib/metanorma/release/aggregation_pipeline.rb
@@ -102,7 +107,6 @@ 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

data/lib/metanorma/release/org_config.rb

@@ -1,90 +0,0 @@
-# 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
-
-      def display_categories
-        @data.fetch("display_categories", [])
-      end
-
-      def display_category_for(doctype)
-        return nil if doctype.nil? || doctype.empty?
-
-        display_categories.each do |cat|
-          doctypes = cat["doctypes"] || []
-          return { "name" => cat["name"], "slug" => cat["slug"] } if doctypes.include?(doctype)
-        end
-        nil
-      end
-
-      private
-
-      def dig_defaults_routing(key)
-        @data.dig("defaults", "routing", key)
-      end
-    end
-  end
-end