lutaml-model 0.8.3 → 0.8.5

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

data/lib/lutaml/model/validation_framework.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "validation/issue"
+require_relative "validation/layer_result"
+require_relative "validation/report"
+require_relative "validation/context"
+require_relative "validation/rule"
+require_relative "validation/registry"
+require_relative "validation/profile"
+require_relative "validation/remediation"
+require_relative "validation/remediation_result"
+
+module Lutaml
+  module Model
+    # Document-level validation framework. Orthogonal to the existing
+    # attribute-level Validation module — this validates structural
+    # integrity, cross-references, and conformance against domain rules.
+    #
+    # @example Run all registered rules
+    #   issues = Lutaml::Model::Validation.validate(context, registry)
+    # @example Run and raise on errors
+    #   Lutaml::Model::Validation.validate!(context, registry)
+    module Validation
+      class << self
+        def new_registry
+          Registry.new
+        end
+
+        def validate(context, registry, profile: nil)
+          rules = if profile
+                    profile.resolve(registry)
+                  else
+                    registry.all
+                  end
+
+          all_issues = []
+          rules.each do |rule|
+            next unless rule.applicable?(context)
+
+            issues = rule.check(context)
+            if context.respond_to?(:add_error)
+              issues.each { |i| context.add_error(i) }
+            end
+            all_issues.concat(issues)
+          end
+
+          all_issues
+        end
+
+        def validate!(context, registry, profile: nil)
+          issues = validate(context, registry, profile: profile)
+          return if issues.empty?
+
+          errors = issues.select(&:error?)
+          unless errors.empty?
+            raise ValidationError.new(format_errors(errors), issues: errors)
+          end
+        end
+
+        private
+
+        def format_errors(errors)
+          errors.map { |e| "[#{e.code}] #{e.message}" }.join("\n")
+        end
+      end
+
+      class ValidationError < StandardError
+        attr_reader :issues
+
+        def initialize(message, issues: [])
+          super(message)
+          @issues = issues
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.3"
+    VERSION = "0.8.5"
   end
 end

data/lib/lutaml/model.rb

@@ -10,6 +10,8 @@ module Lutaml
   autoload :Jsonl, "#{__dir__}/jsonl"
   autoload :Yamls, "#{__dir__}/yamls"
   autoload :Xml, "#{__dir__}/xml"
+  autoload :JsonLd, "#{__dir__}/jsonld"
+  autoload :Turtle, "#{__dir__}/turtle"
 
   module Model
     # Autoloads for lazy loading - set up BEFORE any requires
@@ -115,6 +117,8 @@ module Lutaml
              "#{__dir__}/model/error/liquid_not_enabled_error"
     autoload :LiquidClassNotFoundError,
              "#{__dir__}/model/error/liquid_class_not_found_error"
+    autoload :LiquidDropAlreadyRegisteredError,
+             "#{__dir__}/model/error/liquid_drop_already_registered_error"
     autoload :NoAttributesDefinedLiquidError,
              "#{__dir__}/model/error/no_attributes_defined_liquid_error"
     autoload :IncorrectMappingArgumentsError,
@@ -184,6 +188,8 @@ module Lutaml
              "#{__dir__}/model/error/unresolvable_type_error"
     autoload :MixedContentCollectionError,
              "#{__dir__}/model/error/mixed_content_collection_error"
+    autoload :OrderedContentMappingError,
+             "#{__dir__}/model/error/ordered_content_mapping_error"
 
     # Error for passing incorrect model type
     #
@@ -237,6 +243,10 @@ require "#{__dir__}/jsonl"
 require "#{__dir__}/yamls"
 require "#{__dir__}/xml"
 
+# Optional formats: require "lutaml/jsonld" or "lutaml/turtle" to enable.
+# These are not eagerly loaded because they depend on optional gems
+# (e.g., rdf-turtle) that most users don't need.
+
 # Prepend builder interface into Serialize
 # Builder must be prepended AFTER XML so its initialize runs first
 # (Builder -> XML InstanceMethods -> Serialize)

data/lib/lutaml/rdf/error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    class Error < Lutaml::Model::Error; end
+  end
+end

data/lib/lutaml/rdf/iri.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    class Iri
+      include Comparable
+
+      attr_reader :value
+
+      def initialize(uri_string)
+        @value = uri_string.to_s.freeze
+      end
+
+      def expand(namespace_set)
+        namespace_set.resolve_compact_iri(value)
+      end
+
+      def compact(namespace_set)
+        namespace_set.compact(value)
+      end
+
+      def <=>(other)
+        other.is_a?(self.class) ? value <=> other.value : nil
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && value == other.value
+      end
+      alias_method :eql?, :==
+
+      def hash
+        value.hash
+      end
+
+      def to_s
+        value
+      end
+
+      def inspect
+        "#<#{self.class.name} #{value}>"
+      end
+    end
+  end
+end

data/lib/lutaml/rdf/language_tagged.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    module LanguageTagged
+      def language_tag
+        language
+      end
+    end
+  end
+end

data/lib/lutaml/rdf/literal.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Rdf
+    class Literal
+      include LanguageTagged
+
+      attr_reader :value, :datatype, :language
+
+      def initialize(value, datatype: nil, language: nil)
+        @value = value
+        @datatype = datatype
+        @language = language
+      end
+
+      def to_turtle
+        escaped = escape_turtle(value.to_s)
+        if language
+          "#{escaped}@#{language}"
+        elsif datatype
+          "#{escaped}^^<#{datatype}>"
+        else
+          escaped
+        end
+      end
+
+      def to_jsonld_term
+        if language
+          { "@value" => value, "@language" => language }
+        elsif datatype
+          { "@value" => value, "@type" => datatype.to_s }
+        else
+          value
+        end
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          value == other.value &&
+          datatype == other.datatype &&
+          language == other.language
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [value, datatype, language].hash
+      end
+
+      private
+
+      def escape_turtle(str)
+        escaped = str.gsub(/[\n\r\t"\\]/,
+                           "\\" => "\\\\",
+                           '"' => "\\\"",
+                           "\n" => "\\n",
+                           "\r" => "\\r",
+                           "\t" => "\\t")
+        "\"#{escaped}\""
+      end
+    end
+  end
+end