metanorma-release 0.2.2 → 0.2.3

data/lib/metanorma/release/channel_config.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-
-module Metanorma
-  module Release
-    class ChannelConfig
-      def self.from_yaml(yaml_string)
-        data = YAML.safe_load(yaml_string, permitted_classes: [Symbol])
-        raise ArgumentError, 'Invalid channel config YAML' unless data.is_a?(Hash)
-
-        registry = ChannelRegistry.from_yaml(yaml_string)
-        defaults = data['defaults'] || {}
-        default_visibility = defaults['visibility'] || 'public'
-        default_channels = parse_channels(defaults['channels'])
-
-        new(registry: registry, default_visibility: default_visibility,
-            default_channels: default_channels)
-      end
-
-      def self.from_file(path)
-        if File.directory?(path)
-          channels_yml = File.join(path, 'channels.yml')
-          raise ArgumentError, "Channel config file not found: #{path}" unless File.exist?(channels_yml)
-
-          return from_file(channels_yml)
-        end
-
-        raise ArgumentError, "Channel config file not found: #{path}" unless File.exist?(path)
-
-        from_yaml(File.read(path))
-      end
-
-      def self.empty
-        new(registry: ChannelRegistry.all_allowed,
-            default_visibility: 'public', default_channels: [])
-      end
-
-      def initialize(registry:, default_visibility:, default_channels:)
-        @registry = registry
-        @default_visibility = default_visibility
-        @default_channels = default_channels.freeze
-        freeze
-      end
-
-      attr_reader :registry, :default_visibility, :default_channels
-
-      def self.parse_channels(list)
-        return [] unless list
-
-        list.map { |c| Channel.parse(c.to_s) }
-      end
-    end
-  end
-end

data/lib/metanorma/release/channel_manifest.rb

