lutaml-model 0.7.3 → 0.7.5

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

@@ -3,7 +3,18 @@
 require "erb"
 require "tmpdir"
 require "lutaml/xsd"
-require_relative "templates/simple_type"
+require_relative "xml_compiler/complex_content_restriction"
+require_relative "xml_compiler/attribute_group"
+require_relative "xml_compiler/complex_content"
+require_relative "xml_compiler/simple_content"
+require_relative "xml_compiler/complex_type"
+require_relative "xml_compiler/restriction"
+require_relative "xml_compiler/simple_type"
+require_relative "xml_compiler/attribute"
+require_relative "xml_compiler/sequence"
+require_relative "xml_compiler/element"
+require_relative "xml_compiler/choice"
+require_relative "xml_compiler/group"
 
 module Lutaml
   module Model
@@ -11,92 +22,14 @@ module Lutaml
       module XmlCompiler
         extend self
 
-        DEFAULT_CLASSES = %w[string integer int boolean].freeze
-        ELEMENT_ORDER_IGNORABLE = %w[import include].freeze
-
-        MODEL_TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
-          # frozen_string_literal: true
-          require "lutaml/model"
-          <%=
-            requiring_files = resolve_required_files(content)
-            if requiring_files&.any?
-              requiring_files.map { |file| "require_relative \\\"\#{file}\\\"" }.join("\n") + "\n"
-            end
-          -%>
-
-          class <%= Utils.camel_case(name) %> < <%= resolve_parent_class(content) %>
-          <%=
-            if content&.key_exist?(:attributes)
-              output = content.attributes.map do |attribute|
-                attribute = @attributes[attribute.ref_class.split(":").last] if attribute.key?(:ref_class)
-                "  attribute :\#{Utils.snake_case(attribute.name)}, \#{resolve_attribute_class(attribute)}\#{resolve_attribute_default(attribute) if attribute.key_exist?(:default)}"
-              end.join("\n")
-              output + "\n" if output && !output&.empty?
-            end
-          -%>
-          <%=
-            if content&.key_exist?(:sequence) || content&.key_exist?(:choice) || content&.key_exist?(:group)
-              output = resolve_content(content).map do |element_name, element|
-                element = @elements[element.ref_class.split(":")&.last] if element&.key_exist?(:ref_class)
-                "  attribute :\#{Utils.snake_case(element_name)}, \#{resolve_element_class(element)}\#{resolve_occurs(element.arguments) if element.key_exist?(:arguments)}"
-              end.join("\n")
-              output + "\n" if output && !output&.empty?
-            end
-          -%>
-          <%=
-            if content&.key_exist?(:complex_content)
-              resolve_complex_content(content.complex_content).map do |element_name, element|
-                if element_name == :attributes
-                  element.map { |attribute| "  attribute :\#{Utils.snake_case(attribute.name)}, \#{resolve_attribute_class(attribute)}\#{resolve_attribute_default(attribute.default) if attribute.key_exist?(:default)}" }.join("\n")
-                else
-                  element = @elements[element.ref_class.split(":")&.last] if element&.key_exist?(:ref_class)
-                  "  attribute :\#{Utils.snake_case(element_name)}, \#{resolve_element_class(element)}\#{resolve_occurs(element.arguments) if element.key_exist?(:arguments)}"
-                end
-              end.join("\n")
-              output + "\n" if output && !output&.empty?
-            end
-          -%>
-          <%= "  attribute :content, \#{content[:mixed] ? ':string' : content.simple_content.extension_base}" if content_exist = (content.key_exist?(:simple_content) && content.simple_content.key_exist?(:extension_base)) || content[:mixed] -%>
-
-            xml do
-              root "<%= name %>", mixed: true
-          <%= resolve_namespace(options) %>
-          <%= "    map_content to: :content\n" if content_exist -%>
-          <%=
-            if content&.key_exist?(:attributes)
-              output = content.attributes.map do |attribute|
-                attribute = @attributes[attribute.ref_class.split(":").last] if attribute.key?(:ref_class)
-                "    map_attribute :\#{Utils.snake_case(attribute.name)}, to: :\#{Utils.snake_case(attribute.name)}"
-              end.join("\n")
-              output + "\n" if output && !output&.empty?
-            end
-          -%>
-          <%=
-            if content&.key_exist?(:sequence) || content&.key_exist?(:choice) || content&.key_exist?(:group)
-              output = resolve_content(content).map do |element_name, element|
-                element = @elements[element.ref_class.split(":")&.last] if element&.key_exist?(:ref_class)
-                "    map_element :\#{element_name}, to: :\#{Utils.snake_case(element_name)}"
-              end.join("\n")
-              output + "\n" if output && !output&.empty?
-            end
-          -%>
-          <%=
-            if content&.key_exist?(:complex_content)
-              output = resolve_complex_content(content.complex_content).map do |element_name, element|
-                if element_name == :attributes
-                  element.map { |attribute| "    map_attribute :\#{Utils.snake_case(attribute.name)}, to: :\#{Utils.snake_case(attribute.name)}" }.join("\n")
-                else
-                  element = @elements[element.ref_class.split(":")&.last] if element&.key_exist?(:ref_class)
-                  "    map_element :\#{element_name}, to: :\#{Utils.snake_case(element_name)}"
-                end
-              end.join("\n")
-              output + "\n" if output && !output&.empty?
-            end
-          -%>
-            end
-          end
+        attr_reader :simple_types,
+                    :group_types,
+                    :complex_types,
+                    :elements,
+                    :attributes,
+                    :attribute_groups
 
