metanorma-taste 0.0.4 → 0.1.2

data/lib/metanorma/taste_register.rb

@@ -1,103 +1,241 @@
 # frozen_string_literal: true
 
-require "yaml"
 require "singleton"
+require_relative "taste/taste_config"
+require_relative "taste/base"
 
 module Metanorma
+  # Registry for managing and providing access to taste configurations
+  #
+  # This singleton class automatically discovers taste configurations from the data directory,
+  # loads them using lutaml-model, and provides a centralized registry for accessing
+  # taste instances and their metadata.
+  #
+  # @example Basic usage
+  #   # Get a taste instance
+  #   icc_taste = TasteRegister.get("icc")
+  #
+  #   # List available tastes
+  #   TasteRegister.available_tastes
+  #   # => [:icc, :elf, :enosema]
+  #
+  #   # Get taste configuration
+  #   config = TasteRegister.get_config("icc")
+  #   # => #<Metanorma::Taste::TasteConfig:...>
+  #   puts config.owner  # => "International Color Consortium"
   class TasteRegister
     include Singleton
 
+    # Error raised when an unknown taste is requested
+    class UnknownTasteError < StandardError; end
+
+    # Error raised when taste configuration is invalid
+    class InvalidTasteConfigError < StandardError; end
+
     def initialize
-      @tastes = {}
-      @taste_classes = {}
-      scan_data_directory
+      @taste_configs = {}
+      @taste_instances = {}
+      discover_and_load_tastes
     end
 
+    # Get a taste instance by flavor name
+    #
+    # @param flavor [String, Symbol] The flavor name (e.g., "icc", "elf")
+    # @return [Taste::Base] The taste instance
+    # @raise [UnknownTasteError] If the flavor is not registered
+    #
+    # @example
+    #   taste = TasteRegister.get("icc")
+    #   taste.process_input_adoc_overrides(attrs, options)
     def self.get(flavor)
       instance.get(flavor)
     end
 
+    # Get a taste instance by flavor name
+    #
+    # @param flavor [String, Symbol] The flavor name
+    # @return [Taste::Base] The taste instance
+    # @raise [UnknownTasteError] If the flavor is not registered
     def get(flavor)
-      flavor_sym = flavor.to_sym
-      return @taste_classes[flavor_sym] if @taste_classes[flavor_sym]
+      flavor_sym = normalize_flavor_name(flavor)
+
+      return @taste_instances[flavor_sym] if @taste_instances[flavor_sym]
 
-      config = @tastes[flavor_sym]
-      raise "Unknown taste: #{flavor}" unless config
+      config = @taste_configs[flavor_sym]
+      raise UnknownTasteError, "Unknown taste: #{flavor}" unless config
 
-      # Dynamically create and cache the taste class
-      @taste_classes[flavor_sym] = create_taste_class(flavor_sym, config)
+      @taste_instances[flavor_sym] = create_taste_instance(flavor_sym, config)
     end
 
+    # Get list of available taste flavors
+    #
+    # @return [Array<Symbol>] Array of available flavor names
+    #
+    # @example
+    #   TasteRegister.available_tastes
+    #   # => [:icc, :elf, :enosema]
     def available_tastes
-      @tastes.keys
+      @taste_configs.keys
     end
 
-    def taste_info(flavor)
-      @tastes[flavor.to_sym]
+    # Get detailed information about a specific taste
+    #
+    # @param flavor [String, Symbol] The flavor name
+    # @return [TasteConfig, nil] The taste configuration object, or nil if not found
+    #
+    # @example
+    #   config = TasteRegister.get_config("icc")
+    #   puts config.owner  # => "International Color Consortium"
+    def self.get_config(flavor)
+      instance.get_config(flavor)
+    end
+
+    def get_config(flavor)
+      flavor_sym = normalize_flavor_name(flavor)
+      config = @taste_configs[flavor_sym]
+      return nil unless config
+
+      # Set the directory on the config object
+      config.directory = config_directory_for(flavor_sym)
+      config
+    end
+
+    # Get flavor aliases mapping
+    #
+    # @return [Hash<Symbol, Symbol>] Mapping of flavor to base_flavor
+    #
+    # @example
+    #   aliases = TasteRegister.instance.aliases
+    #   # => { icc: :iso, elf: :iso, enosema: :iso }
+    def self.aliases
+      instance.aliases
     end
 
     def aliases
