subroutine 0.6.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37b6c047ab472cc0e240f78a2fe4998b5a5eb7b1316e2ee16eebe0e335db2986
-  data.tar.gz: ad505a2fd476b71972bce1426f7235b2f5e6577a258a696771c1fb105b744063
+  metadata.gz: 7416fb00f0a0322ec831337e3afaf019d21cc83f4573afa13e8485a64ffb8e7c
+  data.tar.gz: 0d40d5a0843b57c35e046ecfcaedcbf4471386ec64a01577723c8717d98ebdc1
 SHA512:
-  metadata.gz: 0b05231e05c2e1eb6153f489b25e24b5499d2bf6fdb2ef7cbd2e814dc3ffa50f50966d49fb21f3a0b71158856574e89fab59a01b330d76152767a084b7622877
-  data.tar.gz: dbde52dda2095ee0f29b7c7ca35e5305d45e698120ed2f0d3ffd51612e8cf21bf9bd0b82fa1a1d1dfcae708bf3e4a337856108d554d096d6c42253828b73fe1c
+  metadata.gz: 449ff84a202510087c5ab59a6f1809d1b59a1ec77f7e496fb37a6d93369bd5f1a1589fb102bc739763f3c1f3a74614558bb2c70d2ba17448f7df3398a2b1b498
+  data.tar.gz: 6e779574462dc657ce38422a094c556bcf36171698f8c02e165ce850e8aef0e79a7030e1c614332965efc4399c1fc7f8cbd33dc7570d7c92b8e8b5bb562f36a1

data/lib/subroutine/association.rb

@@ -1,18 +1,16 @@
+# frozen_string_literal: true
+
 module Subroutine
   module Association
-
     def self.included(base)
       base.send :extend, ::Subroutine::Association::ClassMethods
       class << base
         alias_method :field_without_associations, :field
         alias_method :field, :field_with_associations
       end
-
     end
 
     module ClassMethods
-
-
       def field_with_associations(*args)
         opts = args.extract_options!
         if opts[:association]
@@ -47,9 +45,8 @@ module Subroutine
       # - unscoped => set true if the record should be looked up via Type.unscoped
 
       def association(field, options = {})
-
         if options[:as] && options[:foreign_key]
-          raise ArgumentError.new(":as and :foreign_key options should be provided together to an association invocation")
+          raise ArgumentError, ':as and :foreign_key options should be provided together to an association invocation'
         end
 
         class_name = options[:class_name]
@@ -61,13 +58,12 @@ module Subroutine
         klass = class_name.to_s if class_name
 
         foreign_key_method = (options[:foreign_key] || "#{field}_id").to_s
-        foreign_type_method = foreign_key_method.gsub(/_id$/, "_type")
-
+        foreign_type_method = foreign_key_method.gsub(/_id$/, '_type')
 
         if poly
           string foreign_type_method
         else
-          class_eval <<-EV, __FILE__, __LINE__+1
+          class_eval <<-EV, __FILE__, __LINE__ + 1
             def #{foreign_type_method}
               #{as.to_s.camelize.inspect}
             end
@@ -78,7 +74,7 @@ module Subroutine
 
         field_without_associations as, options.merge(association: true)
 
-        class_eval <<-EV, __FILE__, __LINE__+1
+        class_eval <<-EV, __FILE__, __LINE__ + 1
           def #{as}_with_association
             return @#{as} if defined?(@#{as})
             @#{as} = begin
@@ -89,7 +85,7 @@ module Subroutine
 
           def #{as}_with_association=(r)
             @#{as} = r
-            #{poly || klass ? "params['#{foreign_type_method}'] = r.nil? ? nil : #{klass.nil? ? "r.class.name" : klass.to_s.inspect}" : ""}
+            #{poly || klass ? "params['#{foreign_type_method}'] = r.nil? ? nil : #{klass.nil? ? 'r.class.name' : klass.to_s.inspect}" : ''}
             params['#{foreign_key_method}'] = r.nil? ? nil : r.id
             r
           end
@@ -100,16 +96,16 @@ module Subroutine
 
         alias_method :"#{as}_without_association=", :"#{as}="
         alias_method :"#{as}=", :"#{as}_with_association="
-
       end
     end
 
     def initialize(*args)
       super(*args)
 
-      self._fields.each_pair do |field, config|
+      _fields.each_pair do |field, config|
         next unless config[:association]
