cmdx 1.1.1 → 1.5.0

data/lib/cmdx/coercions/date.rb

@@ -2,43 +2,45 @@
 
 module CMDx
   module Coercions
-    # Coercion class for converting values to Date objects.
+    # Converts various input types to Date format
     #
-    # This coercion handles conversion of various types to Date objects, with support
-    # for custom date formats and automatic detection of date-like objects.
-    class Date < Coercion
+    # Handles conversion from strings, Date objects, DateTime objects, Time objects,
+    # and other date-like values to Date objects using Ruby's built-in parsing
+    # capabilities and optional custom format parsing.
+    module Date
 
+      extend self
+
+      # Types that are already date-like and don't need conversion
       ANALOG_TYPES = %w[Date DateTime Time].freeze
 
-      # Converts the given value to a Date object.
-      #
-      # @param value [Object] the value to convert to a Date
-      # @param options [Hash] optional configuration
-      # @option options [String] :strptime custom date format for parsing
-      #
-      # @return [Date] the converted Date object
+      # Converts a value to a Date object
       #
-      # @raise [CoercionError] if the value cannot be converted to a Date
+      # @param value [Object] The value to convert to a Date
+      # @param options [Hash] Optional configuration parameters
+      # @option options [String] :strptime Custom date format string for parsing
       #
-      # @example Converting a string with default parsing
-      #   Coercions::Date.call('2023-12-25') #=> #<Date: 2023-12-25>
+      # @return [Date] The converted Date object
       #
-      # @example Converting with custom format
-      #   Coercions::Date.call('25/12/2023', strptime: '%d/%m/%Y') #=> #<Date: 2023-12-25>
+      # @raise [CoercionError] If the value cannot be converted to a Date
       #
-      # @example Converting existing date-like objects
-      #   Coercions::Date.call(DateTime.now) #=> #<Date: 2023-12-25>
+      # @example Convert string to Date using default parsing
+      #   Date.call("2023-12-25")           # => #<Date: 2023-12-25>
+      #   Date.call("Dec 25, 2023")        # => #<Date: 2023-12-25>
+      # @example Convert string using custom format
+      #   Date.call("25/12/2023", strptime: "%d/%m/%Y")  # => #<Date: 2023-12-25>
+      #   Date.call("12-25-2023", strptime: "%m-%d-%Y")  # => #<Date: 2023-12-25>
+      # @example Return existing Date objects unchanged
+      #   Date.call(Date.new(2023, 12, 25)) # => #<Date: 2023-12-25>
+      #   Date.call(DateTime.new(2023, 12, 25)) # => #<Date: 2023-12-25>
       def call(value, options = {})
         return value if ANALOG_TYPES.include?(value.class.name)
         return ::Date.strptime(value, options[:strptime]) if options[:strptime]
 
         ::Date.parse(value)
       rescue TypeError, ::Date::Error
-        raise CoercionError, I18n.t(
-          "cmdx.coercions.into_a",
-          type: "date",
-          default: "could not coerce into a date"
-        )
+        type = Locale.t("cmdx.types.date")
+        raise CoercionError, Locale.t("cmdx.coercions.into_a", type:)
       end
 
     end

data/lib/cmdx/coercions/date_time.rb

@@ -2,45 +2,44 @@
 
 module CMDx
   module Coercions
-    # Coercion class for converting values to DateTime objects.
+    # Converts various input types to DateTime format
     #
-    # This coercion handles conversion of various types to DateTime objects,
-    # with support for custom date/time formats and automatic detection of
-    # analog types (Date, DateTime, Time).
-    class DateTime < Coercion
+    # Handles conversion from date strings, Date objects, Time objects, and other
+    # values that can be converted to DateTime using Ruby's DateTime.parse method
+    # or custom strptime formats.
+    module DateTime
+
+      extend self
 
       ANALOG_TYPES = %w[Date DateTime Time].freeze
 
-      # Converts the given value to a DateTime object.
-      #
-      # @param value [Object] the value to convert to a DateTime
-      # @param options [Hash] optional configuration
-      # @option options [String] :strptime custom format string for parsing
-      #
-      # @return [DateTime] the converted DateTime object
+      # Converts a value to a DateTime
       #
