command_model 1.3.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8af8e3bf9074e89aafc9b7e880eb7c99780a9189f822a6a030c8867a3429b0c7
-  data.tar.gz: 225ab899fa949b25dcbda27e9dac739227f8992d68ea0109afa99e36726f08bd
+  metadata.gz: 894d328023ecf9f0a8935bfe2a198e2fa3d26a55d42b2a4c0178bfa390e9b4bf
+  data.tar.gz: c00d13c0db81fd1a1c9c49e3ff9fa473d62c0c8131ca449acf8f6dd695109a7d
 SHA512:
-  metadata.gz: 1d01d13237af6fda7df4e9002a71fb029558bd1bc114dc7bdfa1f54f288f80fdf76e744550f0a49292f2bd94fd9f13cf9c65870ab0be75af23f041ff148ae8a3
-  data.tar.gz: 43a0c62d7d985aff56a7875c84eafb862e9b92e40e0728ae67e468021590e5e4cdb3f6454d05cd27647432312e5bb197ed259d7b0c640f602715b1d0d7ff801b
+  metadata.gz: 016761f5657fd6b00664d0d8e3730d83055506314fa4a49a02194eaa6e7e7f680d8ae234590616a148c31ccc7ab5dfd613b63385121c8e10dafc96adc426cd9b
+  data.tar.gz: fc0b8d08827f71c8882697eeb2918f9bde7364aecd7f4796e9125727b73ceb0113022427ff76ed1ce96804c624780cc80be23823587828bcf549b6a0cc852d6b

data/.ruby-version

@@ -0,0 +1 @@
+2.5.1

data/.travis.yml

@@ -1,8 +1,6 @@
 language: ruby
 rvm:
   - 2.5.0
-  - 2.4.3
 gemfile:
-  - gemfiles/4.2.gemfile
   - gemfiles/5.0.gemfile
   - gemfiles/5.1.gemfile

data/README.md

@@ -3,9 +3,9 @@
 # CommandModel
 
 CommandModel is an ActiveModel based class that encapsulates the user
-interaction logic that wraps a domain operation. This user interaction
-typically may include sanitizing, validating, normalizing, and typecasting
-input. It also will include the response from the domain operation.
+interaction logic that wraps a domain operation. This user interaction typically
+may include sanitizing, validating, normalizing, and type converting input. It
+also will include the response from the domain operation.
 
 There are three major concerns when handling a user request: input handling,
 domain logic, and persistence. ActiveRecord mixes all three of these concerns
@@ -21,7 +21,7 @@ ActiveRecord style update_attributes.
     account.withdraw amount: 50
 
 But there are multiple complications with the OO approach. How do we integrate
-Rails style validations? How are user-supplied strings typecast? How do we
+Rails style validations? How are user-supplied strings type converted? How do we
 know if the command succeeded? CommandModel solves these problems.
 
 ## Installation
@@ -45,7 +45,7 @@ request.
 
     class WithdrawCommand < CommandModel::Model
       parameter :amount,
-        typecast: :integer,
+        convert: :integer,
         presence: true,
         numericality: { greater_than: 0, less_than_or_equal_to: 500 }
     end
@@ -95,7 +95,7 @@ internal domain logic.
 
     class WithdrawCommand < CommandModel::Model
       parameter :amount,
-        typecast: :integer,
+        convert: :integer,
         presence: true,
         numericality: { greater_than: 0, less_than_or_equal_to: 500 }
       parameter :account_id, presence: true
@@ -130,6 +130,14 @@ integration of Rails form helpers and validations with CommandModel.
 
 ## Version History
 
+* 2.0.1 - April 3, 2023
+    * Date parsing allows 5 digit years
+* 2.0 - April 11, 2018
+    * Rename typecast parameter option to convert
+    * Any callable object can be used as a type converter
+    * Multiple type converters can be chained together
+    * Added StringMutator type converter
+    * Add boolean type conversion
 * 1.3 - February 13, 2018
     * Add decimal type cast
 * 1.2 - October 24, 2014