-        TEMPLATE
+        ELEMENT_ORDER_IGNORABLE = %w[import include].freeze
 
         XML_ADAPTER_NOT_SET_MESSAGE = <<~MSG
           Nokogiri is not set as XML Adapter.
@@ -106,49 +39,43 @@ module Lutaml
           Lutaml::Model.xml_adapter = Lutaml::Model::Adapter::Nokogiri
         MSG
 
+        XML_DEFINED_ATTRIBUTES = {
+          "id" => "id",
+          "lang" => "language",
+          "space" => "NCName",
+          "base" => "anyURI",
+        }.freeze
+
         def to_models(schema, options = {})
           as_models(schema, options: options)
-          @data_types_classes = Templates::SimpleType.create_simple_types(@simple_types)
+          options[:indent] = options[:indent] ? options[:indent].to_i : 2
+          @simple_types.merge!(XmlCompiler::SimpleType.setup_supported_types)
+          classes_list = @simple_types.merge(@complex_types).merge(@group_types)
+          classes_list = classes_list.transform_values { |type| type.to_class(options: options) }
           if options[:create_files]
             dir = options.fetch(:output_dir, "lutaml_models_#{Time.now.to_i}")
             FileUtils.mkdir_p(dir)
-            @data_types_classes.each do |name, content|
-              create_file(name, content, dir)
-            end
-            @complex_types.each do |name, content|
-              create_file(name, MODEL_TEMPLATE.result(binding), dir)
-            end
-            nil
+            classes_list.each { |name, klass| create_file(name, klass, dir) }
+            true
           else
-            simple_types = @data_types_classes.transform_keys do |key|
-              Utils.camel_case(key.to_s)
-            end
-            complex_types = @complex_types.to_h do |name, content|
-              [Utils.camel_case(name), MODEL_TEMPLATE.result(binding)]
-            end
-            classes_hash = simple_types.merge(complex_types)
-            require_classes(classes_hash) if options[:load_classes]
-            classes_hash
+            require_classes(classes_list) if options[:load_classes]
+            classes_list
           end
         end
 
-        private
-
         def create_file(name, content, dir)
+          name = name.split(":").last
           File.write("#{dir}/#{Utils.snake_case(name)}.rb", content)
         end
 
         def require_classes(classes_hash)
           Dir.mktmpdir do |dir|
-            classes_hash.each do |name, klass|
-              create_file(name, klass, dir)
-              require "#{dir}/#{Utils.snake_case(name)}"
-            end
+            classes_hash.each { |name, klass| create_file(name, klass, dir) }
+            # Some files are not created at the time of the require, so we need to require them after all the files are created.
+            classes_hash.each_key { |name| require "#{dir}/#{Utils.snake_case(name)}" }
           end
         end
 
-        # START: STRUCTURE SETUP METHODS
-
         def as_models(schema, options: {})
           raise Error, XML_ADAPTER_NOT_SET_MESSAGE unless Config.xml_adapter.name.end_with?("NokogiriAdapter")
 
@@ -161,9 +88,17 @@ module Lutaml
           @complex_types = MappingHash.new
           @attribute_groups = MappingHash.new
 