-      # @raise [CoercionError] if the value cannot be converted to a DateTime
+      # @param value [Object] The value to convert to DateTime
+      # @param options [Hash] Optional configuration parameters
+      # @option options [String] :strptime Custom date format string for parsing
       #
-      # @example Converting a date string
-      #   Coercions::DateTime.call('2023-12-25') #=> #<DateTime: 2023-12-25T00:00:00+00:00>
+      # @return [DateTime] The converted DateTime value
       #
-      # @example Converting with a custom format
-      #   Coercions::DateTime.call('25/12/2023', strptime: '%d/%m/%Y') #=> #<DateTime: 2023-12-25T00:00:00+00:00>
+      # @raise [CoercionError] If the value cannot be converted to DateTime
       #
-      # @example Passing through existing DateTime objects
-      #   dt = DateTime.now
-      #   Coercions::DateTime.call(dt) #=> dt (unchanged)
+      # @example Convert date strings to DateTime
+      #   DateTime.call("2023-12-25")               # => #<DateTime: 2023-12-25T00:00:00+00:00>
+      #   DateTime.call("Dec 25, 2023")             # => #<DateTime: 2023-12-25T00:00:00+00:00>
+      # @example Convert with custom strptime format
+      #   DateTime.call("25/12/2023", strptime: "%d/%m/%Y")
+      #   # => #<DateTime: 2023-12-25T00:00:00+00:00>
+      # @example Convert existing date objects
+      #   DateTime.call(Date.new(2023, 12, 25))     # => #<DateTime: 2023-12-25T00:00:00+00:00>
+      #   DateTime.call(Time.new(2023, 12, 25))     # => #<DateTime: 2023-12-25T00:00:00+00:00>
       def call(value, options = {})
         return value if ANALOG_TYPES.include?(value.class.name)
         return ::DateTime.strptime(value, options[:strptime]) if options[:strptime]
 
         ::DateTime.parse(value)
       rescue TypeError, ::Date::Error
-        raise CoercionError, I18n.t(
-          "cmdx.coercions.into_a",
-          type: "datetime",
-          default: "could not coerce into a datetime"
-        )
+        type = Locale.t("cmdx.types.date_time")
+        raise CoercionError, Locale.t("cmdx.coercions.into_a", type:)
       end
 
     end

data/lib/cmdx/coercions/float.rb

@@ -2,36 +2,39 @@
 
 module CMDx
   module Coercions
-    # Coercion class for converting values to floats.
+    # Converts various input types to Float format
     #
-    # This coercion handles conversion of various types to float values using
-    # Ruby's built-in Float() method.
-    class Float < Coercion
+    # Handles conversion from numeric strings, integers, and other numeric types
+    # that can be converted to floats using Ruby's Float() method.
+    module Float
 
-      # Converts the given value to a float.
-      #
-      # @param value [Object] the value to convert to a float
-      # @param _options [Hash] optional configuration (currently unused)
+      extend self
+
+      # Converts a value to a Float
       #
-      # @return [Float] the converted float value
+      # @param value [Object] The value to convert to a float
+      # @param options [Hash] Optional configuration parameters (currently unused)
+      # @option options [Object] :unused Currently no options are used
       #
-      # @raise [CoercionError] if the value cannot be converted to a float
+      # @return [Float] The converted float value
       #
-      # @example Converting numeric strings
-      #   Coercions::Float.call("3.14") #=> 3.14
-      #   Coercions::Float.call("42") #=> 42.0
+      # @raise [CoercionError] If the value cannot be converted to a float
       #