data/command_model.gemspec

@@ -15,12 +15,10 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = CommandModel::VERSION
 
-  gem.add_dependency 'activemodel', "> 4.2"
+  gem.required_ruby_version = '>= 2.5.0'
 
-  gem.add_development_dependency 'rake', "~> 11.3.0"
-  gem.add_development_dependency 'rspec', "~> 2.14.1"
-  gem.add_development_dependency 'guard', "~> 2.14.2"
-  gem.add_development_dependency 'guard-rspec', "~> 3.1.0"
-  gem.add_development_dependency 'rb-fsevent', '~> 0.10.2'
+  gem.add_dependency 'activemodel', "> 5.0"
 
+  gem.add_development_dependency 'rake', "~> 12.3.0"
+  gem.add_development_dependency 'rspec', "~> 3.7.0"
 end

data/lib/command_model/convert.rb

@@ -0,0 +1,85 @@
+require 'bigdecimal'
+require 'date'
+
+module CommandModel
+  module Convert
+    class ConvertError < StandardError
+      attr_reader :original_error, :target_type
+
+      def initialize(original_error, target_type)
+        @original_error = original_error
+        @target_type = target_type
+      end
+    end
+
+    class StringMutator
+      def initialize(force_to_s=false, &block)
+        @force_to_s = force_to_s
+        @mutator = block
+      end
+
+      def call(value)
+        if @force_to_s
+          @mutator.call value.to_s
+        elsif value.respond_to? :to_str
+          @mutator.call value.to_str
+        else
+          value
+        end
+      end
+    end
+
+    class Integer
+      def call(value)
+        return nil if value.blank?
+        Integer(value)
+      rescue StandardError => e
+        raise ConvertError.new(e, "integer")
+      end
+    end
+
+    class Decimal
+      def call(value)
+        return nil if value.blank?
+        BigDecimal(value, 16)
+      rescue StandardError => e
+        raise ConvertError.new(e, "number")
+      end
+    end
+
+    class Float
+      def call(value)
+        return nil if value.blank?
+        Float(value)
+      rescue StandardError => e
+        raise ConvertError.new(e, "number")
+      end
+    end
+
+    class Date
+      def call(value)
+        return nil if value.blank?
+        return value if value.kind_of? Date
+        value = value.to_s
+        if value =~ /\A(\d{4,5})-(\d\d)-(\d\d)\z/
+          ::Date.civil($1.to_i, $2.to_i, $3.to_i)
+        else
+          ::Date.strptime(value, "%m/%d/%Y")
+        end
+      rescue StandardError => e
+        raise ConvertError.new(e, "date")
+      end
+    end
+
+    class Boolean
+      def call(value)
+        case value
+        when "", "0", "false", "f", 0
+          then false
+        else
+          !!value
+        end
+      end
+    end
+  end
+end

data/lib/command_model/model.rb

@@ -4,42 +4,43 @@ module CommandModel
     include ActiveModel::Conversion
     extend ActiveModel::Naming
 
-    Parameter = Struct.new(:name, :typecast, :validations)
+    Parameter = Struct.new(:name, :converters, :validations)
 
     # Parameter requires one or more attributes as its first parameter(s).
     # It accepts an options hash as its last parameter.
     #
     # ==== Options
     #
-    # * typecast - The type of object to typecast to. Typecasts are built-in
-    #   for integer, float, and date. Additional typecasts can be defined
-    #   by defining a method typecast_#{name} for a typecast of #{name}.
+    # * convert - An object or array of objects that respond to call and
+    #   convert the assigned value as necessary. Built-in converters exist
+    #   for integer, decimal, float, date, and boolean. These built-in
+    #   converters can be specified by symbol.
     # * validations - All other options are considered validations and are
     #   passed to ActiveModel::Validates.validates
     #
     # ==== Examples
     #
     #   parameter :gender
