lutaml-model 0.8.2 → 0.8.4

data/lib/lutaml/model/services/transformer.rb

@@ -5,6 +5,37 @@ module Lutaml
         def call(value, rule, attribute, format: nil)
           new(rule, attribute, format).call(value)
         end
+
+        private
+
+        def get_transform_static(obj, direction)
+          transform = obj&.transform
+          return nil if transform.nil? || transform.is_a?(Class)
+
+          transform.is_a?(::Hash) ? transform[direction] : transform
+        end
+
+        def apply_static(value, sources, direction, format)
+          methods = sources.filter_map do |obj|
+            get_transform_static(obj, direction)
+          end
+
+          class_transformers = sources.filter_map do |obj|
+            next unless obj&.transform.is_a?(Class) &&
+              obj.transform < Lutaml::Model::ValueTransformer
+
+            obj.transform
+          end
+
+          return value if methods.empty? && class_transformers.empty?
+
+          apply_direction = direction == :import ? :from : :to
+          result = class_transformers.reduce(value) do |v, tc|
+            tc.public_send(apply_direction, v, format)
+          end
+
+          methods.reduce(result) { |tv, m| m.call(tv) }
+        end
       end
 
       attr_reader :rule, :attribute, :format
@@ -16,46 +47,38 @@ module Lutaml
       end
 
       def call(value)
-        # Collect all class-based and hash/proc-based transformers
-        # Apply them in the correct order based on transformation_methods
-
-        # Get ordered transformation methods (already in correct precedence)
         methods = transformation_methods
 
-        # Also check for class-based transformers and add them in correct order
-        class_transformers = []
-        if instance_of?(ExportTransformer)
-          # Export order: attribute first, then rule
-          class_transformers << attribute.transform if attribute&.transform.is_a?(Class) && attribute.transform < Lutaml::Model::ValueTransformer
-          class_transformers << rule.transform if rule&.transform.is_a?(Class) && rule.transform < Lutaml::Model::ValueTransformer
-        else
-          # Import order: rule first, then attribute
-          class_transformers << rule.transform if rule&.transform.is_a?(Class) && rule.transform < Lutaml::Model::ValueTransformer
-          class_transformers << attribute.transform if attribute&.transform.is_a?(Class) && attribute.transform < Lutaml::Model::ValueTransformer
+        class_transformers = ordered_sources.filter_map do |obj|
+          next unless obj&.transform.is_a?(Class) &&
+            obj.transform < Lutaml::Model::ValueTransformer
+
+          obj.transform
         end
 
-        # Apply class transformers first, then hash/proc transformers
         result = class_transformers.reduce(value) do |v, transformer_class|
           apply_class_transformer(v, transformer_class, format)
         end
 
-        # Then apply hash/proc transformers
         methods.reduce(result) do |transformed_value, method|
           method.call(transformed_value)
         end
       end
 
       def apply_class_transformer(value, transformer_class, format)
-        if instance_of?(ExportTransformer)
+        if export_direction?
           transformer_class.to(value, format)
         else
           transformer_class.from(value, format)
         end
       end
 
+      def export_direction?
+        false
+      end
+
       def get_transform(obj, direction)
         transform = obj&.transform
-
         return nil if transform.is_a?(Class)
 
         transform.is_a?(::Hash) ? transform[direction] : transform
@@ -63,26 +86,38 @@ module Lutaml
     end
 
     class ImportTransformer < Transformer
-      # Precedene of transformations:
-      # 1. Rule transform
-      # 2. Attribute transform
+      class << self
+        def call(value, rule, attribute, format: nil)
+          apply_static(value, [rule, attribute], :import, format)
+        end
+      end
+
+      def ordered_sources
+        [rule, attribute]
+      end
+
       def transformation_methods
-        [
-          get_transform(rule, :import),
-          get_transform(attribute, :import),
-        ].compact
+        ordered_sources.filter_map { |obj| get_transform(obj, :import) }
       end
     end
 
     class ExportTransformer < Transformer
