lutaml-model 0.3.1 → 0.3.3

data/lib/lutaml/model/xml_adapter.rb

@@ -1,292 +1,7 @@
-# lib/lutaml/model/xml_adapter.rb
-
-require_relative "xml_namespace"
-require_relative "mapping_hash"
-
 module Lutaml
   module Model
     module XmlAdapter
       XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace".freeze
-
-      class Document
-        attr_reader :root
-
-        def initialize(root)
-          @root = root
-        end
-
-        def self.parse(xml)
-          raise NotImplementedError, "Subclasses must implement `parse`."
-        end
-
-        def children
-          @root.children
-        end
-
-        def declaration(options)
-          version = "1.0"
-          version = options[:declaration] if options[:declaration].is_a?(String)
-
-          encoding = options[:encoding] ? "UTF-8" : nil
-          encoding = options[:encoding] if options[:encoding].is_a?(String)
-
-          declaration = "<?xml version=\"#{version}\""
-          declaration += " encoding=\"#{encoding}\"" if encoding
-          declaration += "?>\n"
-          declaration
-        end
-
-        def to_h
-          parse_element(@root)
-        end
-
-        def order
-          @root.order
-        end
-
-        def handle_nested_elements(builder, value, rule: nil, attribute: nil)
-          options = build_options_for_nested_elements(attribute, rule)
-
-          case value
-          when Array
-            value.each { |val| build_element(builder, val, options) }
-          else
-            build_element(builder, value, options)
-          end
-        end
-
-        def build_options_for_nested_elements(attribute, rule)
-          return {} unless rule
-
-          options = {}
-
-          options[:namespace_prefix] = rule.prefix if rule&.namespace_set?
-          options[:mixed_content] = rule.mixed_content
-
-          options[:mapper_class] = attribute&.type if attribute
-
-          options
-        end
-
-        def parse_element(element)
-          result = Lutaml::Model::MappingHash.new
-          result.item_order = element.order
-
-          element.children.each_with_object(result) do |child, hash|
-            value = child.text? ? child.text : parse_element(child)
-
-            if hash[child.unprefixed_name]
-              hash[child.unprefixed_name] =
-                [hash[child.unprefixed_name], value].flatten
-            else
-              hash[child.unprefixed_name] = value
-            end
-          end
-
-          element.attributes.each_value do |attr|
-            result[attr.unprefixed_name] = attr.value
-          end
-
-          result
-        end
-
-        def build_element(xml, element, options = {})
-          if ordered?(element, options)
-            build_ordered_element(xml, element, options)
-          else
-            build_unordered_element(xml, element, options)
-          end
-        end
-
-        def ordered?(element, options = {})
-          return false unless element.respond_to?(:element_order)
-          return element.ordered? if element.respond_to?(:ordered?)
-          return options[:mixed_content] if options.key?(:mixed_content)
-
-          mapper_class = options[:mapper_class]
-          mapper_class ? mapper_class.mappings_for(:xml).mixed_content? : false
-        end
-
-        def build_namespace_attributes(klass, processed = {})
-          xml_mappings = klass.mappings_for(:xml)
-          attributes = klass.attributes
-
-          attrs = {}
-
-          if xml_mappings.namespace_prefix
-            attrs["xmlns:#{xml_mappings.namespace_prefix}"] =
-              xml_mappings.namespace_uri
-          end
-
-          xml_mappings.mappings.each do |mapping_rule|
-            processed[klass] ||= {}
-
-            next if processed[klass][mapping_rule.name]
-
-            processed[klass][mapping_rule.name] = true
-
-            type = if mapping_rule.delegate
-                     attributes[mapping_rule.delegate].type.attributes[mapping_rule.to].type
-                   else
-                     attributes[mapping_rule.to].type
-                   end
-
-            if type <= Lutaml::Model::Serialize
-              attrs = attrs.merge(build_namespace_attributes(type, processed))
-            end
-
-            if mapping_rule.namespace
-              attrs["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
-            end
-          end
-
-          attrs
-        end
-
-        def build_attributes(element, xml_mapping)
-          attrs = namespace_attributes(xml_mapping)
-
-          xml_mapping.attributes.each_with_object(attrs) do |mapping_rule, hash|
-            if mapping_rule.namespace
-              hash["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
-            end
-
-            hash[mapping_rule.prefixed_name] = element.send(mapping_rule.to)
-          end
-
-          xml_mapping.elements.each_with_object(attrs) do |mapping_rule, hash|
-            if mapping_rule.namespace
-              hash["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
-            end
-          end
-        end
-
-        def attribute_definition_for(element, rule, mapper_class: nil)
-          klass = mapper_class || element.class
-          return klass.attributes[rule.to] unless rule.delegate
-
-          element.send(rule.delegate).class.attributes[rule.to]
-        end
-
-        def attribute_value_for(element, rule)
-          return element.send(rule.to) unless rule.delegate
-
-          element.send(rule.delegate).send(rule.to)
-        end
-
-        def namespace_attributes(xml_mapping)
-          return {} unless xml_mapping.namespace_uri
-
-          key = ["xmlns", xml_mapping.namespace_prefix].compact.join(":")
-          { key => xml_mapping.namespace_uri }
-        end
-      end
-
-      class Element
-        attr_reader :attributes,
-                    :children,
-                    :text,
-                    :namespace_prefix,
-                    :parent_document
-
-        def initialize(
-          name,
-          attributes = {},
-          children = [],
-          text = nil,
-          parent_document: nil,
-          namespace_prefix: nil
-        )
-          @name = extract_name(name)
-          @namespace_prefix = namespace_prefix || extract_namespace_prefix(name)
-          @attributes = attributes # .map { |k, v| Attribute.new(k, v) }
-          @children = children
-          @text = text
-          @parent_document = parent_document
-        end
-
-        def name
-          if namespace_prefix
-            "#{namespace_prefix}:#{@name}"
-          else
-            @name
-          end
-        end
-
-        def unprefixed_name
-          @name
-        end
-
-        def document
-          Document.new(self)
-        end
-
-        def namespaces
-          @namespaces || @parent_document&.namespaces || {}
-        end
-
-        def own_namespaces
-          @namespaces || {}
-        end
-
-        def namespace
-          return default_namespace unless namespace_prefix
-
-          namespaces[namespace_prefix]
-        end
-
-        def attribute_is_namespace?(name)
-          name.to_s.start_with?("xmlns")
-        end
-
-        def add_namespace(namespace)
-          @namespaces ||= {}
-          @namespaces[namespace.prefix] = namespace
-        end
-
-        def default_namespace
-          namespaces[nil] || @parent_document&.namespaces&.dig(nil)
-        end
-
-        def extract_name(name)
-          n = name.to_s.split(":")
-          return name if n.length <= 1
-
-          n[1..].join(":")
-        end
-
-        def extract_namespace_prefix(name)
-          n = name.to_s.split(":")
-          return if n.length <= 1
-
-          n.first
-        end
-
-        def order
-          children.each_with_object([]) do |child, arr|
-            arr << child.unprefixed_name
-          end
-        end
-      end
-
-      class Attribute
-        attr_reader :name, :value, :namespace, :namespace_prefix
-
-        def initialize(name, value, namespace: nil, namespace_prefix: nil)
-          @name = name
-          @value = value
-          @namespace = namespace
-          @namespace_prefix = namespace_prefix
-        end
-
-        def unprefixed_name
-          if namespace_prefix
-            name.split(":").last
-          else
-            name
-          end
-        end
-      end
     end
   end
 end

data/lib/lutaml/model/xml_mapping.rb

@@ -1,4 +1,3 @@
-# lib/lutaml/model/xml_mapping.rb
 require_relative "xml_mapping_rule"
 
 module Lutaml
@@ -10,8 +9,8 @@ module Lutaml
                   :mixed_content
 
       def initialize
-        @elements = []
-        @attributes = []
+        @elements = {}
+        @attributes = {}
         @content_mapping = nil
         @mixed_content = false
       end
@@ -48,7 +47,7 @@ module Lutaml
         prefix: nil,
         mixed: false
       )
-        @elements << XmlMappingRule.new(
+        @elements[name] = XmlMappingRule.new(
           name,
           to: to,
           render_nil: render_nil,
@@ -71,7 +70,7 @@ module Lutaml
                     nil),
         prefix: nil
       )
-        @attributes << XmlMappingRule.new(
+        @attributes[name] = XmlMappingRule.new(
           name,
           to: to,
           render_nil: render_nil,
@@ -82,6 +81,7 @@ module Lutaml
           namespace_set: namespace_set != false,
         )
       end
+
       # rubocop:enable Metrics/ParameterLists
 
       def map_content(
@@ -102,11 +102,11 @@ module Lutaml
       end
 
       def elements
-        @elements
+        @elements.values
       end
 
       def attributes
-        @attributes
+        @attributes.values
       end
 
       def content_mapping

data/lib/lutaml/model/xml_mapping_rule.rb

@@ -1,4 +1,3 @@
-# lib/lutaml/model/xml_mapping_rule.rb
 require_relative "mapping_rule"
 
 module Lutaml
@@ -24,12 +23,12 @@ module Lutaml
           with: with,
           delegate: delegate,
           mixed_content: mixed_content,
-          namespace_set: namespace_set
+          namespace_set: namespace_set,
         )
 
         @namespace = if namespace.to_s == "inherit"
-                       # we are using inherit_namespace in xml builder by
-                       # default so no need to do anything here.
+                     # we are using inherit_namespace in xml builder by
+                     # default so no need to do anything here.
                      else
                        namespace
                      end

data/lib/lutaml/model/yaml_adapter/standard_yaml_adapter.rb

@@ -0,0 +1,34 @@
+require "yaml"
+require_relative "yaml_document"
+
+module Lutaml
+  module Model
+    module YamlAdapter
+      class StandardYamlAdapter < YamlDocument
+        def self.parse(yaml)
+          YAML.safe_load(
+            yaml,
+            permitted_classes: [Date, Time, DateTime, Symbol,
+                                BigDecimal, Hash, Array],
+          )
+        end
+
+        def to_yaml(options = {})
+          YAML.dump(@attributes, options)
+        end
+
+        # TODO: Is this really needed?
+        def self.to_yaml(attributes, *args)
+          new(attributes).to_yaml(*args)
+        end
+
+        # TODO: Is this really needed?
+        def self.from_yaml(yaml, klass)
+          data = parse(yaml)
+          mapped_attrs = klass.send(:apply_mappings, data, :yaml)
+          klass.new(mapped_attrs)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/yaml_adapter/yaml_document.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "yaml_object"
+
+module Lutaml
+  module Model
+    module YamlAdapter
+      # Base class for YAML documents
+      class YamlDocument < YamlObject
+        def self.parse(yaml)
+          raise NotImplementedError, "Subclasses must implement `parse`."
+        end
+
+        def to_yaml(*args)
+          raise NotImplementedError, "Subclasses must implement `to_yaml`."
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/yaml_adapter/yaml_object.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module YamlAdapter
+      # Base class for YAML objects
+      class YamlObject
+        attr_reader :attributes
+
+        def initialize(attributes = {})
+          @attributes = attributes
+        end
+
+        def [](key)
+          @attributes[key]
+        end
+
+        def []=(key, value)
+          @attributes[key] = value
+        end
+
+        def to_h
+          @attributes
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/yaml_adapter.rb

@@ -1,34 +1,8 @@
-# lib/lutaml/model/yaml_adapter.rb
-require "yaml"
+# frozen_string_literal: true
 
 module Lutaml
   module Model
     module YamlAdapter
-      class Standard
-        def initialize(attributes)
-          @attributes = attributes
-        end
-
-        def to_yaml(options = {})
-          YAML.dump(@attributes, options)
-        end
-
-        def self.to_yaml(attributes, *args)
-          new(attributes).to_yaml(*args)
-        end
-
-        def self.from_yaml(yaml, klass)
-          data = parse(yaml)
-          mapped_attrs = klass.send(:apply_mappings, data, :yaml)
-          klass.new(mapped_attrs)
-        end
-
-        def self.parse(yaml)
-          YAML.safe_load(yaml,
-                         permitted_classes: [Date, Time, DateTime, Symbol,
-                                             BigDecimal, Hash, Array])
-        end
-      end
     end
   end
 end

data/lib/lutaml/model.rb

@@ -1,11 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "model/version"
-
-# lib/lutaml/model.rb
-require "nokogiri"
-require "json"
-require "yaml"
 require_relative "model/type"
 require_relative "model/serializable"
 require_relative "model/json_adapter"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.3
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-08-13 00:00:00.000000000 Z
+date: 2024-08-16 00:00:00.000000000 Z
 dependencies: []
 description: 'LutaML creating data models in Ruby
 
@@ -37,8 +37,10 @@ files:
 - lib/lutaml/model/error.rb
 - lib/lutaml/model/error/invalid_value_error.rb
 - lib/lutaml/model/json_adapter.rb
-- lib/lutaml/model/json_adapter/multi_json.rb
-- lib/lutaml/model/json_adapter/standard.rb
+- lib/lutaml/model/json_adapter/json_document.rb
+- lib/lutaml/model/json_adapter/json_object.rb
+- lib/lutaml/model/json_adapter/multi_json_adapter.rb
+- lib/lutaml/model/json_adapter/standard_json_adapter.rb
 - lib/lutaml/model/key_value_mapping.rb
 - lib/lutaml/model/key_value_mapping_rule.rb
 - lib/lutaml/model/mapping_hash.rb
@@ -51,19 +53,29 @@ files:
 - lib/lutaml/model/serializable.rb
 - lib/lutaml/model/serialize.rb
 - lib/lutaml/model/toml_adapter.rb
+- lib/lutaml/model/toml_adapter/toml_document.rb
+- lib/lutaml/model/toml_adapter/toml_object.rb
 - lib/lutaml/model/toml_adapter/toml_rb_adapter.rb
 - lib/lutaml/model/toml_adapter/tomlib_adapter.rb
 - lib/lutaml/model/type.rb
+- lib/lutaml/model/type/date_time.rb
+- lib/lutaml/model/type/json.rb
 - lib/lutaml/model/type/time_without_date.rb
 - lib/lutaml/model/version.rb
 - lib/lutaml/model/xml_adapter.rb
 - lib/lutaml/model/xml_adapter/nokogiri_adapter.rb
 - lib/lutaml/model/xml_adapter/oga_adapter.rb
 - lib/lutaml/model/xml_adapter/ox_adapter.rb
+- lib/lutaml/model/xml_adapter/xml_attribute.rb
+- lib/lutaml/model/xml_adapter/xml_document.rb
+- lib/lutaml/model/xml_adapter/xml_element.rb
+- lib/lutaml/model/xml_adapter/xml_namespace.rb
 - lib/lutaml/model/xml_mapping.rb
 - lib/lutaml/model/xml_mapping_rule.rb
-- lib/lutaml/model/xml_namespace.rb
 - lib/lutaml/model/yaml_adapter.rb
+- lib/lutaml/model/yaml_adapter/standard_yaml_adapter.rb
+- lib/lutaml/model/yaml_adapter/yaml_document.rb
+- lib/lutaml/model/yaml_adapter/yaml_object.rb
 - lutaml-model.gemspec
 - sig/lutaml/model.rbs
 homepage: https://github.com/lutaml/lutaml-model

data/lib/lutaml/model/xml_namespace.rb

@@ -1,47 +0,0 @@
-# frozen_striing_literal: true
-
-module Lutaml
-  module Model
-    class XmlNamespace
-      # Return name
-      #
-      # @return [String]
-      #
-      # @api private
-      attr_accessor :uri
-
-      # Return prefix
-      #
-      # @return [String]
-      #
-      # @api private
-      attr_accessor :prefix
-
-      # Initialize instance
-      #
-      # @param [String, nil] name
-      # @param [String, nil] prefix
-      #
-      # @api private
-      def initialize(uri = nil, prefix = nil)
-        @uri = uri
-        @prefix = normalize_prefix(prefix)
-      end
-
-      def normalize_prefix(prefix)
-        normalized_prefix = prefix.to_s.gsub(/xmlns:?/, "")
-        return if normalized_prefix.empty?
-
-        normalized_prefix
-      end
-
-      def attr_name
-        if prefix && !prefix.empty?
-          "xmlns:#{prefix}"
-        else
-          "xmlns"
-        end
-      end
-    end
-  end
-end