-      # @example Converting other numeric types
-      #   Coercions::Float.call(42) #=> 42.0
-      #   Coercions::Float.call(3.14) #=> 3.14
-      def call(value, _options = {})
+      # @example Convert numeric strings to float
+      #   Float.call("123")        # => 123.0
+      #   Float.call("123.456")    # => 123.456
+      #   Float.call("-42.5")      # => -42.5
+      #   Float.call("1.23e4")     # => 12300.0
+      # @example Convert numeric types to float
+      #   Float.call(42)           # => 42.0
+      #   Float.call(BigDecimal("123.456")) # => 123.456
+      #   Float.call(Rational(3, 4))       # => 0.75
+      #   Float.call(Complex(5.0, 0))      # => 5.0
+      def call(value, options = {})
         Float(value)
       rescue ArgumentError, RangeError, TypeError
-        raise CoercionError, I18n.t(
-          "cmdx.coercions.into_a",
-          type: "float",
-          default: "could not coerce into a float"
-        )
+        type = Locale.t("cmdx.types.float")
+        raise CoercionError, Locale.t("cmdx.coercions.into_a", type:)
       end
 
     end

data/lib/cmdx/coercions/hash.rb

@@ -2,41 +2,40 @@
 
 module CMDx
   module Coercions
-    # Coercion class for converting values to hashes.
+    # Coerces various input types into Hash objects
     #
-    # This coercion handles conversion of various types to hashes, with special
-    # handling for JSON-formatted strings that start with "{" and array-to-hash
-    # conversion using array splatting.
-    class Hash < Coercion
+    # Supports conversion from:
+    # - Hash objects (returned as-is)
+    # - Array objects (converted using Hash[*array])
+    # - JSON strings starting with "{" (parsed into Hash)
+    # - Other types raise CoercionError
+    module Hash
 
-      # Converts the given value to a hash.
-      #
-      # @param value [Object] the value to convert to a hash
-      # @param _options [Hash] optional configuration (currently unused)
-      #
-      # @return [Hash] the converted hash value
+      extend self
+
+      # Coerces a value into a Hash
       #
-      # @raise [CoercionError] if the value cannot be converted to a hash
-      # @raise [JSON::ParserError] if value is a JSON string that cannot be parsed
-      # @raise [ArgumentError] if array cannot be converted to hash pairs
-      # @raise [TypeError] if the value type is not supported
+      # @param value [Object] The value to coerce
+      # @param options [Hash] Additional options (currently unused)
+      # @option options [Symbol] :strict Whether to enforce strict conversion
       #
-      # @example Converting a JSON string
-      #   Coercions::Hash.call('{"a": 1, "b": 2}') #=> {"a" => 1, "b" => 2}
+      # @return [Hash] The coerced hash value
       #
-      # @example Converting an array to hash
-      #   Coercions::Hash.call(["a", 1, "b", 2]) #=> {"a" => 1, "b" => 2}
+      # @raise [CoercionError] When the value cannot be coerced to a Hash
       #
-      # @example Passing through existing hashes
-      #   Coercions::Hash.call({"key" => "value"}) #=> {"key" => "value"}
-      def call(value, _options = {})
-        case value.class.name
-        when "Hash", "ActionController::Parameters"
+      # @example Coerce from existing Hash
+      #   Hash.call({a: 1, b: 2}) # => {a: 1, b: 2}
+      # @example Coerce from Array
+      #   Hash.call([:a, 1, :b, 2]) # => {a: 1, b: 2}
+      # @example Coerce from JSON string
+      #   Hash.call('{"key": "value"}') # => {"key" => "value"}
+      def call(value, options = {})
+        if value.is_a?(::Hash)
           value
-        when "Array"
+        elsif value.is_a?(::Array)
           ::Hash[*value]
-        when "String"
-          value.start_with?("{") ? JSON.parse(value) : raise_coercion_error!
+        elsif value.is_a?(::String) && value.start_with?("{")
+          JSON.parse(value)
         else
           raise_coercion_error!
         end
@@ -46,12 +45,12 @@ module CMDx
 
       private
 
+      # Raises a CoercionError with localized message
+      #
+      # @raise [CoercionError] Always raised with localized error message
       def raise_coercion_error!
-        raise CoercionError, I18n.t(
-          "cmdx.coercions.into_a",
-          type: "hash",
-          default: "could not coerce into a hash"
-        )
+        type = Locale.t("cmdx.types.hash")
+        raise CoercionError, Locale.t("cmdx.coercions.into_a", type:)
       end
 
     end

