lutaml-model 0.7.3 → 0.7.5

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

@@ -4,11 +4,14 @@ module Lutaml
   module Model
     module Schema
       class RelaxngSchema
+        extend SharedMethods
+
         def self.generate(klass, options = {})
+          register = extract_register_from(klass)
           builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
             xml.grammar(xmlns: "http://relaxng.org/ns/structure/1.0") do
               generate_start(xml, klass)
-              generate_define(xml, klass)
+              generate_define(xml, klass, register)
             end
           end
 
@@ -21,34 +24,35 @@ module Lutaml
           end
         end
 
-        def self.generate_attributes(xml, klass)
+        def self.generate_attributes(xml, klass, register)
           klass.attributes.each do |name, attr|
-            if attr.type <= Lutaml::Model::Serialize
-              xml.ref(name: attr.type.name)
+            attr_type = attr.type(register)
+            if attr_type <= Lutaml::Model::Serialize
+              xml.ref(name: attr_type.name)
             elsif attr.collection?
               xml.zeroOrMore do
                 xml.element(name: name) do
-                  xml.data(type: get_relaxng_type(attr.type))
+                  xml.data(type: get_relaxng_type(attr_type))
                 end
               end
             else
               xml.element(name: name) do
-                xml.data(type: get_relaxng_type(attr.type))
+                xml.data(type: get_relaxng_type(attr_type))
               end
             end
           end
         end
 
-        def self.generate_define(xml, klass)
+        def self.generate_define(xml, klass, register)
           xml.define(name: klass.name) do
             xml.element(name: klass.name) do
-              generate_attributes(xml, klass)
+              generate_attributes(xml, klass, register)
             end
           end
 
           klass.attributes.each_value do |attr|
-            if attr.type <= Lutaml::Model::Serialize
-              generate_define(xml, attr.type)
+            if attr.type(register) <= Lutaml::Model::Serialize
+              generate_define(xml, attr.type(register), register)
             end
           end
         end

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

@@ -0,0 +1,36 @@
+require "erb"
+require "ostruct"
+
+require_relative "helpers/template_helper"
+
+module Lutaml
+  module Model
+    module Schema
+      class Context
+        include Lutaml::Model::Schema::Helpers::TemplateHelper
+
+        attr_reader :schema
+
+        def initialize(schema)
+          @schema = schema
+        end
+      end
+
+      class Renderer
+        def self.render(template_path, context = {})
+          new(template_path).render(context)
+        end
+
+        def initialize(template_path)
+          @template = File.read(template_path)
+        end
+
+        def render(context = {})
+          context = Context.new(context[:schema])
+
+          ERB.new(@template, trim_mode: "-").result(context.instance_eval { binding })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module SharedMethods
+        def extract_register_from(klass)
+          register = if klass.class_variable_defined?(:@@register)
+                       klass.class_variable_get(:@@register)
+                     end
+
+          case register
+          when Lutaml::Model::Register
+            register.id
+          when String, Symbol
+            register.to_sym
+          else
+            Lutaml::Model::Config.default_register
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/templates/model.erb

