metanorma-release 0.2.2 → 0.2.3

data/lib/metanorma/release/document_stage.rb

@@ -1,86 +0,0 @@
-# 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

@@ -1,55 +0,0 @@
-# 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

@@ -1,50 +0,0 @@
-# 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/naming_strategy.rb

@@ -1,158 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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/local/config_fetcher.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Release
-    module Platform
-      module Local
-        class ConfigFetcher
-          include Metanorma::Release::ConfigFetcher
-
-          def fetch(source)
-            path = source.sub(/\Alocal:/, '')
-            return nil unless File.exist?(path)
-
-            ChannelConfig.from_file(path)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/release/rake_tasks.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'rake'
-require 'ostruct'
-
-module Metanorma
-  module Release
-    class RakeTasks
-      include Rake::DSL
-
-      def self.install(&block)
-        new(&block).install
-      end
-
-      def initialize(&block)
-        @config = OpenStruct.new(
-          output_dir: '_site',
-          manifest: 'metanorma.release.yml',
-          platform: 'github',
-          concurrency: 4,
-          dest: 'dist',
-          source: 'github',
-          organizations: [],
-          topic: 'metanorma-release'
-        )
-        block&.call(@config)
-      end
-
-      def install
-        install_package_task
-        install_publish_task
-        install_aggregate_task
-      end
-
-      private
-
-      def install_package_task
-        desc 'Package compiled documents'
-        task :"mn:package" do
-          argv = ['--output-dir', @config.output_dir,
-                  '--dest', @config.dest,
-                  '--manifest', @config.manifest]
-          CLI.run_package(argv)
-        end
-      end
-
-      def install_publish_task
-        desc 'Package and publish documents'
-        task :"mn:publish" do
-          argv = ['--platform', @config.platform,
-                  '--output-dir', @config.output_dir,
-                  '--manifest', @config.manifest,
-                  '--concurrency', @config.concurrency.to_s]
-          CLI.run_publish(argv)
-        end
-      end
-
-      def install_aggregate_task
-        desc 'Aggregate released documents'
-        task :"mn:aggregate" do
-          argv = ['--source', @config.source,
-                  '--output-dir', @config.output_dir,
-                  '--concurrency', @config.concurrency.to_s]
-          argv += ['--organizations', @config.organizations.join(',')] if @config.organizations.any?
-          argv += ['--topic', @config.topic] if @config.topic
-          CLI.run_aggregate(argv)
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/release/relaton_enricher.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-require 'relaton/bib'
-require 'json'
-require 'yaml'
-require 'fileutils'
-
-module Metanorma
-  module Release
-    class RelatonEnricher
-      EnrichResult = Struct.new(
-        :item_count, :output_dir, :documents,
-        keyword_init: true
-      )
-
-      @flavor_registry = {}
-
-      class << self
-        def register_flavor(name, &loader)
-          @flavor_registry[name.to_s] = loader
-        end
-
-        attr_reader :flavor_registry
-      end
-
-      register_flavor('calconnect') do
-        require 'relaton/calconnect'
-        Relaton::Calconnect::Item
-      end
-      register_flavor('cc') do
-        require 'relaton/calconnect'
-        Relaton::Calconnect::Item
-      end
-      register_flavor('iso') do
-        require 'relaton/iso'
-        Relaton::Iso::Item
-      end
-      register_flavor('iec') do
-        require 'relaton/iec'
-        Relaton::Iec::BibliographicItem
-      end
-      register_flavor('ogc') do
-        require 'relaton/ogc'
-        Relaton::Ogc::BibliographicItem
-      end
-      register_flavor('ietf') do
-        require 'relaton/ietf'
-        Relaton::Ietf::BibliographicItem
-      end
-      register_flavor('bipm') do
-        require 'relaton/bipm'
-        Relaton::Bipm::BibliographicItem
-      end
-      register_flavor('itu') do
-        require 'relaton/itu'
-        Relaton::Itu::BibliographicItem
-      end
-      register_flavor('nist') do
-        require 'relaton/nist'
-        Relaton::Nist::BibliographicItem
-      end
-      register_flavor('un') do
-        require 'relaton/un'
-        Relaton::Un::BibliographicItem
-      end
-      register_flavor('bsi') do
-        require 'relaton/bsi'
-        Relaton::Bsi::BibliographicItem
-      end
-      register_flavor('ribose') do
-        require 'relaton/ribose'
-        Relaton::Ribose::Item
-      end
-
-      def initialize(flavor: nil, registry_name: 'Document Registry')
-        @flavor = flavor
-        @registry_name = registry_name
-      end
-
-      def enrich(document_index, output_dir, bib_dir: 'relaton')
-        return nil if document_index.empty?
-
-        flavor = resolve_flavor(document_index)
-        klass = resolve_class(flavor)
-        documents = enrich_documents(document_index, output_dir, klass)
-        return nil if documents.empty?
-
-        dest = File.join(output_dir, bib_dir)
-        write_index(documents, dest)
-
-        EnrichResult.new(item_count: documents.length, output_dir: dest,
-                         documents: documents)
-      rescue LoadError
-        warn '  (relaton gem not available — bibliography skipped)'
-        nil
-      end
-
-      private
-
-      def resolve_flavor(document_index)
-        @flavor || document_index.documents.first&.flavor
-      end
-
-      def resolve_class(flavor)
-        loader = self.class.flavor_registry[flavor.to_s]
-        return loader.call if loader
-
-        Relaton::Bib::Item
-      rescue LoadError
-        warn "  (relaton-#{flavor} gem not available — using base Relaton::Bib::Item)"
-        Relaton::Bib::Item
-      end
-
-      def enrich_documents(document_index, output_dir, klass)
-        document_index.documents.map do |doc|
-          rxl = doc.files.find { |f| f.extension == 'rxl' }
-          path = rxl && File.join(output_dir, rxl.path)
-
-          bib = (klass.from_xml(File.read(path)) if path && File.exist?(path))
-
-          enriched = doc.to_h
-          enriched['bibliographic'] = bib.to_h if bib
-          enriched
-        rescue StandardError => e
-          warn "  Skip #{File.basename(path)}: #{e.message}"
-          doc.to_h
-        end
-      end
-
-      def write_index(documents, dest)
-        FileUtils.mkdir_p(dest)
-        index = { 'root' => { 'title' => @registry_name, 'items' => documents } }
-        File.write(File.join(dest, 'index.json'), JSON.pretty_generate(index))
-        File.write(File.join(dest, 'index.yaml'), YAML.dump(index))
-      end
-    end
-  end
-end

