metanorma-release 0.2.1

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module Platform
+      module GitHub
+        class TopicDiscoverer
+          include Metanorma::Release::RepoDiscoverer
+
+          def initialize(client:, organizations:, topic:)
+            @client = client
+            @organizations = organizations
+            @topic = topic
+          end
+
+          def discover
+            @organizations.flat_map do |org|
+              query = "topic:#{@topic} org:#{org}"
+              results = @client.search_repositories(query)
+              results[:items].map do |repo|
+                RepoRef.new(owner: org, repo: repo[:name])
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+begin
+  require 'octokit'
+rescue LoadError
+  raise LoadError, "The octokit gem is required for GitHub adapters. Add `gem 'octokit'` to your Gemfile."
+end
+
+module Metanorma
+  module Release
+    module Platform
+      module GitHub
+        autoload :Publisher, 'metanorma/release/platform/github/publisher'
+        autoload :TopicDiscoverer, 'metanorma/release/platform/github/topic_discoverer'
+        autoload :ReleaseFetcher, 'metanorma/release/platform/github/release_fetcher'
+        autoload :ManifestReader, 'metanorma/release/platform/github/manifest_reader'
+        autoload :ConfigFetcher,  'metanorma/release/platform/github/config_fetcher'
+
+        def self.cache_store(cache_dir:)
+          FileCacheStore.new(cache_dir)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# 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/platform/local/directory_discoverer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module Platform
+      module Local
+        class DirectoryDiscoverer
+          include Metanorma::Release::RepoDiscoverer
+
+          def initialize(base_path:)
+            @base_path = base_path
+          end
+
+          def discover
+            return [] unless Dir.exist?(@base_path)
+
+            Dir.children(@base_path).filter_map do |entry|
+              full = File.join(@base_path, entry)
+              RepoRef.new(owner: 'local', repo: entry) if File.directory?(full)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/release/platform/local/fetcher.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Metanorma
+  module Release
+    module Platform
+      module Local
+        LocalRelease = Struct.new(:tag_name, :body, :prerelease, :draft,
+                                  :html_url, :published_at, :created_at,
+                                  :assets, keyword_init: true)
+        LocalAsset = Struct.new(:name, :browser_download_url, :size, :data,
+                                keyword_init: true)
+
+        class Fetcher
+          include Metanorma::Release::ReleaseFetcher
+
+          def initialize(base_path:)
+            @base_path = base_path
+          end
+
+          def fetch(repo, etag: nil)
+            dir = File.join(@base_path, repo.repo)
+            return FetchResult.new(releases: [], etag: nil, unchanged?: false) unless Dir.exist?(dir)
+
+            releases = Dir.glob(File.join(dir, '*.meta.json')).filter_map do |meta_path|
+              build_release(dir, meta_path)
+            end
+
+            FetchResult.new(releases: releases, etag: nil, unchanged?: false)
+          end
+
+          private
+
+          def build_release(dir, meta_path)
+            data = JSON.parse(File.read(meta_path))
+            base = File.basename(meta_path, '.meta.json')
+            zip_path = File.join(dir, "#{base}.zip")
+
+            unless File.exist?(zip_path)
+              warn "Warning: Missing zip for #{meta_path}, skipping"
+              return nil
+            end
+
+            metadata = ReleaseMetadata.new(data)
+            asset = LocalAsset.new(
+              name: "#{base}.zip",
+              browser_download_url: "file://#{File.expand_path(zip_path)}",
+              size: File.size(zip_path),
+              data: File.binread(zip_path)
+            )
+
+            LocalRelease.new(
+              tag_name: "#{data['id']}/#{data.fetch('edition', '1')}",
+              body: metadata.to_release_body,
+              prerelease: prerelease?(data),
+              draft: false,
+              html_url: "file://#{File.expand_path(dir)}",
+              published_at: File.mtime(zip_path).iso8601,
+              created_at: File.mtime(zip_path).iso8601,
+              assets: [asset]
+            )
+          rescue JSON::ParserError
+            warn "Warning: Invalid metadata JSON in #{meta_path}, skipping"
+            nil
+          end
+
+          def prerelease?(data)
+            stage = data['stage'].to_s
+            %w[working-draft committee-draft draft-standard final-draft].include?(stage)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+module Metanorma
+  module Release
+    module Platform
+      module Local
+        class Publisher
+          include Metanorma::Release::Publisher
+
+          def initialize(output_dir:)
+            @output_dir = output_dir
+          end
+
+          def publish(tag, artifact, metadata, channels:, force_replace: false)
+            FileUtils.mkdir_p(@output_dir)
+
+            zip_dest = File.join(@output_dir, artifact.asset_name)
+            meta_dest = File.join(@output_dir, meta_file_name(artifact.asset_name))
+
+            if force_replace
+              File.delete(zip_dest) if File.exist?(zip_dest)
+              File.delete(meta_dest) if File.exist?(meta_dest)
+            end
+
+            FileUtils.cp(artifact.zip_path, zip_dest)
+            File.write(meta_dest, metadata.to_json)
+
+            PublishResult.new(tag: tag.to_s, url: "file://#{File.expand_path(zip_dest)}", created?: true)
+          end
+
+          private
+
+          def meta_file_name(asset_name)
+            base = asset_name.sub(/\.zip$/, '')
+            "#{base}.meta.json"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/release/platform/local.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module Platform
+      module Local
+        autoload :Publisher, 'metanorma/release/platform/local/publisher'
+        autoload :DirectoryDiscoverer, 'metanorma/release/platform/local/directory_discoverer'
+        autoload :Fetcher, 'metanorma/release/platform/local/fetcher'
+        autoload :ConfigFetcher, 'metanorma/release/platform/local/config_fetcher'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module Platform
+      module Null
+        class Publisher
+          include Metanorma::Release::Publisher
+
+          def publish(tag, _artifact, _metadata, channels:, force_replace: false)
+            PublishResult.new(tag: tag.to_s, url: 'null://', created?: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/release/platform/null.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module Platform
+      module Null
+        autoload :Publisher, 'metanorma/release/platform/null/publisher'
+      end
+    end
+  end
+end

data/lib/metanorma/release/platform.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module Platform
+      autoload :GitHub, 'metanorma/release/platform/github'
+      autoload :Local, 'metanorma/release/platform/local'
+      autoload :Null, 'metanorma/release/platform/null'
+    end
+  end
+end

data/lib/metanorma/release/platform_factory.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Release
+    module PlatformFactory
+      PUBLISHER_REGISTRY = {
+        'null' => ->(_opts) { Platform::Null::Publisher.new },
+        'local' => ->(opts) { Platform::Local::Publisher.new(output_dir: opts[:output_dir]) }
+      }.freeze
+
+      AGGREGATION_REGISTRY = {
+        'local' => lambda { |opts, _token|
+          path = opts[:source].sub('local:', '')
+          {
+            discoverer: Platform::Local::DirectoryDiscoverer.new(base_path: path),
+            fetcher: Platform::Local::Fetcher.new(base_path: path)
+          }
+        }
+      }.freeze
+
+      def self.build_publisher(platform, options)
+        factory = PUBLISHER_REGISTRY[platform]
+        raise ArgumentError, "Unknown platform: #{platform}. Available: #{PUBLISHER_REGISTRY.keys.join(', ')}" unless factory
+
+        factory.call(options)
+      end
+
+      def self.build_aggregation_adapters(options)
+        source = options[:source]
+        if source.start_with?('local:')
+          adapters = AGGREGATION_REGISTRY['local'].call(options, options[:token])
+          adapters[:manifest_reader] = NullManifestReader.new
+          return adapters
+        end
+
+        require 'octokit'
+        client = build_github_client(options[:token])
+
+        discoverer = if options[:repos]
+                       repos = options[:repos].map { |r| RepoRef.from_string(r) }
+                       StaticDiscoverer.new(repos: repos)
+                     else
+                       Platform::GitHub::TopicDiscoverer.new(
+                         client: client, organizations: options[:organizations], topic: options[:topic]
+                       )
+                     end
+
+        {
+          discoverer: discoverer,
+          fetcher: Platform::GitHub::ReleaseFetcher.new(client: client),
+          manifest_reader: Platform::GitHub::ManifestReader.new(client: client)
+        }
+      end
+
+      def self.build_github_client(token)
+        require 'octokit'
+        token ? Octokit::Client.new(access_token: token) : Octokit::Client.new
+      end
+
+      class StaticDiscoverer
+        include RepoDiscoverer
+
+        def initialize(repos:)
+          @repos = repos
+        end
+
+        def discover
+          @repos
+        end
+      end
+
+      class NullManifestReader
+        include Metanorma::Release::ManifestReader
+        def read(_repo) = nil
+      end
+    end
+  end
+end

data/lib/metanorma/release/rake_tasks.rb

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

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

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