-    #   parameter :name, :presence => true
-    #   parameter :birthdate, :typecast => :date
+    #   parameter :name, presence: true
+    #   parameter :birthdate, convert: :date
     #   parameter :height, :weight,
-    #     :typecast => :integer,
-    #     :presence => true,
-    #     :numericality => { :greater_than_or_equal_to => 0 }
+    #     convert: [CommandModel::Convert::StringMutator.new { |s| s.gsub(",", "")}, :integer],
+    #     presence: true,
+    #     numericality: { :greater_than_or_equal_to => 0 }
     def self.parameter(*args)
       options = args.last.kind_of?(Hash) ? args.pop.clone : {}
-      typecast = options.delete(:typecast)
+      converters = options.delete(:convert)
 
       args.each do |name|
         attr_reader name
 
-        if typecast
-          attr_typecasting_writer name, typecast
+        if converters
+          attr_type_converting_writer name, Array(converters)
         else
           attr_writer name
         end
         validates name, options.clone if options.present? # clone options because validates mutates the hash :(
-        parameters.push Parameter.new name, typecast, options
+        parameters.push Parameter.new name, converters, options
       end
     end
 
@@ -48,21 +49,37 @@ module CommandModel
       @parameters ||= []
     end
 
-    def self.attr_typecasting_writer(name, target_type) #:nodoc
-      eval <<-END_EVAL
-        public def #{name}=(value)
-          typecast_value = typecast_#{target_type}(value)
-          if typecast_value
-            @typecast_errors.delete("#{name}")
-            @#{name} = typecast_value
+    def self.attr_type_converting_writer(name, converters) #:nodoc
+      converters = converters.map do |c|
+        if c.respond_to? :call
+          c
+        else
+          case c.to_s
+          when "integer"
+            CommandModel::Convert::Integer.new
+          when "decimal"
+            CommandModel::Convert::Decimal.new
+          when "float"
+            CommandModel::Convert::Float.new
+          when "date"
+            CommandModel::Convert::Date.new
+          when "boolean"
+            CommandModel::Convert::Boolean.new
           else
-            @typecast_errors["#{name}"] = "#{target_type}"
-            @#{name} = value
+            raise ArgumentError, "unknown converter #{c}"
           end
-
-          @#{name}
         end
-      END_EVAL
+      end
+
+      define_method "#{name}=" do |value|
+        converted_value = converters.reduce(value) { |v, c| c.call(v) }
+        instance_variable_set "@#{name}", converted_value
+        instance_variable_get("@type_conversion_errors").delete(name)
+        instance_variable_get "@#{name}"
+      rescue CommandModel::Convert::ConvertError => e
+        instance_variable_get("@type_conversion_errors")[name] = e.target_type
+        instance_variable_set "@#{name}", value
+      end
     end
 
     # Executes a block of code if the command model is valid.
@@ -113,7 +130,7 @@ module CommandModel
     # instance of the same class is passed in then the parameters are copied
     # to the new object.
     def initialize(parameters={})
-      @typecast_errors = {}
+      @type_conversion_errors = {}
       set_parameters parameters
     end
 
@@ -179,30 +196,8 @@ module CommandModel
         end
       end
 
-      def typecast_integer(value)
-        Integer(value) rescue nil
-      end
-
-      def typecast_decimal(value)
-        BigDecimal(value, 16) rescue nil
-      end
-
-      def typecast_float(value)
-        Float(value) rescue nil
-      end
-
-      def typecast_date(value)
-        return value if value.kind_of? Date
-        value = value.to_s
-        if value =~ /\A(\d\d\d\d)-(\d\d)-(\d\d)\z/
-          Date.civil($1.to_i, $2.to_i, $3.to_i) rescue nil
-        else
-          Date.strptime(value, "%m/%d/%Y") rescue nil
-        end
-      end
-
       def include_typecasting_errors
-        @typecast_errors.each do |attribute, target_type|
+        @type_conversion_errors.each do |attribute, target_type|
           unless errors[attribute].present?
             errors.add attribute, "is not a #{target_type}"
           end