data/lib/cmdx/coercions/integer.rb

@@ -2,37 +2,43 @@
 
 module CMDx
   module Coercions
-    # Coercion class for converting values to integers.
+    # Converts various input types to Integer format
     #
-    # This coercion handles conversion of various types to integers using Ruby's
-    # built-in Integer() method, which provides strict type conversion.
-    class Integer < Coercion
+    # Handles conversion from strings, numbers, and other values to integers
+    # using Ruby's Integer() method. Raises CoercionError for values that
+    # cannot be converted to integers.
+    module Integer
 
-      # Converts the given value to an integer.
-      #
-      # @param value [Object] the value to convert to an integer
-      # @param _options [Hash] optional configuration (currently unused)
+      extend self
+
+      # Converts a value to an Integer
       #
-      # @return [Integer] the converted integer value
+      # @param value [Object] The value to convert to an integer
+      # @param options [Hash] Optional configuration parameters (currently unused)
+      # @option options [Object] :unused Currently no options are used
       #
-      # @raise [CoercionError] if the value cannot be converted to an integer
+      # @return [Integer] The converted integer value
       #
-      # @example Converting numeric strings
-      #   Coercions::Integer.call("123") #=> 123
-      #   Coercions::Integer.call("-456") #=> -456
+      # @raise [CoercionError] If the value cannot be converted to an integer
       #
-      # @example Converting other numeric types
-      #   Coercions::Integer.call(123.45) #=> 123
-      #   Coercions::Integer.call(Time.now) #=> 1672574400 (timestamp)
-      #   Coercions::Integer.call(Complex(42, 0)) #=> 42
-      def call(value, _options = {})
+      # @example Convert numeric strings to integers
+      #   Integer.call("42")      # => 42
+      #   Integer.call("-123")    # => -123
+      #   Integer.call("0")       # => 0
+      # @example Convert numeric types to integers
+      #   Integer.call(42.0)      # => 42
+      #   Integer.call(3.14)      # => 3
+      #   Integer.call(0.0)       # => 0
+      # @example Handle edge cases
+      #   Integer.call("")        # => 0
+      #   Integer.call(nil)       # => 0
+      #   Integer.call(false)     # => 0
+      #   Integer.call(true)      # => 1
+      def call(value, options = {})
         Integer(value)
-      rescue ArgumentError, FloatDomainError, RangeError, TypeError # rubocop:disable Lint/ShadowedException
-        raise CoercionError, I18n.t(
-          "cmdx.coercions.into_an",
-          type: "integer",
-          default: "could not coerce into an integer"
-        )
+      rescue ArgumentError, FloatDomainError, RangeError, TypeError
+        type = Locale.t("cmdx.types.integer")
+        raise CoercionError, Locale.t("cmdx.coercions.into_an", type:)
       end
 
     end

data/lib/cmdx/coercions/rational.rb

@@ -2,37 +2,42 @@
 
 module CMDx
   module Coercions
-    # Coercion class for converting values to rational numbers.
+    # Converts various input types to Rational format
     #
-    # This coercion handles conversion of various types to rational numbers,
-    # using Ruby's built-in Rational() method for type conversion.
-    class Rational < Coercion
+    # Handles conversion from strings, numbers, and other values to rational
+    # numbers using Ruby's Rational() method. Raises CoercionError for values
+    # that cannot be converted to rational numbers.
+    module Rational
 
-      # Converts the given value to a rational number.
-      #
-      # @param value [Object] the value to convert to a rational number
-      # @param _options [Hash] optional configuration (currently unused)
-      #
-      # @return [Rational] the converted rational value
+      extend self
+
+      # Converts a value to a Rational
       #
-      # @raise [CoercionError] if the value cannot be converted to a rational number
+      # @param value [Object] The value to convert to a rational number
+      # @param options [Hash] Optional configuration parameters (currently unused)
+      # @option options [Object] :unused Currently no options are used
       #
