lutaml-model 0.3.23 → 0.3.25

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

@@ -0,0 +1,38 @@
+module Lutaml
+  module Model
+    module Type
+      class Boolean < Value
+        def self.cast(value)
+          return nil if value.nil?
+          return true if value == true || value.to_s.match?(/^(true|t|yes|y|1)$/i)
+          return false if value == false || value.to_s.match?(/^(false|f|no|n|0)$/i)
+
+          value
+        end
+
+        def self.serialize(value)
+          return nil if value.nil?
+
+          cast(value) # Return actual boolean instead of string
+        end
+
+        # Format-specific serialization methods
+        def to_xml
+          value.to_s
+        end
+
+        def to_json(*_args)
+          value
+        end
+
+        def to_yaml
+          value
+        end
+
+        def to_toml
+          value.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Lutaml
+  module Model
+    module Type
+      class Date < Value
+        def self.cast(value)
+          return nil if value.nil?
+
+          case value
+          when ::DateTime, ::Time
+            value.to_date
+          when ::Date
+            value
+          else
+            ::Date.parse(value.to_s)
+          end
+        rescue ArgumentError
+          nil
+        end
+
+        # xs:date format
+        def self.serialize(value)
+          return nil if value.nil?
+
+          value&.iso8601
+        end
+
+        # This is to handle where Ruby's YAML safe_load does not handle
+        # the Date/Time classes
+        def to_yaml
+          value&.iso8601.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -4,15 +4,43 @@ module Lutaml
   module Model
     module Type
       # Date and time representation
-      class DateTime
+      class DateTime < Value
         def self.cast(value)
-          return if value.nil?
+          return nil if value.nil?
 
-          ::DateTime.parse(value.to_s).new_offset(0)
+          case value
+          when ::DateTime then value
+          when ::Time then value.to_datetime
+          else ::DateTime.parse(value.to_s)
+          end
+        rescue ArgumentError
+          nil
         end
 
         def self.serialize(value)
-          value.iso8601
+          return nil if value.nil?
+
+          cast(value)&.iso8601
+        end
+
+        # xs:dateTime format (ISO8601 with timezone)
+        def to_xml
+          value&.iso8601
+        end
+
+        # RFC3339 (ISO8601 with timezone)
+        def to_json(*_args)
+          value&.iso8601
+        end
+
+        # YAML timestamp format (native)
+        def to_yaml
+          value&.iso8601
+        end
+
+        # TOML datetime format (RFC3339)
+        def to_toml
+          value&.iso8601
         end
       end
     end

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