data/lib/metanorma/release/release_metadata.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Metanorma
-  module Release
-    class ReleaseMetadata
-      SCHEMA_VERSION = 1
-
-      def self.from_document(metadata, channels:)
-        data = {
-          'version' => SCHEMA_VERSION,
-          'id' => metadata.id.to_s,
-          'title' => metadata.title,
-          'edition' => metadata.version.edition,
-          'stage' => metadata.version.stage.to_s,
-          'doctype' => metadata.doctype.to_s,
-          'revdate' => metadata.revdate,
-          'formats' => metadata.formats,
-          'channels' => channels.map(&:to_s),
-          'flavor' => metadata.flavor,
-          'sourcePath' => metadata.source_path
-        }
-        new(data)
-      end
-
-      def self.from_json(json_string)
-        data = JSON.parse(json_string)
-        raise ArgumentError, 'Missing required field: id' unless data['id']
-        raise ArgumentError, 'Missing required field: title' unless data['title']
-
-        new(data)
-      end
-
-      def self.from_release_body(body)
-        return nil if body.nil? || body.empty?
-
-        match = body.match(/<!--\s*mn-release-metadata\s*\n(.*?)\n-->/m)
-        return nil unless match
-
-        json_str = match[1]
-        begin
-          from_json(json_str)
-        rescue JSON::ParserError
-          nil
-        end
-      end
-
-      def initialize(data)
-        @data = data
-        freeze
-      end
-
-      def to_json(*_args)
-        JSON.generate(@data)
-      end
-
-      def to_release_body
-        json_str = JSON.generate(@data)
-        "<!-- mn-release-metadata\n#{json_str}\n-->"
-      end
-
-      def to_h
-        @data.dup
-      end
-
-      def id         = @data['id']
-      def title      = @data['title']
-      def edition    = @data['edition']
-      def stage      = @data['stage']
-      def doctype    = @data['doctype']
-      def revdate    = @data['revdate']
-      def formats    = @data['formats'] || []
-      def channels   = @data['channels'] || []
-      def flavor     = @data['flavor']
-      def source_path = @data['sourcePath']
-    end
-  end
-end