@@ -1,192 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-
-module Metanorma
-  module Release
-    class DocumentReleasePolicy
-      def self.from_defaults(visibility, channels)
-        ch = build_channels(visibility, channels)
-        is_released = visibility != 'private' || !ch.empty?
-        new(release: is_released, channels: ch, stage_allow_list: nil)
-      end
-
-      def self.from_entry(entry)
-        ch = build_channels(entry.visibility, entry.channels)
-        new(release: true, channels: ch, stage_allow_list: entry.stages_set)
-      end
-
-      def self.not_released
-        new(release: false, channels: [].freeze, stage_allow_list: nil)
-      end
-
-      def initialize(release:, channels:, stage_allow_list:)
-        @release = release
-        @channels = channels.freeze
-        @stage_allow_list = stage_allow_list
-        freeze
-      end
-
-      def release?
-        @release
-      end
-
-      attr_reader :channels, :stage_allow_list
-
-      def self.build_channels(visibility, explicit_channels)
-        return explicit_channels if explicit_channels && !explicit_channels.empty?
-
-        case visibility
-        when 'public'  then [Channel.public('default')]
-        when 'members' then [Channel.members('default')]
-        else [].freeze
-        end
-      end
-    end
-
-    class ManifestEntry
-      attr_reader :source, :pattern, :visibility, :channels, :stages
-
-      def initialize(source:, pattern:, visibility:, channels:, stages:)
-        @source = source
-        @pattern = pattern
-        @visibility = visibility
-        @channels = channels
-        @stages = stages
-        freeze
-      end
-
-      def match_priority
-        return 100 if source
-        return 50 + pattern.to_s.length if pattern
-
-        0
-      end
-
-      def stages_set
-        return nil if stages.nil? || stages.empty?
-
-        Set.new(stages.map(&:downcase))
-      end
-    end
-
-    class ChannelManifest
-      def self.parse(yaml_hash)
-        defaults = yaml_hash['defaults'] || {}
-        default_visibility = defaults['visibility'] || 'public'
-        default_channels = parse_channels(defaults['channels'])
-        entries = parse_entries(yaml_hash['documents'] || [])
-        config_source = yaml_hash['config']
-
-        new(entries: entries, default_visibility: default_visibility,
-            default_channels: default_channels, explicit: true, config_source: config_source)
-      end
-
-      def self.from_yaml(yaml_string)
-        yaml = YAML.safe_load(yaml_string, permitted_classes: [Symbol])
-        raise ArgumentError, 'Manifest YAML is empty' unless yaml.is_a?(Hash)
-
-        parse(yaml)
-      end
-
-      def self.from_file(path)
-        raise ArgumentError, "Manifest file not found: #{path}" unless File.exist?(path)
-
-        from_yaml(File.read(path))
-      end
-
-      def self.all_public
-        new(entries: [], default_visibility: 'public',
-            default_channels: [Channel.public('default')], explicit: false, config_source: nil)
-      end
-
-      def self.all_private
-        new(entries: [], default_visibility: 'private',
-            default_channels: [], explicit: false, config_source: nil)
-      end
-
-      def initialize(entries:, default_visibility:, default_channels:, explicit:, config_source: nil)
-        @entries = entries
-        @default_visibility = default_visibility
-        @default_channels = default_channels.freeze
-        @explicit = explicit
-        @config_source = config_source
-        freeze
-      end
-
-      def resolve(document)
-        return default_policy unless @explicit
-
-        entry = find_best_match(document)
-        return DocumentReleasePolicy.from_defaults(@default_visibility, @default_channels) unless entry
-
-        DocumentReleasePolicy.from_entry(entry)
-      end
-
-      def list_all
-        @entries
-      end
-
-      def all_channels
-        (@default_channels + @entries.flat_map(&:channels)).uniq
-      end
-
-      def explicit?
-        @explicit
-      end
-
-      attr_reader :config_source
-
-      private
-
-      def default_policy
-        DocumentReleasePolicy.from_defaults(@default_visibility, @default_channels)
-      end
-
-      def find_best_match(document)
-        source = extract_source(document)
-        matches = @entries.select { |e| entry_matches?(e, source) }
-        return nil if matches.empty?
-
-        matches.max_by(&:match_priority)
-      end
-
-      def entry_matches?(entry, source)
-        return false unless source
-        return true if entry.source && entry.source == source
-        return true if entry.pattern && File.fnmatch?(entry.pattern, source)
-
-        false
-      end
-
-      def extract_source(document)
-        document['source_path']
-      end
-
-      def self.parse_channels(channel_list)
-        return [] unless channel_list
-
-        channel_list.map { |c| Channel.parse(c.to_s) }
-      end
-
-      def self.parse_entries(documents)
-        documents.map do |doc|
-          validate_entry!(doc)
-          ManifestEntry.new(
-            source: doc['source'],
-            pattern: doc['pattern'],
-            visibility: doc['visibility'],
-            channels: parse_channels(doc['channels']),
-            stages: doc['stages']
-          )
-        end
-      end
-
-      def self.validate_entry!(doc)
-        return unless doc['source']&.include?('..')
-
-        raise ArgumentError, "Path traversal detected in manifest source: #{doc['source']}"
-      end
-    end
-  end
-end

data/lib/metanorma/release/channel_registry.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-
-module Metanorma
-  module Release
-    class ChannelRegistry
-      def self.from_yaml(yaml_string)
-        data = YAML.safe_load(yaml_string, permitted_classes: [Symbol])
-        raise ArgumentError, 'Invalid channel registry YAML' unless data.is_a?(Hash)
-
-        channels = parse_channel_list(data['channels'])
-        new(channels: channels)
-      end
-
-      def self.from_file(path)
-        raise ArgumentError, "Channel registry file not found: #{path}" unless File.exist?(path)
-
-        from_yaml(File.read(path))
-      end
-
-      def self.all_allowed
-        new(channels: [])
-      end
-
-      def initialize(channels:)
-        @channels = channels.freeze
-        @channel_set = channels.to_set
-        freeze
-      end
-
-      def valid?(channel)
-        return true if @channels.empty?
-
-        @channel_set.include?(channel)
-      end
-
-      def include?(channel_or_string)
-        valid?(Channel.parse(channel_or_string.to_s))
-      end
-
-      attr_reader :channels
-
-      def empty?
-        @channels.empty?
-      end
-
-      def self.parse_channel_list(list)
-        return [] unless list
-
-        list.filter_map do |entry|
-          case entry
-          when Hash   then Channel.parse(entry['name'].to_s)
-          when String then Channel.parse(entry)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/release/config_fetcher.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Release
-    module ConfigFetcher
-      def fetch(source)
-        raise NotImplementedError, "#{self.class} must implement #fetch"
-      end
-    end
-  end
-end