data/lib/command_model/version.rb

@@ -1,3 +1,3 @@
 module CommandModel
-  VERSION = "1.3.0"
+  VERSION = "2.0.1"
 end

data/lib/command_model.rb

@@ -2,6 +2,7 @@ require "active_model"
 
 require "command_model/version"
 require "command_model/model"
+require "command_model/convert"
 
 module CommandModel
 end

data/spec/convert_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+describe "CommandModel::Convert" do
+  describe "StringMutator" do
+    subject { CommandModel::Convert::StringMutator.new { |s| s.gsub(",", "") } }
+
+    it "strips commas from strings" do
+      expect(subject.("1,000")).to eq("1000")
+    end
+
+    it "does nothing to non-strings" do
+      expect(subject.(nil)).to eq(nil)
+      expect(subject.(42)).to eq(42)
+      expect(subject.(:bla)).to eq(:bla)
+    end
+  end
+
+  describe "Integer" do
+    subject { CommandModel::Convert::Integer.new }
+
+    it "casts to integer when valid string" do
+      expect(subject.("42")).to eq(42)
+    end
+
+    it "accepts nil" do
+      expect(subject.(nil)).to eq(nil)
+    end
+
+    it "converts empty string to nil" do
+      expect(subject.("")).to eq(nil)
+    end
+
+    it "raises ConvertError when invalid string" do
+      expect { subject.("asdf") }.to raise_error(CommandModel::Convert::ConvertError)
+      expect { subject.("0.1") }.to raise_error(CommandModel::Convert::ConvertError)
+    end
+  end
+
+  describe "Float" do
+    subject { CommandModel::Convert::Float.new }
+
+    it "casts to float when valid string" do
+      expect(subject.("42")).to eq(42.0)
+      expect(subject.("42.5")).to eq(42.5)
+    end
+
+    it "accepts nil" do
+      expect(subject.(nil)).to eq(nil)
+    end
+
+    it "converts empty string to nil" do
+      expect(subject.("")).to eq(nil)
+    end
+
+    it "raises ConvertError when invalid string" do
+      expect { subject.("asdf") }.to raise_error(CommandModel::Convert::ConvertError)
+    end
+  end
+
+  describe "Decimal" do
+    subject { CommandModel::Convert::Decimal.new }
+
+    it "converts to BigDecimal when valid string" do
+      expect(subject.("42")).to eq(BigDecimal("42"))
+      expect(subject.("42.5")).to eq(BigDecimal("42.5"))
+    end
+
+    it "converts to BigDecimal when float" do
+      expect(subject.(42.0)).to eq(BigDecimal("42"))
+    end
+
+    it "converts to BigDecimal when int" do
+      expect(subject.(42)).to eq(BigDecimal("42"))
+    end
+
+    it "accepts nil" do
+      expect(subject.(nil)).to eq(nil)
+    end
+
+    it "converts empty string to nil" do
+      expect(subject.("")).to eq(nil)
+    end
+
+    it "raises ConvertError when invalid string" do
+      expect { subject.("asdf") }.to raise_error(CommandModel::Convert::ConvertError)
+    end
+  end
+
+  describe "Date" do
+    subject { CommandModel::Convert::Date.new }
+
+    it "casts to date when valid string" do
+      expect(subject.("01/01/2000")).to eq(Date.civil(2000,1,1))
+      expect(subject.("1/1/2000")).to eq(Date.civil(2000,1,1))
+      expect(subject.("2000-01-01")).to eq(Date.civil(2000,1,1))
+      expect(subject.("29000-01-01")).to eq(Date.civil(29000,1,1))
+    end
+
+    it "returns existing date unchanged" do
+      date = Date.civil(2000,1,1)
+      expect(subject.(date)).to eq(date)
+    end
+
+    it "accepts nil" do
+      expect(subject.(nil)).to eq(nil)
+    end
+
+    it "converts empty string to nil" do
+      expect(subject.("")).to eq(nil)
+    end
+
+    it "raises ConvertError when invalid string" do
+      expect { subject.("asdf") }.to raise_error(CommandModel::Convert::ConvertError)
+      expect { subject.("3/50/1290") }.to raise_error(CommandModel::Convert::ConvertError)
+    end
+  end
+
+  describe "Boolean" do
+    subject { CommandModel::Convert::Boolean.new }
+
+    it "casts to true when any non-false value" do
+      expect(subject.("true")).to eq(true)
+      expect(subject.("t")).to eq(true)
+      expect(subject.("1")).to eq(true)
+      expect(subject.(true)).to eq(true)
+      expect(subject.(Object.new)).to eq(true)
+      expect(subject.(42)).to eq(true)
+    end
+
+    it "casts to false when false values" do
+      expect(subject.("")).to eq(false)
+      expect(subject.("0")).to eq(false)
+      expect(subject.("f")).to eq(false)
+      expect(subject.("false")).to eq(false)
+      expect(subject.(0)).to eq(false)
+      expect(subject.(nil)).to eq(false)
+      expect(subject.(false)).to eq(false)
+    end
+  end
+end