+          populate_default_values
           schema_to_models(Array(parsed_schema))
         end
 
+        def populate_default_values
+          XML_DEFINED_ATTRIBUTES.each do |name, value|
+            @attributes[name] = Attribute.new(name: name)
+            @attributes[name].type = value
+          end
+        end
+
         def schema_to_models(schemas)
           return if schemas.empty?
 
@@ -171,12 +106,12 @@ module Lutaml
             schema_to_models(schema.include) if schema.include&.any?
             schema_to_models(schema.import) if schema.import&.any?
             resolved_element_order(schema).each do |order_item|
-              item_name = order_item&.name
+              item_name = order_item.name if order_item.respond_to?(:name)
               case order_item
               when Xsd::SimpleType
                 @simple_types[item_name] = setup_simple_type(order_item)
               when Xsd::Group
-                @group_types[item_name] = setup_group_type(order_item)
+                @group_types[item_name] = setup_group_type(order_item, root_call: true)
               when Xsd::ComplexType
                 @complex_types[item_name] = setup_complex_type(order_item)
               when Xsd::Element
@@ -192,20 +127,37 @@ module Lutaml
         end
 
         def setup_simple_type(simple_type)
-          MappingHash.new.tap do |hash|
-            setup_restriction(simple_type.restriction, hash) if simple_type&.restriction
-            hash[:union] = setup_union(simple_type.union) if simple_type.union
+          SimpleType.new(simple_type.name).tap do |type_object|
+            if union = simple_type.union
+              type_object.unions = union.member_types.split
+            elsif restriction = simple_type.restriction
+              type_object.base_class = restriction.base&.split(":")&.last
+              type_object.instance = setup_restriction(restriction)
+            end
           end
         end
 
-        def restriction_content(hash, restriction)
-          return hash unless restriction.respond_to?(:max_length)
+        def restriction_content(instance, restriction)
+          return instance unless restriction.respond_to?(:max_length)
+
+          restriction_min_max(restriction, instance, field: :max_length, value_method: :min)
+          restriction_min_max(restriction, instance, field: :min_length, value_method: :max)
+          restriction_min_max(restriction, instance, field: :min_inclusive, value_method: :max)
+          restriction_min_max(restriction, instance, field: :max_inclusive, value_method: :min)
+          restriction_min_max(restriction, instance, field: :max_exclusive, value_method: :max)
+          restriction_min_max(restriction, instance, field: :min_exclusive, value_method: :min)
+          instance.length = restriction_length(restriction.length) if restriction.length&.any?
+        end
+
+        # Use min/max to get the value from the field_value array.
+        def restriction_min_max(restriction, instance, field:, value_method: :min)
+          field_value = restriction.public_send(field)
+          return unless field_value&.any?
 
-          hash[:max_length] = restriction.max_length.map(&:value).min if restriction.max_length&.any?
-          hash[:min_length] = restriction.min_length.map(&:value).max if restriction.min_length&.any?
-          hash[:min_inclusive] = restriction.min_inclusive.map(&:value).max if restriction.min_inclusive&.any?
-          hash[:max_inclusive] = restriction.max_inclusive.map(&:value).min if restriction.max_inclusive&.any?
-          hash[:length] = restriction_length(restriction.length) if restriction.length&.any?
+          instance.public_send(
+            :"#{field}=",
+            field_value.map(&:value).send(value_method).to_s,
+          )
         end
 
         def restriction_length(lengths)
@@ -218,215 +170,220 @@ module Lutaml
         end
 
         def setup_complex_type(complex_type)
-          MappingHash.new.tap do |hash|
-            hash[:attributes] = [] if complex_type.attribute&.any?
-            hash[:attribute_groups] = [] if complex_type.attribute_group&.any?
-            hash[:mixed] = complex_type.mixed
+          ComplexType.new.tap do |instance|
+            instance.id = complex_type.id
+            instance.name = complex_type.name
+            instance.mixed = complex_type.mixed
             resolved_element_order(complex_type).each do |element|
               case element
               when Xsd::Attribute
-                hash[:attributes] << setup_attribute(element)
+                instance << setup_attribute(element)
               when Xsd::Sequence
-                hash[:sequence] = setup_sequence(element)
+                instance << setup_sequence(element)
               when Xsd::Choice
