subroutine 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab045b5fde4a639699ed15240b6549dd909454da
-  data.tar.gz: 56ac432123c26d31a5265c304fce0c6268dab892
+  metadata.gz: 55319d241f3bd11613cff48ead9bae0355dfe8fa
+  data.tar.gz: 147c53874dfa950fb987b31b4b9742f0f3a7e7f1
 SHA512:
-  metadata.gz: bebe659c3d84427adbacbe3bc0bffecfcfef2155cd6c4497a530f820d0198c43e2f899933b32c82ec21f678d2d021f1a0fd4f50524ef1faf9793247185f2253a
-  data.tar.gz: 6e561078a1f08f1159f25ee590ad5cdeff1d185aba711f36ec0ef4ac0263f8ae79715e557d84b7ee3ebe318cc74f93de65676ac82986913d11fb738a9092113d
+  metadata.gz: 697e9e97d7161ac52db1c226ffa7f4e665d90d3c4f1b1fe58c1ae6e6d98555ae1a82538985b6b85c8690a4eef7385e74530068f054417cd34c45ff40a9a4f46c
+  data.tar.gz: 72303c67318d9aba48903ed4cf6ea9595adf22004f5af775f59a1df9d0082d08af1ed6954cd19b165d288669e58802b3ab1a391c30c0f36272d0e50e55e08d0f

data/.gitignore

@@ -12,3 +12,4 @@
 *.o
 *.a
 mkmf.log
+*.gem

data/README.md

@@ -1,6 +1,6 @@
 # Subroutine
 
-A gem that provides an interface for creating feature-driven operations. It loosly implements the command pattern if you're interested in nerding out a bit. See the examples below, it'll be more clear.
+A gem that provides an interface for creating feature-driven operations. It loosely implements the command pattern if you're interested in nerding out a bit. See the examples below, it'll be more clear.
 
 ## Examples
 
@@ -114,7 +114,7 @@ end
 
 ## Usage
 
-Both the `Subroutine::Op` class and it's instances provide `submit` and `submit!` methods with identical signatures. Here are ways to invoke an op:
+The `Subroutine::Op` class' `submit` and `submit!` methods have the same signature as the class' constructor, enabling a few different ways to utilize an op. Here they are:
 
 #### Via the class' `submit` method
 

data/lib/subroutine/failure.rb

@@ -0,0 +1,12 @@
+module Subroutine
+
+  class Failure < StandardError
+    attr_reader :record
+    def initialize(record)
+      @record = record
+      errors = @record.errors.full_messages.join(", ")
+      super(errors)
+    end
+  end
+
+end

data/lib/subroutine/op.rb