-        next unless @original_params.has_key?(field)
+        next unless @original_params.key?(field)
+
         send("#{field}=", @original_params[field]) # this gets the _id and _type into the params hash
       end
     end
@@ -127,6 +123,5 @@ module Subroutine
 
       scope.find(_id)
     end
-
   end
 end

data/lib/subroutine/auth.rb

@@ -1,23 +1,22 @@
+# frozen_string_literal: true
+
 module Subroutine
   module Auth
-
     class NotAuthorizedError < ::StandardError
-
       def initialize(msg = nil)
-        msg = I18n.t("errors.#{msg}", default: "Sorry, you are not authorized to perform this action.") if msg.is_a?(Symbol)
-        msg ||= I18n.t('errors.unauthorized', default: "Sorry, you are not authorized to perform this action.")
+        msg = I18n.t("errors.#{msg}", default: 'Sorry, you are not authorized to perform this action.') if msg.is_a?(Symbol)
+        msg ||= I18n.t('errors.unauthorized', default: 'Sorry, you are not authorized to perform this action.')
         super msg
       end
 
       def status
         401
       end
-
     end
 
     class AuthorizationNotDeclaredError < ::StandardError
       def initialize(msg = nil)
-        super(msg || "Authorization management has not been declared on this class")
+        super(msg || 'Authorization management has not been declared on this class')
       end
     end
 
@@ -30,9 +29,7 @@ module Subroutine
       end
     end
 
-
     module ClassMethods
-
       def authorize(validation_name)
         validate validation_name, unless: :skip_auth_checks?
       end
@@ -66,7 +63,7 @@ module Subroutine
         policy_name = opts[:policy] || :policy
 
         if_conditionals = Array(opts[:if])
-        unless_conditionals = Array( opts[:unless])
+        unless_conditionals = Array(opts[:unless])
 
         validate unless: :skip_auth_checks? do
           run_it = true
@@ -84,17 +81,16 @@ module Subroutine
 
           next unless run_it
 
-          p = self.send(policy_name)
-          if !p || meths.any?{|m| !(p.respond_to?("#{m}?") ? p.send("#{m}?") : p.send(m)) }
+          p = send(policy_name)
+          if !p || meths.any? { |m| !(p.respond_to?("#{m}?") ? p.send("#{m}?") : p.send(m)) }
             unauthorized! opts[:error]
           end
         end
       end
-
     end
 
     def initialize(*args)
-      raise Subroutine::Auth::AuthorizationNotDeclaredError.new if(!self.class.authorization_declared)
+      raise Subroutine::Auth::AuthorizationNotDeclaredError unless self.class.authorization_declared
 
       super(args.extract_options!)
       @skip_auth_checks = false
@@ -117,8 +113,7 @@ module Subroutine
 
     def unauthorized!(reason = nil)
       reason ||= :unauthorized
-      raise ::Subroutine::Auth::NotAuthorizedError.new(reason)
+      raise ::Subroutine::Auth::NotAuthorizedError, reason
     end
-
   end
 end

data/lib/subroutine/failure.rb

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

data/lib/subroutine/filtered_errors.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module Subroutine
   class FilteredErrors < SimpleDelegator
-
     def add(*args)
       return if __getobj__.instance_variable_get('@base')._error_ignores[args[0].to_sym]
+
       __getobj__.add(*args)
     end
-
   end
 end

data/lib/subroutine/op.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/object/duplicable'
 require 'active_support/core_ext/object/deep_dup'
@@ -86,9 +88,9 @@ module Subroutine
 
       def inherited(child)
         super
-        child._fields = self._fields.dup
-        child._error_map = self._error_map.dup
-        child._error_ignores = self._error_ignores.dup
+        child._fields = _fields.dup
+        child._error_map = _error_map.dup
+        child._error_ignores = _error_ignores.dup
       end
 
       def submit!(*args)
@@ -121,7 +123,7 @@ module Subroutine
 
           def #{field_name}=(v)
             config = #{field_name}_config
-            v = ::Subroutine::TypeCaster.cast(v, config[:type])
+            v = ::Subroutine::TypeCaster.cast(v, config)
             @params["#{field_name}"] = v
           end
 
@@ -134,16 +136,13 @@ module Subroutine
           end
 
         EV
-
       end
 
       def _ignore_errors(field_name)
         _error_ignores[field_name.to_sym] = true
       end
-
     end
 
-
     class_attribute :_outputs
     self._outputs = {}
 
@@ -159,9 +158,8 @@ module Subroutine
     attr_reader :original_params
     attr_reader :params, :defaults
 