-      # Precedene of transformations (reverse order):
-      # 1. Attribute transform
-      # 2. Rule transform
+      class << self
+        def call(value, rule, attribute, format: nil)
+          apply_static(value, [attribute, rule], :export, format)
+        end
+      end
+
+      def ordered_sources
+        [attribute, rule]
+      end
+
       def transformation_methods
-        [
-          get_transform(attribute, :export),
-          get_transform(rule, :export),
-        ].compact
+        ordered_sources.filter_map { |obj| get_transform(obj, :export) }
+      end
+
+      def export_direction?
+        true
       end
     end
   end

data/lib/lutaml/model/transform.rb

@@ -3,21 +3,58 @@
 module Lutaml
   module Model
     class Transform
+      @transform_cache = {}
+
+      # Maximum number of cached Transform instances before eviction.
+      MAX_CACHE_SIZE = 256
+
       def self.data_to_model(context, data, format, options = {})
-        new(context, options[:register]).data_to_model(data, format, options)
+        register = options[:register] || Lutaml::Model::Config.default_register
+        transform = cached_transform(context, register)
+        transform.data_to_model(data, format, options)
       end
 
       def self.model_to_data(context, model, format, options = {})
         register = model.lutaml_register if model.respond_to?(:lutaml_register)
-        new(context, register).model_to_data(model, format, options)
+        register ||= Lutaml::Model::Config.default_register
+        transform = cached_transform(context, register)
+        transform.model_to_data(model, format, options)
       end
 
-      attr_reader :context, :attributes, :lutaml_register
+      def self.cached_transform(context, register)
+        @transform_cache ||= {}
+        cache_key = [context.object_id, register]
+        entry = @transform_cache[cache_key]
+        return entry if entry
+
+        evict_if_needed if @transform_cache.size >= MAX_CACHE_SIZE
+        @transform_cache[cache_key] = new(context, register)
+      end
+
+      def self.clear_cache!
+        @transform_cache&.clear
+      end
+
+      def self.cache_size
+        @transform_cache&.size || 0
+      end
+
+      def self.evict_if_needed
+        # Evict oldest half of entries when cache is full
+        keys_to_remove = @transform_cache.keys.first(@transform_cache.size / 2)
+        keys_to_remove.each { |k| @transform_cache.delete(k) }
+      end
+      private_class_method :evict_if_needed
+
+      attr_reader :context, :lutaml_register
 
       def initialize(context, register = nil)
         @context = context
         @lutaml_register = register || Lutaml::Model::Config.default_register
-        @attributes = context.attributes(lutaml_register)
+      end
+
+      def attributes
+        context.attributes(lutaml_register)
       end
 
       def model_class

data/lib/lutaml/model/uninitialized_class.rb

@@ -49,16 +49,22 @@ module Lutaml
       end
 
       def method_missing(method, *_args, &)
-        if method.end_with?("?")
-          false
-        else
-          super
-        end
+        return false if method.end_with?("?")
+
+        nil
       end
 
       def respond_to_missing?(method_name, _include_private = false)
         method_name.end_with?("?")
       end
+
+      def dup
+        self
+      end
+
+      def clone
+        self
+      end
     end
   end
 end