data/lib/metanorma/release/config_locator.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Release
-    class ConfigLocator
-      CONFIG_FILES = ['.metanorma.yml', '.metanorma.yaml'].freeze
-      CONFIG_DIRS = ['.metanorma'].freeze
-
-      def self.find(start_dir = Dir.pwd)
-        new.find(start_dir)
-      end
-
-      def find(start_dir)
-        dir = File.expand_path(start_dir)
-        loop do
-          CONFIG_FILES.each do |name|
-            path = File.join(dir, name)
-            return ChannelConfig.from_file(path) if File.exist?(path)
-          end
-
-          CONFIG_DIRS.each do |name|
-            path = File.join(dir, name)
-            next unless File.directory?(path)
-
-            channels = File.join(path, 'channels.yml')
-            return ChannelConfig.from_file(channels) if File.exist?(channels)
-          end
-
-          parent = File.dirname(dir)
-          return nil if parent == dir
-
-          dir = parent
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/release/config_resolver.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Release
-    module ConfigResolver
-      def resolve_channel_config(cli_source, manifest)
-        return fetch_config(cli_source) if cli_source
-        return fetch_config(manifest.config_source) if manifest&.config_source
-
-        found = ConfigLocator.find
-        return found if found
-
-        ChannelConfig.empty
-      end
-
-      def load_manifest(path)
-        return nil unless path && File.exist?(path)
-
-        ChannelManifest.from_file(path)
-      end
-
-      private
-
-      def fetch_config(source)
-        if source.start_with?('local:')
-          Platform::Local::ConfigFetcher.new.fetch(source)
-        elsif source.include?('/')
-          Platform::Local::ConfigFetcher.new.fetch("local:#{source}")
-        else
-          require 'octokit'
-          client = PlatformFactory.build_github_client(nil)
-          Platform::GitHub::ConfigFetcher.new(client: client).fetch(source)
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/release/document_id.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Release
-    class DocumentId
-      def self.from_raw(raw_identifier)
-        normalized = raw_identifier.to_s.downcase.gsub(/[^a-z0-9]+/, '-').gsub(/^-|-$/, '')
-        raise ArgumentError, 'Document ID cannot be empty' if normalized.empty?
-
-        new(normalized)
-      end
-
-      def self.from_normalized(value)
-        raise ArgumentError, 'Document ID cannot be empty' if value.nil? || value.strip.empty?
-
-        new(value.to_s.strip)
-      end
-
-      def initialize(value)
-        @value = value
-        freeze
-      end
-
-      def to_s
-        @value
-      end
-
-      def tag_prefix
-        @value
-      end
-
-      def file_name
-        @value
-      end
-
-      def eql?(other)
-        other.is_a?(self.class) && @value == other.to_s
-      end
-
-      def hash
-        @value.hash
-      end
-    end
-  end
-end