data/spec/model_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 class ExampleCommand < CommandModel::Model
-  parameter :name, :presence => true
+  parameter :name, presence: true
   parameter :title
 end
 
@@ -14,57 +14,63 @@ describe CommandModel::Model do
 
     it "creates an attribute reader" do
       klass.parameter :foo
-      klass.new.methods.should include(:foo)
+      expect(klass.new.methods).to include(:foo)
     end
 
     it "creates an attribute writer" do
       klass.parameter :foo
-      klass.new.methods.should include(:foo=)
+      expect(klass.new.methods).to include(:foo=)
     end
 
     it "round trips values through writing and reading" do
       klass.parameter :foo
       instance = klass.new
       instance.foo = 42
-      instance.foo.should eq(42)
+      expect(instance.foo).to eq(42)
     end
 
     it "accepts multiple attributes" do
       klass.parameter :foo, :bar
-      klass.new.methods.should include(:foo)
-      klass.new.methods.should include(:foo=)
-      klass.new.methods.should include(:bar)
-      klass.new.methods.should include(:bar=)
+      expect(klass.new.methods).to include(:foo)
+      expect(klass.new.methods).to include(:foo=)
+      expect(klass.new.methods).to include(:bar)
+      expect(klass.new.methods).to include(:bar=)
     end
 
-    it "accepts multiple attributes with typecast" do
-      klass.parameter :foo, :bar, :typecast => "integer"
-      klass.new.methods.should include(:foo)
-      klass.new.methods.should include(:foo=)
-      klass.new.methods.should include(:bar)
-      klass.new.methods.should include(:bar=)
+    it "accepts multiple attributes with convert" do
+      klass.parameter :foo, :bar, :convert => :integer
+      expect(klass.new.methods).to include(:foo)
+      expect(klass.new.methods).to include(:foo=)
+      expect(klass.new.methods).to include(:bar)
+      expect(klass.new.methods).to include(:bar=)
     end
 
     it "accepts multiple attributes with validation" do
       klass.parameter :foo, :bar, :presence => true
-      klass.new.methods.should include(:foo)
-      klass.new.methods.should include(:foo=)
-      klass.new.methods.should include(:bar)
-      klass.new.methods.should include(:bar=)
+      expect(klass.new.methods).to include(:foo)
+      expect(klass.new.methods).to include(:foo=)
+      expect(klass.new.methods).to include(:bar)
+      expect(klass.new.methods).to include(:bar=)
     end
 
-    it "creates typecasting writer" do
-      klass.send(:define_method, :typecast_42) { |value| 42 }
-      klass.parameter :answer, :typecast => "42"
+    it "converts via callable" do
+      klass.parameter :answer, convert: ->(value) { 42 }
       instance = klass.new
       instance.answer = "foo"
