metanorma-release 0.2.1

data/lib/metanorma/release/document_metadata.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    class DocumentMetadata
+      attr_reader :id, :title, :version, :doctype, :document_type,
+                  :flavor, :revdate, :source_path, :output_dir,
+                  :formats, :file_base_name
+
+      def initialize(id:, title:, version:, doctype:, document_type:,
+                     flavor:, revdate:, source_path:, output_dir:,
+                     formats:, file_base_name:)
+        @id = id
+        @title = title
+        @version = version
+        @doctype = doctype
+        @document_type = document_type
+        @flavor = flavor
+        @revdate = revdate
+        @source_path = source_path
+        @output_dir = output_dir
+        @formats = formats.freeze
+        @file_base_name = file_base_name
+        @lookup = {
+          'id' => @id, 'title' => @title, 'doctype' => @doctype,
+          'document_type' => @document_type, 'flavor' => @flavor,
+          'revdate' => @revdate, 'source_path' => @source_path,
+          'output_dir' => @output_dir, 'formats' => @formats,
+          'file_base_name' => @file_base_name
+        }.freeze
+        freeze
+      end
+
+      def [](key)
+        @lookup[key]
+      end
+    end
+  end
+end

data/lib/metanorma/release/document_stage.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    class DocumentStage
+      PUBLISHED_NAMES = %w[published in-force approved standard].freeze
+
+      STAGE_ABBREVS = {
+        'working-draft' => 'wd',
+        'committee-draft' => 'cd',
+        'draft-standard' => 'ds',
+        'final-draft' => 'fd',
+        'proposal' => 'proposal',
+        'informational' => 'info',
+        'withdrawn' => 'withdrawn',
+        'cancelled' => 'cancelled'
+      }.freeze
+
+      ISO_STAGE_MAP = {
+        20 => 'working-draft',
+        30 => 'committee-draft',
+        40 => 'draft-standard',
+        50 => 'final-draft',
+        60 => 'published',
+        95 => 'withdrawn'
+      }.freeze
+
+      def self.from_status(status_string)
+        raise ArgumentError, 'Stage cannot be empty' if status_string.nil? || status_string.strip.empty?
+
+        normalized = status_string.to_s.downcase.strip.gsub(/\s+/, '-')
+        new(normalized)
+      end
+
+      def self.from_iso_stage(stage, _substage = nil)
+        name = ISO_STAGE_MAP[stage.to_i] || ISO_STAGE_MAP.values.first
+        new(name)
+      end
+
+      def self.published
+        new('published')
+      end
+
+      def self.working_draft
+        new('working-draft')
+      end
+
+      def initialize(name)
+        @name = name
+        freeze
+      end
+
+      def to_s
+        @name
+      end
+
+      def published?
+        PUBLISHED_NAMES.include?(@name)
+      end
+
+      def draft?
+        !published? && @name != 'withdrawn' && @name != 'cancelled'
+      end
+
+      def withdrawn?
+        @name == 'withdrawn'
+      end
+
+      def cancelled?
+        @name == 'cancelled'
+      end
+
+      def tag_suffix
+        STAGE_ABBREVS[@name].to_s
+      end
+
+      def eql?(other)
+        other.is_a?(self.class) && @name == other.to_s
+      end
+
+      def hash
+        @name.hash
+      end
+    end
+  end
+end

data/lib/metanorma/release/document_type.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module DocumentType
+      STANDARD    = 'standard'
+      IETF_DRAFT  = 'ietf-draft'
+      IETF_RFC    = 'ietf-rfc'
+      ISO         = 'iso'
+      IEC         = 'iec'
+      IEEE        = 'ieee'
+      ITU         = 'itu'
+      BIPM        = 'bipm'
+      IHO         = 'iho'
+      OGC         = 'ogc'
+      OIML        = 'oiml'
+      UN          = 'un'
+      CSA         = 'csa'
+      PDFA        = 'pdfa'
+      MPFA        = 'mpfa'
+      M3AAWG      = 'm3aawg'
+      RIBOSE      = 'ribose'
+
+      DETECTION_RULES = [
+        [/^RFC\s/i,                              IETF_RFC],
+        [/^draft-/i,                             IETF_DRAFT],
+        [/^ISO/i,                                ISO],
+        [/^IEC/i,                                IEC],
+        [/^IEEE/i,                               IEEE],
+        [/^ITU-/i,                               ITU],
+        [/^BIPM/i,                               BIPM],
+        [/^[A-Z]-\d/i,                           IHO],
+        [/^\d{2}-\d{2,3}/,                       OGC],
+        [/^OIML/i,                               OIML],
+        [/^GE\./i,                               UN],
+        [/^csa-/i,                               CSA],
+        [/^(AN|BPG|TN)\s/i,                      PDFA],
+        [%r{^SU/}i, MPFA],
+        [/^M3AAWG/i,                             M3AAWG],
+        [/^Ribose/i,                             RIBOSE]
+      ].freeze
+
+      def self.from_identifier(raw_id)
+        id = raw_id.to_s.strip
+        return STANDARD if id.empty?
+
+        DETECTION_RULES.each do |pattern, type|
+          return type if id.match?(pattern)
+        end
+
+        STANDARD
+      end
+    end
+  end
+end

