metanorma-release 0.2.1

data/lib/metanorma/release/release_pipeline.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    class ReleasePipeline
+      Dependencies = Struct.new(
+        :extractor, :filters, :change_detector,
+        :packager, :publisher, :naming_registry,
+        :manifest, :channel_override, :channel_config,
+        keyword_init: true
+      )
+
+      Config = Struct.new(
+        :output_dir, :manifest_path, :force, :force_replace_patterns,
+        :concurrency, :default_visibility,
+        keyword_init: true
+      )
+
+      def initialize(deps)
+        @deps = deps
+      end
+
+      def run(config)
+        documents = @deps.extractor.discover(config.output_dir)
+        filtered = apply_filters(documents)
+        results = phase_one(filtered, config)
+        phase_two(results, config)
+      end
+
+      private
+
+      def apply_filters(documents)
+        return documents unless @deps.filters && !@deps.filters.empty?
+
+        @deps.filters.reduce(documents) { |docs, filter| filter.apply(docs) }
+      end
+
+      def phase_one(documents, config)
+        documents.map do |doc|
+          strategy = @deps.naming_registry.resolve(doc.document_type)
+          tag = strategy.compute_tag(doc.id.to_s, doc.version)
+          canonical_base = strategy.compute_canonical_base(doc.id.to_s, doc.version)
+          change = @deps.change_detector.detect(doc, tag, force: config.force)
+
+          { document: doc, tag: tag, canonical_base: canonical_base,
+            changed: change.changed?, change_result: change }
+        end
+      end
+
+      def phase_two(candidates, config)
+        released = []
+        skipped = []
+        failed = []
+        released_artifacts = []
+
+        candidates.each do |candidate|
+          doc = candidate[:document]
+          tag = candidate[:tag]
+
+          unless candidate[:changed]
+            skipped << doc
+            next
+          end
+
+          begin
+            policy = resolve_policy(doc, config)
+            unless policy.release?
+              skipped << doc
+              next
+            end
+
+            artifact = @deps.packager.package(doc, canonical_base: candidate[:canonical_base])
+            channels = resolve_channels(doc, policy)
+            metadata_json = ReleaseMetadata.from_document(doc, channels: channels)
+            force = config.force_replace_patterns&.any? { |p| File.fnmatch?(p, doc.id.to_s) } || false
+
+            result = @deps.publisher.publish(tag, artifact, metadata_json, channels: channels, force_replace: force)
+            released << doc
+            released_artifacts << ReleasedArtifact.new(
+              id: doc.id.to_s, tag: tag.to_s,
+              url: result.url, channels: channels.map(&:to_s)
+            )
+          rescue StandardError => e
+            failed << { document: doc, error: e.message }
+          end
+        end
+
+        ReleaseResult.new(released: released, skipped: skipped, failed: failed,
+                          released_artifacts: released_artifacts)
+      end
+
+      def resolve_policy(doc, _config)
+        return @deps.manifest.resolve(doc) if @deps.manifest
+
+        DocumentReleasePolicy.from_defaults('public', [Channel.public('default')])
+      end
+
+      def resolve_channels(_doc, policy)
+        channels = if @deps.channel_override && !@deps.channel_override.empty?
+                     @deps.channel_override
+                   else
+                     policy.channels
+                   end
+
+        validate_channels(channels)
+      end
+
+      def validate_channels(channels)
+        return channels unless @deps.channel_config
+
+        channels.select { |ch| @deps.channel_config.registry.valid?(ch) }
+      end
+    end
+  end
+end

data/lib/metanorma/release/release_tag.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    class ReleaseTag
+      PRE_RELEASE_SUFFIXES = %w[-wd -cd -ds -fd -proposal].freeze
+
+      def self.from(doc_id, version)
+        tag = "#{doc_id}/#{version.tag_component}"
+        new(tag: tag, pre_release: version.pre_release?)
+      end
+
+      def self.create(tag, pre_release:)
+        raise ArgumentError, 'Tag must contain a slash separator' unless tag.include?('/')
+
+        new(tag: tag, pre_release: pre_release)
+      end
+
+      def self.parse(tag)
+        raise ArgumentError, 'Tag must contain a slash separator' unless tag.include?('/')
+
+        pre = PRE_RELEASE_SUFFIXES.any? { |s| tag.include?(s) }
+        new(tag: tag, pre_release: pre)
+      end
+
+      def initialize(tag:, pre_release:)
+        @tag = tag
+        @pre_release = pre_release
+        freeze
+      end
+
+      def to_s
+        @tag
+      end
+
+      def pre_release?
+        @pre_release
+      end
+
+      def eql?(other)
+        other.is_a?(self.class) && @tag == other.to_s
+      end
+
+      def hash
+        @tag.hash
+      end
+    end
+  end
+end