@@ -0,0 +1,9 @@
+require "lutaml/model"
+
+<%= open_namespaces(schema.namespaces) %>
+<%= indent(schema.namespaces.size) %>class <%= schema.name %> < <%= schema.parent_class %>
+<% schema.attributes.each do |attribute| -%>
+<%= attribute_line(attribute, schema.namespaces.size + 1) %>
+<% end -%>
+<%= indent(schema.namespaces.size) %>end
+<%= close_namespaces(schema.namespaces) %>

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class Attribute
+          attr_accessor :id,
+                        :ref,
+                        :name,
+                        :type,
+                        :default
+
+          TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
+            <%= indent %>attribute :<%= resolved_name %>, :<%= resolved_type %>
+          TEMPLATE
+
+          XML_MAPPING_TEMPLATE = ERB.new(<<~XML_MAPPING_TEMPLATE, trim_mode: "-")
+            <%= indent %>map_attribute :<%= resolved_name(change_case: false) %>, to: :<%= resolved_name %><%= namespace_prefix_option %>
+          XML_MAPPING_TEMPLATE
+
+          def initialize(name: nil, ref: nil)
+            @name = name
+            @ref = ref
+          end
+
+          def to_attributes(indent)
+            return if skippable?
+
+            TEMPLATE.result(binding)
+          end
+
+          def to_xml_mapping(indent)
+            return if skippable?
+
+            XML_MAPPING_TEMPLATE.result(binding)
+          end
+
+          def required_files
+            return if skippable?
+
+            raw_type = resolved_type(change_case: false)
+            if raw_type == "decimal"
+              "require \"bigdecimal\""
+            elsif !SimpleType.skippable?(raw_type)
+              "require_relative \"#{Utils.snake_case(raw_type)}\""
+            end
+          end
+
+          private
+
+          def resolved_name(change_case: true)
+            @current_name ||= name || referenced_instance&.name
+            change_case ? Utils.snake_case(@current_name) : @current_name
+          end
+
+          def resolved_type(change_case: true)
+            @current_type ||= type || referenced_instance&.type
+            klass_name = last_of_split(@current_type)
+            change_case ? Utils.snake_case(klass_name) : klass_name
+          end
+
+          def referenced_instance
+            @referenced_instance ||= XmlCompiler.attributes[last_of_split]
+          end
+
+          def last_of_split(field = ref)
+            field&.split(":")&.last
+          end
+
+          def skippable?
+            resolved_name == "schema_location"
+          end
+
+          def namespace_prefix_option
+            return "" unless Utils.present?(ref)
+            return "" unless ref.start_with?("xml:")
+
+            ", namespace: \"http://www.w3.org/XML/1998/namespace\", prefix: \"xml\""
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class AttributeGroup
+          attr_accessor :name, :ref, :instances
+
+          def initialize(name: nil, ref: nil)
+            @name = name
+            @ref = ref
+            @instances = []
+          end
+
+          def <<(instance)
+            return if instance.nil?
+
+            @instances << instance
+          end
+
+          def to_attributes(indent)
+            resolved_instances.map { |instance| instance.to_attributes(indent) }
+          end
+
+          def to_xml_mapping(indent)
+            resolved_instances.map { |instance| instance.to_xml_mapping(indent) }
+          end
+
+          def required_files
+            resolved_instances.map(&:required_files)
+          end
+
+          private
+
+          def resolved_instances
+            return @instances unless Utils.present?(@ref)
+
+            XmlCompiler.attribute_groups[@ref]&.instances
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class Choice
+          attr_accessor :instances, :min_occurs, :max_occurs
+
+          INDENT = "  "
+
+          TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
+            <%= indent %>choice<%= block_options %> do
+            <%= instances.map { |instance| instance.to_attributes(indent + INDENT) }.join -%>
+            <%= indent %>end
+          TEMPLATE
+
+          def initialize
+            @instances = []
+          end
+
+          def <<(instance)
+            return if instance.nil?
+
+            @instances << instance
+          end
+
+          def to_attributes(indent = INDENT)
+            TEMPLATE.result(binding)
+          end
+
+          def to_xml_mapping(indent = INDENT)
+            instances.filter_map { |instance| instance.to_xml_mapping(indent) }.join
+          end
+
+          def required_files
+            @instances.map(&:required_files).flatten.compact
+          end
+
+          private
+
+          def min_option
+            "min: #{min_occurs.nil? ? 1 : min_occurs.to_i}"
+          end
+
+          def max_option
+            value = case max_occurs
+                    when "unbounded"
+                      "Float::INFINITY"
+                    when NilClass
+                      1
+                    else
+                      max_occurs.to_i
+                    end
+            ", max: #{value}"
+          end
+
+          def block_options
+            ["(", min_option, max_option, ")"].compact.join
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class ComplexContent
+          attr_accessor :restriction
+
+          def initialize(restriction = nil)
+            @restriction = restriction
+          end
+
+          def to_attributes(indent)
+            restriction&.to_attributes(indent)
+          end
+
+          def to_xml_mapping(indent)
+            restriction&.to_xml_mapping(indent)
+          end
+
+          def required_files
+            restriction&.required_files
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class ComplexContentRestriction
+          attr_accessor :base, :instances
+
+          def initialize(base: nil, instances: [])
+            @base = base
+            @instances = instances
+          end
+
+          def <<(instance)
+            return if instance.nil?
+
+            @instances << instance
+          end
+
+          def to_attributes(indent)
+            instances.map { |instance| instance.to_attributes(indent) }
+          end
+
+          def to_xml_mapping(indent)
+            instances.map { |instance| instance.to_xml_mapping(indent) }
+          end
+
+          def required_files
+            instances.map(&:required_files)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class ComplexType
+          attr_accessor :id,
+                        :name,
+                        :mixed,
+                        :instances,
+                        :base_class,
+                        :simple_content
+
+          SERIALIZABLE_BASE_CLASS = "Lutaml::Model::Serializable".freeze
+
+          SIMPLE_CONTENT_ATTRIBUTE_TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
+            <%= @indent %>attribute :content, :<%= simple_content_type %>
+            <%= simple_content.to_attributes(@indent) if simple_content? -%>
+          TEMPLATE
+
+          TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
+            # frozen_string_literal: true
+
+            <%= required_files.uniq.join("\n") + "\n" -%>
+            class <%= Utils.camel_case(name) %> < <%= base_class_name %>
+            <%= instances.flat_map { |instance| instance.to_attributes(@indent) }.join + "\n" -%>
+            <%= simple_content_attribute -%>
+            <%= @indent %>xml do
+            <%= extended_indent %>root "<%= name %>"<%= root_options %>
+            <%= namespace_and_prefix %>
+            <%= "\#{extended_indent}map_content to: :content" if simple_content? || mixed %>
+            <%= instances.flat_map { |instance| instance.to_xml_mapping(extended_indent) }.join -%>
+            <%= simple_content.to_xml_mapping(extended_indent) if simple_content? -%>
+            <%= @indent %>end
+
+            <%= @indent %>def self.register
+            <%= extended_indent %>Lutaml::Model::GlobalRegister.lookup(Lutaml::Model::Config.default_register)
+            <%= @indent %>end
+
+            <%= @indent %>def self.register_class_with_id
+            <%= extended_indent %>register.register_model(self, id: :<%= Utils.snake_case(name) %>)
+            <%= @indent %>end
+            end
+
+            <%= Utils.camel_case(name) %>.register_class_with_id
+          TEMPLATE
+
+          def initialize(base_class: SERIALIZABLE_BASE_CLASS)
+            @base_class = base_class
+            @instances = []
+          end
+
+          def <<(instance)
+            return if instance.nil?
+
+            @instances << instance
+          end
+
+          def simple_content?
+            Utils.present?(@simple_content)
+          end
+
+          def to_class(options: {})
+            setup_options(options)
+            TEMPLATE.result(binding)
+          end
+
+          def required_files
+            files = [base_class_require]
+            files.concat(@instances.map(&:required_files).flatten.compact.uniq)
+            files.concat(simple_content.required_files) if simple_content?
+            files
+          end
+
+          private
+
+          def setup_options(options)
+            @namespace, @prefix = options.values_at(:namespace, :prefix)
+            @indent = " " * options&.fetch(:indent, 2)
+          end
+
+          def simple_content_type
+            return "string" unless simple_content?
+
+            Utils.snake_case(last_of_split(simple_content.base_class))
+          end
+
+          def simple_content_attribute
+            SIMPLE_CONTENT_ATTRIBUTE_TEMPLATE.result(binding) if simple_content? || mixed
+          end
+
+          def root_options
+            return "" unless mixed
+
+            ", mixed: true"
+          end
+
+          def namespace_and_prefix
+            return "" if Utils.blank?(@namespace) && Utils.blank?(@prefix)
+
+            [namespace_option, @prefix&.inspect].compact.join(", ")
+          end
+
+          def extended_indent
+            @indent * 2
+          end
+
+          def namespace_option
+            "#{extended_indent}namespace #{@namespace.inspect}"
+          end
+
+          def base_class_name
+            case base_class
+            when SERIALIZABLE_BASE_CLASS
+              SERIALIZABLE_BASE_CLASS
+            else
+              Utils.camel_case(last_of_split(base_class))
+            end
+          end
+
+          def base_class_require
+            case base_class
+            when SERIALIZABLE_BASE_CLASS
+              "require \"lutaml/model\""
+            else
+              "require_relative \"#{Utils.snake_case(last_of_split(base_class))}\""
+            end
+          end
+
+          def last_of_split(field)
+            field&.split(":")&.last
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class Element
+          attr_accessor :id,
+                        :ref,
+                        :name,
+                        :type,
+                        :fixed,
+                        :default,
+                        :max_occurs,
+                        :min_occurs
+
+          def initialize(name: nil, ref: nil)
+            @name = name
+            @ref = ref
+          end
+
+          def to_attributes(indent)
+            return if skippable?
+            return unless resolved_type
+
+            "#{indent}attribute :#{resolved_name}, :#{resolved_type}#{attribute_options}\n"
+          end
+
+          def to_xml_mapping(indent)
+            return if skippable?
+            return unless resolved_type
+
+            "#{indent}map_element :#{resolved_name(change_case: false)}, to: :#{resolved_name}#{render_default_option}\n"
+          end
+
+          def required_files
+            return if skippable?
+
+            element_type = resolved_type(change_case: false)
+            return "require \"bigdecimal\"" if element_type == "decimal"
+            return if SimpleType.skippable?(element_type)
+
+            "require_relative \"#{Utils.snake_case(element_type)}\""
+          end
+
+          private
+
+          def resolved_instance
+            @resolved_instance ||= XmlCompiler.instance_variable_get(:@elements)[last_of_split]
+          end
+
+          def resolved_type(change_case: true)
+            @current_type ||= type || resolved_instance&.type
+            klass_name = last_of_split(@current_type)
+            change_case ? Utils.snake_case(klass_name) : klass_name
+          end
+
+          def resolved_name(change_case: true)
+            @current_name ||= name || resolved_instance&.name
+            change_case ? Utils.snake_case(@current_name) : @current_name
+          end
+
+          def collection_option
+            return if min_occurs.nil? && max_occurs.nil?
+
+            min_value = min_occurs.nil? ? 1 : min_occurs.to_i
+            ", collection: #{min_value}..#{max_value}"
+          end
+
+          def max_value
+            return "Float::INFINITY" if max_occurs == "unbounded"
+            return 1 if max_occurs.nil?
+
+            max_occurs.to_i
+          end
+
+          def default_option
+            return if default.nil?
+
+            ", default: -> { #{default.inspect} }"
+          end
+
+          def render_default_option
+            return if default.nil?
+
+            ", render_default: true"
+          end
+
+          def attribute_options
+            [collection_option, default_option].compact.join
+          end
+
+          def last_of_split(field = ref)
+            field&.split(":")&.last
+          end
+
+          def skippable?
+            resolved_name == "schema_location"
+          end
+        end
+      end
+    end
+  end
+end