-
     def initialize(inputs = {})
-      @original_params  = inputs.with_indifferent_access
+      @original_params = inputs.with_indifferent_access
       @params = sanitize_params(@original_params)
       @defaults = sanitize_defaults
       @outputs = {}
@@ -173,13 +171,13 @@ module Subroutine
 
     def output(name, value)
       unless _outputs.key?(name.to_sym)
-        raise ::Subroutine::UnknownOutputError.new(name)
+        raise ::Subroutine::UnknownOutputError, name
       end
+
       @outputs[name.to_sym] = value
     end
 
     def submit!
-
       begin
         observe_submission do
           validate_and_perform
@@ -197,13 +195,13 @@ module Subroutine
       if errors.empty?
         _outputs.each_pair do |name, config|
           if config[:required] && !@outputs.key?(name)
-            raise ::Subroutine::OutputNotSetError.new(name)
+            raise ::Subroutine::OutputNotSetError, name
           end
         end
 
         true
       else
-        raise ::Subroutine::Failure.new(self)
+        raise ::Subroutine::Failure, self
       end
     end
 
@@ -239,10 +237,10 @@ module Subroutine
     end
 
     def validate_and_perform
-      bool = observe_validation{ valid? }
+      bool = observe_validation { valid? }
       return false unless bool
 
-      observe_perform{ perform }
+      observe_perform { perform }
     end
 
     # implement this in your concrete class.
@@ -260,8 +258,7 @@ module Subroutine
     def inherit_errors(error_object)
       error_object = error_object.errors if error_object.respond_to?(:errors)
 
-      error_object.each do |k,v|
-
+      error_object.each do |k, v|
         next if _error_ignores[k.to_sym]
 
         if respond_to?(k)
@@ -269,7 +266,7 @@ module Subroutine
         elsif _error_map[k.to_sym]
           errors.add(_error_map[k.to_sym], v)
         else
-          errors.add(:base, error_object.full_message(k,v))
+          errors.add(:base, error_object.full_message(k, v))
         end
       end
 
@@ -282,7 +279,8 @@ module Subroutine
       out = {}.with_indifferent_access
       _fields.each_pair do |field, config|
         next unless inputs.key?(field)
-        out[field] = ::Subroutine::TypeCaster.cast(inputs[field], config[:type])
+
+        out[field] = ::Subroutine::TypeCaster.cast(inputs[field], config)
       end
 
       out
@@ -293,6 +291,7 @@ module Subroutine
 
       _fields.each_pair do |field, config|
         next if config[:default].nil?
+
         deflt = config[:default]
         if deflt.respond_to?(:call)
           deflt = deflt.call
@@ -301,7 +300,7 @@ module Subroutine
           # 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])
+        defaults[field] = ::Subroutine::TypeCaster.cast(deflt, config)
       end
 
       defaults

data/lib/subroutine/output_not_set_error.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module Subroutine
   class OutputNotSetError < StandardError
     def initialize(name)
       super("Expected output '#{name}' to be set upon completion of perform but was not.")
     end
   end
-
 end

data/lib/subroutine/type_caster.rb

@@ -1,60 +1,63 @@
+# frozen_string_literal: true
+
 require 'date'
 require 'time'
 require 'bigdecimal'
+require 'securerandom'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/object/try'
 require 'active_support/core_ext/array/wrap'
 
 module Subroutine
   module TypeCaster
-
-    def casters
+    def self.casters
       @casters ||= {}
     end
-    module_function :casters
 
-    def register(*names, &block)
+    def self.register(*names, &block)
       names.each do |n|
         casters[n] = block
       end
     end
-    module_function :register
 
-    def cast(value, type, *args)
+    def self.cast(value, options = {})
+      type = options[:type]
       return value if value.nil? || type.nil?
 
       caster = casters[type]
-      caster ? caster.call(value, *args) : value
-    end
-    module_function :cast
+      return value unless caster
 
+      caster.call(value, options)
+    end
   end
 end
 
-Subroutine::TypeCaster.register :number, :float do |value, *meths|
+::Subroutine::TypeCaster.register :number, :float do |value, options = {}|
   next nil if value.blank?
-  meth = meths.detect{|m| value.respond_to?(m) }
+
+  meth = (options[:methods] || []).detect { |m| value.respond_to?(m) }
   meth ? value.send(meth) : value.to_f
 end
 