data/lib/metanorma/release/repo_ref.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    class RepoRef
+      attr_reader :owner, :repo
+
+      def self.from_string(str)
+        parts = str.split('/', 2)
+        raise ArgumentError, "Invalid repo reference: #{str}" unless parts.length == 2
+
+        new(owner: parts[0], repo: parts[1])
+      end
+
+      def initialize(owner:, repo:)
+        @owner = owner
+        @repo = repo
+        freeze
+      end
+
+      def to_s
+        "#{owner}/#{repo}"
+      end
+
+      def eql?(other)
+        other.is_a?(self.class) && owner == other.owner && repo == other.repo
+      end
+
+      def hash
+        [owner, repo].hash
+      end
+    end
+  end
+end

data/lib/metanorma/release/rxl_extractor.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+begin
+  require 'nokogiri'
+rescue LoadError
+  raise LoadError, "The nokogiri gem is required for RxlExtractor. Add `gem 'nokogiri'` to your Gemfile."
+end
+
+module Metanorma
+  module Release
+    class RxlExtractor
+      def initialize(fallback_flavor: nil)
+        @fallback_flavor = fallback_flavor
+      end
+
+      def discover(output_dir)
+        rxl_files = Dir.glob(File.join(output_dir, '**', '*.rxl'))
+        rxl_files.filter_map do |path|
+          extract(path)
+        rescue StandardError => e
+          warn "Warning: Skipping #{path}: #{e.message}"
+          nil
+        end
+      end
+
+      def extract(rxl_path)
+        raise ArgumentError, "RXL file not found: #{rxl_path}" unless File.exist?(rxl_path)
+
+        content = File.read(rxl_path)
+        doc = Nokogiri::XML(content, nil, 'UTF-8', Nokogiri::XML::ParseOptions::STRICT)
+        extract_from_xml(doc, rxl_path)
+      rescue Nokogiri::XML::SyntaxError => e
+        warn "Warning: Failed to parse RXL #{rxl_path}: #{e.message}"
+        fallback_metadata(rxl_path)
+      end
+
+      private
+
+      def extract_from_xml(xml, rxl_path)
+        bibdata = xml.at_xpath('/bibdata') || xml.root
+        raw_id = text_of(bibdata, 'docidentifier') || derive_id_from_path(rxl_path)
+        id = DocumentId.from_raw(raw_id)
+        title = text_of(bibdata, 'title') || ''
+        edition = text_of(bibdata, 'edition') || '1'
+        stage_node = bibdata.at_xpath('status/stage')
+        stage = if stage_node
+                  DocumentStage.from_iso_stage(stage_node.text.to_i)
+                else
+                  DocumentStage.published
+                end
+        version = DocumentVersion.from(edition, stage)
+        doctype = text_of(bibdata, 'ext/doctype') || ''
+        revdate = extract_revdate(bibdata)
+        flavor = @fallback_flavor || detect_flavor(raw_id)
+        output_dir = File.dirname(rxl_path)
+        file_base_name = File.basename(rxl_path, '.rxl')
+        formats = detect_formats(output_dir, file_base_name)
+        document_type = DocumentType.from_identifier(raw_id)
+
+        DocumentMetadata.new(
+          id: id, title: title, version: version, doctype: doctype,
+          document_type: document_type, flavor: flavor, revdate: revdate,
+          source_path: derive_source_path(rxl_path), output_dir: output_dir,
+          formats: formats, file_base_name: file_base_name
+        )
+      end
+
+      def fallback_metadata(rxl_path)
+        file_base_name = File.basename(rxl_path, '.rxl')
+        id = DocumentId.from_raw(file_base_name)
+        DocumentMetadata.new(
+          id: id, title: '', version: DocumentVersion.published(edition: '0'),
+          doctype: '', document_type: 'standard', flavor: nil, revdate: nil,
+          source_path: rxl_path, output_dir: File.dirname(rxl_path),
+          formats: [], file_base_name: file_base_name
+        )
+      end
+
+      def text_of(node, xpath)
+        n = node.at_xpath(xpath)
+        n&.text&.strip
+      end
+
+      def extract_revdate(bibdata)
+        date_node = bibdata.at_xpath("date[@type='published']/on") ||
+                    bibdata.at_xpath('date/on')
+        date_node&.text&.strip
+      end
+
+      def detect_formats(output_dir, base_name)
+        extensions = []
+        %w[html pdf xml rxl doc].each do |ext|
+          path = File.join(output_dir, "#{base_name}.#{ext}")
+          extensions << ext if File.exist?(path)
+        end
+        extensions
+      end
+
+      def detect_flavor(raw_id)
+        return nil if raw_id.nil?
+
+        parts = raw_id.split(/\s|-/)
+        parts.first&.downcase
+      end
+
+      def derive_id_from_path(rxl_path)
+        File.basename(rxl_path, '.rxl')
+      end
+
+      def derive_source_path(rxl_path)
+        rxl_path.sub(/\.rxl$/, '.adoc')
+      end
+    end
+  end
+end

