lutaml-model 0.7.1 → 0.7.7

data/lib/lutaml/model/schema/xsd_schema.rb

@@ -4,40 +4,44 @@ module Lutaml
   module Model
     module Schema
       class XsdSchema
+        extend SharedMethods
+
         def self.generate(klass, options = {})
+          register = extract_register_from(klass)
           builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
             xml.schema(xmlns: "http://www.w3.org/2001/XMLSchema") do
-              generate_complex_type(xml, klass)
+              generate_complex_type(xml, klass, nil, register)
             end
           end
 
           options[:pretty] ? builder.to_xml(indent: 2) : builder.to_xml
         end
 
-        def self.generate_complex_type(xml, klass, element_name = nil)
+        def self.generate_complex_type(xml, klass, element_name = nil, register)
           xml.element(name: element_name || klass.name) do
             xml.complexType do
               xml.sequence do
-                generate_elements(xml, klass)
+                generate_elements(xml, klass, register)
               end
             end
           end
         end
 
-        def self.generate_elements(xml, klass)
+        def self.generate_elements(xml, klass, register)
           klass.attributes.each do |name, attr|
-            if attr.type <= Lutaml::Model::Serialize
-              generate_complex_type(xml, attr.type, name)
+            attr_type = attr.type(register)
+            if attr_type <= Lutaml::Model::Serialize
+              generate_complex_type(xml, attr_type, name, register)
             elsif attr.collection?
               xml.element(name: name, minOccurs: "0", maxOccurs: "unbounded") do
                 xml.complexType do
                   xml.sequence do
-                    xml.element(name: "item", type: get_xsd_type(attr.type))
+                    xml.element(name: "item", type: get_xsd_type(attr_type))
                   end
                 end
               end
             else
-              xml.element(name: name, type: get_xsd_type(attr.type))
+              xml.element(name: name, type: get_xsd_type(attr_type))
             end
           end
         end

data/lib/lutaml/model/schema/yaml_schema.rb

@@ -1,49 +1,55 @@
+require_relative "base_schema"
 require "yaml"
 
 module Lutaml
   module Model
     module Schema
-      class YamlSchema
-        def self.generate(klass, options = {})
-          schema = generate_schema(klass)
-          options[:pretty] ? schema.to_yaml : YAML.dump(schema)
-        end
+      class YamlSchema < BaseSchema
+        class << self
+          def generate(
+            klass,
+            id: nil,
+            title: nil,
+            description: nil,
+            pretty: false
+          )
+            options = {
+              schema: "https://json-schema.org/draft/2020-12/schema",
+              id: id,
+              title: title,
+              description: description,
+              pretty: pretty,
+            }
 
-        def self.generate_schema(klass)
-          {
-            "type" => "map",
-            "mapping" => generate_mapping(klass),
-          }
-        end
+            super(klass, options)
+          end
 
-        def self.generate_mapping(klass)
-          klass.attributes.each_with_object({}) do |(name, attr), mapping|
-            mapping[name.to_s] = generate_attribute_schema(attr)
+          def format_schema(schema, options)
+            <<~SCHEMA
+              %YAML 1.1
+              #{options[:pretty] ? schema.to_yaml : YAML.dump(schema)}
+            SCHEMA
           end
-        end
 
-        def self.generate_attribute_schema(attr)
-          if attr.type <= Lutaml::Model::Serialize
-            generate_schema(attr.type)
-          elsif attr.collection?
-            {
-              "type" => "seq",
-              "sequence" => [{ "type" => get_yaml_type(attr.type) }],
-            }
-          else
-            { "type" => get_yaml_type(attr.type) }
+          def generate_model_classes(schema)
+            definitions = definition_collection_class.new(schema["$defs"])
+
+            definitions.transform_values do |definition|
+              generate_model_class(definition)
+            end
           end
-        end
 
-        def self.get_yaml_type(type)
-          {
-            Lutaml::Model::Type::String => "str",
-            Lutaml::Model::Type::Integer => "int",
-            Lutaml::Model::Type::Boolean => "bool",
-            Lutaml::Model::Type::Float => "float",
-            Lutaml::Model::Type::Decimal => "float",
-            Lutaml::Model::Type::Hash => "map",
-          }[type] || "str" # Default to string for unknown types
+          private
+
+          def generate_model_class(schema)
+            template = File.join(__dir__, "templates", "model.erb")
+
+            Lutaml::Model::Schema::Renderer.render(template, schema: schema)
+          end
+
+          def definition_collection_class
+            Lutaml::Model::Schema::Decorators::DefinitionCollection
+          end
         end
       end
     end