-Subroutine::TypeCaster.register :integer, :int, :epoch do |value|
-  Subroutine::TypeCaster.cast(value, :number, :to_i)
+::Subroutine::TypeCaster.register :integer, :int, :epoch do |value, _options = {}|
+  ::Subroutine::TypeCaster.cast(value, type: :number, methods: [:to_i])
 end
 
-Subroutine::TypeCaster.register :decimal, :big_decimal do |value|
-  Subroutine::TypeCaster.cast(value, :number, :to_d, :to_f)
+::Subroutine::TypeCaster.register :decimal, :big_decimal do |value, _options = {}|
+  ::Subroutine::TypeCaster.cast(value, type: :number, methods: [:to_d, :to_f])
 end
 
-Subroutine::TypeCaster.register :string, :text do |value|
+::Subroutine::TypeCaster.register :string, :text do |value, _options = {}|
   String(value)
 end
 
-Subroutine::TypeCaster.register :boolean, :bool do |value|
+::Subroutine::TypeCaster.register :boolean, :bool do |value, _options = {}|
   !!(String(value) =~ /^(yes|true|1|ok)$/)
 end
 
-Subroutine::TypeCaster.register :iso_date do |value|
+::Subroutine::TypeCaster.register :iso_date do |value, _options = {}|
   next nil unless value.present?
+
   d = nil
   d ||= value if value.is_a?(::Date)
   d ||= value if value.try(:acts_like?, :date)
@@ -62,8 +65,9 @@ Subroutine::TypeCaster.register :iso_date do |value|
   d.iso8601
 end
 
-Subroutine::TypeCaster.register :iso_time do |value|
+::Subroutine::TypeCaster.register :iso_time do |value, _options = {}|
   next nil unless value.present?
+
   t = nil
   t ||= value if value.is_a?(::Time)
   t ||= value if value.try(:acts_like?, :time)
@@ -71,20 +75,24 @@ Subroutine::TypeCaster.register :iso_time do |value|
   t.utc.iso8601
 end
 
-Subroutine::TypeCaster.register :date do |value|
+::Subroutine::TypeCaster.register :date do |value, _options = {}|
   next nil unless value.present?
+
   ::Date.parse(String(value))
 end
 
-Subroutine::TypeCaster.register :time, :timestamp, :datetime do |value|
+::Subroutine::TypeCaster.register :time, :timestamp, :datetime do |value, _options = {}|
   next nil unless value.present?
+
   ::Time.parse(String(value))
 end
 
-Subroutine::TypeCaster.register :hash, :object, :hashmap, :dict do |value|
+::Subroutine::TypeCaster.register :hash, :object, :hashmap, :dict do |value, _options = {}|
   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' }
+    value.each_pair do |k, v|
+      value[k] = ::Subroutine::TypeCaster.cast(v, type: :hash) if v.class.name == 'ActionController::Parameters'
+    end
     next value
   end
 
@@ -93,10 +101,28 @@ Subroutine::TypeCaster.register :hash, :object, :hashmap, :dict do |value|
   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|
+::Subroutine::TypeCaster.register :array do |value, options = {}|
   next [] if value.blank?
-  ::Array.wrap(value)
+
+  out = ::Array.wrap(value)
+  out = out.map { |v| ::Subroutine::TypeCaster.cast(v, type: options[:of]) } if options[:of]
+  out
+end
+
+::Subroutine::TypeCaster.register :file do |value, options = {}|
+  next nil if value.blank?
+
+  next value if defined?(::Tempfile) && value.is_a?(::Tempfile)
+  next value if value.is_a?(::File)
+
+  value = ::Base64.decode64(value) if options[:base64]
+
+  ::Tempfile.new(SecureRandom.hex).tap do |f|
+    f.write(value)
+    f.rewind
+  end
 end

data/lib/subroutine/unknown_output_error.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module Subroutine
   class UnknownOutputError < StandardError
     def initialize(name)
       super("Unknown output '#{name}'")
     end
   end
-
 end

data/lib/subroutine/version.rb

@@ -1,10 +1,10 @@
-module Subroutine
+# frozen_string_literal: true
 
+module Subroutine
   MAJOR = 0
-  MINOR = 6
-  PATCH = 3
+  MINOR = 7
+  PATCH = 0
   PRE   = nil
 
   VERSION = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
-
 end

data/lib/subroutine.rb

@@ -1,2 +1,4 @@
-require "subroutine/version"
-require "subroutine/op"
+# frozen_string_literal: true
+
+require 'subroutine/version'
+require 'subroutine/op'