data/lib/metanorma/release/stage_filter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    class StageFilter
+      def initialize(stages)
+        @stages = Set.new(stages.map(&:downcase))
+        @all = @stages.empty?
+      end
+
+      def matches?(release_metadata)
+        return true if @all
+
+        @stages.include?(release_metadata['stage'].to_s.downcase)
+      end
+    end
+  end
+end

data/lib/metanorma/release/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    VERSION = '0.2.1'
+  end
+end

data/lib/metanorma/release/zip_packager.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+begin
+  require 'zip'
+rescue LoadError
+  raise LoadError, "The rubyzip gem is required for ZipPackager. Add `gem 'rubyzip'` to your Gemfile."
+end
+
+module Metanorma
+  module Release
+    class ZipPackager
+      include Packager
+
+      def package(metadata, canonical_base:)
+        dir = metadata.output_dir
+        base = metadata.file_base_name
+        files = Dir.glob(File.join(dir, "#{base}.*")).reject { |f| File.directory?(f) }
+
+        zip_path = File.join(dir, "#{canonical_base}.zip")
+        File.delete(zip_path) if File.exist?(zip_path)
+        Zip::File.open(zip_path, Zip::File::CREATE) do |zipfile|
+          files.each do |file|
+            ext = File.extname(file)
+            entry_name = "#{canonical_base}#{ext}"
+            zipfile.add(entry_name, file)
+          end
+        end
+
+        Artifact.new(
+          zip_path: zip_path,
+          asset_name: "#{canonical_base}.zip",
+          size: File.size(zip_path)
+        )
+      end
+    end
+  end
+end