-      # @example Converting a string fraction
-      #   Coercions::Rational.call('1/2') #=> (1/2)
+      # @return [Rational] The converted rational number
       #
-      # @example Converting an integer
-      #   Coercions::Rational.call(5) #=> (5/1)
+      # @raise [CoercionError] If the value cannot be converted to a rational number
       #
-      # @example Converting a float
-      #   Coercions::Rational.call(0.25) #=> (1/4)
-      def call(value, _options = {})
+      # @example Convert numeric strings to rational numbers
+      #   Rational.call("3/4")     # => (3/4)
+      #   Rational.call("2.5")     # => (5/2)
+      #   Rational.call("0")       # => (0/1)
+      # @example Convert numeric types to rational numbers
+      #   Rational.call(3.14)      # => (157/50)
+      #   Rational.call(2)         # => (2/1)
+      #   Rational.call(0.5)       # => (1/2)
+      # @example Handle edge cases
+      #   Rational.call("")        # => (0/1)
+      #   Rational.call(nil)       # => (0/1)
+      #   Rational.call(0)         # => (0/1)
+      def call(value, options = {})
         Rational(value)
-      rescue ArgumentError, FloatDomainError, RangeError, TypeError, ZeroDivisionError # rubocop:disable Lint/ShadowedException
-        raise CoercionError, I18n.t(
-          "cmdx.coercions.into_a",
-          type: "rational",
-          default: "could not coerce into a rational"
-        )
+      rescue ArgumentError, FloatDomainError, RangeError, TypeError, ZeroDivisionError
+        type = Locale.t("cmdx.types.rational")
+        raise CoercionError, Locale.t("cmdx.coercions.into_a", type:)
       end
 
     end

data/lib/cmdx/coercions/string.rb

@@ -2,34 +2,31 @@
 
 module CMDx
   module Coercions
-    # Coercion class for converting values to strings.
+    # Coerces values to String type using Ruby's built-in String() method.
     #
-    # This coercion handles conversion of various types to strings using Ruby's
-    # built-in String() method, which provides consistent string conversion
-    # behavior across different object types.
-    class String < Coercion
+    # This coercion handles various input types by converting them to their
+    # string representation. It's a simple wrapper around Ruby's String()
+    # method for consistency with the CMDx coercion interface.
+    module String
 
-      # Converts the given value to a string.
-      #
-      # @param value [Object] the value to convert to a string
-      # @param _options [Hash] optional configuration (currently unused)
-      #
-      # @return [String] the converted string value
+      extend self
+
+      # Coerces a value to String type.
       #
-      # @raise [TypeError] if the value cannot be converted to a string
+      # @param value [Object] The value to coerce to a string
+      # @param options [Hash] Optional configuration parameters (unused in this coercion)
       #
-      # @example Converting numbers
-      #   Coercions::String.call(123) #=> "123"
-      #   Coercions::String.call(45.67) #=> "45.67"
+      # @return [String] The coerced string value
       #
-      # @example Converting symbols and nil
-      #   Coercions::String.call(:symbol) #=> "symbol"
-      #   Coercions::String.call(nil) #=> ""
+      # @raise [TypeError] If the value cannot be converted to a string
       #
-      # @example Converting boolean values
-      #   Coercions::String.call(true) #=> "true"
-      #   Coercions::String.call(false) #=> "false"
-      def call(value, _options = {})
+      # @example Basic string coercion
+      #   String.call("hello")           # => "hello"
+      #   String.call(42)                # => "42"
+      #   String.call([1, 2, 3])         # => "[1, 2, 3]"
+      #   String.call(nil)               # => ""
+      #   String.call(true)              # => "true"
+      def call(value, options = {})
         String(value)
       end
 