-                hash[:choice] = setup_choice(element)
+                instance << setup_choice(element)
               when Xsd::ComplexContent
-                hash[:complex_content] = setup_complex_content(element)
+                instance << setup_complex_content(element, instance.name, instance)
               when Xsd::AttributeGroup
-                hash[:attribute_groups] << setup_attribute_groups(element)
+                instance << setup_attribute_groups(element)
               when Xsd::Group
-                hash[:group] = setup_group_type(element)
+                instance << setup_group_type(element)
               when Xsd::SimpleContent
-                hash[:simple_content] = setup_simple_content(element)
+                instance.simple_content = setup_simple_content(element)
               end
             end
           end
         end
 
         def setup_simple_content(simple_content)
-          if simple_content.extension
-            setup_extension(simple_content.extension)
-          elsif simple_content.restriction
-            setup_restriction(simple_content.restriction, {})
+          SimpleContent.new.tap do |instance|
+            if simple_content.extension
+              instance.base_class = simple_content.extension.base
+              setup_extension(simple_content.extension, instance)
+            elsif simple_content.restriction
+              instance.base_class = simple_content.restriction.base
+              instance << setup_restriction(simple_content.restriction)
+            end
           end
         end
 
         def setup_sequence(sequence)
-          MappingHash.new.tap do |hash|
-            hash[:sequences] = [] if sequence.sequence&.any?
-            hash[:elements] = [] if sequence.element&.any?
-            hash[:choice] = [] if sequence.choice&.any?
-            hash[:groups] = [] if sequence.group&.any?
-            resolved_element_order(sequence).each do |instance|
-              case instance
-              when Xsd::Sequence
-                hash[:sequences] << setup_sequence(instance)
-              when Xsd::Element
-                hash[:elements] << if instance.name
-                  setup_element(instance)
-                else
-                  create_mapping_hash(instance.ref, hash_key: :ref_class)
-                end
-              when Xsd::Choice
-                hash[:choice] << setup_choice(instance)
-              when Xsd::Group
-                hash[:groups] << if instance.name
-                  setup_group_type(instance)
-                else
-                  create_mapping_hash(instance.ref, hash_key: :ref_class)
-                end
-              when Xsd::Any
-                # No implementation yet!
-              end
+          Sequence.new.tap do |instance|
+            resolved_element_order(sequence).each do |object|
+              # No implementation yet for Xsd::Any!
+              next if object.is_a?(Xsd::Any)
+
+              instance << case object
+                          when Xsd::Sequence
+                            setup_sequence(object)
+                          when Xsd::Element
+                            setup_element(object)
+                          when Xsd::Choice
+                            setup_choice(object)
+                          when Xsd::Group
+                            setup_group_type(object)
+                          end
             end
           end
         end
 
-        def setup_group_type(group)
-          MappingHash.new.tap do |hash|
-            if group.ref
-              hash[:ref_class] = group.ref
-            else
-              resolved_element_order(group).map do |instance|
-                case instance
-                when Xsd::Sequence
-                  hash[:sequence] = setup_sequence(instance)
-                when Xsd::Choice
-                  hash[:choice] = setup_choice(instance)
-                end
-              end
-            end
+        def setup_group_type(group, root_call: false)
+          object = Group.new(group.name, group.ref)
+          object.instance = setup_group_type_instance(group)
+          @group_types[group.name] = object if group.name && !root_call
+          object
+        end
+
+        def setup_group_type_instance(group)
+          if sequence = group.sequence
+            setup_sequence(sequence)
+          elsif choice = group.choice
+            setup_choice(choice)
           end
         end
 
         def setup_choice(choice)
-          MappingHash.new.tap do |hash|
+          Choice.new.tap do |instance|
+            instance.min_occurs = choice.min_occurs
+            instance.max_occurs = choice.max_occurs
             resolved_element_order(choice).each do |element|
-              case element
-              when Xsd::Element
-                element_name = element.name || @elements[element.ref.split(":").last]&.element_name
-                hash[element_name] = setup_element(element)
-              when Xsd::Sequence
-                hash[:sequence] = setup_sequence(element)
-              when Xsd::Group
-                hash[:group] = setup_group_type(element)
-              when Xsd::Choice
-                hash[:choice] = setup_choice(element)
-              end
+              instance << case element
+                          when Xsd::Element
+                            setup_element(element)
+                          when Xsd::Sequence
+                            setup_sequence(element)
+                          when Xsd::Group
+                            setup_group_type(element)
+                          when Xsd::Choice
+                            setup_choice(element)
+                          end
             end
           end
         end
 