data/lib/metanorma/release.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    require_relative 'release/version'
+
+    # Domain value objects
+    autoload :ChannelAudience, 'metanorma/release/channel_audience'
+    autoload :Channel,         'metanorma/release/channel'
+    autoload :ChannelRegistry, 'metanorma/release/channel_registry'
+    autoload :ChannelConfig,   'metanorma/release/channel_config'
+    autoload :ConfigLocator,   'metanorma/release/config_locator'
+    autoload :ContentHash,     'metanorma/release/content_hash'
+    autoload :DocumentId,      'metanorma/release/document_id'
+    autoload :DocumentStage,   'metanorma/release/document_stage'
+    autoload :DocumentType,    'metanorma/release/document_type'
+    autoload :DocumentVersion, 'metanorma/release/document_version'
+    autoload :ReleaseTag,      'metanorma/release/release_tag'
+    autoload :RepoRef,         'metanorma/release/repo_ref'
+
+    # Domain strategies
+    autoload :NamingStrategy,      'metanorma/release/naming_strategy'
+    autoload :EditionNaming,       'metanorma/release/naming_strategy'
+    autoload :VersionNaming,       'metanorma/release/naming_strategy'
+    autoload :InternetDraftNaming, 'metanorma/release/naming_strategy'
+    autoload :RfcNaming,           'metanorma/release/naming_strategy'
+    autoload :DraftSuffixNaming,   'metanorma/release/naming_strategy'
+    autoload :NamingRegistry,      'metanorma/release/naming_strategy'
+
+    # Manifest & policy
+    autoload :ChannelManifest,       'metanorma/release/channel_manifest'
+    autoload :DocumentReleasePolicy, 'metanorma/release/channel_manifest'
+    autoload :ManifestEntry,         'metanorma/release/channel_manifest'
+
+    # Metadata
+    autoload :DocumentMetadata, 'metanorma/release/document_metadata'
+    autoload :ReleaseMetadata,  'metanorma/release/release_metadata'
+    autoload :RxlExtractor,     'metanorma/release/rxl_extractor'
+
+    # Interfaces
+    autoload :Extractor,        'metanorma/release/interfaces'
+    autoload :Filter,           'metanorma/release/interfaces'
+    autoload :ChangeDetector,   'metanorma/release/interfaces'
+    autoload :Packager,         'metanorma/release/interfaces'
+    autoload :Publisher,        'metanorma/release/interfaces'
+
+    # Pipeline components
+    autoload :ChangeResult,              'metanorma/release/interfaces'
+    autoload :Artifact,                  'metanorma/release/interfaces'
+    autoload :PublishResult,             'metanorma/release/interfaces'
+    autoload :ReleasedArtifact,          'metanorma/release/interfaces'
+    autoload :ReleaseResult,             'metanorma/release/interfaces'
+    autoload :ContentHashChangeDetector, 'metanorma/release/change_detector'
+    autoload :ZipPackager,               'metanorma/release/zip_packager'
+    autoload :ReleasePipeline,           'metanorma/release/release_pipeline'
+
+    # Cache
+    autoload :CacheStore,      'metanorma/release/cache_store'
+    autoload :FileCacheStore,  'metanorma/release/cache_store'
+    autoload :NullCacheStore,  'metanorma/release/cache_store'
+
+    # Aggregation filters
+    autoload :ChannelFilter,   'metanorma/release/channel_filter'
+    autoload :ConfigFetcher,   'metanorma/release/config_fetcher'
+    autoload :StageFilter,   'metanorma/release/stage_filter'
+    autoload :DeltaState,    'metanorma/release/delta_state'
+    autoload :NullDeltaState, 'metanorma/release/delta_state'
+
+    # Document index
+    autoload :DocumentFile,       'metanorma/release/document_index'
+    autoload :DocumentSource,     'metanorma/release/document_index'
+    autoload :IndexParameters,    'metanorma/release/document_index'
+    autoload :IndexSummary,       'metanorma/release/document_index'
+    autoload :AggregatedDocument, 'metanorma/release/document_index'
+    autoload :DocumentIndex,      'metanorma/release/document_index'
+
+    # Asset processing
+    autoload :FileRouting,       'metanorma/release/file_routing'
+    autoload :ByDocument,        'metanorma/release/file_routing'
+    autoload :Flat,              'metanorma/release/file_routing'
+    autoload :ByFormat,          'metanorma/release/file_routing'
+    autoload :FileRoutingFactory, 'metanorma/release/file_routing'
+    autoload :AssetProcessor,    'metanorma/release/asset_processor'
+
+    # Aggregation
+    autoload :RepoDiscoverer,    'metanorma/release/aggregation_interfaces'
+    autoload :ReleaseFetcher,    'metanorma/release/aggregation_interfaces'
+    autoload :ManifestReader,    'metanorma/release/aggregation_interfaces'
+    autoload :IndexGenerator,    'metanorma/release/aggregation_interfaces'
+    autoload :FetchResult,       'metanorma/release/aggregation_interfaces'
+    autoload :RepoReport,        'metanorma/release/aggregation_interfaces'
+    autoload :RepoError,         'metanorma/release/aggregation_interfaces'
+    autoload :AggregationPipeline, 'metanorma/release/aggregation_pipeline'
+
+    # Platform namespace
+    autoload :Platform, 'metanorma/release/platform'
+
+    # Platform factory
+    autoload :PlatformFactory, 'metanorma/release/platform_factory'
+
+    # Relaton enrichment
+    autoload :RelatonEnricher, 'metanorma/release/relaton_enricher'
+
+    # CLI & Rake
+    autoload :CLI, 'metanorma/release/cli'
+    autoload :RakeTasks, 'metanorma/release/rake_tasks'
+
+    # Commands
+    autoload :PackageCommand, 'metanorma/release/commands/package'
+    autoload :PublishCommand, 'metanorma/release/commands/publish'
+    autoload :AggregateCommand, 'metanorma/release/commands/aggregate'
+
+    # Config resolution
+    autoload :ConfigResolver, 'metanorma/release/config_resolver'
+  end
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: metanorma-release
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Ribose Inc.
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-05-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: relaton-bib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+description: 'Manages the full release lifecycle of Metanorma documents: discover
+  compiled documents, extract metadata, detect changes, package as zip, publish to
+  platforms (GitHub Releases, GitLab, local filesystem), and aggregate published releases
+  into index.json with a file tree for any site generator.'
+email:
+- open.source@ribose.com
+executables:
+- mn-release
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- CHANGELOG.md
+- PROMPT.md
+- README.adoc
+- Rakefile
+- exe/mn-release
+- lib/metanorma/release.rb
+- lib/metanorma/release/aggregation_interfaces.rb
+- lib/metanorma/release/aggregation_pipeline.rb
+- lib/metanorma/release/asset_processor.rb
+- lib/metanorma/release/cache_store.rb
+- lib/metanorma/release/change_detector.rb
+- lib/metanorma/release/channel.rb
+- lib/metanorma/release/channel_audience.rb
+- lib/metanorma/release/channel_config.rb
+- lib/metanorma/release/channel_filter.rb
+- lib/metanorma/release/channel_manifest.rb
+- lib/metanorma/release/channel_registry.rb
+- lib/metanorma/release/cli.rb
+- lib/metanorma/release/commands/aggregate.rb
+- lib/metanorma/release/commands/package.rb
+- lib/metanorma/release/commands/publish.rb
+- lib/metanorma/release/config_fetcher.rb
+- lib/metanorma/release/config_locator.rb
+- lib/metanorma/release/config_resolver.rb
+- lib/metanorma/release/content_hash.rb
+- lib/metanorma/release/delta_state.rb
+- lib/metanorma/release/document_id.rb
+- lib/metanorma/release/document_index.rb
+- lib/metanorma/release/document_metadata.rb
+- lib/metanorma/release/document_stage.rb
+- lib/metanorma/release/document_type.rb
+- lib/metanorma/release/document_version.rb
+- lib/metanorma/release/file_routing.rb
+- lib/metanorma/release/interfaces.rb
+- lib/metanorma/release/naming_strategy.rb
+- lib/metanorma/release/platform.rb
+- lib/metanorma/release/platform/github.rb
+- lib/metanorma/release/platform/github/config_fetcher.rb
+- lib/metanorma/release/platform/github/manifest_reader.rb
+- lib/metanorma/release/platform/github/publisher.rb
+- lib/metanorma/release/platform/github/release_fetcher.rb
+- lib/metanorma/release/platform/github/topic_discoverer.rb
+- lib/metanorma/release/platform/local.rb
+- lib/metanorma/release/platform/local/config_fetcher.rb
+- lib/metanorma/release/platform/local/directory_discoverer.rb
+- lib/metanorma/release/platform/local/fetcher.rb
+- lib/metanorma/release/platform/local/publisher.rb
+- lib/metanorma/release/platform/null.rb
+- lib/metanorma/release/platform/null/publisher.rb
+- lib/metanorma/release/platform_factory.rb
+- lib/metanorma/release/rake_tasks.rb
+- lib/metanorma/release/relaton_enricher.rb
+- lib/metanorma/release/release_metadata.rb
+- lib/metanorma/release/release_pipeline.rb
+- lib/metanorma/release/release_tag.rb
+- lib/metanorma/release/repo_ref.rb
+- lib/metanorma/release/rxl_extractor.rb
+- lib/metanorma/release/stage_filter.rb
+- lib/metanorma/release/version.rb
+- lib/metanorma/release/zip_packager.rb
+homepage: https://github.com/metanorma/metanorma-release
+licenses:
+- BSD-2-Clause
+metadata:
+  homepage_uri: https://github.com/metanorma/metanorma-release
+  source_code_uri: https://github.com/metanorma/metanorma-release
+  changelog_uri: https://github.com/metanorma/metanorma-release/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Release lifecycle management for Metanorma documents
+test_files: []