data/lib/cmdx/coercions/symbol.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Coercions
+    # Coerces values to Symbol type using Ruby's to_sym method.
+    #
+    # This coercion handles various input types by converting them to symbols.
+    # It provides error handling for values that cannot be converted to symbols
+    # and raises appropriate CMDx coercion errors with localized messages.
+    module Symbol
+
+      extend self
+
+      # Coerces a value to Symbol type.
+      #
+      # @param value [Object] The value to coerce to a symbol
+      # @param options [Hash] Optional configuration parameters (unused in this coercion)
+      #
+      # @return [Symbol] The coerced symbol value
+      #
+      # @raise [CoercionError] If the value cannot be converted to a symbol
+      #
+      # @example Basic symbol coercion
+      #   Symbol.call("hello")           # => :hello
+      #   Symbol.call("user_id")         # => :user_id
+      #   Symbol.call("")                # => :""
+      #   Symbol.call(:existing)         # => :existing
+      def call(value, options = {})
+        value.to_sym
+      rescue NoMethodError
+        type = Locale.t("cmdx.types.symbol")
+        raise CoercionError, Locale.t("cmdx.coercions.into_a", type:)
+      end
+
+    end
+  end
+end

data/lib/cmdx/coercions/time.rb

@@ -2,34 +2,38 @@
 
 module CMDx
   module Coercions
-    # Coercion class for converting values to Time objects.
+    # Converts various input types to Time format
     #
-    # This coercion handles conversion of various types to Time objects, with special
-    # handling for analog types (DateTime, Time) and custom format parsing.
-    class Time < Coercion
+    # Handles conversion from strings, dates, and other time-like objects to Time
+    # using Ruby's built-in time parsing methods. Supports custom strptime formats
+    # and raises CoercionError for values that cannot be converted to Time.
+    module Time
+
+      extend self
 
       ANALOG_TYPES = %w[DateTime Time].freeze
 
-      # Converts the given value to a Time object.
-      #
-      # @param value [Object] the value to convert to a Time object
-      # @param options [Hash] optional configuration
-      # @option options [String] :strptime custom format string for parsing
-      #
-      # @return [Time] the converted Time object
+      # Converts a value to a Time object
       #
-      # @raise [CoercionError] if the value cannot be converted to a Time object
+      # @param value [Object] The value to convert to a Time object
+      # @param options [Hash] Optional configuration parameters
+      # @option options [String] :strptime Custom strptime format string for parsing
       #
-      # @example Converting with custom format
-      #   Coercions::Time.call('2023-12-25 14:30', strptime: '%Y-%m-%d %H:%M') #=> 2023-12-25 14:30:00
+      # @return [Time] The converted Time object
       #
-      # @example Converting standard time strings
-      #   Coercions::Time.call('2023-12-25 14:30:00') #=> 2023-12-25 14:30:00
-      #   Coercions::Time.call('Dec 25, 2023') #=> 2023-12-25 00:00:00
+      # @raise [CoercionError] If the value cannot be converted to a Time object
       #
-      # @example Analog types pass through unchanged
-      #   time = Time.now
-      #   Coercions::Time.call(time) #=> time (unchanged)
+      # @example Convert time-like objects
+      #   Time.call(Time.now)                    # => Time object (unchanged)
+      #   Time.call(DateTime.now)                # => Time object (converted)
+      #   Time.call(Date.today)                  # => Time object (converted)
+      # @example Convert strings with default parsing
+      #   Time.call("2023-12-25 10:30:00")      # => Time object
+      #   Time.call("2023-12-25")               # => Time object
+      #   Time.call("10:30:00")                 # => Time object
+      # @example Convert strings with custom format
+      #   Time.call("25/12/2023", strptime: "%d/%m/%Y")  # => Time object
+      #   Time.call("12-25-2023", strptime: "%m-%d-%Y")  # => Time object
       def call(value, options = {})
         return value if ANALOG_TYPES.include?(value.class.name)
         return value.to_time if value.respond_to?(:to_time)
@@ -37,11 +41,8 @@ module CMDx
 
         ::Time.parse(value)
       rescue ArgumentError, TypeError
-        raise CoercionError, I18n.t(
-          "cmdx.coercions.into_a",
-          type: "time",
-          default: "could not coerce into a time"
-        )
+        type = Locale.t("cmdx.types.time")
+        raise CoercionError, Locale.t("cmdx.coercions.into_a", type:)
       end
 
     end