lutaml-model 0.3.1 → 0.3.2

data/lib/lutaml/model/serialize.rb

@@ -1,4 +1,3 @@
-# lib/lutaml/model/serialize.rb
 require_relative "yaml_adapter"
 require_relative "xml_adapter"
 require_relative "config"
@@ -41,6 +40,7 @@ module Lutaml
           end
         end
 
+        # Define an attribute for the model
         def attribute(name, type, options = {})
           attr = Attribute.new(name, type, options)
           attributes[name] = attr
@@ -50,7 +50,7 @@ module Lutaml
           end
 
           define_method(:"#{name}=") do |value|
-            if options[:values] && !options[:values].include?(value)
+            unless self.class.attr_value_valid?(name, value)
               raise Lutaml::Model::InvalidValueError.new(name, value, options[:values])
             end
 
@@ -58,6 +58,17 @@ module Lutaml
           end
         end
 
+        # Check if the value to be assigned is valid for the attribute
+        def attr_value_valid?(name, value)
+          attr = attributes[name]
+
+          return true unless attr.options[:values]
+
+          # If value validation failed but there is a default value, do not
+          # raise a validation error
+          attr.options[:values].include?(value || attr.default)
+        end
+
         FORMATS.each do |format|
           define_method(format) do |&block|
             klass = format == :xml ? XmlMapping : KeyValueMapping
@@ -193,6 +204,8 @@ module Lutaml
               if v.is_a?(Hash)
                 attr_rule.type.new(v)
               else
+                # TODO: This code is problematic because Type.cast does not know
+                # about all the types.
                 Lutaml::Model::Type.cast(
                   v, attr_rule.type
                 )
@@ -201,6 +214,8 @@ module Lutaml
           elsif value.is_a?(Hash) && attr_rule.type != Lutaml::Model::Type::Hash
             generate_model_object(attr_rule.type, value)
           else
+            # TODO: This code is problematic because Type.cast does not know
+            # about all the types.
             Lutaml::Model::Type.cast(value, attr_rule.type)
           end
         end
@@ -209,8 +224,11 @@ module Lutaml
           klass = format == :xml ? XmlMapping : KeyValueMapping
           klass.new.tap do |mapping|
             attributes&.each do |name, attr|
-              mapping.map_element(name.to_s, to: name,
-                                             render_nil: attr.render_nil?)
+              mapping.map_element(
+                name.to_s,
+                to: name,
+                render_nil: attr.render_nil?,
+              )
             end
           end
         end

data/lib/lutaml/model/toml_adapter/toml_document.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "toml_object"
+
+module Lutaml
+  module Model
+    module TomlAdapter
+      # Base class for TOML documents
+      class TomlDocument < TomlObject
+        def self.parse(toml)
+          raise NotImplementedError, "Subclasses must implement `parse`."
+        end
+
+        def to_toml(*args)
+          raise NotImplementedError, "Subclasses must implement `to_toml`."
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/toml_adapter/toml_object.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module TomlAdapter
+      # Base class for TOML objects
+      class TomlObject
+        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/toml_adapter/toml_rb_adapter.rb

@@ -1,11 +1,10 @@
-# lib/lutaml/model/toml_adapter/toml_rb_adapter.rb
 require "toml-rb"
-require_relative "../toml_adapter"
+require_relative "toml_document"
 
 module Lutaml
   module Model
     module TomlAdapter
-      class TomlRbDocument < Document
+      class TomlRbAdapter < TomlDocument
         def self.parse(toml)
           data = TomlRB.parse(toml)
           new(data)

data/lib/lutaml/model/toml_adapter/tomlib_adapter.rb

@@ -1,11 +1,10 @@
-# lib/lutaml/model/toml_adapter/tomlib_adapter.rb
 require "tomlib"
-require_relative "../toml_adapter"
+require_relative "toml_document"
 
 module Lutaml
   module Model
     module TomlAdapter
-      class TomlibDocument < Document
+      class TomlibAdapter < TomlDocument
         def self.parse(toml)
           data = Tomlib.load(toml)
           new(data)

data/lib/lutaml/model/toml_adapter.rb

@@ -1,37 +1,6 @@
-# lib/lutaml/model/toml_adapter.rb
-
 module Lutaml
   module Model
     module TomlAdapter
-      class TomlObject
-        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
-
-      class Document < TomlObject
-        def self.parse(toml)
-          raise NotImplementedError, "Subclasses must implement `parse`."
-        end
-
-        def to_toml(*args)
-          raise NotImplementedError, "Subclasses must implement `to_toml`."
-        end
-      end
     end
   end
 end

data/lib/lutaml/model/type/date_time.rb

@@ -0,0 +1,20 @@
+require "date"
+
+module Lutaml
+  module Model
+    module Type
+      # Date and time representation
+      class DateTime
+        def self.cast(value)
+          return if value.nil?
+
+          ::DateTime.parse(value.to_s).new_offset(0)
+        end
+
+        def self.serialize(value)
+          value.iso8601
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/type/json.rb

@@ -0,0 +1,34 @@
+require "json"
+
+module Lutaml
+  module Model
+    module Type
+      # JSON representation
+      class Json
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def to_json(*_args)
+          @value.to_json
+        end
+
+        def ==(other)
+          @value == (other.is_a?(::Hash) ? other : other.value)
+        end
+
+        def self.cast(value)
+          return value if value.is_a?(self) || value.nil?
+
+          new(::JSON.parse(value))
+        end
+
+        def self.serialize(value)
+          value.to_json
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/type/time_without_date.rb

@@ -1,11 +1,12 @@
-# lib/lutaml/model/type/time_without_date.rb
 module Lutaml
   module Model
     module Type
+      # Time representation without date
       class TimeWithoutDate
         def self.cast(value)
-          parsed_time = ::Time.parse(value.to_s)
-          parsed_time.strftime("%H:%M:%S")
+          return if value.nil?
+
+          ::Time.parse(value.to_s)
         end
 
         def self.serialize(value)

data/lib/lutaml/model/type.rb

@@ -1,170 +1,97 @@
-# lib/lutaml/model/type.rb
 require "date"
 require "bigdecimal"
 require "securerandom"
 require "uri"
 require "ipaddr"
-require "json"
 
 module Lutaml
   module Model
     module Type
-      %w(String
-         Integer
-         Float
-         Date
-         Time
-         Boolean
-         Decimal
-         Hash
-         UUID
-         Symbol
-         BigInteger
-         Binary
-         URL
-         Email
-         IPAddress
-         JSON
-         Enum).each do |t|
+      # This module provides a set of methods to cast and serialize values
+
+      # TODO: Make Boolean a separate class
+
+      %w(
+        String
+        Integer
+        Float
+        Date
+        Time
+        Boolean
+        Decimal
+        Hash
+        Uuid
+        Symbol
+        Binary
+        Url
+        IpAddress
+        Json
+      ).each do |t|
         class_eval <<~HEREDOC, __FILE__, __LINE__ + 1
-          class #{t}                        # class Integer
+                     class #{t}                        # class Integer
             def self.cast(value)            #   def self.cast(value)
               return if value.nil?          #     return if value.nil?
-
               Type.cast(value, #{t})        #     Type.cast(value, Integer)
             end                             #   end
 
             def self.serialize(value)       #   def self.serialize(value)
               return if value.nil?          #     return if value.nil?
-
               Type.serialize(value, #{t})   #     Type.serialize(value, Integer)
             end                             #   end
           end                               # end
         HEREDOC
       end
 
-      class TimeWithoutDate
-        def self.cast(value)
-          return if value.nil?
-
-          ::Time.parse(value.to_s)
-          # .strftime("%H:%M:%S")
-        end
-
-        def self.serialize(value)
-          value.strftime("%H:%M:%S")
-        end
-      end
-
-      class DateTime
-        def self.cast(value)
-          return if value.nil?
-
-          ::DateTime.parse(value.to_s).new_offset(0)
-        end
-
-        def self.serialize(value)
-          value.iso8601
-        end
-      end
-
+      # TODO: Remove this. The XSD code depends on this but actually should
+      # be converted into a collection, not a specific Array type.
       class Array
         def initialize(array)
           Array(array)
         end
       end
 
-      class TextWithTags
-        attr_reader :content
-
-        def initialize(ordered_text_with_tags)
-          @content = ordered_text_with_tags
-        end
-
-        def self.cast(value)
-          return value if value.is_a?(self)
-
-          new(value)
-        end
-
-        def self.serialize(value)
-          value.content.join
-        end
-      end
-
-      class JSON
-        attr_reader :value
-
-        def initialize(value)
-          @value = value
-        end
-
-        def to_json(*_args)
-          @value.to_json
-        end
-
-        def ==(other)
-          @value == if other.is_a?(::Hash)
-                      other
-                    else
-                      other.value
-                    end
-        end
-
-        def self.cast(value)
-          return value if value.is_a?(self) || value.nil?
-
-          new(::JSON.parse(value))
-        end
-
-        def self.serialize(value)
-          value.to_json
-        end
-      end
-
       UUID_REGEX = /\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\z/
 
       def self.cast(value, type)
         return if value.nil?
 
-        if [String, Email].include?(type)
+        case type.to_s.split("::").last
+        when "String"
           value.to_s
-        elsif [Integer, BigInteger].include?(type)
+        when "Integer"
           value.to_i
-        elsif type == Float
+        when "Float"
           value.to_f
-        elsif type == Date
+        when "Date"
           begin
             ::Date.parse(value.to_s)
           rescue ArgumentError
             nil
           end
-        elsif type == DateTime
+        when "DateTime"
           DateTime.cast(value)
-        elsif type == Time
+        when "Time"
           ::Time.parse(value.to_s)
-        elsif type == TimeWithoutDate
+        when "TimeWithoutDate"
           TimeWithoutDate.cast(value)
-        elsif type == Boolean
+        when "Boolean"
           to_boolean(value)
-        elsif type == Decimal
+        when "Decimal"
           BigDecimal(value.to_s)
-        elsif type == Hash
+        when "Hash"
           normalize_hash(Hash(value))
-        elsif type == UUID
+        when "Uuid"
           UUID_REGEX.match?(value) ? value : SecureRandom.uuid
-        elsif type == Symbol
+        when "Symbol"
           value.to_sym
-        elsif type == Binary
+        when "Binary"
           value.force_encoding("BINARY")
-        elsif type == URL
+        when "Url"
           URI.parse(value.to_s)
-        elsif type == IPAddress
+        when "IpAddress"
           IPAddr.new(value.to_s)
-        elsif type == JSON
-          JSON.cast(value)
-        # elsif type == Enum
-        #   value
+        when "Json"
+          Json.cast(value)
         else
           value
         end
@@ -173,21 +100,22 @@ module Lutaml
       def self.serialize(value, type)
         return if value.nil?
 
-        if type == Date
+        case type.to_s.split("::").last
+        when "Date"
           value.iso8601
-        elsif type == DateTime
+        when "DateTime"
           DateTime.serialize(value)
-        elsif type == Integer
+        when "Integer"
           value.to_i
-        elsif type == Float
+        when "Float"
           value.to_f
-        elsif type == Boolean
+        when "Boolean"
           to_boolean(value)
-        elsif type == Decimal
+        when "Decimal"
           value.to_s("F")
-        elsif type == Hash
+        when "Hash"
           Hash(value)
-        elsif type == JSON
+        when "Json"
           value.to_json
         else
           value.to_s
@@ -195,8 +123,13 @@ module Lutaml
       end
 
       def self.to_boolean(value)
-        return true if value == true || value.to_s =~ (/^(true|t|yes|y|1)$/i)
-        return false if value == false || value.nil? || value.to_s =~ (/^(false|f|no|n|0)$/i)
+        if value == true || value.to_s =~ (/^(true|t|yes|y|1)$/i)
+          return true
+        end
+
+        if value == false || value.nil? || value.to_s =~ (/^(false|f|no|n|0)$/i)
+          return false
+        end
 
         raise ArgumentError.new("invalid value for Boolean: \"#{value}\"")
       end
@@ -217,3 +150,7 @@ module Lutaml
     end
   end
 end
+
+require_relative "type/time_without_date"
+require_relative "type/date_time"
+require_relative "type/json"

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.3.1"
+    VERSION = "0.3.2"
   end
 end

data/lib/lutaml/model/xml_adapter/nokogiri_adapter.rb

@@ -1,11 +1,10 @@
-# lib/lutaml/model/xml_adapter/nokogiri_adapter.rb
 require "nokogiri"
-require_relative "../xml_adapter"
+require_relative "xml_document"
 
 module Lutaml
   module Model
     module XmlAdapter
-      class NokogiriDocument < Document
+      class NokogiriAdapter < XmlDocument
         def self.parse(xml)
           parsed = Nokogiri::XML(xml)
           root = NokogiriElement.new(parsed.root)
@@ -154,11 +153,11 @@ module Lutaml
         end
       end
 
-      class NokogiriElement < Element
+      class NokogiriElement < XmlElement
         def initialize(node, root_node: nil)
           if root_node
             node.namespaces.each do |prefix, name|
-              namespace = Lutaml::Model::XmlNamespace.new(name, prefix)
+              namespace = XmlNamespace.new(name, prefix)
 
               root_node.add_namespace(namespace)
             end
@@ -172,7 +171,7 @@ module Lutaml
                      attr.name
                    end
 
-            attributes[name] = Attribute.new(
+            attributes[name] = XmlAttribute.new(
               name,
               attr.value,
               namespace: attr.namespace&.href,

data/lib/lutaml/model/xml_adapter/oga_adapter.rb

@@ -1,11 +1,10 @@
-# lib/lutaml/model/xml_adapter/oga_adapter.rb
 require "oga"
-require_relative "../xml_adapter"
+require_relative "xml_document"
 
 module Lutaml
   module Model
     module XmlAdapter
-      class OgaDocument < Document
+      class OgaAdapter < XmlDocument
         def self.parse(xml)
           parsed = Oga.parse_xml(xml)
           root = OgaElement.new(parsed)
@@ -51,10 +50,10 @@ module Lutaml
         end
       end
 
-      class OgaElement < Element
+      class OgaElement < XmlElement
         def initialize(node)
           attributes = node.attributes.each_with_object({}) do |attr, hash|
-            hash[attr.name] = Attribute.new(attr.name, attr.value)
+            hash[attr.name] = XmlAttribute.new(attr.name, attr.value)
           end
           super(node.name, attributes, parse_children(node), node.text)
         end

data/lib/lutaml/model/xml_adapter/ox_adapter.rb

@@ -1,11 +1,10 @@
-# lib/lutaml/model/xml_adapter/ox_adapter.rb
 require "ox"
-require_relative "../xml_adapter"
+require_relative "xml_document"
 
 module Lutaml
   module Model
     module XmlAdapter
-      class OxDocument < Document
+      class OxAdapter < XmlDocument
         def self.parse(xml)
           parsed = Ox.parse(xml)
           root = OxElement.new(parsed)
@@ -137,16 +136,16 @@ module Lutaml
         end
       end
 
-      class OxElement < Element
+      class OxElement < XmlElement
         def initialize(node, root_node: nil)
           if node.is_a?(String)
             super("text", {}, [], node, parent_document: root_node)
           else
             namespace_attributes(node.attributes).each do |(name, value)|
               if root_node
-                root_node.add_namespace(Lutaml::Model::XmlNamespace.new(value, name))
+                root_node.add_namespace(XmlNamespace.new(value, name))
               else
-                add_namespace(Lutaml::Model::XmlNamespace.new(value, name))
+                add_namespace(XmlNamespace.new(value, name))
               end
             end
 
@@ -156,11 +155,11 @@ module Lutaml
               namespace_prefix = name.to_s.split(":").first
               if (n = name.to_s.split(":")).length > 1
                 namespace = (root_node || self).namespaces[namespace_prefix]&.uri
-                namespace ||= Lutaml::Model::XmlAdapter::XML_NAMESPACE_URI
+                namespace ||= XML_NAMESPACE_URI
                 prefix = n.first
               end
 
-              hash[name.to_s] = Attribute.new(
+              hash[name.to_s] = XmlAttribute.new(
                 name.to_s,
                 value,
                 namespace: namespace,
@@ -173,7 +172,7 @@ module Lutaml
               attributes,
               parse_children(node, root_node: root_node || self),
               node.text,
-              parent_document: root_node
+              parent_document: root_node,
             )
           end
         end

data/lib/lutaml/model/xml_adapter/xml_attribute.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      # Represents an XML attribute
+      class XmlAttribute
+        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