@@ -0,0 +1,42 @@
+module Lutaml
+  module Model
+    module Type
+      class Decimal < Value
+        def self.cast(value)
+          return nil if value.nil?
+
+          check_dependencies!(value)
+          case value
+          when BigDecimal
+            # If already a BigDecimal, return as-is
+            value
+          else
+            # Convert to string first to handle various input types
+            BigDecimal(value.to_s)
+          end
+        rescue ArgumentError
+          nil
+        end
+
+        # # xs:decimal format
+        def self.serialize(value)
+          return nil if value.nil?
+
+          check_dependencies!(value)
+          value = cast(value)
+          value.to_s("F") # Use fixed-point notation to match test expectations
+        end
+
+        def self.from_xml(value)
+          cast(value.text)
+        end
+
+        def self.check_dependencies!(value)
+          unless defined?(BigDecimal)
+            raise TypeNotEnabledError.new("Decimal", value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Lutaml
+  module Model
+    module Type
+      class Float < Value
+        def self.cast(value)
+          return nil if value.nil?
+
+          value.to_f
+        end
+
+        def self.serialize(value)
+          return nil if value.nil?
+
+          cast(value)
+        end
+
+        # Instance methods for specific formats
+        # xs:float format
+        def to_xml
+          value.to_s
+        end
+
+        def to_yaml
+          value
+        end
+
+        def to_json(*_args)
+          value
+        end
+
+        def to_yaml
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Lutaml
+  module Model
+    module Type
+      class Hash < Value
+        def self.cast(value)
+          return nil if value.nil?
+
+          hash = if value.respond_to?(:to_h)
+                   value.to_h
+                 else
+                   Hash(value)
+                 end
+
+          normalize_hash(hash)
+        end
+
+        def self.normalize_hash(hash)
+          return hash["text"] if hash.keys == ["text"]
+
+          hash = hash.to_h if hash.is_a?(Lutaml::Model::MappingHash)
+
+          hash = hash.except("text")
+
+          hash.transform_values do |value|
+            if value.is_a?(::Hash)
+              # Only process if value is a Hash
+              nested = normalize_hash(value)
+              # Only include non-text nodes in nested hashes if it's a hash
+              nested.is_a?(::Hash) ? nested.except("text") : nested
+            else
+              value
+            end
+          end
+        end
+
+        def self.serialize(value)
+          return nil if value.nil?
+          return value if value.is_a?(Hash)
+
+          value.respond_to?(:to_h) ? value.to_h : Hash(value)
+        end
+
+        # Format-specific serialization methods
+        def to_xml
+          value
+        end
+
+        def to_json(*_args)
+          value
+        end
+
+        def to_yaml
+          value
+        end
+
+        def to_toml
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Lutaml
+  module Model
+    module Type
+      class Integer < Value
+        def self.cast(value)
+          return nil if value.nil?
+          return 1 if value === true
+          return 0 if value === false
+
+          case value
+          when ::String
+            if value.match?(/^0[0-7]+$/) # Octal
+              value.to_i(8)
+            elsif value.match?(/^-?\d+(\.\d+)?(e-?\d+)?$/i) # Float/exponential
+              Float(value).to_i
+            else
+              begin
+                Integer(value, 10)
+              rescue StandardError
+                nil
+              end
+            end
+          else
+            begin
+              Integer(value)
+            rescue StandardError
+              nil
+            end
+          end
+        end
+
+        # Override serialize to return Integer instead of String
+        def self.serialize(value)
+          return nil if value.nil?
+
+          cast(value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Lutaml
+  module Model
+    module Type
+      class String < Value
+        def self.cast(value)
+          return nil if value.nil?
+
+          value.to_s
+        end
+
+        # xs:string format
+        def to_xml
+          value&.to_s
+        end
+
+        # JSON string
+        def to_json(*_args)
+          value
+        end
+
+        # YAML string
+        def to_yaml
+          value
+        end
+
+        # TOML string
+        def to_toml
+          value&.to_s
+        end
+
+        def self.from_xml(value)
+          cast(value)
+        end
+
+        def self.from_json(value)
+          cast(value)
+        end
+
+        def self.from_yaml(value)
+          cast(value)
+        end
+
+        def self.from_toml(value)
+          cast(value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require "time"
+
+module Lutaml
+  module Model
+    module Type
+      class Time < Value
+        def self.cast(value)
+          return nil if value.nil?
+
+          case value
+          when ::Time then value
+          when ::DateTime then value.to_time
+          else ::Time.parse(value.to_s)
+          end
+        rescue ArgumentError
+          nil
+        end
+
+        def self.serialize(value)
+          return nil if value.nil?
+
+          value = cast(value)
+          # value&.strftime("%Y-%m-%dT%H:%M:%S%:z")
+          value&.iso8601
+        end
+
+        # # xs:time format (HH:MM:SS.mmm±HH:MM)
+        # def to_xml
+        #   value&.strftime("%H:%M:%S%:z")
+        # end
+
+        # # ISO8601 time format
+        # def to_json
+        #   value&.iso8601
+        # end
+
+        # # YAML timestamp format (native)
+        # def to_yaml
+        #   value
+        # end
+
+        # # TOML time format (HH:MM:SS.mmm)
+        # def to_toml
+        #   value&.strftime("%H:%M:%S.%L")
+        # end
+      end
+    end
+  end
+end

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

@@ -1,16 +1,48 @@
+require "time"
+
 module Lutaml
   module Model
     module Type
-      # Time representation without date
-      class TimeWithoutDate
+      class TimeWithoutDate < Value
+        # TODO: we probably want to do something like this because using
+        # Time.parse will set the date to today.
+        #
+        # time = ::Time.parse(value.to_s)
+        # ::Time.new(1, 1, 1, time.hour, time.min, time.sec)
+
         def self.cast(value)
-          return if value.nil?
+          return nil if value.nil?
 
-          ::Time.parse(value.to_s)
+          case value
+          when ::Time then value
+          else ::Time.parse(value.to_s)
+          end
+        rescue ArgumentError
+          nil
         end
 
         def self.serialize(value)
-          value.strftime("%H:%M:%S")
+          return nil if value.nil?
+
+          value = cast(value)
+          value.strftime("%H:%M:%S") # Format as HH:MM:SS
+        end
+
+        # Instance methods for format-specific serialization
+        def to_xml
+          self.class.serialize(value)
+        end
+
+        def to_json(*_args)
+          self.class.serialize(value)
+        end
+
+        def to_yaml
+          self.class.serialize(value)
+        end
+
+        def to_toml
+          value.strftime("%H:%M:%S.%L") # Include milliseconds for TOML
         end
       end
     end

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

@@ -0,0 +1,52 @@
+require_relative "../config"
+
+module Lutaml
+  module Model
+    module Type
+      # Base class for all value types
+      class Value
+        attr_reader :value
+
+        def initialize(value)
+          @value = self.class.cast(value)
+        end
+
+        def self.cast(value)
+          return nil if value.nil?
+
+          value
+        end
+
+        def self.serialize(value)
+          return nil if value.nil?
+
+          new(value).to_s
+        end
+
+        # Instance methods for serialization
+        def to_s
+          value.to_s
+        end
+
+        # Format-specific instance methods
+        ::Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
+          define_method(:"to_#{format}") do
+            value
+          end
+        end
+
+        # Class-level format conversion
+        def self.from_format(value, format)
+          new(send(:"from_#{format}", value))
+        end
+
+        # Default format-specific class methods that can be overridden
+        ::Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
+          define_singleton_method(:"from_#{format}") do |value|
+            cast(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/type.rb

@@ -1,136 +1,72 @@
-require "date"
-require "bigdecimal"
-
 module Lutaml
   module Model
     module Type
-      # 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
-      ).each do |t|
-        class_eval <<~HEREDOC, __FILE__, __LINE__ + 1
-                     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
-
-      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?
-
-        case type.to_s.split("::").last
-        when "String"
-          value.to_s
-        when "Integer"
-          value.to_i
-        when "Float"
-          value.to_f
-        when "Date"
-          begin
-            ::Date.parse(value.to_s)
-          rescue ArgumentError
-            nil
-          end
-        when "DateTime"
-          DateTime.cast(value)
-        when "Time"
-          ::Time.parse(value.to_s)
-        when "TimeWithoutDate"
-          TimeWithoutDate.cast(value)
-        when "Boolean"
-          to_boolean(value)
-        when "Decimal"
-          unless defined?(BigDecimal)
-            raise Lutaml::Model::TypeNotEnabledError.new("Decimal", value)
+      TYPE_CODES = {
+        string: "Lutaml::Model::Type::String",
+        integer: "Lutaml::Model::Type::Integer",
+        float: "Lutaml::Model::Type::Float",
+        decimal: "Lutaml::Model::Type::Decimal",
+        date: "Lutaml::Model::Type::Date",
+        time: "Lutaml::Model::Type::Time",
+        date_time: "Lutaml::Model::Type::DateTime",
+        time_without_date: "Lutaml::Model::Type::TimeWithoutDate",
+        boolean: "Lutaml::Model::Type::Boolean",
+        hash: "Lutaml::Model::Type::Hash",
+      }.freeze
+
+      class << self
+        def register_builtin_types
+          TYPE_CODES.each do |type_name, type_class|
+            register(type_name, const_get(type_class))
           end
-
-          BigDecimal(value.to_s)
-        when "Hash"
-          normalize_hash(Hash(value))
-        else
-          value
         end
-      end
-
-      def self.serialize(value, type)
-        return if value.nil?
 
-        case type.to_s.split("::").last
-        when "Date"
-          value.iso8601
-        when "DateTime"
-          DateTime.serialize(value)
-        when "Integer"
-          value.to_i
-        when "Float"
-          value.to_f
-        when "Boolean"
-          to_boolean(value)
-        when "Decimal"
-          unless defined?(BigDecimal)
-            raise Lutaml::Model::TypeNotEnabledError.new("Decimal", value)
+        def register(type_name, type_class)
+          unless type_class < Value
+            raise TypeError,
+                  "class '#{type_class}' is not a valid Lutaml::Model::Type::Value"
           end
 
-          value.to_s("F")
-        when "Hash"
-          Hash(value)
-        else
-          value.to_s
+          @registry ||= {}
+          @registry[type_name.to_sym] = type_class
         end
-      end
 
-      def self.to_boolean(value)
-        if value == true || value.to_s =~ (/^(true|t|yes|y|1)$/i)
-          return true
-        end
+        def lookup(type_name)
+          @registry ||= {}
+          klass = @registry[type_name.to_sym]
 
-        if value == false || value.nil? || value.to_s =~ (/^(false|f|no|n|0)$/i)
-          return false
-        end
+          raise UnknownTypeError.new(type_name) unless klass
 
-        raise ArgumentError.new("invalid value for Boolean: \"#{value}\"")
-      end
+          klass
+        end
 
-      def self.normalize_hash(hash)
-        return hash["text"] if hash.keys == ["text"]
+        def cast(value, type)
+          return nil if value.nil?
 
-        hash = hash.to_h if hash.is_a?(Lutaml::Model::MappingHash)
+          type.cast(value)
+        end
 
-        hash.filter_map do |key, value|
-          next if key == "text"
+        def serialize(value, type)
+          return nil if value.nil?
 
-          if value.is_a?(::Hash)
-            [key, normalize_hash(value)]
-          else
-            [key, value]
-          end
-        end.to_h
+          type.serialize(value)
+        end
       end
     end
   end
 end
 
-require_relative "type/time_without_date"
+# Register built-in types
+require_relative "type/value"
+require_relative "type/string"
+require_relative "type/integer"
+require_relative "type/float"
+require_relative "type/date"
+require_relative "type/time"
 require_relative "type/date_time"
+require_relative "type/time_without_date"
+require_relative "type/boolean"
+require_relative "type/decimal"
+require_relative "type/hash"
+
+Lutaml::Model::Type.register_builtin_types