data/lib/metanorma/release/document_index.rb

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Metanorma
-  module Release
-    DocumentFile = Struct.new(:name, :path, keyword_init: true) do
-      def extension
-        File.extname(name).delete_prefix('.')
-      end
-    end
-
-    DocumentSource = Struct.new(
-      :owner, :repo, :tag, :release_url, :release_date,
-      keyword_init: true
-    ) do
-      def repo_key
-        "#{owner}/#{repo}"
-      end
-    end
-
-    IndexParameters = Struct.new(
-      :organizations, :channels, :topic, :repo_count,
-      keyword_init: true
-    )
-
-    IndexSummary = Struct.new(
-      :repo_count, :document_count, :channels_found,
-      keyword_init: true
-    )
-
-    class AggregatedDocument
-      def self.from_h(hash)
-        files = (hash['files'] || []).map do |f|
-          DocumentFile.new(name: f['name'], path: f['path'])
-        end
-        source_data = hash['source'] || {}
-        source = DocumentSource.new(
-          owner: source_data['owner'], repo: source_data['repo'],
-          tag: source_data['tag'], release_url: source_data['releaseUrl'],
-          release_date: source_data['releaseDate']
-        )
-        new(
-          id: hash['id'], title: hash['title'], edition: hash['edition'],
-          stage: hash['stage'], doctype: hash.fetch('doctype', ''),
-          channels: hash['channels'] || [], formats: hash['formats'] || [],
-          flavor: hash['flavor'], content_hash: hash['contentHash'],
-          source: source, files: files
-        )
-      end
-
-      attr_reader :id, :title, :edition, :stage, :doctype, :channels,
-                  :formats, :flavor, :content_hash, :source, :files
-
-      def initialize(id:, title:, edition:, stage:, doctype:, channels:,
-                     formats:, flavor:, content_hash:, source:, files:)
-        @id = id
-        @title = title
-        @edition = edition
-        @stage = stage
-        @doctype = doctype
-        @channels = channels.freeze
-        @formats = formats.freeze
-        @flavor = flavor
-        @content_hash = content_hash
-        @source = source
-        @files = files.freeze
-        freeze
-      end
-
-      def to_h
-        {
-          'id' => id, 'title' => title, 'edition' => edition,
-          'stage' => stage, 'doctype' => doctype,
-          'channels' => channels, 'formats' => formats,
-          'flavor' => flavor, 'contentHash' => content_hash,
-          'source' => {
-            'owner' => source.owner, 'repo' => source.repo,
-            'tag' => source.tag, 'releaseUrl' => source.release_url,
-            'releaseDate' => source.release_date
-          },
-          'files' => files.map { |f| { 'name' => f.name, 'path' => f.path } }
-        }
-      end
-    end
-
-    class DocumentIndex
-      SCHEMA_VERSION = 1
-
-      SchemaError = Class.new(StandardError)
-
-      def self.from_json(json_string)
-        data = JSON.parse(json_string)
-        validate!(data)
-        new(
-          documents: (data['documents'] || []).map { |d| AggregatedDocument.from_h(d) },
-          parameters: IndexParameters.new(
-            organizations: data.dig('parameters', 'organizations') || [],
-            channels: data.dig('parameters', 'channels') || [],
-            topic: data.dig('parameters', 'topic'),
-            repo_count: data.dig('parameters', 'repoCount') || 0
-          ),
-          generated_at: data['generatedAt']
-        )
-      end
-
-      def self.from_documents(documents, parameters:)
-        new(documents: documents, parameters: parameters)
-      end
-
-      def initialize(documents:, parameters:, generated_at: nil)
-        @documents = documents.freeze
-        @parameters = parameters
-        @generated_at = generated_at || Time.now.utc.iso8601
-        freeze
-      end
-
-      attr_reader :documents, :parameters
-
-      def summary
-        IndexSummary.new(
-          repo_count: @parameters.repo_count,
-          document_count: @documents.length,
-          channels_found: channels
-        )
-      end
-
-      def channels
-        @documents.flat_map(&:channels).uniq.sort
-      end
-
-      def document_count
-        @documents.length
-      end
-
-      def empty?
-        @documents.empty?
-      end
-
-      def to_h
-        {
-          'version' => SCHEMA_VERSION,
-          'generatedAt' => @generated_at,
-          'parameters' => {
-            'organizations' => @parameters.organizations,
-            'channels' => @parameters.channels,
-            'topic' => @parameters.topic,
-            'repoCount' => @parameters.repo_count
-          },
-          'summary' => {
-            'repoCount' => summary.repo_count,
-            'documentCount' => summary.document_count,
-            'channelsFound' => summary.channels_found
-          },
-          'documents' => @documents.map(&:to_h)
-        }
-      end
-
-      def to_json(*_args)
-        JSON.generate(to_h)
-      end
-
-      def write(path)
-        FileUtils.mkdir_p(File.dirname(path))
-        File.write(path, to_json)
-      end
-
-      def self.validate!(data)
-        raise SchemaError, "Missing 'version' field" unless data.key?('version')
-        unless data['version'] == SCHEMA_VERSION
-          raise SchemaError,
-                "Unsupported schema version: #{data['version']}. Expected #{SCHEMA_VERSION}"
-        end
-        raise SchemaError, "Missing 'documents' field" unless data.key?('documents')
-
-        data['documents'].each do |doc|
-          raise SchemaError, "Document missing required field 'id'" unless doc.key?('id')
-          raise SchemaError, "Document missing required field 'title'" unless doc.key?('title')
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/release/document_metadata.rb

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