subroutine 0.5.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 51dd4d01f29eee0ec20fedb8cd5fc0de95ce73db
-  data.tar.gz: 8dad3a9f2520e5512c2132a56ed75867f9c4b4fa
+  metadata.gz: 388f424f1515f93ce602dd4b6578288733a0c7e8
+  data.tar.gz: 8514ac581bf6afa707d12801a45f017833cd3e2b
 SHA512:
-  metadata.gz: bedcc9b19e8e29542920bfb858a2022440d99486b85da42f9d7aed895487e24fc249bfc379301f5e07f7348af769a0e3dced6873746c030bd51b117d3c2b4e23
-  data.tar.gz: 49c40b9764b62942b64623b1891fb1626e6c6756d627b99c3fa10f62f8d1f7c792a55286fbcedf4ee5ad3d969387e67303fcfb982fe0519f077bdf6d0c76026d
+  metadata.gz: e008b4415a368b7df088f4049cf08714951fdce842c53c9ddd11c31401ded7e2cc42997325a62012f753adeca942765d86c0f33df6fa1fc4534471a9512b432a
+  data.tar.gz: cf77b24680e08978e7b927c7b4999da80b72bbcd9247811052ed4d7eca49ec32f79c7db3750159dcb3718d7cab9b8ac37b9ab7647f6e04e85d306ab98016a91b

data/lib/subroutine/op.rb

@@ -3,16 +3,14 @@ require 'active_support/core_ext/object/duplicable'
 require 'active_support/core_ext/object/deep_dup'
 require 'active_model'
 
-require "subroutine/failure"
-require "subroutine/type_caster"
-require "subroutine/filtered_errors"
-require "subroutine/output_not_set_error"
-require "subroutine/unknown_output_error"
+require 'subroutine/failure'
+require 'subroutine/type_caster'
+require 'subroutine/filtered_errors'
+require 'subroutine/output_not_set_error'
+require 'subroutine/unknown_output_error'
 
 module Subroutine
-
   class Op
-
     include ::ActiveModel::Model
     include ::ActiveModel::Validations::Callbacks
 
@@ -21,9 +19,7 @@ module Subroutine
     }.freeze
 
     class << self
-
-      ::Subroutine::TypeCaster::TYPES.values.flatten.each do |caster|
-
+      ::Subroutine::TypeCaster.casters.each_key do |caster|
         next if method_defined?(caster)
 
         class_eval <<-EV, __FILE__, __LINE__ + 1
@@ -46,15 +42,12 @@ module Subroutine
           _field(f, options)
         end
       end
-
-      alias_method :fields, :field
+      alias fields field
 
       def outputs(*names)
         options = names.extract_options!
         names.each do |name|
-          self._outputs = self._outputs.merge({
-            name.to_sym => DEFAULT_OUTPUT_OPTIONS.merge(options)
-          })
+          self._outputs = _outputs.merge(name.to_sym => DEFAULT_OUTPUT_OPTIONS.merge(options))
 
           class_eval <<-EV, __FILE__, __LINE__ + 1
             def #{name}
@@ -69,7 +62,7 @@ module Subroutine
           _ignore_errors(f)
         end
       end
-      alias_method :ignore_errors, :ignore_error
+      alias ignore_errors ignore_error
 
       def inputs_from(*ops)
         options = ops.extract_options!
@@ -98,7 +91,6 @@ module Subroutine
         child._error_ignores = self._error_ignores.dup
       end
 
-
       def submit!(*args)
         op = new(*args)
         op.submit!
@@ -115,23 +107,21 @@ module Subroutine
       protected
 
       def _field(field_name, options = {})
-        self._fields[field_name.to_sym] = options
+        _fields[field_name.to_sym] = options
 
         if options[:aka]
           Array(options[:aka]).each do |as|
-            self._error_map[as.to_sym] = field_name.to_sym
+            _error_map[as.to_sym] = field_name.to_sym
           end
         end
 
-        if options[:ignore_errors]
-          _ignore_errors(field_name)
-        end
+        _ignore_errors(field_name) if options[:ignore_errors]
 
         class_eval <<-EV, __FILE__, __LINE__ + 1
 
           def #{field_name}=(v)
             config = #{field_name}_config
-            v = type_caster.cast(v, config[:type])
+            v = ::Subroutine::TypeCaster.cast(v, config[:type])
             @params["#{field_name}"] = v
           end
 
