lutaml-model 0.3.24 → 0.3.26

data/lib/lutaml/model/attribute.rb

@@ -9,6 +9,7 @@ module Lutaml
         delegate
         collection
         values
+        pattern
       ].freeze
 
       def initialize(name, type, options = {})
@@ -34,15 +35,23 @@ module Lutaml
 
       def cast_type!(type)
         case type
+        when Symbol
+          begin
+            Type.lookup(type)
+          rescue UnknownTypeError
+            raise ArgumentError, "Unknown Lutaml::Model::Type: #{type}"
+          end
+        when String
+          begin
+            Type.const_get(type)
+          rescue NameError
+            raise ArgumentError, "Unknown Lutaml::Model::Type: #{type}"
+          end
         when Class
           type
-        when String
-          Type.const_get(type)
-        when Symbol
-          Type.const_get(type.to_s.split("_").collect(&:capitalize).join)
+        else
+          raise ArgumentError, "Unknown Lutaml::Model::Type: #{type}"
         end
-      rescue NameError
-        raise ArgumentError, "Unknown Lutaml::Model::Type: #{type}"
       end
 
       def cast_value(value)
@@ -79,23 +88,12 @@ module Lutaml
         cast_value(value)
       end
 
-      def enum_values
-        @options.key?(:values) ? @options[:values] : []
+      def pattern
+        options[:pattern]
       end
 
-      # Check if the value to be assigned is valid for the attribute
-      #
-      # Currently there are 2 validations
-      #   1. Value should be from the values list if they are defined
-      #      e.g values: ["foo", "bar"] is set then any other value for this
-      #          attribute will raise `Lutaml::Model::InvalidValueError`
-      #
-      #   2. Value count should be between the collection range if defined
-      #      e.g if collection: 0..5 is set then the value greater then 5
-      #          will raise `Lutaml::Model::CollectionCountOutOfRangeError`
-      def validate_value!(value)
-        valid_value!(value)
-        valid_collection!(value)
+      def enum_values
+        @options.key?(:values) ? @options[:values] : []
       end
 
       def valid_value!(value)
@@ -115,14 +113,32 @@ module Lutaml
         options[:values].include?(value)
       end
 
-      def validate_value!(value)
-        # return true if none of the validations are present
-        return true if enum_values.empty? && singular?
+      def valid_pattern!(value)
+        return true unless type == Lutaml::Model::Type::String
+        return true unless pattern
+
+        unless pattern.match?(value)
+          raise Lutaml::Model::PatternNotMatchedError.new(name, pattern, value)
+        end
+
+        true
+      end
 
+      # Check if the value to be assigned is valid for the attribute
+      #
+      # Currently there are 2 validations
+      #   1. Value should be from the values list if they are defined
+      #      e.g values: ["foo", "bar"] is set then any other value for this
+      #          attribute will raise `Lutaml::Model::InvalidValueError`
+      #
+      #   2. Value count should be between the collection range if defined
+      #      e.g if collection: 0..5 is set then the value greater then 5
+      #          will raise `Lutaml::Model::CollectionCountOutOfRangeError`
+      def validate_value!(value)
         # Use the default value if the value is nil
         value = default if value.nil?
 
-        valid_value!(value) && valid_collection!(value)
+        valid_value!(value) && valid_collection!(value) && valid_pattern!(value)
       end
 
       def validate_collection_range
@@ -194,7 +210,9 @@ module Lutaml
         elsif type <= Serialize
           type.hash_representation(value, format, options)
         else
-          type.serialize(value)
+          # Convert to Value instance if not already
+          value = type.new(value) unless value.is_a?(Type::Value)
+          value.send(:"to_#{format}")
         end
       end
 
@@ -208,7 +226,7 @@ module Lutaml
         elsif type <= Serialize && value.is_a?(Hash)
           type.apply_mappings(value, format, options)
         else
-          Lutaml::Model::Type.cast(value, type)
+          type.cast(value)
         end
       end
 