-      instance.answer.should eq(42)
+      expect(instance.answer).to eq(42)
+    end
+
+    it "converts with multiple converters" do
+      klass.parameter :num, convert: [CommandModel::Convert::StringMutator.new { |s| s.gsub(",", "")}, :integer]
+      instance = klass.new
+      instance.num = "1,000"
+      expect(instance.num).to eq(1000)
     end
 
     it "creates validations" do
       instance = ExampleCommand.new
-      instance.should_not be_valid
-      instance.errors[:name].should be_present
+      expect(instance).to_not be_valid
+      expect(instance.errors[:name]).to be_present
     end
   end
 
@@ -72,7 +78,7 @@ describe CommandModel::Model do
     it "returns all parameters in class" do
       klass = Class.new(CommandModel::Model)
       klass.parameter :name, presence: true
-      klass.parameter :birthdate, typecast: :date, presence: true
+      klass.parameter :birthdate, convert: :date, presence: true
 
       expected = [
         CommandModel::Model::Parameter.new(:name, nil, { presence: true }),
@@ -85,35 +91,35 @@ describe CommandModel::Model do
 
   describe "self.execute" do
     it "accepts object of same kind and returns it" do
-      ExampleCommand.execute(example_command) {}.should eq(example_command)
+      expect(ExampleCommand.execute(example_command) {}).to eq(example_command)
     end
 
     it "accepts attributes, creates object, and returns it" do
       c = ExampleCommand.execute(:name => "John") {}
-      c.should be_kind_of(ExampleCommand)
-      c.name.should eq("John")
+      expect(c).to be_kind_of(ExampleCommand)
+      expect(c.name).to eq("John")
     end
 
     it "calls passed block when there are no validation errors on Model" do
       block_ran = false
       ExampleCommand.execute(example_command) { block_ran = true }
-      block_ran.should eq(true)
+      expect(block_ran).to eq(true)
     end
 
     it "does not call passed block when there are validation errors on Model" do
       block_ran = false
       ExampleCommand.execute(invalid_example_command) { block_ran = true }
-      block_ran.should eq(false)
+      expect(block_ran).to eq(false)
     end
 
     it "records execution attempt when there not no validation errors on Model" do
       ExampleCommand.execute(example_command) {}
-      example_command.execution_attempted?.should eq(true)
+      expect(example_command.execution_attempted?).to eq(true)
     end
 
     it "records execution attempt when there are validation errors on Model" do
       ExampleCommand.execute(invalid_example_command) {}
-      invalid_example_command.execution_attempted?.should eq(true)
+      expect(invalid_example_command.execution_attempted?).to eq(true)
     end
 
     it "is not successful if block adds error to Model" do
@@ -121,24 +127,24 @@ describe CommandModel::Model do
         command.errors.add :base, "foo"
       end
 
-      example_command.should_not be_success
+      expect(example_command).to_not be_success
     end
   end
 
   describe "self.success" do
     it "creates a successful command model" do
       response = ExampleCommand.success
-      response.should be_kind_of(ExampleCommand)
-      response.should be_success
+      expect(response).to be_kind_of(ExampleCommand)
+      expect(response).to be_success
     end
   end
 
   describe "self.failure" do
     it "creates a command model with an error" do
       response = ExampleCommand.failure "something broke"
-      response.should be_kind_of(ExampleCommand)
-      response.should_not be_success
-      response.errors[:base].should eq(["something broke"])
+      expect(response).to be_kind_of(ExampleCommand)
+      expect(response).to_not be_success
+      expect(response.errors[:base]).to eq(["something broke"])
     end
   end
 
@@ -146,7 +152,7 @@ describe CommandModel::Model do
   describe "initialize" do
     it "assigns parameters from hash" do
       m = ExampleCommand.new :name => "John"
-      m.name.should eq("John")
+      expect(m.name).to eq("John")
     end
 
     it "assigns parameters from other CommandModel" do
@@ -159,7 +165,7 @@ describe CommandModel::Model do
   describe "call" do
     context "when valid" do
       it "calls execute" do
-        example_command.should_receive(:execute)
+        expect(example_command).to receive(:execute)
         example_command.call
       end
 
@@ -170,7 +176,7 @@ describe CommandModel::Model do
 
     context "when invalid" do
       it "does not call execute" do
-        invalid_example_command.should_not_receive(:execute)
+        expect(invalid_example_command).to_not receive(:execute)
         invalid_example_command.call
       end
 
@@ -194,24 +200,24 @@ describe CommandModel::Model do
   describe "execution_attempted!" do
     it "sets execution_attempted? to true" do
       example_command.execution_attempted!
-      example_command.execution_attempted?.should eq(true)
+      expect(example_command.execution_attempted?).to eq(true)
     end
   end
 
   describe "success?" do
     it "is false before execution" do
-      example_command.should_not be_success
+      expect(example_command).to_not be_success
     end
 
     it "is false after execution with errors" do
       example_command.execution_attempted!
       example_command.errors.add :base, "foo"
-      example_command.success?.should eq(false)
+      expect(example_command.success?).to eq(false)
     end
 
     it "is true after execution without errors" do
       example_command.execution_attempted!
-      example_command.success?.should eq(true)
+      expect(example_command.success?).to eq(true)
     end
   end
 
@@ -219,7 +225,7 @@ describe CommandModel::Model do
     it "is a hash of all parameter name and values" do
       klass = Class.new(CommandModel::Model)
       klass.parameter :name, presence: true
-      klass.parameter :birthdate, typecast: :date, presence: true
+      klass.parameter :birthdate, convert: :date, presence: true
 
       expected = { name: "John", birthdate: Date.new(1980,1,1) }
       instance = klass.new expected
@@ -241,85 +247,16 @@ describe CommandModel::Model do
     end
   end
 
-  describe "typecast_integer" do
-    it "casts to integer when valid string" do
-      example_command.send(:typecast_integer, "42").should eq(42)
-    end
-
-    it "returns nil when invalid string" do
-      example_command.send(:typecast_integer, "asdf").should be_nil
-      example_command.send(:typecast_integer, nil).should be_nil
-      example_command.send(:typecast_integer, "").should be_nil
-      example_command.send(:typecast_integer, "0.1").should be_nil
-    end
+  it "includes type conversion errors in validations" do
+    example_command.instance_variable_get(:@type_conversion_errors)["name"] = "integer"
+    expect(example_command).to_not be_valid
+    expect(example_command.errors["name"]).to be
   end
 
-  describe "typecast_float" do
-    it "casts to float when valid string" do
-      example_command.send(:typecast_float, "42").should eq(42.0)
-      example_command.send(:typecast_float, "42.5").should eq(42.5)
-    end
-
-    it "returns nil when invalid string" do
-      example_command.send(:typecast_float, "asdf").should be_nil
-      example_command.send(:typecast_float, nil).should be_nil
-      example_command.send(:typecast_float, "").should be_nil
-    end
+  it "does not include type conversion error in validations if the attribute already has an error" do
+    invalid_example_command.instance_variable_get(:@type_conversion_errors)["name"] = "integer"
+    expect(invalid_example_command).to_not be_valid
+    expect(invalid_example_command.errors["name"]).to be
+    expect(invalid_example_command.errors["name"].find { |e| e =~ /integer/ }).to_not be
   end
-
-  describe "typecast_decimal" do
-    it "converts to BigDecimal when valid string" do
-      example_command.send(:typecast_decimal, "42").should eq(BigDecimal("42"))
-      example_command.send(:typecast_decimal, "42.5").should eq(BigDecimal("42.5"))
-    end
-
-    it "converts to BigDecimal when float" do
-      example_command.send(:typecast_decimal, 42.0).should eq(BigDecimal("42"))
-    end
-
-    it "converts to BigDecimal when int" do
-      example_command.send(:typecast_decimal, 42).should eq(BigDecimal("42"))
-    end
-
-    it "returns nil when invalid string" do
-      example_command.send(:typecast_decimal, "asdf").should be_nil
-      example_command.send(:typecast_decimal, nil).should be_nil
-      example_command.send(:typecast_decimal, "").should be_nil
-    end
-  end
-
-  describe "typecast_date" do
-    it "casts to date when valid string" do
-      example_command.send(:typecast_date, "01/01/2000").should eq(Date.civil(2000,1,1))
-      example_command.send(:typecast_date, "1/1/2000").should eq(Date.civil(2000,1,1))
-      example_command.send(:typecast_date, "2000-01-01").should eq(Date.civil(2000,1,1))
-    end
-
-    it "returns existing date unchanged" do
-      date = Date.civil(2000,1,1)
-      example_command.send(:typecast_date, date).should eq(date)
-    end
-
-    it "returns nil when invalid string" do
-      example_command.send(:typecast_date, "asdf").should be_nil
-      example_command.send(:typecast_date, nil).should be_nil
-      example_command.send(:typecast_date, "").should be_nil
-      example_command.send(:typecast_date, "3/50/1290").should be_nil
-    end
-  end
-
-  it "includes typecasting errors in validations" do
-    example_command.instance_variable_get(:@typecast_errors)["name"] = "integer"
-    example_command.should_not be_valid
-    example_command.errors["name"].should be
-  end
-
-  it "does not include typecasting error in validations if the attribute already has an error" do
-    invalid_example_command.instance_variable_get(:@typecast_errors)["name"] = "integer"
-    invalid_example_command.should_not be_valid
-    invalid_example_command.errors["name"].should be
-    invalid_example_command.errors["name"].find { |e| e =~ /integer/ }.should_not be
-  end
-
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: command_model
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Jack Christensen
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-02-14 00:00:00.000000000 Z
+date: 2023-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -16,84 +16,42 @@ dependencies:
     requirements:
     - - ">"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 11.3.0
+        version: 12.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 11.3.0
+        version: 12.3.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.1
+        version: 3.7.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.1
-- !ruby/object:Gem::Dependency
-  name: guard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.14.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.14.2
-- !ruby/object:Gem::Dependency
-  name: guard-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.1.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.1.0
-- !ruby/object:Gem::Dependency
-  name: rb-fsevent
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.10.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.10.2
+        version: 3.7.0
 description: CommandModel - when update_attributes isn't enough.
 email:
 - jack@jackchristensen.com
@@ -103,9 +61,9 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".ruby-version"
 - ".travis.yml"
 - Gemfile
-- Guardfile
 - LICENSE
 - README.md
 - Rakefile
@@ -170,18 +128,19 @@ files:
 - examples/bank/vendor/assets/javascripts/.gitkeep
 - examples/bank/vendor/assets/stylesheets/.gitkeep
 - examples/bank/vendor/plugins/.gitkeep
-- gemfiles/4.2.gemfile
 - gemfiles/5.0.gemfile
 - gemfiles/5.1.gemfile
 - lib/command_model.rb
+- lib/command_model/convert.rb
 - lib/command_model/model.rb
 - lib/command_model/version.rb
+- spec/convert_spec.rb
 - spec/model_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/JackC/command_model
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -189,20 +148,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
-signing_key: 
+rubygems_version: 3.4.1
+signing_key:
 specification_version: 4
 summary: CommandModel integrates Rails validations with command objects. This allows
   errors from command execution to easily be handled with the familiar Rails validation
   system.
 test_files:
+- spec/convert_spec.rb
 - spec/model_spec.rb
 - spec/spec_helper.rb

data/Guardfile

@@ -1,9 +0,0 @@
-# A sample Guardfile
-# More info at https://github.com/guard/guard#readme
-
-guard 'rspec', :version => 2 do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/command_model/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { "spec" }
-end
-

data/gemfiles/4.2.gemfile

@@ -1,5 +0,0 @@
-source "https://rubygems.org"
-
-gem "activemodel", "~> 4.2.0"
-
-gemspec :path=>"../"