-      # Build aliases dynamically from registered tastes
-      aliases = {}
-      @tastes.each do |flavor, info|
-        aliases[flavor] = info[:base_flavor] if info[:base_flavor]
+      @taste_configs.each_with_object({}) do |(flavor, config), aliases|
+        aliases[flavor] = config.base_flavor&.to_sym if config.base_flavor
       end
-      aliases
     end
 
     private
 
-    def scan_data_directory
-      data_dir = File.join(File.dirname(__FILE__), "..", "..", "data")
-      return unless Dir.exist?(data_dir)
+    # Discover and load all taste configurations from the data directory
+    #
+    # Scans the data directory for subdirectories containing config.yaml files,
+    # loads each configuration using lutaml-model, and registers them.
+    def discover_and_load_tastes
+      data_directory_path = data_directory
+      return unless data_directory_path && Dir.exist?(data_directory_path)
 
-      Dir.entries(data_dir).each do |entry|
-        next if entry.start_with?(".")
+      taste_directories = find_taste_directories(data_directory_path)
+      taste_directories.each { |dir| load_taste_from_directory(dir) }
+    end
 
-        taste_dir = File.join(data_dir, entry)
-        next unless Dir.exist?(taste_dir)
+    # Get the path to the data directory
+    #
+    # @return [String] Path to the data directory
+    def data_directory
+      File.join(File.dirname(__FILE__), "..", "..", "data")
+    end
 
-        config_file = File.join(taste_dir, "config.yaml")
-        next unless File.exist?(config_file)
+    # Find all valid taste directories in the data directory
+    #
+    # @param data_dir [String] Path to the data directory
+    # @return [Array<String>] Array of taste directory paths
+    def find_taste_directories(data_dir)
+      Dir.entries(data_dir)
+        .reject { |entry| entry.start_with?(".") }
+        .map { |entry| File.join(data_dir, entry) }
+        .select { |path| Dir.exist?(path) && has_config_file?(path) }
+    end
 
-        register_taste(entry, taste_dir, config_file)
+    # Check if a directory contains a config.yaml file
+    #
+    # @param directory [String] Directory path to check
+    # @return [Boolean] True if config.yaml exists
+    def has_config_file?(directory)
+      File.exist?(File.join(directory, "config.yaml"))
+    end
+
+    # Load and register a taste configuration from a directory
+    #
+    # @param taste_directory [String] Path to the taste directory
+    # @raise [InvalidTasteConfigError] If the configuration is invalid
+    def load_taste_from_directory(taste_directory)
+      config_file = File.join(taste_directory, "config.yaml")
+      directory_name = File.basename(taste_directory)
+
+      begin
+        config_content = File.read(config_file)
+        config = Taste::TasteConfig.from_yaml(config_content)
+
+        validate_taste_config!(config, directory_name)
+        register_taste_config(config, taste_directory)
+      rescue StandardError => e
+        raise InvalidTasteConfigError,
+              "Failed to load taste from #{taste_directory}: #{e.message}"
       end
     end
 
-    def register_taste(directory_name, taste_dir, config_file)
-      config = YAML.load_file(config_file)
-      flavor = config["flavor"]&.to_sym || directory_name.to_sym
-
-      @tastes[flavor] = {
-        flavor: flavor,
-        owner: config["owner"],
-        base_flavor: config["base-flavor"]&.to_sym,
-        directory: taste_dir,
-        config: config,
-        copyright_notice: config["copyright-notice"],
-        i18n_dictionary: config["i18n-dictionary"],
-        publisher_logo: config["publisher-logo"],
-        base_override: config["base-override"] || {},
-        doctypes: config["doctypes"] || {}
-      }
-    end
-
-    def create_taste_class(flavor, config)
-      # Create a dynamic class that inherits from Base
-      taste_class = Class.new(Taste::Base) do
-        define_method :initialize do
-          super(flavor, config)
-        end
+    # Validate that a taste configuration is complete and valid
+    #
+    # @param config [Taste::TasteConfig] The configuration to validate
+    # @param directory_name [String] The directory name for fallback
+    # @raise [InvalidTasteConfigError] If validation fails
+    def validate_taste_config!(config, directory_name)
+      unless config.flavor || directory_name
+        raise InvalidTasteConfigError, "Taste must have a flavor name"
       end
