lutaml-model 0.8.16 → 0.8.18

data/lib/lutaml/model/schema/xml_compiler/simple_type.rb

@@ -1,265 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Model
-    module Schema
-      module XmlCompiler
-        class SimpleType
-          attr_accessor :class_name, :base_class, :instance, :unions
-
-          LUTAML_VALUE_CLASS_NAME = "Lutaml::Model::Type::Value"
-
-          SUPPORTED_DATA_TYPES = {
-            nonNegativeInteger: { skippable: false,
-                                  class_name: "Lutaml::Model::Type::String", validations: { pattern: /\+?[0-9]+/ } },
-            normalizedString: { skippable: false,
-                                class_name: "Lutaml::Model::Type::String", validations: { transform: "value.gsub(/[\\r\\n\\t]/, ' ')" } },
-            positiveInteger: { skippable: false,
-                               class_name: "Lutaml::Model::Type::Integer", validations: { min_inclusive: 0 } },
-            unsignedShort: { skippable: false,
-                             class_name: "Lutaml::Model::Type::Integer", validations: { min_inclusive: 0, max_inclusive: 65535 } },
-            base64Binary: { skippable: false,
-                            class_name: "Lutaml::Model::Type::String", validations: { pattern: /\A([A-Za-z0-9+\/]+={0,2}|\s)*\z/ } },
-            unsignedLong: { skippable: false,
-                            class_name: "Lutaml::Model::Type::Integer", validations: { min_inclusive: 0, max_inclusive: 18446744073709551615 } },
-            unsignedByte: { skippable: false,
-                            class_name: "Lutaml::Model::Type::Integer", validations: { min_inclusive: 0, max_inclusive: 255 } },
-            unsignedInt: { skippable: false,
-                           class_name: "Lutaml::Model::Type::Integer", validations: { min_inclusive: 0, max_inclusive: 4294967295 } },
-            hexBinary: { skippable: false,
-                         class_name: "Lutaml::Model::Type::String", validations: { pattern: /([0-9a-fA-F]{2})*/ } },
-            language: { skippable: false,
-                        class_name: "Lutaml::Model::Type::String", validations: { pattern: /\A[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*\z/ } },
-            dateTime: { skippable: true,
-                        class_name: "Lutaml::Model::Type::DateTime" },
-            boolean: { skippable: true,
-                       class_name: "Lutaml::Model::Type::Boolean" },
-            integer: { skippable: true,
-                       class_name: "Lutaml::Model::Type::Integer" },
-            decimal: { skippable: true,
-                       class_name: "Lutaml::Model::Type::Decimal" },
-            string: { skippable: true,
-                      class_name: "Lutaml::Model::Type::String" },
-            double: { skippable: true,
-                      class_name: "Lutaml::Model::Type::Float" },
-            NCName: { skippable: false,
-                      class_name: "Lutaml::Model::Type::String", validations: { pattern: /\A[a-zA-Z_][\w.-]*\z/ } },
-            anyURI: { skippable: false,
-                      class_name: "Lutaml::Model::Type::String", validations: { pattern: "\\A\#{URI::DEFAULT_PARSER.make_regexp(%w[http https ftp])}\\z" } },
-            token: { skippable: false,
-                     class_name: "Lutaml::Model::Type::String", validations: { pattern: /\A[^\t\n\f\r ]+(?: [^\t\n\f\r ]+)*\z/ } },
-            byte: { skippable: false,
-                    class_name: "Lutaml::Model::Type::Integer", validations: { min_inclusive: -128, max_inclusive: 127 } },
-            long: { skippable: false,
-                    class_name: "Lutaml::Model::Type::Decimal" },
-            int: { skippable: true,
-                   class_name: "Lutaml::Model::Type::Integer" },
-            id: { skippable: false, class_name: "Lutaml::Model::Type::String",
-                  validations: { pattern: /\A[a-zA-Z_][\w.-]*\z/ } },
-          }.freeze
-
-          INSTANCE_MODEL_TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
-            # frozen_string_literal: true
-            require "lutaml/model"
-
-            <%= "\#{required_files}\n" -%>
-            <%= module_opening -%>
-            class <%= klass_name %><%= " < \#{parent_class}" if parent_class %>
-            <%= @indent %>def self.cast(value, options = {})
-            <%= extended_indent %>return if value.nil?
-
-            <%= instance&.to_method_body(extended_indent) %>
-                value = super(value, options)
-                value
-              end
-            <%= registration_methods -%>
-            end
-            <%= module_closing -%>
-            <%= registration_execution -%>
-          TEMPLATE
-
-          UNION_MODEL_TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
-            # frozen_string_literal: true
-            require "lutaml/model"
-            <%= union_required_files %>
-
-            <%= module_opening -%>
-            class <%= klass_name %> < <%= LUTAML_VALUE_CLASS_NAME %>
-            <%= @indent %>def self.cast(value, options = {})
-            <%= extended_indent %>return if value.nil?
-
-            <%= union_class_method_body %>
-              end
-            <%= registration_methods -%>
-            end
-            <%= module_closing -%>
-            <%= registration_execution -%>
-          TEMPLATE
-
-          def initialize(name, unions = [])
-            @class_name = name
-            @unions = unions
-            @module_namespace = nil
-          end
-
-          def to_class(options: {})
-            setup_options(options)
-            template = unions&.any? ? UNION_MODEL_TEMPLATE : INSTANCE_MODEL_TEMPLATE
-            template.result(binding)
-          end
-
-          def required_files
-            files = Array(instance&.required_files)
-            # Don't add requires for parent classes if using module namespace
-            # They're handled via central autoload registry
-            if !@module_namespace && require_parent?
-              files << "require_relative \"#{Utils.snake_case(parent_class)}\""
-            end
-            # Filter out require_relative when using autoload, keep external requires
-            if @module_namespace
-              files = files.select { |f| f.start_with?("require \"") }
-            end
-            files.join("\n")
-          end
-
-          private
-
-          def setup_options(options)
-            @indent = " " * options&.fetch(:indent, 2)
-            @extended_indent = @indent * 2
-            @module_namespace = options[:module_namespace]
-            @modules = @module_namespace&.split("::") || []
-            @register_id = options[:register_id]
-          end
-
-          def module_opening
-            return "" if @modules.empty?
-
-            @modules.map.with_index do |mod, i|
-              "#{'  ' * i}module #{mod}"
-            end.join("\n") + "\n"
-          end
-
-          def module_closing
-            return "" if @modules.empty?
-
-            @modules.reverse.map.with_index do |_mod, i|
-              "#{'  ' * (@modules.size - i - 1)}end"
-            end.join("\n")
-          end
-
-          def registration_methods
-            if @module_namespace
-              # Still need register method for union types that call register.get_class
-              <<~REGISTRATION
-
-                #{@indent}def self.register
-                #{extended_indent}Lutaml::Model::Config.default_register
-                #{@indent}end
-              REGISTRATION
-            else
-              <<~REGISTRATION
-
-                #{@indent}def self.register
-                #{extended_indent}@register ||= Lutaml::Model::Config.default_register
-                #{@indent}end
-
-                #{@indent}def self.register_class_with_id
-                #{extended_indent}context = Lutaml::Model::GlobalContext.context(Lutaml::Model::Config.default_register)
-                #{extended_indent}context.registry.register(:#{Utils.snake_case(class_name)}, self)
-                #{@indent}end
-              REGISTRATION
-            end
-          end
-
-          def registration_execution
-            return "" if @module_namespace
-
-            "\n#{klass_name}.register_class_with_id"
-          end
-
-          def klass_name
-            @klass_name ||= Utils.camel_case(class_name)
-          end
-
-          def require_parent?
-            return false if Utils.blank?(base_class)
-
-            !!!SUPPORTED_DATA_TYPES[base_class&.to_sym]&.dig(:skippable)
-          end
-
-          def parent_class
-            type_info = SUPPORTED_DATA_TYPES[base_class&.to_sym]
-            return type_info[:class_name] if type_info&.dig(:skippable)
-            return Utils.camel_case(base_class.to_s) if !!!type_info&.dig(:skippable) && Utils.present?(base_class)
-
-            LUTAML_VALUE_CLASS_NAME
-          end
-
-          def union_class_method_body
-            unions.map do |union|
-              "#{extended_indent}Lutaml::Model::GlobalContext.resolve_type(:#{down_union_class_name(union)}, @register).cast(value, options)"
-            end.join(" ||\n  ")
-          end
-
-          def union_required_files
-            # Don't add requires for union classes if using module namespace
-            # They're handled via central autoload registry
-            return "" if @module_namespace
-
-            unions.filter_map do |union|
-              next if SUPPORTED_DATA_TYPES.dig(last_of_split(union).to_sym,
-                                               :skippable)
-
-              "require_relative \"#{down_union_class_name(union)}\""
-            end.join("\n")
-          end
-
-          def down_union_class_name(union)
-            Utils.snake_case(last_of_split(union))
-          end
-
-          def last_of_split(field)
-            field&.split(":")&.last
-          end
-
-          def extended_indent
-            @extended_indent || "    "
-          end
-
-          class << self
-            def setup_supported_types
-              SUPPORTED_DATA_TYPES.reject do |_, simple_type|
-                simple_type[:skippable]
-              end.each_with_object({}) do |(name, simple_type), hash|
-                str_name = name.to_s
-                new(str_name).tap do |instance|
-                  instance.base_class = Utils.base_class_snake_case(simple_type[:class_name])
-                  instance.instance = setup_restriction(instance.base_class,
-                                                        simple_type[:validations])
-                  hash[str_name] = instance
-                end
-              end
-            end
-
-            def setup_restriction(base_class, validations)
-              return unless validations
-
-              Restriction.new.tap do |restriction|
-                restriction.base_class = base_class
-                restriction.min_inclusive = validations[:min_inclusive]
-                restriction.max_inclusive = validations[:max_inclusive]
-                restriction.pattern = validations[:pattern]
-                restriction.transform = validations[:transform]
-              end
-            end
-
-            def skippable?(type)
-              SUPPORTED_DATA_TYPES.dig(type&.to_sym, :skippable)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/model/schema/xml_compiler/xml_namespace_class.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Model
-    module Schema
-      module XmlCompiler
-        # Generates XmlNamespace class definitions from XSD namespace URIs
-        class XmlNamespaceClass
-          attr_accessor :uri, :prefix_default, :class_name
-
-          TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
-            # frozen_string_literal: true
-
-            require "lutaml/model"
-
-            <%= module_opening -%>
-            # Namespace: <%= uri %>
-            class <%= class_name %> < Lutaml::Xml::W3c::XmlNamespace
-              uri <%= uri.inspect %>
-              prefix_default <%= prefix_default.inspect %>
-            end
-            <%= module_closing -%>
-          TEMPLATE
-
-          def initialize(uri:, prefix: nil, class_name: nil)
-            @uri = uri
-            @prefix_default = prefix || derive_prefix_from_uri(uri)
-            @class_name = class_name || derive_class_name_from_uri(uri)
-            @module_namespace = nil
-          end
-
-          def to_class(options: {})
-            @module_namespace = options[:module_namespace]
-            @modules = @module_namespace&.split("::") || []
-            TEMPLATE.result(binding)
-          end
-
-          def required_file
-            "require_relative \"#{Utils.snake_case(class_name)}\""
-          end
-
-          def class_reference
-            class_name
-          end
-
-          private
-
-          def module_opening
-            return "" if @modules.empty?
-
-            @modules.map.with_index do |mod, i|
-              "#{'  ' * i}module #{mod}"
-            end.join("\n") + "\n"
-          end
-
-          def module_closing
-            return "" if @modules.empty?
-
-            @modules.reverse.map.with_index do |_mod, i|
-              "#{'  ' * (@modules.size - i - 1)}end"
-            end.join("\n")
-          end
-
-          def derive_prefix_from_uri(uri)
-            # Extract meaningful part from URI
-            # http://schemas.openxmlformats.org/officeDocument/2006/math -> "m"
-            # http://www.w3.org/2001/XMLSchema -> "xs"
-            case uri
-            when %r{/math$}
-              "m"
-            when %r{XMLSchema}
-              "xs"
-            when %r{/(\w+)$}
-              $1[0..2] # First 3 chars
-            else
-              "ns" # Generic prefix
-            end
-          end
-
-          def derive_class_name_from_uri(uri)
-            # Extract domain and path components
-            # http://schemas.openxmlformats.org/officeDocument/2006/math
-            # -> OoxmlMathNamespace
-            return "XmlSchemaNamespace" if uri.include?("XMLSchema")
-
-            parsed_uri = URI.parse(uri)
-            parts = parsed_uri.host&.split(".")&.reject(&:empty?) || []
-            path_parts = parsed_uri.path&.split("/")&.reject(&:empty?) || []
-
-            # Use reverse domain notation + meaningful path parts
-            # Filter out version numbers and empty parts
-            name_parts = parts.reverse.take(2) + path_parts.last(2)
-            name_parts = name_parts.map do |p|
-              Utils.camel_case(p.gsub(/\d+/, "").gsub(/[^a-zA-Z]/, ""))
-            end
-              .reject(&:empty?)
-
-            # Fallback if no valid parts
-            return "DefaultNamespace" if name_parts.empty?
-
-            "#{name_parts.join}Namespace"
-          rescue URI::InvalidURIError, StandardError
-            # Fallback for invalid URIs or any other errors
-            "DefaultNamespace"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-require_relative "base"
-
-module Lutaml
-  module Model
-    module Services
-      class DefaultValueResolver < Base
-        def initialize(attribute, register, instance_object)
-          super()
-
-          @attribute = attribute
-          @register = register
-          @instance_object = instance_object
-        end
-
-        # Get the default value with proper instance context and casting
-        # Returns the evaluated and casted default value
-        def default
-          attribute.cast_value(default_value, register)
-        end
-
-        # Get the default value with proper instance context
-        # Returns the evaluated default value (procs are executed)
-        def default_value
-          raw_value = raw_default_value
-          return raw_value unless raw_value.is_a?(Proc)
-
-          # Execute proc in instance context if available, otherwise call it directly
-          if instance_object
-            instance_object.instance_exec(&raw_value)
-          else
-            raw_value.call
-          end
-        end
-
-        # Get the raw default value without executing procs
-        def raw_default_value
-          if attribute.delegate
-            # For delegated attributes, recursively resolve through the service
-            delegated_attr = attribute.type(register).attributes[attribute.to]
-            self.class.new(delegated_attr, register,
-                           instance_object).raw_default_value
-          elsif attribute.options.key?(:default)
-            attribute.options[:default]
-          else
-            Lutaml::Model::UninitializedClass.instance
-          end
-        end
-
-        # Check if a default value is set (not uninitialized)
-        def default_set?
-          !Utils.uninitialized?(raw_default_value)
-        end
-
-        private
-
-        attr_reader :attribute, :register, :instance_object
-      end
-    end
-  end
-end

data/spec/lutaml/model/services/default_value_resolver_spec.rb

@@ -1,162 +0,0 @@
-require "spec_helper"
-
-class TestModel < Lutaml::Model::Serializable
-  attribute :_class, :string, default: -> { self.class.name }
-end
-
-RSpec.describe Lutaml::Model::Services::DefaultValueResolver do
-  let(:register) { Lutaml::Model::Config.default_register }
-  let(:instance) { nil }
-
-  describe "#default_value" do
-    context "when default is a static value" do
-      let(:attribute) do
-        Lutaml::Model::Attribute.new("name", :string, default: "John")
-      end
-
-      it "returns the static value" do
-        resolver = described_class.new(attribute, register, instance)
-        expect(resolver.default_value).to eq("John")
-      end
-    end
-
-    context "when default is a proc without instance context" do
-      let(:attribute) do
-        Lutaml::Model::Attribute.new("count", :integer, default: -> { 42 })
-      end
-
-      it "executes the proc" do
-        resolver = described_class.new(attribute, register, instance)
-        expect(resolver.default_value).to eq(42)
-      end
-    end
-
-    context "when default is a proc with instance context" do
-      let(:model) { TestModel.new }
-      let(:attribute) { TestModel.attributes[:_class] }
-
-      it "executes the proc in the instance context" do
-        resolver = described_class.new(attribute, register, model)
-        expect(resolver.default_value).to eq("TestModel")
-      end
-    end
-  end
-
-  describe "#default" do
-    context "when default is a static value" do
-      let(:attribute) do
-        Lutaml::Model::Attribute.new("count", :integer, default: "42")
-      end
-
-      it "returns the casted value" do
-        resolver = described_class.new(attribute, register, instance)
-        expect(resolver.default).to eq(42)
-      end
-    end
-
-    context "when default is a proc" do
-      let(:attribute) do
-        Lutaml::Model::Attribute.new("file", :string, default: -> {
-          Pathname.new("avatar.png")
-        })
-      end
-
-      it "returns the casted proc result" do
-        resolver = described_class.new(attribute, register, instance)
-        expect(resolver.default).to eq("avatar.png")
-      end
-    end
-
-    context "when default is a proc with instance context" do
-      let(:model) { TestModel.new }
-      let(:attribute) { TestModel.attributes[:_class] }
-
-      it "executes and casts the proc in the instance context" do
-        resolver = described_class.new(attribute, register, model)
-        expect(resolver.default).to eq("TestModel")
-      end
-    end
-  end
-
-  describe "#raw_default_value" do
-    context "when default is not set" do
-      let(:attribute) do
-        Lutaml::Model::Attribute.new("name", :string)
-      end
-
-      it "returns uninitialized" do
-        resolver = described_class.new(attribute, register, instance)
-        expect(resolver.raw_default_value).to be(Lutaml::Model::UninitializedClass.instance)
-      end
-    end
-
-    context "when default is a static value" do
-      let(:attribute) do
-        Lutaml::Model::Attribute.new("name", :string, default: "John")
-      end
-
-      it "returns the static value without execution" do
-        resolver = described_class.new(attribute, register, instance)
-        expect(resolver.raw_default_value).to eq("John")
-      end
-    end
-
-    context "when default is a proc" do
-      let(:proc_default) { -> { "John" } }
-      let(:attribute) do
-        Lutaml::Model::Attribute.new("name", :string, default: proc_default)
-      end
-
-      it "returns the proc without execution" do
-        resolver = described_class.new(attribute, register, instance)
-        expect(resolver.raw_default_value).to eq(proc_default)
-      end
-    end
-
-    context "when default is nil" do
-      let(:attribute) do
-        Lutaml::Model::Attribute.new("value", :string, default: nil)
-      end
-
-      it "returns nil" do
-        resolver = described_class.new(attribute, register, instance)
-        expect(resolver.raw_default_value).to be_nil
-      end
-    end
-  end
-
-  describe "#default_set?" do
-    context "when default is not set" do
-      let(:attribute) do
-        Lutaml::Model::Attribute.new("name", :string)
-      end
-
-      it "returns false" do
-        resolver = described_class.new(attribute, register, instance)
-        expect(resolver.default_set?).to be(false)
-      end
-    end
-
-    context "when default is a static value" do
-      let(:attribute) do
-        Lutaml::Model::Attribute.new("name", :string, default: "John")
-      end
-
-      it "returns true" do
-        resolver = described_class.new(attribute, register, instance)
-        expect(resolver.default_set?).to be(true)
-      end
-    end
-
-    context "when default is a proc" do
-      let(:attribute) do
-        Lutaml::Model::Attribute.new("name", :string, default: -> { "John" })
-      end
-
-      it "returns true" do
-        resolver = described_class.new(attribute, register, instance)
-        expect(resolver.default_set?).to be(true)
-      end
-    end
-  end
-end

data/spec/lutaml/xml/schema/compiler/attribute_group_spec.rb

@@ -1,71 +0,0 @@
-require "spec_helper"
-require "support/xml/schema_helper"
-
-RSpec.describe Lutaml::Model::Schema::XmlCompiler::AttributeGroup do
-  let(:attribute_group) { described_class.new(name: "foo", ref: nil) }
-  let(:dummy_class) do
-    Class.new do
-      def to_attributes(indent); end
-      def to_xml_mapping(indent); end
-      def required_files; end
-    end
-  end
-
-  describe "#initialize" do
-    it "sets name, ref, and empty instances" do
-      ag = described_class.new(name: "bar", ref: "baz")
-      expect(ag.name).to eq("bar")
-      expect(ag.ref).to eq("baz")
-      expect(ag.instances).to eq([])
-    end
-  end
-
-  describe "#<<" do
-    it "adds instances to the list" do
-      instance = instance_double(dummy_class, to_attributes: "attr",
-                                              to_xml_mapping: "xml", required_files: "files")
-      expect { attribute_group << instance }.to change {
-        attribute_group.instances.size
-      }.by(1)
-      expect(attribute_group.instances).to include(instance)
-    end
-
-    it "ignores nil instances" do
-      expect { attribute_group << nil }.not_to(change do
-        attribute_group.instances.size
-      end)
-    end
-  end
-
-  describe "#to_attributes" do
-    it "returns attributes from resolved_instances" do
-      instance = instance_double(dummy_class, to_attributes: "attr")
-      attribute_group.instances = [instance]
-      expect(attribute_group.to_attributes("  ").join).to include("attr")
-    end
-  end
-
-  describe "#to_xml_mapping" do
-    it "returns xml mappings from resolved_instances" do
-      instance = instance_double(dummy_class, to_xml_mapping: "xml")
-      attribute_group.instances = [instance]
-      expect(attribute_group.to_xml_mapping("  ").join).to include("xml")
-    end
-  end
-
-  describe "#required_files" do
-    it "collects required_files from resolved_instances" do
-      instance = instance_double(dummy_class, required_files: "files")
-      attribute_group.instances = [instance]
-      expect(attribute_group.required_files.join).to include("files")
-    end
-  end
-
-  describe "private methods" do
-    it "resolved_instances returns @instances if ref is not present" do
-      attribute_group.instances = [1, 2]
-      attribute_group.ref = nil
-      expect(attribute_group.send(:resolved_instances)).to eq([1, 2])
-    end
-  end
-end