@@ -0,0 +1,222 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_model'
+
+require "subroutine/failure"
+require "subroutine/type_caster"
+
+module Subroutine
+
+  class Op
+
+    include ::ActiveModel::Model
+    include ::ActiveModel::Validations::Callbacks
+
+    class << self
+
+      ::Subroutine::TypeCaster::TYPES.values.flatten.each do |caster|
+
+        next if method_defined?(caster)
+
+        class_eval <<-EV, __FILE__, __LINE__ + 1
+          def #{caster}(*args)
+            options = args.extract_options!
+            options[:type] = #{caster.inspect}
+            args.push(options)
+            field(*args)
+          end
+        EV
+      end
+
+      # fields can be provided in the following way:
+      # field :field1, :field2
+      # field :field3, :field4, default: 'my default'
+      def field(*fields)
+        options = fields.extract_options!
+
+        fields.each do |f|
+          _field(f, options)
+        end
+      end
+
+      alias_method :fields, :field
+
+
+      def inputs_from(*ops)
+        ops.each do |op|
+          op._fields.each_pair do |field_name, options|
+            field(field_name, options)
+          end
+        end
+      end
+
+      def inherited(child)
+        super
+        child._fields = self._fields.dup
+      end
+
+
+      def submit!(*args)
+        op = new(*args)
+        op.submit!
+
+        op
+      end
+
+      def submit(*args)
+        op = new(*args)
+        op.submit
+        op
+      end
+
+      protected
+
+      def _field(field_name, options = {})
+        self._fields[field_name.to_sym] = options
+
+        class_eval <<-EV, __FILE__, __LINE__ + 1
+
+          def #{field_name}=(v)
+            config = #{field_name}_config
+            @#{field_name} = type_caster.cast(v, config[:type])
+          end
+
+          def #{field_name}
+            return @#{field_name} if defined?(@#{field_name})
+            config = #{field_name}_config
+            deflt = config[:default]
+            deflt = deflt.call if deflt.respond_to?(:call)
+            type_caster.cast(deflt, config[:type])
+          end
+
+          def #{field_name}_config
+            self._fields[:#{field_name}]
+          end
+
+        EV
+
+      end
+
+    end
+
+
+    class_attribute :_fields
+    self._fields = {}
+
+    attr_reader :original_params
+    attr_reader :params
+
+
+    def initialize(inputs = {})
+      @original_params  = inputs.with_indifferent_access
+      @params           = {}
+    end
+
+
+    def submit!
+      unless submit
+        raise ::Subroutine::Failure.new(self)
+      end
+      true
+    end
+
+    # the action which should be invoked upon form submission (from the controller)
+    def submit
+      observe_submission do
+        @params = filter_params(@original_params)
+
+        set_accessors(@params)
+
+        validate_and_perform
+      end
+
+    rescue Exception => e
+
+      if e.respond_to?(:record)
+        inherit_errors_from(e.record) unless e.record == self
+        false
+      else
+        raise e
+      end
+    end
+
+    protected
+
+    def type_caster
+      @type_caster ||= ::Subroutine::TypeCaster.new
+    end
+
+    # these enable you to 1) add log output or 2) add performance monitoring such as skylight.
+    def observe_submission
+      yield
+    end
+
+    def observe_validation
+      yield
+    end
+
+    def observe_perform
+      yield
+    end
+
+
+    def validate_and_perform
+      bool = observe_validation do
+        valid?
+      end
+
+      return false unless bool
+
+      observe_perform do
+        perform
+      end
+    end
+
+    # implement this in your concrete class.
+    def perform
+      raise NotImplementedError
+    end
+
+    # check if a specific field was provided
+    def field_provided?(key)
+      @params.has_key?(key)
+    end
+
+    # applies the errors to the form object from the child object
+    def inherit_errors_from(object)
+      inherit_errors(object.errors)
+    end
+
+
+    # applies the errors in error_object to self
+    # returns false so failure cases can end with this invocation
+    def inherit_errors(error_object)
+      error_object.each do |k,v|
+
+        if respond_to?("#{k}")
+          errors.add(k, v)
+        else
+          errors.add(:base, error_object.full_message(k,v))
+        end
+
+      end
+
+      false
+    end
+
+
+    # if you want to use strong parameters or something in your form object you can do so here.
+    # by default we just slice the inputs to the defined fields
+    def filter_params(inputs)
+      inputs.slice(*_fields.keys)
+    end
+
+
+    def set_accessors(inputs)
+      inputs.each do |key, value|
+        send("#{key}=", value) if respond_to?("#{key}=")
+      end
+    end
+
+  end
+
+end

data/lib/subroutine/type_caster.rb

@@ -0,0 +1,117 @@
+require 'date'
+require 'time'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/array/wrap'
+
+module Subroutine
+  class TypeCaster
+
+
+    TYPES = {
+      :integer => [:int, :integer, :epoch],
+      :number => [:number, :float, :decimal],
+      :string => [:string, :text],
+      :boolean => [:bool, :boolean],
+      :iso_date => [:iso_date],
+      :iso_time => [:iso_time],
+      :date => [:date],
+      :time => [:time, :timestamp],
+      :hash => [:object, :hashmap, :dict],
+      :array => [:array]
+    }
+
+
+    def cast(value, type)
+      return value if value.nil? || type.nil?
+
+      case type.to_sym
+      when *TYPES[:integer]
+        cast_number(value).try(:to_i)
+      when *TYPES[:number]
+        cast_number(value)
+      when *TYPES[:string]
+        cast_string(value)
+      when *TYPES[:boolean]
+        cast_boolean(value)
+      when *TYPES[:iso_date]
+        t = cast_iso_time(value)
+        t ? t.split('T')[0] : t
+      when *TYPES[:date]
+        cast_date(value).try(:to_date)
+      when *TYPES[:iso_time]
+        cast_iso_time(value)
+      when *TYPES[:time]
+        cast_time(value)
+      when *TYPES[:hash]
+        cast_hash(value)
+      when *TYPES[:array]
+        cast_array(value)
+      else
+        value
+      end
+    end
+
+    protected
+
+    def cast_number(value)
+      val = cast_string(value).strip
+      return nil if val.blank?
+      val.to_f
+    end
+
+    def cast_string(value)
+      String(value)
+    end
+
+    def cast_boolean(value)
+      !!(cast_string(value) =~ /^(yes|true|1|ok)$/)
+    end
+
+    def cast_time(value)
+      return nil unless value.present?
+      ::Time.parse(cast_string(value))
+    end
+
+    def cast_date(value)
+      return nil unless value.present?
+      ::Date.parse(cast_string(value))
+    end
+
+    def cast_iso_time(value)
+      return nil unless value.present?
+      t = nil
+      t ||= value if value.is_a?(::Time)
+      t ||= value if value.try(:acts_like?, :time)
+      t ||= ::Time.parse(cast_string(value))
+      t.utc.iso8601
+    end
+
+    def cast_iso_date(value)
+      return nil unless value.present?
+      d = nil
+      d ||= value if value.is_a?(::Date)
+      d ||= value if value.try(:acts_like?, :date)
+      d ||= ::Date.parse(cast_string(value))
+      d.iso8601
+    end
+
+    def cast_hash(value)
+      _cast_hash(value).try(:stringify_keys)
+    end
+
+    def _cast_hash(value)
+      return value if value.is_a?(Hash)
+      return {} if value.blank?
+      return value.to_h if value.respond_to?(:to_h)
+      return ::Hash[value.to_a] if value.respond_to?(:to_a)
+      {}
+    end
+
+    def cast_array(value)
+      return [] if value.blank?
+      ::Array.wrap(value)
+    end
+
+  end
+end

data/lib/subroutine/version.rb

@@ -1,8 +1,8 @@
 module Subroutine
 
   MAJOR = 0
-  MINOR = 0
-  PATCH = 1
+  MINOR = 1
+  PATCH = 0
   PRE   = nil
 
   VERSION = [MAJOR, MINOR, PATCH, PRE].compact.join('.')

data/lib/subroutine.rb

@@ -1,243 +1,2 @@
 require "subroutine/version"
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_model'
-
-module Subroutine
-
-  class Failure < StandardError
-    attr_reader :record
-    def initialize(record)
-      @record = record
-      errors = @record.errors.full_messages.join(", ")
-      super(errors)
-    end
-  end
-
-  class Op
-
-    include ::ActiveModel::Model
-    include ::ActiveModel::Validations::Callbacks
-
-    class << self
-
-      # fields can be provided in the following way:
-      # field :field1, :field2
-      # field :field3, :field4, default: 'my default'
-      # field field5: 'field5 default', field6: 'field6 default'
-      def field(*fields)
-        last_hash = fields.extract_options!
-        options   = last_hash.slice(:default, :scope)
-
-        fields << last_hash.except(:default, :scope)
-
-        fields.each do |f|
-
-          if f.is_a?(Hash)
-            f.each do |k,v|
-              field(k, options.merge(:default => v))
-            end
-          else
-
-            _field(f, options)
-          end
-        end
-
-      end
-      alias_method :fields, :field
-
-
-      def inputs_from(*ops)
-        ops.each do |op|
-          field(*op._fields)
-          defaults(op._defaults)
-          error_map(op._error_map)
-        end
-      end
-
-
-      def default(pairs)
-        self._defaults.merge!(pairs.stringify_keys)
-      end
-      alias_method :defaults, :default
-
-
-      def error_map(map)
-        self._error_map.merge!(map)
-      end
-      alias_method :error_maps, :error_map
-
-
-      def inherited(child)
-        super
-
-        child._fields     = []
-        child._defaults   = {}
-        child._error_map  = {}
-
-        child._fields      |= self._fields
-        child._defaults.merge!(self._defaults)
-        child._error_map.merge!(self._error_map)
-      end
-
-
-      def submit!(*args)
-        op = new(*args)
-        op.submit!
-
-        op
-      end
-
-      def submit(*args)
-        op = new(*args)
-        op.submit
-        op
-      end
-
-      protected
-
-      def _field(field_name, options = {})
-        field = [options[:scope], field_name].compact.join('_')
-        self._fields += [field]
-
-        attr_accessor field
-
-        default(field => options[:default]) if options[:default]
-      end
-
-    end
-
-
-    class_attribute :_fields
-    self._fields = []
-    class_attribute :_defaults
-    self._defaults = {}
-    class_attribute :_error_map
-    self._error_map = {}
-
-    attr_reader :original_params
-    attr_reader :params
-
-
-    def initialize(inputs = {})
-      @original_params  = inputs.with_indifferent_access
-      @params           = {}
-
-      self.class._defaults.each do |k,v|
-        self.send("#{k}=", v.respond_to?(:call) ? v.call : v)
-      end
-    end
-
-
-    def submit!
-      unless submit
-        raise ::Subroutine::Failure.new(self)
-      end
-      true
-    end
-
-    # the action which should be invoked upon form submission (from the controller)
-    def submit
-      observe_submission do
-        @params = filter_params(@original_params)
-
-        set_accessors(@params)
-
-        validate_and_perform
-      end
-
-    rescue Exception => e
-      if e.respond_to?(:record)
-        inherit_errors_from(e.record) unless e.record == self
-        false
-      else
-        raise e
-      end
-    end
-
-    protected
-
-    # these enable you to 1) add log output or 2) add performance monitoring such as skylight.
-    def observe_submission
-      yield
-    end
-
-    def observe_validation
-      yield
-    end
-
-    def observe_perform
-      yield
-    end
-
-
-    def validate_and_perform
-      bool = observe_validation do
-        valid?
-      end
-      return false unless bool
-
-      observe_perform do
-        perform
-      end
-    end
-
-    # implement this in your concrete class.
-    def perform
-      raise NotImplementedError
-    end
-
-    def field_provided?(key)
-      @params.has_key?(key)
-    end
-
-
-    # applies the errors to the form object from the child object, optionally at the namespace provided
-    def inherit_errors_from(object, namespace = nil)
-      inherit_errors(object.errors, namespace)
-    end
-
-
-    # applies the errors in error_object to self, optionally at the namespace provided
-    # returns false so failure cases can end with this invocation
-    def inherit_errors(error_object, namespace = nil)
-      error_object.each do |k,v|
-
-        keys  = [k, [namespace, k].compact.join('_')].map(&:to_sym).uniq
-        keys  = keys.map{|key| _error_map[key] || key }
-
-        match = keys.detect{|key| self.respond_to?(key) || @original_params.try(:has_key?, key) }
-
-        if match
-          errors.add(match, v)
-        else
-          errors.add(:base, error_object.full_message(k, v))
-        end
-
-      end
-
-      false
-    end
-
-
-    # if you want to use strong parameters or something in your form object you can do so here.
-    def filter_params(inputs)
-      inputs.slice(*_fields)
-    end
-
-
-    def set_accessors(inputs, namespace = nil)
-      inputs.each do |key, value|
-
-        setter = [namespace, key].compact.join('_')
-
-        if respond_to?("#{setter}=") && _fields.include?(setter)
-          send("#{setter}=", value)
-        elsif value.is_a?(Hash)
-          set_accessors(value, setter)
-        end
-      end
-    end
-
-  end
-
-end
+require "subroutine/op"

data/test/subroutine/base_test.rb

@@ -5,12 +5,12 @@ module Subroutine
 
     def test_simple_fields_definition
       op = ::SignupOp.new
-      assert_equal ['email', 'password'], op._fields
+      assert_equal [:email, :password], op._fields.keys.sort
     end
 
     def test_inherited_fields
       op = ::AdminSignupOp.new
-      assert_equal ['email', 'password', 'priveleges'], op._fields
+      assert_equal [:email, :password, :priveleges], op._fields.keys.sort
     end
 
     def test_class_attribute_usage
@@ -20,45 +20,28 @@ module Subroutine
       bid = ::AdminSignupOp._fields.object_id
 
       refute_equal sid, bid
-
-      sid = ::SignupOp._defaults.object_id
-      bid = ::AdminSignupOp._defaults.object_id
-
-      refute_equal sid, bid
-
-      sid = ::SignupOp._error_map.object_id
-      bid = ::AdminSignupOp._error_map.object_id
-
-      refute_equal sid, bid
-
     end
 
     def test_inputs_from_inherited_fields_without_inheriting_from_the_class
       refute ::BusinessSignupOp < ::SignupOp
 
-      ::SignupOp._fields.each do |field|
-        assert_includes ::BusinessSignupOp._fields, field
-      end
+      user_fields = ::SignupOp._fields.keys
+      biz_fields = ::BusinessSignupOp._fields.keys
 
-      ::SignupOp._defaults.each_pair do |k,v|
-        assert_equal v, ::BusinessSignupOp._defaults[k]
-      end
-
-      ::SignupOp._error_map.each_pair do |k,v|
-        assert_equal v, ::BusinessSignupOp._error_map[k]
+      user_fields.each do |field|
+        assert_includes biz_fields, field
       end
     end
 
     def test_defaults_declaration_options
-      assert_equal ::DefaultsOp._defaults, {
-        'foo' => 'foo',
-        'baz' => 'baz',
-        'bar' => 'bar'
-      }
+      op = ::DefaultsOp.new
+      assert_equal 'foo', op.foo
+      assert_equal 'bar', op.bar
     end
 
     def test_inherited_defaults_override_correctly
-      assert_equal 'barstool', ::InheritedDefaultsOp._defaults['bar']
+      op = ::InheritedDefaultsOp.new
+      assert_equal 'barstool', op.bar
     end
 
     def test_accessors_are_created
@@ -87,6 +70,9 @@ module Subroutine
       assert_nil op.email
       assert_nil op.password
       assert_equal 'min', op.priveleges
+
+      op.priveleges = 'max'
+      assert_equal 'max', op.priveleges
     end
 
     def test_validations_are_evaluated_before_perform_is_invoked
@@ -107,7 +93,7 @@ module Subroutine
       assert op.perform_called
       refute op.perform_finished
 
-      assert_equal ["has gotta be @admin.com"], op.errors[:email]
+      assert_equal ["Email address has gotta be @admin.com"], op.errors[:base]
     end
 
     def test_when_valid_perform_completes_it_returns_control

data/test/subroutine/type_caster_test.rb

@@ -0,0 +1,224 @@
+require 'test_helper'
+
+module Subroutine
+  class TypeCasterTest < TestCase
+
+    def op
+      @op ||= TypeCastOp.new
+    end
+
+    def test_integer_inputs
+      op.integer_input = nil
+      assert_equal nil, op.integer_input
+
+      op.integer_input = 'foo'
+      assert_equal 0, op.integer_input
+
+      op.integer_input = '4.5'
+      assert_equal 4, op.integer_input
+
+      op.integer_input = 0.5
+      assert_equal 0, op.integer_input
+
+      op.integer_input = 5.2
+      assert_equal 5, op.integer_input
+
+      op.integer_input = 6
+      assert_equal 6, op.integer_input
+    end
+
+    def test_number_inputs
+      op.number_input = nil
+      assert_equal nil, op.number_input
+
+      op.number_input = 4
+      assert_equal 4.0, op.number_input
+
+      op.number_input = 0.5
+      assert_equal 0.5, op.number_input
+
+      op.number_input = 'foo'
+      assert_equal 0.0, op.number_input
+    end
+
+    def test_string_inputs
+      op.string_input = nil
+      assert_equal nil, op.string_input
+
+      op.string_input = ""
+      assert_equal '', op.string_input
+
+      op.string_input = "foo"
+      assert_equal 'foo', op.string_input
+
+      op.string_input = 4
+      assert_equal '4', op.string_input
+
+      op.string_input = 4.2
+      assert_equal '4.2', op.string_input
+    end
+
+    def test_boolean_inputs
+      op.boolean_input = nil
+      assert_equal nil, op.boolean_input
+
+      op.boolean_input = 'yes'
+      assert_equal true, op.boolean_input
+
+      op.boolean_input = 'no'
+      assert_equal false, op.boolean_input
+
+      op.boolean_input = 'true'
+      assert_equal true, op.boolean_input
+
+      op.boolean_input = 'false'
+      assert_equal false, op.boolean_input
+
+      op.boolean_input = 'ok'
+      assert_equal true, op.boolean_input
+
+      op.boolean_input = ''
+      assert_equal false, op.boolean_input
+
+      op.boolean_input = true
+      assert_equal true, op.boolean_input
+
+      op.boolean_input = false
+      assert_equal false, op.boolean_input
+
+      op.boolean_input = '1'
+      assert_equal true, op.boolean_input
+
+      op.boolean_input = '0'
+      assert_equal false, op.boolean_input
+
+      op.boolean_input = 1
+      assert_equal true, op.boolean_input
+
+      op.boolean_input = 0
+      assert_equal false, op.boolean_input
+    end
+
+    def test_hash_inputs
+      op.object_input = nil
+      assert_equal nil, op.object_input
+
+      op.object_input = ''
+      assert_equal({}, op.object_input)
+
+      op.object_input = [[:a,:b]]
+      assert_equal({"a" => :b}, op.object_input)
+
+      op.object_input = false
+      assert_equal({}, op.object_input)
+
+      op.object_input = {foo: 'bar'}
+      assert_equal({'foo' => 'bar'}, op.object_input)
+
+      op.object_input = {"foo" => {:bar => :baz}}
+      assert_equal({"foo" => {:bar => :baz}}, op.object_input)
+    end
+
+    def test_array_inputs
+      op.array_input = nil
+      assert_equal nil, op.array_input
+
+      op.array_input = ''
+      assert_equal [], op.array_input
+
+      op.array_input = 'foo'
+      assert_equal ['foo'], op.array_input
+
+      op.array_input = ['foo']
+      assert_equal ['foo'], op.array_input
+
+      op.array_input = {:bar => true}
+      assert_equal [{:bar => true}], op.array_input
+    end
+
+    def test_date_inputs
+      op.date_input = nil
+      assert_equal nil, op.date_input
+
+      op.date_input = "2022-12-22"
+      assert_equal ::Date, op.date_input.class
+      refute_equal ::DateTime, op.date_input.class
+
+      assert_equal 2022, op.date_input.year
+      assert_equal 12, op.date_input.month
+      assert_equal 22, op.date_input.day
+
+      op.date_input = "2023-05-05T10:00:30"
+      assert_equal ::Date, op.date_input.class
+      refute_equal ::DateTime, op.date_input.class
+
+      assert_equal 2023, op.date_input.year
+      assert_equal 5, op.date_input.month
+      assert_equal 5, op.date_input.day
+
+      op.date_input = "2020-05-03 13:44:45 -0400"
+
+      assert_equal ::Date, op.date_input.class
+      refute_equal ::DateTime, op.date_input.class
+
+      assert_equal 2020, op.date_input.year
+      assert_equal 5, op.date_input.month
+      assert_equal 3, op.date_input.day
+    end
+
+
+    def test_time_inputs
+      op.time_input = nil
+      assert_equal nil, op.time_input
+
+      op.time_input = "2022-12-22"
+      assert_equal ::Time, op.time_input.class
+      refute_equal ::DateTime, op.time_input.class
+
+      assert_equal 2022, op.time_input.year
+      assert_equal 12, op.time_input.month
+      assert_equal 22, op.time_input.day
+      assert_equal 0, op.time_input.hour
+      assert_equal 0, op.time_input.min
+      assert_equal 0, op.time_input.sec
+
+      op.time_input = "2023-05-05T10:00:30Z"
+      assert_equal ::Time, op.time_input.class
+      refute_equal ::DateTime, op.time_input.class
+
+      assert_equal 2023, op.time_input.year
+      assert_equal 5, op.time_input.month
+      assert_equal 5, op.time_input.day
+      assert_equal 10, op.time_input.hour
+      assert_equal 0, op.time_input.min
+      assert_equal 30, op.time_input.sec
+    end
+
+    def test_iso_date_inputs
+      op.iso_date_input = nil
+      assert_equal nil, op.iso_date_input
+
+      op.iso_date_input = "2022-12-22"
+      assert_equal ::String, op.iso_date_input.class
+      assert_equal "2022-12-22", op.iso_date_input
+
+      op.iso_date_input = Date.parse("2022-12-22")
+      assert_equal ::String, op.iso_date_input.class
+      assert_equal "2022-12-22", op.iso_date_input
+    end
+
+    def test_iso_time_inputs
+      op.iso_time_input = nil
+      assert_equal nil, op.iso_time_input
+
+      op.iso_time_input = "2022-12-22T10:30:24Z"
+      assert_equal ::String, op.iso_time_input.class
+      assert_equal "2022-12-22T10:30:24Z", op.iso_time_input
+
+      op.iso_time_input = Time.parse("2022-12-22T10:30:24Z")
+      assert_equal ::String, op.iso_time_input.class
+      assert_equal "2022-12-22T10:30:24Z", op.iso_time_input
+    end
+
+  end
+end

data/test/support/ops.rb

@@ -18,14 +18,12 @@ end
 
 class SignupOp < ::Subroutine::Op
 
-  field :email
-  field :password
+  string :email
+  string :password
 
   validates :email, :presence => true
   validates :password, :presence => true
 
-  error_map :email_address => :email
-
   attr_reader :perform_called
   attr_reader :perform_finished
 
@@ -74,7 +72,7 @@ end
 
 class BusinessSignupOp < ::Subroutine::Op
 
-  field :business_name
+  string :business_name
   inputs_from ::SignupOp
 
 end
@@ -82,16 +80,27 @@ end
 class DefaultsOp < ::Subroutine::Op
 
   field :foo, :default => 'foo'
-
-  field baz: 'baz'
-
-  field :bar
-  default :bar => 'bar'
+  field :bar, :default => 'bar'
 
 end
 
 class InheritedDefaultsOp < ::DefaultsOp
 
-  default :bar => 'barstool'
+  field :bar, :default => 'barstool'
+
+end
+
+class TypeCastOp < ::Subroutine::Op
+
+  integer :integer_input
+  number :number_input
+  string :string_input
+  boolean :boolean_input
+  date :date_input
+  time :time_input, :default => lambda{ Time.now }
+  iso_date :iso_date_input
+  iso_time :iso_time_input
+  object :object_input
+  array :array_input, :default => 'foo'
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: subroutine
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Mike Nelson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-07 00:00:00.000000000 Z
+date: 2015-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -100,9 +100,13 @@ files:
 - gemfiles/am41.gemfile
 - gemfiles/am42.gemfile
 - lib/subroutine.rb
+- lib/subroutine/failure.rb
+- lib/subroutine/op.rb
+- lib/subroutine/type_caster.rb
 - lib/subroutine/version.rb
 - subroutine.gemspec
 - test/subroutine/base_test.rb
+- test/subroutine/type_caster_test.rb
 - test/support/ops.rb
 - test/test_helper.rb
 homepage: https://github.com/mnelson/subroutine
@@ -137,5 +141,6 @@ test_files:
 - gemfiles/am41.gemfile
 - gemfiles/am42.gemfile
 - test/subroutine/base_test.rb
+- test/subroutine/type_caster_test.rb
 - test/support/ops.rb
 - test/test_helper.rb