+    end
+
+    # Register a taste configuration in the registry
+    #
+    # @param config [Taste::TasteConfig] The configuration to register
+    # @param directory [String] The taste directory path
+    def register_taste_config(config, directory)
+      # Use config flavor or fall back to directory name
+      flavor = config.flavor&.to_sym || File.basename(directory).to_sym
+
+      # Store the config and remember its directory
+      @taste_configs[flavor] = config
+      @config_directories ||= {}
+      @config_directories[flavor] = directory
+    end
 
-      # Define the class constant dynamically
-      class_name = flavor.to_s.split(/[-_]/).map(&:capitalize).join
+    # Create a taste instance for the given flavor and configuration
+    #
+    # @param flavor [Symbol] The flavor name
+    # @param config [Taste::TasteConfig] The taste configuration
+    # @return [Taste::Base] The created taste instance
+    def create_taste_instance(flavor, config)
+      directory = config_directory_for(flavor)
+
+      # Create dynamic class if it doesn't exist
+      class_name = flavor.to_s.capitalize
       unless Taste.const_defined?(class_name)
-        Taste.const_set(class_name,
-                        taste_class)
+        Taste.const_set(class_name, Class.new(Taste::Base))
       end
 
-      taste_class.new
+      # Create instance of the dynamic class
+      dynamic_class = Taste.const_get(class_name)
+      dynamic_class.new(flavor, config, directory: directory)
+    end
+
+    # Get the directory path for a registered flavor
+    #
+    # @param flavor [Symbol] The flavor name
+    # @return [String] The directory path
+    def config_directory_for(flavor)
+      @config_directories ||= {}
+      @config_directories[flavor] || File.join(data_directory, flavor.to_s)
+    end
+
+    # Normalize flavor name to symbol
+    #
+    # @param flavor [String, Symbol] The flavor name
+    # @return [Symbol] Normalized flavor name
+    def normalize_flavor_name(flavor)
+      flavor.to_sym
     end
   end
 end

data/metanorma-taste.gemspec

@@ -32,18 +32,5 @@ Gem::Specification.new do |spec|
   spec.bindir = "bin"
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "debug"
-  spec.add_development_dependency "equivalent-xml", "~> 0.6"
-  spec.add_development_dependency "metanorma"
-  spec.add_development_dependency "metanorma-iso"
-  spec.add_development_dependency "mnconvert"
-  spec.add_development_dependency "pry"
-  spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "rspec-command", "~> 1.0"
-  spec.add_development_dependency "rubocop", "~> 1"
-  spec.add_development_dependency "rubocop-performance"
-  spec.add_development_dependency "sassc-embedded", "~> 1"
-  spec.add_development_dependency "simplecov", "~> 0.15"
-  spec.add_development_dependency "xml-c14n"
+  spec.add_dependency "lutaml-model", "~>0.7"
 end

metadata

@@ -1,211 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-taste
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-01 00:00:00.000000000 Z
+date: 2025-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: debug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: equivalent-xml
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.6'
-- !ruby/object:Gem::Dependency
-  name: metanorma
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: metanorma-iso
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: mnconvert
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: rspec-command
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1'
-- !ruby/object:Gem::Dependency
-  name: rubocop-performance
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: sassc-embedded
+  name: lutaml-model
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
-  type: :development
+        version: '0.7'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.15'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.15'
-- !ruby/object:Gem::Dependency
-  name: xml-c14n
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
 description: Library to process and handle default Metanorma Tastes, providing configuration-driven
   customization of Metanorma flavours.
 email:
@@ -232,11 +50,19 @@ files:
 - data/enosema/logo.svg
 - data/icc/config.yaml
 - data/icc/copyright.adoc
+- data/icc/htmlcoverpage.html
+- data/icc/htmlstylesheet-override.scss
 - data/icc/i18n.yaml
-- data/icc/icc.png
+- data/icc/icc-full-new.svg
+- data/icc/icc-full.svg
+- data/icc/icc-small-new.svg
+- data/icc/icc-small.svg
 - lib/metanorma-taste.rb
 - lib/metanorma/taste.rb
 - lib/metanorma/taste/base.rb
+- lib/metanorma/taste/base_override.rb
+- lib/metanorma/taste/doctype_config.rb
+- lib/metanorma/taste/taste_config.rb
 - lib/metanorma/taste/version.rb
 - lib/metanorma/taste_register.rb
 - metanorma-taste.gemspec