-        def setup_union(union)
-          union.member_types.split.map do |member_type|
-            @simple_types[member_type]
-          end.flatten
-        end
-
         def setup_attribute(attribute)
-          MappingHash.new.tap do |attr_hash|
-            if attribute.ref
-              attr_hash[:ref_class] = attribute.ref
-            else
-              attr_hash[:name] = attribute.name
-              attr_hash[:base_class] = attribute.type
-              attr_hash[:default] = attribute.default if attribute.default
-            end
+          instance = Attribute.new(name: attribute.name, ref: attribute.ref)
+          if attribute.name
+            instance.type = setup_attribute_type(attribute)
+            instance.default = attribute.default
           end
+          instance
+        end
+
+        def setup_attribute_type(attribute)
+          return attribute.type if attribute.type
+
+          simple_type = attribute.simple_type
+          attr_name = "ST_#{attribute.name}"
+          simple_type.name = attr_name
+          @simple_types[attr_name] = setup_simple_type(simple_type)
+          attr_name
         end
 
         def setup_attribute_groups(attribute_group)
-          MappingHash.new.tap do |hash|
-            if attribute_group.ref
-              hash[:ref_class] = attribute_group.ref
-            else
-              hash[:attributes] = [] if attribute_group.attribute&.any?
-              hash[:attribute_groups] = [] if attribute_group.attribute_group&.any?
-              resolved_element_order(attribute_group).each do |instance|
-                case instance
-                when Xsd::Attribute
-                  hash[:attributes] << setup_attribute(instance)
-                when Xsd::AttributeGroup
-                  hash[:attribute_groups] << setup_attribute_groups(instance)
-                end
-              end
+          instance = AttributeGroup.new(name: attribute_group.name, ref: attribute_group.ref)
+          if attribute_group.name
+            resolved_element_order(attribute_group).each do |object|
+              group_attribute = case object
+                                when Xsd::Attribute
+                                  setup_attribute(object)
+                                when Xsd::AttributeGroup
+                                  setup_attribute_groups(object)
+                                end
+              instance << group_attribute if group_attribute
             end
           end
+          instance
         end
 
-        def create_mapping_hash(value, hash_key: :class_name)
-          MappingHash.new.tap do |hash|
-            hash[hash_key] = value
+        def setup_element(element)
+          element_name = element.name
+          instance = Element.new(name: element_name, ref: element.ref)
+          instance.min_occurs = element.min_occurs
+          instance.max_occurs = element.max_occurs
+          if element_name
+            instance.type = setup_element_type(element, instance)
+            instance.id = element.id
+            instance.fixed = element.fixed
+            instance.default = element.default
           end
+          instance
         end
 
-        def setup_element(element)
-          MappingHash.new.tap do |hash|
-            if element.ref
-              hash[:ref_class] = element.ref
-            else
-              hash[:type_name] = element.type
-              hash[:element_name] = element.name
-              element_arguments(element, hash)
-              return hash unless complex_type = element.complex_type
-
-              hash[:complex_type] = setup_complex_type(complex_type)
-              @complex_types[complex_type.name] = hash[:complex_type]
+        # Populates @simple_types or @complex_types based on elements available value.
+        def setup_element_type(element, _instance)
+          return element.type if element.type
+
+          type, prefix = element.simple_type ? ["simple", "ST"] : ["complex", "CT"]
+          type_instance = element.public_send(:"#{type}_type")
+          type_instance.name = [prefix, element.name].join("_")
+          instance_variable_get(:"@#{type}_types")[type_instance.name] = public_send(:"setup_#{type}_type", type_instance)
+          type_instance.name
+        end
+
+        def setup_restriction(restriction)
+          Restriction.new.tap do |instance|
+            instance.base_class = restriction.base
+            restriction_patterns(restriction.pattern, instance) if restriction.respond_to?(:pattern)
+            restriction_content(instance, restriction)
+            if restriction.respond_to?(:enumeration) && restriction.enumeration&.any?
+              instance.enumerations = restriction.enumeration.map(&:value)
             end
           end
         end
 