data/lib/metanorma/release/document_version.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    class DocumentVersion
+      attr_reader :edition, :stage
+
+      def self.from(edition, stage)
+        ed = edition.to_s.strip
+        ed = '0' if ed.empty?
+        new(edition: ed, stage: stage)
+      end
+
+      def self.published(edition:)
+        new(edition: edition.to_s.strip, stage: DocumentStage.published)
+      end
+
+      def initialize(edition:, stage:)
+        @edition = edition
+        @stage = stage
+        freeze
+      end
+
+      def tag_component
+        base = "ed#{edition}"
+        return base if stage.published?
+
+        suffix = stage.tag_suffix
+        suffix.empty? ? base : "#{base}-#{suffix}"
+      end
+
+      def pre_release?
+        stage.draft?
+      end
+
+      def file_name(doc_id)
+        base = "#{doc_id}-#{tag_component}"
+        "#{base}.zip"
+      end
+
+      def eql?(other)
+        other.is_a?(self.class) && edition == other.edition && stage.eql?(other.stage)
+      end
+
+      def hash
+        [edition, stage].hash
+      end
+    end
+  end
+end

data/lib/metanorma/release/file_routing.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module FileRouting
+      def compute_path(file_name, metadata)
+        raise NotImplementedError, "#{self.class} must implement #compute_path"
+      end
+    end
+
+    class ByDocument
+      include FileRouting
+
+      def compute_path(file_name, metadata)
+        "#{metadata['id']}/#{file_name}"
+      end
+    end
+
+    class Flat
+      include FileRouting
+
+      def compute_path(file_name, _metadata)
+        file_name
+      end
+    end
+
+    class ByFormat
+      include FileRouting
+
+      def compute_path(file_name, _metadata)
+        ext = File.extname(file_name).delete_prefix('.')
+        "#{ext}/#{file_name}"
+      end
+    end
+
+    module FileRoutingFactory
+      ROUTING_MAP = {
+        'by-document' => ByDocument,
+        'flat' => Flat,
+        'by-format' => ByFormat
+      }.freeze
+
+      def self.from_name(name)
+        klass = ROUTING_MAP[name]
+        raise ArgumentError, "Unknown routing mode: #{name}. Available: #{ROUTING_MAP.keys.join(', ')}" unless klass
+
+        klass.new
+      end
+    end
+  end
+end

data/lib/metanorma/release/interfaces.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module Extractor
+      def discover(output_dir)
+        raise NotImplementedError, "#{self.class} must implement #discover"
+      end
+
+      def extract(rxl_path)
+        raise NotImplementedError, "#{self.class} must implement #extract"
+      end
+    end
+
+    module Filter
+      def apply(documents)
+        raise NotImplementedError, "#{self.class} must implement #apply"
+      end
+    end
+
+    module ChangeDetector
+      def detect(metadata, tag, force: false)
+        raise NotImplementedError, "#{self.class} must implement #detect"
+      end
+    end
+
+    module Packager
+      def package(metadata, canonical_base:)
+        raise NotImplementedError, "#{self.class} must implement #package"
+      end
+    end
+
+    module Publisher
+      def publish(tag, artifact, metadata, channels:, force_replace: false)
+        raise NotImplementedError, "#{self.class} must implement #publish"
+      end
+    end
+
+    ChangeResult = Struct.new(:changed?, :current_hash, :previous_hash, keyword_init: true)
+    Artifact = Struct.new(:zip_path, :asset_name, :size, keyword_init: true)
+    PublishResult = Struct.new(:tag, :url, :created?, keyword_init: true)
+
+    ReleasedArtifact = Struct.new(:id, :tag, :url, :channels, keyword_init: true)
+
+    ReleaseResult = Struct.new(:released, :skipped, :failed, :released_artifacts, keyword_init: true)
+  end
+end

