canon 0.2.11 → 0.2.12

data/lib/canon/config/config_dsl.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Canon
+  class Config
+    # DSL for declaring config-backed attributes on a config class.
+    #
+    # A config class (DiffConfig, MatchConfig, FormatConfig) extends this
+    # module and declares each user-tunable attribute with {config_key}.
+    # The DSL generates the matching getter/setter pair and registers
+    # the attribute's metadata (type, enum, default, coercion) in a
+    # per-class registry so other components (EnvSchema, TypeConverter)
+    # can discover it without duplicating the schema.
+    #
+    # Goals (lutaml/canon TODO.improve/07):
+    # - Eliminate the 5-line getter/setter boilerplate per attribute
+    # - Provide a single source of truth for attribute types/enums
+    # - Keep the public API stable (methods behave exactly as before)
+    #
+    # @example Declare a simple boolean key
+    #   class DiffConfig
+    #     extend ConfigDSL
+    #     config_key :verbose_diff, type: :boolean, default: false
+    #   end
+    #
+    # @example Declare an enum-constrained symbol key
+    #   config_key :mode, type: :symbol,
+    #                       enum: %i[by_line by_object pretty_diff],
+    #                       default: :by_line
+    #
+    # @example Declare a key with setter coercion
+    #   config_key :preserve_whitespace_elements,
+    #             type: :string_array,
+    #             default: [],
+    #             coerce: ->(v) { Array(v).map(&:to_s) }
+    module ConfigDSL
+      # Per-class attribute registry, lazily initialized on first
+      # +config_key+ declaration.  Stored on the extending class so
+      # each config class owns its own map without registry leakage.
+      def config_keys
+        @config_keys ||= {}
+      end
+
+      # Declare a config-backed attribute.
+      #
+      # Generates a getter and setter on the extending class.  The
+      # getter reads through the resolver; the setter validates against
+      # +enum+ (if provided), applies +coerce+ (if provided), and
+      # writes through the resolver.
+      #
+      # @param name [Symbol] Attribute name
+      # @param type [Symbol] Type tag for ENV conversion
+      #   (:boolean, :integer, :symbol, :string, :string_array,
+      #    :pass_through)
+      # @param enum [Array, nil] Allowed values; setter validates
+      # @param default [Object, Proc] Default value, or a callable that
+      #   returns the default.  Callables are evaluated each time the
+      #   resolver is (re)built, so they pick up runtime state such as
+      #   +ColorDetector.supports_color?+ when stubs are installed by
+      #   the test suite.
+      # @param coerce [Proc, nil] Setter coercion proc (value → value)
+      # @param getter_coerce [Proc, nil] Getter coercion proc
+      # @return [void]
+      def config_key(name, type: :pass_through, enum: nil, default: nil,
+                     coerce: nil, getter_coerce: nil)
+        sym = name.to_sym
+        config_keys[sym] = {
+          type: type,
+          enum: enum,
+          default: default,
+          default_proc: default.is_a?(Proc) ? default : nil,
+          coerce: coerce,
+          getter_coerce: getter_coerce,
+        }.freeze
+
+        define_getter(sym, getter_coerce)
+        define_setter(sym, coerce)
+      end
+
+      # Resolve a declared default to a concrete value.
+      #
+      # If the declared default is a callable (e.g. a proc or method
+      # object), it is invoked each time this method is called so the
+      # result reflects the current runtime state.  Otherwise the
+      # stored default value is returned as-is.
+      #
+      # @param key [Symbol] Attribute name
+      # @return [Object] Resolved default value (may be +nil+)
+      def resolve_default(key)
+        meta = config_keys[key]
+        return nil unless meta
+
+        proc_form = meta[:default_proc]
+        return proc_form.call if proc_form
+
+        meta[:default]
+      end
+
+      # Validate a value against an attribute's enum, if any.
+      #
+      # Mirrors the original +DiffConfig.validate_config_value!+ API
+      # so existing call sites (and specs) keep working.
+      #
+      # @param key [Symbol] Attribute name
+      # @param value [Object] Value to validate
+      # @raise [ArgumentError] if value is not in the enum
+      # @return [void]
+      def validate_config_value!(key, value)
+        meta = config_keys[key]
+        return unless meta&.dig(:enum)
+        return if meta[:enum].include?(value)
+
+        raise ArgumentError,
+              "Invalid value #{value.inspect} for #{key}. " \
+              "Valid values: #{meta[:enum].map(&:inspect).join(', ')}"
+      end
+
+      # Enum constraint map, keyed by attribute name.
+      #
+      # Derived from declared config_keys for backward compatibility
+      # with the original +VALID_ENUM_VALUES+ constant.
+      #
+      # @return [Hash{Symbol => Array}] Enum values per attribute
+      def enum_values
+        config_keys.filter_map { |k, m| [k, m[:enum]] if m[:enum] }.to_h
+      end
+
+      private
+
+      # Define the reader method for +name+.
+      def define_getter(name, getter_coerce)
+        if getter_coerce
+          define_method(name) do
+            instance_exec(@resolver.resolve(name), &getter_coerce)
+          end
+        else
+          define_method(name) do
+            @resolver.resolve(name)
+          end
+        end
+      end
+
+      # Define the writer method for +name+.
+      def define_setter(name, coerce)
+        if coerce
+          define_method("#{name}=") do |value|
+            coerced = instance_exec(value, &coerce)
+            self.class.validate_config_value!(name, coerced)
+            @resolver.set_programmatic(name, coerced)
+          end
+        else
+          define_method("#{name}=") do |value|
+            self.class.validate_config_value!(name, value)
+            @resolver.set_programmatic(name, value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/canon/config/env_provider.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "env_schema"
-require_relative "type_converter"
-
 module Canon
   class Config
     # Provides environment variable values for configuration

data/lib/canon/config/env_schema.rb

@@ -2,59 +2,31 @@
 
 module Canon
   class Config
-    # Schema definition for configuration attributes
-    # Defines attribute types and ENV variable mappings
+    # Schema definition for configuration attributes.
+    #
+    # Diff attribute types and names are derived lazily from
+    # +Canon::Config::DiffConfig.config_keys+ (the single source of
+    # truth declared via {ConfigDSL}).  Match and Format attribute
+    # types are declared here because those config classes do not yet
+    # use the DSL.
+    #
+    # The lookup is intentionally lazy so that {EnvSchema} can be
+    # loaded before {DiffConfig} is defined — the methods are only
+    # called once a {DiffConfig} instance is being built, by which
+    # time the DSL registry is populated.
     class EnvSchema
-      ATTRIBUTE_TYPES = {
-        # DiffConfig attributes
-        mode: :symbol,
-        use_color: :boolean,
-        context_lines: :integer,
-        grouping_lines: :integer,
-        show_diffs: :symbol,
-        verbose_diff: :boolean,
-        algorithm: :symbol,
-        parser: :symbol,
-        show_raw_inputs: :boolean,
-        show_raw_expected: :boolean,
-        show_raw_received: :boolean,
-        show_preprocessed_inputs: :boolean,
-        show_preprocessed_expected: :boolean,
-        show_preprocessed_received: :boolean,
-        show_prettyprint_inputs: :boolean,
-        show_prettyprint_expected: :boolean,
-        show_prettyprint_received: :boolean,
-        show_line_numbered_inputs: :boolean,
-        character_visualization: :symbol,     # true, false, :content_only
-        display_format: :symbol,
-        display_preprocessing: :symbol,       # :none, :pretty_print, :normalize_pretty_print, :c14n
-        pretty_printer_indent: :integer,
-        pretty_printer_indent_type: :symbol,  # :space or :tab
-        preserve_whitespace_elements: :string_array,
-        collapse_whitespace_elements: :string_array,
-        strip_whitespace_elements: :string_array,
-        pretty_printed_expected: :boolean,
-        pretty_printed_received: :boolean,
-        pretty_printer_sort_attributes: :boolean,
-        compact_semantic_report: :boolean,
-        expand_difference: :boolean,
-        theme: :symbol,
-
-        # MatchConfig attributes
+      MATCH_ATTRIBUTE_TYPES = {
         profile: :symbol,
+      }.freeze
 
-        # FormatConfig attributes
+      FORMAT_ATTRIBUTE_TYPES = {
         preprocessing: :string,
-
-        # Size limits to prevent hangs on large files
-        max_file_size: :integer,
-        max_node_count: :integer,
-        max_diff_lines: :integer,
       }.freeze
 
       class << self
         def type_for(attribute)
-          ATTRIBUTE_TYPES[attribute.to_sym]
+          key = attribute.to_sym
+          diff_type(key) || match_type(key) || format_type(key)
         end
 
         def env_key(format, config_type, attribute)
@@ -65,29 +37,47 @@ module Canon
           "CANON_#{attribute.to_s.upcase}"
         end
 
+        # All diff attributes declared via {ConfigDSL} on {DiffConfig}.
+        #
+        # @return [Array<Symbol>]
         def all_diff_attributes
-          %i[mode use_color context_lines grouping_lines show_diffs
-             verbose_diff algorithm parser show_raw_inputs show_raw_expected show_raw_received
-             show_preprocessed_inputs show_preprocessed_expected show_preprocessed_received
-             show_prettyprint_inputs show_prettyprint_expected show_prettyprint_received
-             show_line_numbered_inputs character_visualization
-             display_format display_preprocessing
-             pretty_printer_indent pretty_printer_indent_type
-             preserve_whitespace_elements collapse_whitespace_elements strip_whitespace_elements
-             pretty_printed_expected pretty_printed_received
-             pretty_printer_sort_attributes
-             compact_semantic_report expand_difference
-             max_file_size max_node_count max_diff_lines theme]
+          diff_config_keys.keys
         end
 
+        # Match attributes subject to ENV override.
+        #
+        # @return [Array<Symbol>]
         def all_match_attributes
           %i[profile
-             preserve_whitespace_elements collapse_whitespace_elements strip_whitespace_elements]
+             preserve_whitespace_elements collapse_whitespace_elements
+             strip_whitespace_elements]
         end
 
+        # Format attributes subject to ENV override.
+        #
+        # @return [Array<Symbol>]
         def all_format_attributes
           %i[preprocessing]
         end
+
+        private
+
+        def diff_type(key)
+          meta = diff_config_keys[key]
+          meta&.fetch(:type)
+        end
+
+        def match_type(key)
+          MATCH_ATTRIBUTE_TYPES[key]
+        end
+
+        def format_type(key)
+          FORMAT_ATTRIBUTE_TYPES[key]
+        end
+
+        def diff_config_keys
+          Canon::Config::DiffConfig.config_keys
+        end
       end
     end
   end

data/lib/canon/config/profile_loader.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "yaml"
-require_relative "env_schema"
 
 module Canon
   class Config