-        def setup_restriction(restriction, hash)
-          hash[:base_class] = restriction.base
-          restriction_patterns(restriction.pattern, hash) if restriction.respond_to?(:pattern)
-          restriction_content(hash, restriction)
-          return hash unless restriction.respond_to?(:enumeration) && restriction.enumeration&.any?
-
-          hash[:values] = restriction.enumeration.map(&:value)
-          hash
+        def setup_complex_content_restriction(restriction, compiler_complex_type)
+          ComplexContentRestriction.new.tap do |instance|
+            compiler_complex_type.base_class = restriction.base
+            resolved_element_order(restriction).each do |element|
+              instance << case element
+                          when Xsd::Attribute
+                            setup_attribute(element)
+                          when Xsd::AttributeGroup
+                            setup_attribute_groups(element)
+                          when Xsd::Sequence
+                            setup_sequence(element)
+                          when Xsd::Choice
+                            setup_choice(element)
+                          when Xsd::Group
+                            setup_group_type(element)
+                          end
+            end
+          end
         end
 
-        def restriction_patterns(patterns, hash)
+        def restriction_patterns(patterns, instance)
           return if Utils.blank?(patterns)
 
-          hash[:pattern] = patterns.map { |p| "(#{p.value})" }.join("|")
-          hash
+          instance.pattern = patterns.map { |p| "(#{p.value})" }.join("|")
         end
 
-        def setup_complex_content(complex_content)
-          MappingHash.new.tap do |hash|
-            hash[:mixed] = true if complex_content.mixed
-            if complex_content.extension
-              hash[:extension] = setup_extension(complex_content.extension)
+        def setup_complex_content(complex_content, name, compiler_complex_type)
+          @complex_types[name] = ComplexContent.new.tap do |instance|
+            compiler_complex_type.mixed = complex_content.mixed
+            if extension = complex_content.extension
+              setup_extension(extension, compiler_complex_type)
             elsif restriction = complex_content.restriction
-              setup_restriction(restriction, hash)
-            end
-          end
-        end
-
-        def setup_extension(extension)
-          MappingHash.new.tap do |hash|
-            hash[:extension_base] = extension.base
-            hash[:attribute_groups] = [] if extension&.attribute_group&.any?
-            hash[:attributes] = [] if extension&.attribute&.any?
-            resolved_element_order(extension).each do |element|
-              case element
-              when Xsd::Attribute
-                hash[:attributes] << setup_attribute(element)
-              when Xsd::Sequence
-                hash[:sequence] = setup_sequence(element)
-              when Xsd::Choice
-                hash[:choice] = setup_choice(element)
-              end
+              instance.restriction = setup_complex_content_restriction(restriction, compiler_complex_type)
             end
           end
         end
 
-        def element_arguments(element, element_hash)
-          MappingHash.new.tap do |hash|
-            hash[:min_occurs] = element.min_occurs if element.min_occurs
-            hash[:max_occurs] = element.max_occurs if element.max_occurs
-            element_hash[:arguments] = hash if hash&.any?
+        def setup_extension(extension, instance)
+          instance.base_class = extension.base
+          resolved_element_order(extension).each do |element|
+            instance << case element
+                        when Xsd::Attribute
+                          setup_attribute(element)
+                        when Xsd::AttributeGroup
+                          setup_attribute_groups(element)
+                        when Xsd::Sequence
+                          setup_sequence(element)
+                        when Xsd::Choice
+                          setup_choice(element)
+                        when Xsd::Group
+                          setup_group_type(element)
+                        end
           end
         end
 
@@ -434,8 +391,7 @@ module Lutaml
           return [] if object.element_order.nil?
 
           object.element_order.each_with_object(object.element_order.dup) do |builder_instance, array|
-            next array.delete(builder_instance) if builder_instance.text?
-            next array.delete(builder_instance) if ELEMENT_ORDER_IGNORABLE.include?(builder_instance.name)
+            next array.delete(builder_instance) if builder_instance.text? || ELEMENT_ORDER_IGNORABLE.include?(builder_instance.name)
 
             index = 0
             array.each_with_index do |element, i|
@@ -446,318 +402,6 @@ module Lutaml
             end
           end
         end