data/lib/metanorma/release/naming_strategy.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module NamingStrategy
+      def compute_tag(id, version)
+        raise NotImplementedError, "#{self.class} must implement #compute_tag"
+      end
+
+      def compute_asset_name(id, version)
+        raise NotImplementedError, "#{self.class} must implement #compute_asset_name"
+      end
+
+      def compute_canonical_base(id, version)
+        raise NotImplementedError, "#{self.class} must implement #compute_canonical_base"
+      end
+    end
+
+    class EditionNaming
+      include NamingStrategy
+
+      def compute_tag(id, version)
+        tag = "#{id}/#{version.tag_component}"
+        ReleaseTag.create(tag, pre_release: version.pre_release?)
+      end
+
+      def compute_asset_name(id, version)
+        "#{id}-#{version.tag_component}.zip"
+      end
+
+      def compute_canonical_base(id, version)
+        "#{id}-#{version.tag_component}"
+      end
+    end
+
+    class VersionNaming
+      include NamingStrategy
+
+      def compute_tag(id, version)
+        tag = "#{id}/v#{version.edition}"
+        ReleaseTag.create(tag, pre_release: version.pre_release?)
+      end
+
+      def compute_asset_name(id, version)
+        "#{id}-v#{version.edition}.zip"
+      end
+
+      def compute_canonical_base(id, version)
+        "#{id}-v#{version.edition}"
+      end
+    end
+
+    class InternetDraftNaming
+      include NamingStrategy
+
+      DRAFT_PATTERN = /\Adraft-ietf-([a-z0-9-]+?)-(\d+)\z/i
+
+      def compute_tag(id, version)
+        match = id.match(DRAFT_PATTERN)
+        return fallback_tag(id, version) unless match
+
+        name = match[1]
+        num = match[2]
+        ReleaseTag.create("id-#{name}/#{num}", pre_release: true)
+      end
+
+      def compute_asset_name(id, _version)
+        "#{id}.zip"
+      end
+
+      def compute_canonical_base(id, _version)
+        id.to_s
+      end
+
+      private
+
+      def fallback_tag(id, _version)
+        tag = "#{id}/draft"
+        ReleaseTag.create(tag, pre_release: true)
+      end
+    end
+
+    class RfcNaming
+      include NamingStrategy
+
+      def compute_tag(id, version)
+        tag = "#{id}/ed#{version.edition}"
+        ReleaseTag.create(tag, pre_release: version.pre_release?)
+      end
+
+      def compute_asset_name(id, _version)
+        "#{id}.zip"
+      end
+
+      def compute_canonical_base(id, version)
+        "#{id}-ed#{version.edition}"
+      end
+    end
+
+    class DraftSuffixNaming
+      include NamingStrategy
+
+      DRAFT_SUFFIX = /-d(\d+)\z/
+
+      def compute_tag(id, version)
+        match = id.to_s.match(DRAFT_SUFFIX)
+        return @fallback.compute_tag(id, version) unless match
+
+        base = id.to_s.sub(DRAFT_SUFFIX, '')
+        num = match[1]
+        ReleaseTag.create("#{base}/#{num}", pre_release: true)
+      end
+
+      def compute_asset_name(id, version)
+        match = id.to_s.match(DRAFT_SUFFIX)
+        return @fallback.compute_asset_name(id, version) unless match
+
+        "#{id}.zip"
+      end
+
+      def compute_canonical_base(id, version)
+        match = id.to_s.match(DRAFT_SUFFIX)
+        return @fallback.compute_canonical_base(id, version) unless match
+
+        id.to_s
+      end
+
+      def initialize
+        @fallback = EditionNaming.new
+      end
+    end
+
+    class NamingRegistry
+      def initialize(default: EditionNaming.new)
+        @default = default
+        @strategies = {}
+      end
+
+      def register(document_type, strategy)
+        @strategies[document_type] = strategy
+      end
+
+      def resolve(document_type)
+        @strategies.fetch(document_type, @default)
+      end
+
+      def self.default_registry
+        registry = new
+        registry.register(DocumentType::IETF_DRAFT, InternetDraftNaming.new)
+        registry.register(DocumentType::IETF_RFC,   RfcNaming.new)
+        registry.register(DocumentType::IEEE,       DraftSuffixNaming.new)
+        registry.register(DocumentType::IHO,        VersionNaming.new)
+        registry.register(DocumentType::OGC,        VersionNaming.new)
+        registry
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Metanorma
+  module Release
+    module Platform
+      module GitHub
+        class ConfigFetcher
+          include Metanorma::Release::ConfigFetcher
+
+          def initialize(client:)
+            @client = client
+          end
+
+          def fetch(source)
+            repo, path = parse_source(source)
+            content = @client.contents(repo, path: path)
+            return nil unless content
+
+            ChannelConfig.from_yaml(content['content'].unpack1('m0'))
+          rescue StandardError
+            nil
+          end
+
+          private
+
+          def parse_source(source)
+            if source.include?('#')
+              parts = source.split('#', 2)
+              [parts[0], parts[1]]
+            else
+              [source, 'channels.yml']
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Metanorma
+  module Release
+    module Platform
+      module GitHub
+        class ManifestReader
+          include Metanorma::Release::ManifestReader
+
+          def initialize(client:)
+            @client = client
+          end
+
+          def read(repo)
+            content = @client.contents(repo.to_s, path: 'metanorma.release.yml')
+            return nil unless content
+
+            yaml = content['content'].unpack1('m0')
+            parsed = YAML.safe_load(yaml, permitted_classes: [Symbol])
+            return nil unless parsed.is_a?(Hash)
+
+            (parsed['channels'] || []).map(&:to_s)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module Platform
+      module GitHub
+        class Publisher
+          include Metanorma::Release::Publisher
+
+          def initialize(client:, repo:)
+            @client = client
+            @repo = repo
+          end
+
+          def publish(tag, artifact, metadata, channels:, force_replace: false)
+            tag_name = tag.to_s
+
+            if force_replace
+              delete_existing_release(tag_name)
+              return create_release(tag_name, metadata, artifact)
+            end
+
+            existing = find_release(tag_name)
+
+            if existing
+              update_release(existing, metadata)
+            else
+              create_release(tag_name, metadata, artifact)
+            end
+          end
+
+          private
+
+          def find_release(tag_name)
+            @client.releases(@repo).find { |r| r['tag_name'] == tag_name }
+          rescue StandardError
+            nil
+          end
+
+          def create_release(tag_name, metadata, artifact)
+            release = @client.create_release(
+              @repo, tag_name,
+              name: tag_name,
+              body: metadata.to_release_body,
+              prerelease: tag_name.match?(/-(wd|cd|ds|fd|proposal)$/)
+            )
+            upload_asset(release['id'], artifact)
+            PublishResult.new(tag: tag_name, url: release['html_url'], created?: true)
+          end
+
+          def update_release(release, metadata)
+            @client.update_release(release['url'], body: metadata.to_release_body)
+            PublishResult.new(tag: release['tag_name'], url: release['html_url'], created?: false)
+          end
+
+          def upload_asset(release_id, artifact)
+            @client.upload_asset(release_id, artifact.zip_path, content_type: 'application/zip')
+          end
+
+          def delete_existing_release(tag_name)
+            release = find_release(tag_name)
+            @client.delete_release(release['url']) if release
+            begin
+              @client.delete_ref(@repo, "tags/#{tag_name}")
+            rescue StandardError
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module Platform
+      module GitHub
+        GitHubRelease = Struct.new(:tag_name, :body, :prerelease, :draft,
+                                   :html_url, :published_at, :created_at,
+                                   :assets, keyword_init: true)
+        GitHubAsset = Struct.new(:name, :browser_download_url, :size, :data,
+                                 keyword_init: true)
+
+        class ReleaseFetcher
+          include Metanorma::Release::ReleaseFetcher
+
+          def initialize(client:)
+            @client = client
+          end
+
+          def fetch(repo, etag: nil)
+            releases = @client.releases(repo.to_s)
+            parsed = releases.map { |r| parse_release(r) }
+            FetchResult.new(releases: parsed, etag: "etag-#{repo}", unchanged?: false)
+          end
+
+          private
+
+          def parse_release(r)
+            assets = (r[:assets] || []).map do |a|
+              GitHubAsset.new(
+                name: a[:name],
+                browser_download_url: a[:browser_download_url],
+                size: a[:size],
+                data: nil
+              )
+            end
+            GitHubRelease.new(
+              tag_name: r[:tag_name],
+              body: r[:body],
+              prerelease: r[:prerelease],
+              draft: r[:draft],
+              html_url: r[:html_url],
+              published_at: r[:published_at],
+              created_at: r[:created_at],
+              assets: assets
+            )
+          end
+        end
+      end
+    end
+  end
+end