@@ -219,6 +237,13 @@ module Lutaml
           raise StandardError,
                 "Invalid options given for `#{name}` #{invalid_opts}"
         end
+
+        if options.key?(:pattern) && type != Lutaml::Model::Type::String
+          raise StandardError,
+                "Invalid option `pattern` given for `#{name}`, `pattern` is only allowed for :string type"
+        end
+
+        true
       end
 
       def validate_type!(type)

data/lib/lutaml/model/error/pattern_not_matched_error.rb

@@ -0,0 +1,17 @@
+module Lutaml
+  module Model
+    class PatternNotMatchedError < Error
+      def initialize(attr_name, pattern, value)
+        @attr_name = attr_name
+        @pattern = pattern
+        @value = value
+
+        super()
+      end
+
+      def to_s
+        "#{@attr_name}: \"#{@value}\" does not match #{@pattern.inspect}"
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/type_error.rb

@@ -0,0 +1,9 @@
+module Lutaml
+  module Model
+    class TypeError < Error
+      def initialize(message)
+        super("Type Error: #{message}")
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/unknown_type_error.rb

@@ -0,0 +1,9 @@
+module Lutaml
+  module Model
+    class UnknownTypeError < Error
+      def initialize(type_name)
+        super("Unknown type '#{type_name}'")
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/validation_error.rb

@@ -1,4 +1,3 @@
-# lib/lutaml/model/error/validation_error.rb
 module Lutaml
   module Model
     class ValidationError < Error

data/lib/lutaml/model/error.rb

@@ -7,7 +7,10 @@ end
 
 require_relative "error/invalid_value_error"
 require_relative "error/incorrect_mapping_argument_error"
+require_relative "error/pattern_not_matched_error"
 require_relative "error/unknown_adapter_type_error"
 require_relative "error/collection_count_out_of_range_error"
 require_relative "error/validation_error"
 require_relative "error/type_not_enabled_error"
+require_relative "error/type_error"
+require_relative "error/unknown_type_error"

data/lib/lutaml/model/mapping_hash.rb

@@ -28,6 +28,14 @@ module Lutaml
         @item_order = order
       end
 
+      def text
+        self["#cdata-section"] || self["text"]
+      end
+
+      def text?
+        key?("#cdata-section") || key?("text")
+      end
+
       def ordered?
         @ordered
       end

data/lib/lutaml/model/serialize.rb

@@ -310,7 +310,10 @@ module Lutaml
         def apply_xml_mapping(doc, instance, options = {})
           return instance unless doc
 
-          options[:default_namespace] = mappings_for(:xml)&.namespace_uri if options[:default_namespace].nil?
+          if options[:default_namespace].nil?
+            options[:default_namespace] =
+              mappings_for(:xml)&.namespace_uri
+          end
           mappings = mappings_for(:xml).mappings
 
           if doc.is_a?(Array)
@@ -340,7 +343,7 @@ module Lutaml
             value = if rule.raw_mapping?
                       doc.node.inner_xml
                     elsif rule.content_mapping?
-                      doc["text"]
+                      doc[rule.content_key]
                     elsif doc.key_exist?(rule.namespaced_name(options[:default_namespace]))
                       doc.fetch(rule.namespaced_name(options[:default_namespace]))
                     else
@@ -396,10 +399,12 @@ module Lutaml
 
           value = if value.is_a?(Array)
                     value.map do |v|
-                      text_hash?(attr, v) ? v["text"] : v
+                      text_hash?(attr, v) ? v.text : v
                     end
+                  elsif attr&.raw? && value
+                    value.node.children.map(&:to_xml).join
                   elsif text_hash?(attr, value)
-                    value["text"]
+                    value.text
                   else
                     value
                   end
@@ -423,7 +428,7 @@ module Lutaml
 
         def text_hash?(attr, value)
           return false unless value.is_a?(Hash)
-          return value.keys == ["text"] unless attr
+          return value.one? && value.text? unless attr
 
           !(attr.type <= Serialize) && attr.type != Lutaml::Model::Type::Hash
         end

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