-
-        # END: STRUCTURE SETUP METHODS
-
-        # START: TEMPLATE RESOLVER METHODS
-        def resolve_parent_class(content)
-          return "Lutaml::Model::Serializable" unless content.dig(:complex_content, :extension)
-
-          Utils.camel_case(content.dig(:complex_content, :extension, :extension_base))
-        end
-
-        def resolve_attribute_class(attribute)
-          attr_class = attribute.base_class.split(":")&.last
-          case attr_class
-          when *DEFAULT_CLASSES
-            ":#{attr_class}"
-          else
-            Utils.camel_case(attr_class)
-          end
-        end
-
-        def resolve_element_class(element)
-          element_class = element.type_name.split(":").last
-          case element_class
-          when *DEFAULT_CLASSES
-            ":#{element_class}"
-          else
-            Utils.camel_case(element_class)
-          end
-        end
-
-        def resolve_occurs(arguments)
-          min_occurs = arguments[:min_occurs]
-          max_occurs = arguments[:max_occurs]
-          max_occurs = max_occurs.to_s&.match?(/[A-Za-z]+/) ? nil : max_occurs.to_i if max_occurs
-          ", collection: #{max_occurs ? min_occurs.to_i..max_occurs : true}"
-        end
-
-        def resolve_content(content, hash = MappingHash.new)
-          content.each do |key, value|
-            case key
-            when :sequence
-              resolve_sequence(value, hash)
-            when :choice
-              resolve_choice(value, hash)
-            when :group
-              resolve_group(value, hash)
-            end
-          end
-          hash
-        end
-
-        def resolve_elements(elements, hash = MappingHash.new)
-          elements.each do |element|
-            if element.key?(:ref_class)
-              new_element = @elements[element.ref_class.split(":").last]
-              hash[new_element.element_name] = new_element
-            else
-              hash[element.element_name] = element
-            end
-          end
-          hash
-        end
-
-        def resolve_sequence(sequence, hash = MappingHash.new)
-          sequence.each do |key, value|
-            case key
-            when :sequence
-              resolve_sequence(value, hash)
-            when :elements
-              resolve_elements(value, hash)
-            when :groups
-              value.each { |group| resolve_group(group, hash) }
-            when :choice
-              value.each { |choice| resolve_choice(choice, hash) }
-            end
-          end
-          hash
-        end
-
-        def resolve_choice(choice, hash = MappingHash.new)
-          choice.each do |key, value|
-            case key
-            when :element
-              [resolve_elements(value, hash)]
-            when :group
-              resolve_group(value, hash)
-            when String
-              hash[key] = value
-            when :sequence
-              resolve_sequence(value, hash)
-            end
-          end
-          hash
-        end
-
-        def resolve_group(group, hash = MappingHash.new)
-          group.each do |key, value|
-            case key
-            when :ref_class
-              resolve_group(@group_types[value.split(":").last], hash)
-            when :choice
-              resolve_choice(value, hash)
-            when :group
-              resolve_group(value, hash)
-            when :sequence
-              resolve_sequence(value, hash)
-            end
-          end
-          hash
-        end
-
-        def resolve_complex_content(complex_content, hash = MappingHash.new)
-          complex_content.each do |key, value|
-            case key
-            when :extension
-              resolve_extension(value, hash)
-            when :restriction
-              # TODO: No implementation yet!
-              hash
-            end
-          end
-          hash
-        end
-
-        def resolve_extension(extension, hash = MappingHash.new)
-          hash[:attributes] = extension.attributes if extension.key?(:attributes)
-          resolve_sequence(extension.sequence, hash) if extension.key?(:sequence)
-          resolve_choice(extension.choice, hash) if extension.key?(:choice)
-          hash
-        end
-
-        def resolve_attribute_default(attribute)
-          klass = attribute.base_class.split(":").last
-          default = attribute[:default]
-          ", default: #{resolve_attribute_default_value(klass, default)}"
-        end
-
-        def resolve_attribute_default_value(klass, default)
-          return default.inspect unless DEFAULT_CLASSES.include?(klass)
-
-          klass = "integer" if klass == "int"
-          type_klass = Lutaml::Model::Type.const_get(klass.capitalize)
-          type_klass.cast(default)
-        end
-
-        def resolve_namespace(options)
-          namespace_str = "namespace \"#{options[:namespace]}\"" if options.key?(:namespace)
-          namespace_str += ", \"#{options[:prefix]}\"" if options.key?(:prefix) && options.key?(:namespace)
-          namespace_str += "\n" if namespace_str
-          namespace_str
-        end
-
-        def resolve_required_files(content)
-          @required_files = []
-          content.each do |key, value|
-            case key
-            when :sequence
-              required_files_sequence(value)
-            when :choice
-              required_files_choice(value)
-            when :group
-              required_files_group(value)
-            when :attributes
-              required_files_attribute(value)
-            when :attribute_groups
-              value.each do |attribute_group|
-                required_files_attribute_groups(attribute_group)
-              end
-            when :complex_content
-              required_files_complex_content(value)
-            when :simple_content
-              required_files_simple_content(value)
-            end
-          end
-          @required_files.uniq.sort_by(&:length)
-        end
-
-        # END: TEMPLATE RESOLVER METHODS
-
-        # START: REQUIRED FILES LIST COMPILER METHODS
-        def required_files_simple_content(simple_content)
-          simple_content.each do |key, value|
-            case key
-            when :extension_base
-              # Do nothing.
-            when :attributes
-              required_files_attribute(value)
-            when :extension
-              required_files_extension(value)
-            when :restriction
-              required_files_restriction(value)
-            end
-          end
-        end
-
-        def required_files_complex_content(complex_content)
-          complex_content.each do |key, value|
-            case key
-            when :extension
-              required_files_extension(value)
-            when :restriction
-              required_files_restriction(value)
-            end
-          end
-        end
-
-        def required_files_extension(extension)
-          extension.each do |key, value|
-            case key
-            when :attribute_group
-              required_files_attribute_groups(value)
-            when :attribute, :attributes
-              required_files_attribute(value)
-            when :extension_base
-              # Do nothing.
-            when :sequence
-              required_files_sequence(value)
-            when :choice
-              required_files_choice(value)
-            end
-          end
-        end
-
-        def required_files_restriction(restriction)
-          restriction.each do |key, value|
-            case key
-            when :base
-              @required_files << Utils.snake_case(value.split(":").last)
-            end
-          end
-        end
-
-        def required_files_attribute_groups(attr_groups)
-          attr_groups.each do |key, value|
-            case key
-            when :ref_class
-              required_files_attribute_groups(@attribute_groups[value.split(":").last])
-            when :attribute, :attributes
-              required_files_attribute(value)
-            end
-          end
-        end
-
-        def required_files_attribute(attributes)
-          attributes.each do |attribute|
-            next if attribute[:ref_class]&.start_with?("xml") || attribute[:base_class]&.start_with?("xml")
-
-            attribute = @attributes[attribute.ref_class.split(":").last] if attribute.key_exist?(:ref_class)
-            attr_class = attribute.base_class.split(":")&.last
-            next if DEFAULT_CLASSES.include?(attr_class)
-
-            @required_files << Utils.snake_case(attr_class)
-          end
-        end
-
-        def required_files_choice(choice)
-          choice.each do |key, value|
-            case key
-            when String
-              value = @elements[value.ref_class.split(":").last] if value.key?(:ref_class)
-              @required_files << Utils.snake_case(value.type_name.split(":").last)
-            when :element
-              required_files_elements(value)
-            when :group
-              required_files_group(value)
-            when :choice
-              required_files_choice(value)
-            when :sequence
-              required_files_sequence(value)
-            end
-          end
-        end
-
-        def required_files_group(group)
-          group.each do |key, value|
-            case key
-            when :ref_class
-              required_files_group(@group_types[value.split(":").last])
-            when :choice
-              required_files_choice(value)
-            when :sequence
-              required_files_sequence(value)
-            end
-          end
-        end
-
-        def required_files_sequence(sequence)
-          sequence.each do |key, value|
-            case key
-            when :elements
-              required_files_elements(value)
-            when :sequence
-              required_files_sequence(value)
-            when :groups
-              value.each { |group| required_files_group(group) }
-            when :choice
-              value.each { |choice| required_files_choice(choice) }
-            end
-          end
-        end
-
-        def required_files_elements(elements)
-          elements.each do |element|
-            element = @elements[element.ref_class.split(":").last] if element.key_exist?(:ref_class)
-            element_class = element.type_name.split(":").last
-            next if DEFAULT_CLASSES.include?(element_class)
-
-            @required_files << Utils.snake_case(element_class)
-          end
-        end
-
-        # END: REQUIRED FILES LIST COMPILER METHODS
       end
     end
   end