data/lib/lutaml/model/validation/concerns/has_issues.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Validation
+      # Shared severity filtering for objects that expose an `issues`
+      # collection. Included by LayerResult and Report.
+      module HasIssues
+        def errors
+          issues.select(&:error?)
+        end
+
+        def warnings
+          issues.select(&:warning?)
+        end
+
+        def infos
+          issues.select(&:info?)
+        end
+
+        def notices
+          issues.select(&:notice?)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/validation/context.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Validation
+      # Mutable validation context that accumulates errors and provides
+      # per-rule state. Used when validation needs imperative error
+      # accumulation (e.g., streaming SAX validation).
+      class Context
+        attr_reader :errors
+
+        def initialize
+          @errors = []
+          @per_rule_state = {}
+        end
+
+        def add_error(issue)
+          @errors << issue
+        end
+
+        def add_errors(issues)
+          @errors.concat(issues)
+        end
+
+        def rule_state(rule_code)
+          @per_rule_state[rule_code] ||= {}
+        end
+
+        def reset!
+          @errors.clear
+          @per_rule_state.clear
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/validation/issue.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Validation
+      # Serializable validation issue with severity, code, location, and
+      # suggestion. Used by Rule#check to report problems and aggregated
+      # by LayerResult and Report.
+      class Issue < Lutaml::Model::Serializable
+        # Allowed severity levels for validation issues.
+        SEVERITIES = %w[error warning info notice].freeze
+
+        attribute :severity, :string
+        attribute :code, :string
+        attribute :message, :string
+        attribute :location, :string
+        attribute :line, :integer
+        attribute :suggestion, :string
+
+        json do
+          map "severity", to: :severity
+          map "code", to: :code
+          map "message", to: :message
+          map "location", to: :location
+          map "line", to: :line
+          map "suggestion", to: :suggestion
+        end
+
+        def initialize(attributes = {})
+          super
+          validate_severity!
+        end
+
+        def error?
+          severity == "error"
+        end
+
+        def warning?
+          severity == "warning"
+        end
+
+        def info?
+          severity == "info"
+        end
+
+        def notice?
+          severity == "notice"
+        end
+
+        private
+
+        def validate_severity!
+          return if severity.nil? || SEVERITIES.include?(severity)
+
+          raise ArgumentError,
+                "Invalid severity: #{severity}. " \
+                "Must be one of: #{SEVERITIES.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/validation/layer_result.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "issue"
+require_relative "concerns/has_issues"
+
+module Lutaml
+  module Model
+    module Validation
+      class LayerResult < Lutaml::Model::Serializable
+        include HasIssues
+
+        attribute :name, :string
+        attribute :status, :string
+        attribute :duration_ms, :integer
+        attribute :issues, Issue, collection: true
+
+        json do
+          map "name", to: :name
+          map "status", to: :status
+          map "duration_ms", to: :duration_ms
+          map "issues", to: :issues
+        end
+
+        def pass?
+          status == "pass"
+        end
+
+        def fail?
+          status == "fail"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/validation/profile.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Lutaml
+  module Model
+    module Validation
+      # Composable validation profile loaded from YAML. Selects which rules
+      # run during validation. Profiles can import other profiles for
+      # rule reuse across validation levels (e.g., basic → strict).
+      class Profile
+        attr_reader :name, :description, :rule_names, :imports
+
+        def initialize(name:, description: nil, rule_names: [], imports: [])
+          @name = name
+          @description = description
+          @rule_names = rule_names
+          @imports = imports
+        end
+
+        def self.load(path)
+          data = YAML.safe_load_file(path, symbolize_names: false)
+          unless data.is_a?(::Hash) && data["name"].is_a?(String)
+            raise ArgumentError,
+                  "Profile YAML must contain a 'name' string key: #{path}"
+          end
+
+          new(
+            name: data["name"],
+            description: data["description"],
+            rule_names: data["rules"] || [],
+            imports: data["import"] || [],
+          )
+        end
+
+        def resolve(registry, profiles_by_name = {}, visited: Set.new)
+          if visited.include?(name)
+            raise ArgumentError,
+                  "Circular profile import detected: #{name}"
+          end
+
+          resolved = resolve_imports(registry, profiles_by_name,
+                                     visited: visited + [name])
+          resolved | resolve_names(registry)
+        end
+
+        private
+
+        def resolve_names(registry)
+          rule_names.filter_map do |name|
+            registry.all.find { |r| r.class.name == name }
+          end
+        end
+
+        def resolve_imports(registry, profiles_by_name, visited: Set.new)
+          imports.flat_map do |import_name|
+            imported = profiles_by_name[import_name]
+            next [] unless imported
+
+            imported.resolve(registry, profiles_by_name, visited: visited)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/validation/registry.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Validation
+      # Instance-based rule registry. Register rule classes, look up by
+      # code or category, and instantiate all registered rules for
+      # validation runs.
+      class Registry
+        def initialize
+          @rules = []
+          @mutex = Mutex.new
+          @all = nil
+        end
+
+        def register(rule_class)
+          @mutex.synchronize do
+            return if @rules.include?(rule_class)
+
+            @rules << rule_class
+            @all = nil
+          end
+        end
+
+        def auto_discover(dir, pattern: "**/*_rule.rb")
+          Dir.glob(File.join(dir, pattern)).each { |path| require path }
+        end
+
+        def all
+          @mutex.synchronize do
+            @all ||= @rules.map(&:new)
+          end
+        end
+
+        def for_category(category)
+          all.select { |r| r.category == category }
+        end
+
+        def find(code)
+          all.find { |r| r.code == code }
+        end
+
+        def reset!
+          @mutex.synchronize do
+            @rules.clear
+            @all = nil
+          end
+        end
+
+        def rule_classes
+          @rules.dup
+        end
+
+        def size
+          @rules.size
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/validation/remediation.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Validation
+      # Abstract base class for validation remediation. Subclass and
+      # override {#id}, {#targets}, {#applicable?}, {#fix}, and
+      # {#preview} to implement auto-fix logic for specific issue codes.
+      class Remediation
+        def id
+          nil
+        end
+
+        def targets
+          nil
+        end
+
+        def applicable?(_context, _report)
+          true
+        end
+
+        def fix(_context, _report)
+          raise NotImplementedError,
+                "#{self.class}#fix must be implemented by subclass"
+        end
+
+        def preview(_context, _report)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/validation/remediation_result.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Validation
+      # Result of a remediation fix attempt. Serializable to JSON.
+      class RemediationResult < Lutaml::Model::Serializable
+        attribute :success, :boolean
+        attribute :message, :string
+        attribute :fixed_codes, :string, collection: true
+
+        json do
+          map "success", to: :success
+          map "message", to: :message
+          map "fixed_codes", to: :fixed_codes
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/validation/report.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "concerns/has_issues"
+require_relative "issue"
+require_relative "layer_result"
+
+module Lutaml
+  module Model
+    module Validation
+      class Report < Lutaml::Model::Serializable
+        include HasIssues
+
+        attribute :source, :string
+        attribute :timestamp, :string
+        attribute :valid, :boolean
+        attribute :duration_ms, :integer
+        attribute :layers, LayerResult, collection: true
+
+        json do
+          map "source", to: :source
+          map "timestamp", to: :timestamp
+          map "valid", to: :valid
+          map "duration_ms", to: :duration_ms
+          map "layers", to: :layers
+        end
+
+        def initialize(attributes = {})
+          super
+          self.timestamp ||= Time.now.utc.iso8601
+        end
+
+        def issues
+          layers ? layers.flat_map(&:issues) : []
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/validation/rule.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Validation
+      # Abstract base class for validation rules. Subclass and override
+      # {#code}, {#category}, {#severity}, {#applicable?}, and {#check}
+      # to implement domain-specific validation logic.
+      #
+      # Use the private {#issue} helper inside {#check} to create issues
+      # that inherit the rule's severity and code by default.
+      class Rule
+        def code
+          nil
+        end
+
+        def category
+          :general
+        end
+
+        def severity
+          "error"
+        end
+
+        def applicable?(_context)
+          true
+        end
+
+        def check(_context)
+          []
+        end
+
+        def needs_deferred?
+          false
+        end
+
+        def collect(_element, _context); end
+
+        def complete(_context)
+          []
+        end
+
+        private
+
+        def issue(message, location: nil, line: nil, suggestion: nil,
+                  severity: nil, code: nil)
+          Issue.new(
+            severity: severity || self.severity,
+            code: code || self.code,
+            message: message,
+            location: location,
+            line: line,
+            suggestion: suggestion,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/validation.rb

@@ -11,7 +11,8 @@ module Lutaml
 
           begin
             if value.respond_to?(:validate)
-              errors.concat(value.validate)
+              sub_errors = value.validate
+              errors.concat(sub_errors) if sub_errors.is_a?(Array)
             else
               resolver = Lutaml::Model::Services::DefaultValueResolver.new(
                 attr, register, self