data/lib/lutaml/model/schema.rb

@@ -1,3 +1,4 @@
+require_relative "schema/shared_methods"
 require_relative "schema/json_schema"
 require_relative "schema/xsd_schema"
 require_relative "schema/relaxng_schema"

data/lib/lutaml/model/sequence.rb

@@ -18,30 +18,16 @@ module Lutaml
         instance_eval(&block)
       end
 
-      def map_element(
-        name,
-        to: nil,
-        render_nil: false,
-        render_default: false,
-        with: {},
-        delegate: nil,
-        cdata: false,
-        namespace: nil,
-        prefix: nil,
-        transform: {}
-      )
-        @attributes << @model.map_element(
-          name,
-          to: to,
-          render_nil: render_nil,
-          render_default: render_default,
-          with: with,
-          delegate: delegate,
-          cdata: cdata,
-          namespace: namespace,
-          prefix: prefix,
-          transform: transform,
-        )
+      def map_element(name, **kwargs)
+        @attributes << @model.map_element(name, **kwargs)
+      end
+
+      def import_model_mappings(model)
+        return import_mappings_later(model) if later_importable?(model)
+        raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
+
+        @model.import_model_mappings(model)
+        @attributes.concat(Utils.deep_dup(model.mappings_for(:xml).elements))
       end
 
       def map_attribute(*)
@@ -56,16 +42,60 @@ module Lutaml
         raise Lutaml::Model::UnknownSequenceMappingError.new("map_all")
       end
 
-      def validate_content!(element_order)
-        defined_order = @attributes.map { |rule| rule.name.to_s }
-        start_index = element_order.index(defined_order.first)
+      def validate_content!(element_order, model_class)
+        validate_sequence!(
+          extract_defined_order(model_class.attributes),
+          element_order,
+        )
+      end
 
-        defined_order.each.with_index(start_index) do |element, i|
-          unless element_order[i] == element
-            raise Lutaml::Model::IncorrectSequenceError.new(element, element_order[i])
+      private
+
+      def validate_sequence!(defined_order, element_order)
+        eo_index = element_order_index(element_order, defined_order)
+
+        defined_order.each do |element, klass_attr|
+          if klass_attr.collection?
+            if add_missing_element?(element_order, eo_index, element, klass_attr)
+              element_order.insert(eo_index, element)
+            else
+              occurrences = klass_attr.sequenced_appearance_count(element_order, element, eo_index)
+              next eo_index += occurrences if occurrences.positive?
+            end
           end
+
+          next eo_index += 1 if element_order[eo_index] == element
+
+          raise Lutaml::Model::IncorrectSequenceError.new(element, element_order[eo_index])
+        end
+      end
+
+      def add_missing_element?(element_order, eo_index, element, klass_attr)
+        return false unless klass_attr.collection_range.min.zero?
+
+        element_order[eo_index] != element && !element_order.include?(element)
+      end
+
+      def element_order_index(element_order, defined_order)
+        element_order.find_index { |d| defined_order.key?(d) } || 0
+      end
+
+      def extract_defined_order(model_attrs)
+        @attributes.each_with_object({}) do |rule, acc|
+          acc[rule.name.to_s] = model_attrs[rule.to.to_s] ||
+            model_attrs[rule.to.to_sym]
         end
       end
+
+      def later_importable?(model)
+        model.is_a?(Symbol) ||
+          model.is_a?(String)
+      end
+
+      def import_mappings_later(model)
+        @model.sequence_importable_mappings[self] << model.to_sym
+        @model.set_mappings_imported(false)
+      end
     end
   end
 end

data/lib/lutaml/model/serialization_adapter.rb

@@ -0,0 +1,22 @@
+module Lutaml
+  module Model
+    class SerializationAdapter
+      def self.handles_format(format)
+        # Lutaml::Model::Config.register_format(format, self)
+        @handles = format
+      end
+
+      def self.document_class(klass = nil)
+        if klass
+          @document_class = klass
+        else
+          @document_class
+        end
+      end
+
+      def self.parse(data, _options = {})
+        document_class.parse(data, create_additions: false)
+      end
+    end
+  end
+end