data/test/subroutine/association_test.rb

@@ -1,19 +1,20 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module Subroutine
   class AuthTest < TestCase
-
     def doug
-      @doug ||= ::User.new(id: 1, email_address: "doug@example.com")
+      @doug ||= ::User.new(id: 1, email_address: 'doug@example.com')
     end
 
     def fred
-      @fred ||= ::User.new(id: 2, email_address: "fred@example.com")
+      @fred ||= ::User.new(id: 2, email_address: 'fred@example.com')
     end
 
     def test_it_sets_accessors_on_init
       op = SimpleAssociationOp.new user: doug
-      assert_equal "User", op.user_type
+      assert_equal 'User', op.user_type
       assert_equal doug.id, op.user_id
     end
 
@@ -23,7 +24,7 @@ module Subroutine
       ::User.expects(:all).returns(all_mock)
       all_mock.expects(:find).with(1).returns(doug)
 
-      op = SimpleAssociationOp.new user_type: "User", user_id: doug.id
+      op = SimpleAssociationOp.new user_type: 'User', user_id: doug.id
       assert_equal doug, op.user
     end
 
@@ -33,7 +34,7 @@ module Subroutine
       ::User.expects(:all).returns(all_mock)
       all_mock.expects(:find).with(1).returns(doug)
 
-      op = SimpleAssociationOp.new user_type: "users", user_id: doug.id
+      op = SimpleAssociationOp.new user_type: 'users', user_id: doug.id
       assert_equal doug, op.user
     end
 
@@ -45,7 +46,7 @@ module Subroutine
       all_mock.expects(:unscoped).returns(unscoped_mock)
       unscoped_mock.expects(:find).with(1).returns(doug)
 
-      op = UnscopedSimpleAssociationOp.new user_type: "User", user_id: doug.id
+      op = UnscopedSimpleAssociationOp.new user_type: 'User', user_id: doug.id
       assert_equal doug, op.user
     end
 
@@ -55,13 +56,13 @@ module Subroutine
       ::AdminUser.expects(:all).returns(all_mock)
       all_mock.expects(:find).with(1).returns(doug)
 
-      op = PolymorphicAssociationOp.new(admin_type: "AdminUser", admin_id: doug.id)
+      op = PolymorphicAssociationOp.new(admin_type: 'AdminUser', admin_id: doug.id)
       assert_equal doug, op.admin
     end
 
     def test_it_allows_the_class_to_be_set
       op = ::AssociationWithClassOp.new(admin: doug)
-      assert_equal "AdminUser", op.admin_type
+      assert_equal 'AdminUser', op.admin_type
     end
 
     def test_it_inherits_associations_via_inputs_from
@@ -70,9 +71,9 @@ module Subroutine
       ::User.expects(:all).returns(all_mock)
       all_mock.expects(:find).with(1).returns(doug)
 
-      op = ::InheritedSimpleAssociation.new(user_type: "User", user_id: doug.id)
+      op = ::InheritedSimpleAssociation.new(user_type: 'User', user_id: doug.id)
       assert_equal doug, op.user
-      assert_equal "User", op.user_type
+      assert_equal 'User', op.user_type
       assert_equal doug.id, op.user_id
     end
 
@@ -84,9 +85,9 @@ module Subroutine
       all_mock.expects(:unscoped).returns(unscoped_mock)
       unscoped_mock.expects(:find).with(1).returns(doug)
 
-      op = ::InheritedUnscopedAssociation.new(user_type: "User", user_id: doug.id)
+      op = ::InheritedUnscopedAssociation.new(user_type: 'User', user_id: doug.id)
       assert_equal doug, op.user
-      assert_equal "User", op.user_type
+      assert_equal 'User', op.user_type
       assert_equal doug.id, op.user_id
     end
 
@@ -96,11 +97,10 @@ module Subroutine
       ::AdminUser.expects(:all).returns(all_mock)
       all_mock.expects(:find).with(1).returns(doug)
 
-      op = ::InheritedPolymorphicAssociationOp.new(admin_type: "AdminUser", admin_id: doug.id)
+      op = ::InheritedPolymorphicAssociationOp.new(admin_type: 'AdminUser', admin_id: doug.id)
       assert_equal doug, op.admin
-      assert_equal "AdminUser", op.admin_type
+      assert_equal 'AdminUser', op.admin_type
       assert_equal doug.id, op.admin_id
     end
-
   end
 end