@@ -140,7 +130,7 @@ module Subroutine
           end
 
           def #{field_name}_config
-            self._fields[:#{field_name}]
+            _fields[:#{field_name}]
           end
 
         EV
@@ -148,7 +138,7 @@ module Subroutine
       end
 
       def _ignore_errors(field_name)
-        self._error_ignores[field_name.to_sym] = true
+        _error_ignores[field_name.to_sym] = true
       end
 
     end
@@ -234,10 +224,6 @@ module Subroutine
 
     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
@@ -251,17 +237,11 @@ module Subroutine
       yield
     end
 
-
     def validate_and_perform
-      bool = observe_validation do
-        valid?
-      end
-
+      bool = observe_validation{ valid? }
       return false unless bool
 
-      observe_perform do
-        perform
-      end
+      observe_perform{ perform }
     end
 
     # implement this in your concrete class.
@@ -271,7 +251,7 @@ module Subroutine
 
     # check if a specific field was provided
     def field_provided?(key)
-      @params.has_key?(key)
+      @params.key?(key)
     end
 
     # applies the errors in error_object to self
@@ -281,30 +261,27 @@ module Subroutine
 
       error_object.each do |k,v|
 
-        next if self._error_ignores[k.to_sym]
+        next if _error_ignores[k.to_sym]
 
-        if respond_to?("#{k}")
+        if respond_to?(k)
           errors.add(k, v)
-        elsif self._error_map[k.to_sym]
-          errors.add(self._error_map[k.to_sym], v)
+        elsif _error_map[k.to_sym]
+          errors.add(_error_map[k.to_sym], 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 sanitize_params(inputs)
       out = {}.with_indifferent_access
-      self._fields.each_pair do |field, config|
-        if inputs.has_key?(field)
-          out[field] = type_caster.cast(inputs[field], config[:type])
-        end
+      _fields.each_pair do |field, config|
+        next unless inputs.key?(field)
+        out[field] = ::Subroutine::TypeCaster.cast(inputs[field], config[:type])
       end
 
       out
@@ -313,23 +290,20 @@ module Subroutine
     def sanitize_defaults
       defaults = {}.with_indifferent_access
 
-      self._fields.each_pair do |field, config|
-        unless config[:default].nil?
-          deflt = config[:default]
-          if deflt.respond_to?(:call)
-            deflt = deflt.call
-          elsif deflt.duplicable? # from active_support
-            # Some classes of default values need to be duplicated, or the instance field value will end up referencing
-            # the class global default value, and potentially modify it.
-            deflt = deflt.deep_dup # from active_support
-          end
-          defaults[field] = type_caster.cast(deflt, config[:type])
+      _fields.each_pair do |field, config|
+        next if config[:default].nil?
+        deflt = config[:default]
+        if deflt.respond_to?(:call)
+          deflt = deflt.call
+        elsif deflt.duplicable? # from active_support
+          # Some classes of default values need to be duplicated, or the instance field value will end up referencing
+          # the class global default value, and potentially modify it.
+          deflt = deflt.deep_dup # from active_support
         end
+        defaults[field] = ::Subroutine::TypeCaster.cast(deflt, config[:type])
       end
 
       defaults
     end
-
   end
-
 end

data/lib/subroutine/type_caster.rb

@@ -6,128 +6,97 @@ require 'active_support/core_ext/object/try'
 require 'active_support/core_ext/array/wrap'
 
 module Subroutine
-  class TypeCaster
+  module TypeCaster
 
+    def casters
+      @casters ||= {}
+    end
+    module_function :casters
 
-    TYPES = {
-      :integer => [:int, :integer, :epoch],
-      :number => [:number, :float],
-      :decimal => [:decimal, :big_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, :to_i)
-      when *TYPES[:number]
-        cast_number(value, :to_f)
-      when *TYPES[:decimal]
-        cast_number(value, :to_d, :to_f)
-      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
+    def register(*names, &block)
+      names.each do |n|
+        casters[n] = block
       end
     end
+    module_function :register
 
-    protected
-
-    def cast_number(value, *meths)
-      return nil if value.blank?
-      meth = meths.detect{|m| value.respond_to?(m) }
-      meth ? value.send(meth) : value
-    end
+    def cast(value, type, *args)
+      return value if value.nil? || type.nil?
 
-    def cast_string(value)
-      String(value)
+      caster = casters[type]
+      caster ? caster.call(value, *args) : value
     end
+    module_function :cast
 
-    def cast_boolean(value)
-      !!(cast_string(value) =~ /^(yes|true|1|ok)$/)
-    end
+  end
+end
 
-    def cast_time(value)
-      return nil unless value.present?
-      ::Time.parse(cast_string(value))
-    end
+Subroutine::TypeCaster.register :number do |value, *meths|
+  next nil if value.blank?
+  meth = meths.detect{|m| value.respond_to?(m) }
+  meth ? value.send(meth) : value.to_f
+end
 
-    def cast_date(value)
-      return nil unless value.present?
-      ::Date.parse(cast_string(value))
-    end
+Subroutine::TypeCaster.register :integer, :int, :epoch do |value|
+  Subroutine::TypeCaster.cast(value, :number, :to_i)
+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
+Subroutine::TypeCaster.register :decimal, :big_decimal do |value|
+  Subroutine::TypeCaster.cast(value, :number, :to_d, :to_f)
+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
+Subroutine::TypeCaster.register :string, :text do |value|
+  String(value)
+end
 
-    def cast_hash(value)
-      _cast_hash(value).try(:stringify_keys)
-    end
+Subroutine::TypeCaster.register :boolean, :bool do |value|
+  !!(String(value) =~ /^(yes|true|1|ok)$/)
+end
 
-    def _cast_hash(value)
-      return _cast_action_controller_query_params(value) if is_action_controller_query_params?(value)
-      return value if value.is_a?(Hash)
-      return {} if value.blank?
-      return value.to_hash if value.respond_to?(:to_hash)
-      return value.to_h if value.respond_to?(:to_h)
-      return ::Hash[value.to_a] if value.respond_to?(:to_a)
-      {}
-    end
+Subroutine::TypeCaster.register :iso_date do |value|
+  next nil unless value.present?
+  d = nil
+  d ||= value if value.is_a?(::Date)
+  d ||= value if value.try(:acts_like?, :date)
+  d ||= ::Date.parse(String(value))
+  d.iso8601
+end
 
-    def _cast_action_controller_query_params(value)
-      value = value.to_hash
-      value.each_pair{|k,v| value[k] = _cast_action_controller_query_params(v) if is_action_controller_query_params?(v) }
-      value
-    end
+Subroutine::TypeCaster.register :iso_time do |value|
+  next nil unless value.present?
+  t = nil
+  t ||= value if value.is_a?(::Time)
+  t ||= value if value.try(:acts_like?, :time)
+  t ||= ::Time.parse(String(value))
+  t.utc.iso8601
+end
 
-    def is_action_controller_query_params?(value)
-      value.class.name == "ActionController::Parameters"
-    end
+Subroutine::TypeCaster.register :date do |value|
+  next nil unless value.present?
+  ::Date.parse(String(value))
+end
 
-    def cast_array(value)
-      return [] if value.blank?
-      ::Array.wrap(value)
-    end
+Subroutine::TypeCaster.register :time, :timestamp, :datetime do |value|
+  next nil unless value.present?
+  ::Time.parse(String(value))
+end
 
+Subroutine::TypeCaster.register :hash, :object, :hashmap, :dict do |value|
+  if value.class.name == 'ActionController::Parameters'
+    value = value.to_hash
+    value.each_pair { |k, v| value[k] = Subroutine::TypeCaster.cast(v, :hash) if v.class.name == 'ActionController::Parameters' }
+    next value
   end
+
+  next value if value.is_a?(Hash)
+  next {} if value.blank?
+  next value.to_hash if value.respond_to?(:to_hash)
+  next value.to_h if value.respond_to?(:to_h)
+  next ::Hash[value.to_a] if value.respond_to?(:to_a)
+  {}
+end
+
+Subroutine::TypeCaster.register :array do |value|
+  next [] if value.blank?
+  ::Array.wrap(value)
 end

data/lib/subroutine/version.rb

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

data/test/support/ops.rb

@@ -119,7 +119,6 @@ class TypeCastOp < ::Subroutine::Op
   iso_time :iso_time_input
   object :object_input
   array :array_input, :default => 'foo'
-
 end
 
 class OpWithAuth < ::Subroutine::Op

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: subroutine
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Mike Nelson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-23 00:00:00.000000000 Z
+date: 2018-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel