subroutine 0.6.3 → 0.7.0

data/test/subroutine/auth_test.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module Subroutine
   class AuthTest < TestCase
-
     def user
-      @user ||= ::User.new(email_address: "doug@example.com")
+      @user ||= ::User.new(email_address: 'doug@example.com')
     end
 
     def test_it_throws_an_error_if_authorization_is_not_defined
@@ -45,12 +46,12 @@ module Subroutine
       CustomAuthorizeOp.submit! user
 
       assert_raises ::Subroutine::Auth::NotAuthorizedError do
-        CustomAuthorizeOp.submit! User.new(email_address: "foo@bar.com")
+        CustomAuthorizeOp.submit! User.new(email_address: 'foo@bar.com')
       end
     end
 
     def test_it_does_not_run_authorizations_if_explicitly_bypassed
-      op = CustomAuthorizeOp.new User.new(email_address: "foo@bar.com")
+      op = CustomAuthorizeOp.new User.new(email_address: 'foo@bar.com')
       op.skip_auth_checks!
       op.submit!
     end
@@ -66,10 +67,10 @@ module Subroutine
     end
 
     def test_it_runs_policies_with_conditionals
-       # if: false
+      # if: false
       op = IfConditionalPolicyOp.new(user, check_policy: false)
       assert op.submit!
-       # unless: true
+      # unless: true
       op = UnlessConditionalPolicyOp.new(user, unless_check_policy: true)
       assert op.submit!
 
@@ -85,6 +86,5 @@ module Subroutine
         op.submit!
       end
     end
-
   end
 end

data/test/subroutine/base_test.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module Subroutine
   class OpTest < TestCase
-
     def test_simple_fields_definition
       op = ::SignupOp.new
       assert_equal [:email, :password], op._fields.keys.sort
@@ -35,15 +36,15 @@ module Subroutine
 
     def test_inputs_from_ignores_except_fields
       op = ::ExceptFooBarOp.new
-      refute op._fields.keys.include? :foo
-      refute op._fields.keys.include? :bar
+      refute op._fields.key?(:foo)
+      refute op._fields.key?(:bar)
       assert_equal [:baz], op._fields.keys.sort
     end
 
     def test_inputs_from_only_fields
       op = ::OnlyFooBarOp.new
-      assert op._fields.keys.include? :foo
-      assert op._fields.keys.include? :bar
+      assert op._fields.key?(:foo)
+      assert op._fields.key?(:bar)
       refute_equal [:baz], op._fields.keys.sort
     end
 
@@ -101,18 +102,18 @@ module Subroutine
     end
 
     def test_validation_errors_can_be_inherited_and_transformed
-      op = ::AdminSignupOp.new(:email => 'foo@bar.com', :password => 'password123')
+      op = ::AdminSignupOp.new(email: 'foo@bar.com', password: 'password123')
 
       refute op.submit
 
       assert op.perform_called
       refute op.perform_finished
 
-      assert_equal ["has gotta be @admin.com"], op.errors[:email]
+      assert_equal ['has gotta be @admin.com'], op.errors[:email]
     end
 
     def test_when_valid_perform_completes_it_returns_control
-      op = ::SignupOp.new(:email => 'foo@bar.com', :password => 'password123')
+      op = ::SignupOp.new(email: 'foo@bar.com', password: 'password123')
       op.submit!
 
       assert op.perform_called
@@ -124,7 +125,7 @@ module Subroutine
     end
 
     def test_it_raises_an_error_when_used_with_a_bang_and_performing_or_validation_fails
-      op = ::SignupOp.new(:email => 'foo@bar.com')
+      op = ::SignupOp.new(email: 'foo@bar.com')
 
       err = assert_raises ::Subroutine::Failure do
         op.submit!
@@ -146,9 +147,8 @@ module Subroutine
         SignupOp.submit!
       end
 
-      op = SignupOp.submit! :email => 'foo@bar.com', :password => 'password123'
+      op = SignupOp.submit! email: 'foo@bar.com', password: 'password123'
       assert_equal 'foo@bar.com', op.created_user.email_address
-
     end
 
     def test_it_ignores_specific_errors
@@ -159,87 +159,87 @@ module Subroutine
     def test_it_does_not_inherit_ignored_errors
       op = ::WhateverSignupOp.new
       other = ::SignupOp.new
-      other.errors.add(:whatever, "fail")
+      other.errors.add(:whatever, 'fail')
       op.send(:inherit_errors, other)
       assert_equal [], op.errors[:whatever]
     end
 
     def test_it_sets_the_params_and_defaults_immediately
-      op = ::AdminSignupOp.new(email: "foo")
+      op = ::AdminSignupOp.new(email: 'foo')
       assert_equal({
-        "email" => "foo"
-      }, op.params)
+                     'email' => 'foo'
+                   }, op.params)
 
       assert_equal({
-        "privileges" => "min",
-      }, op.defaults)
+                     'privileges' => 'min'
+                   }, op.defaults)
 
       assert_equal({
-        "email" => "foo",
-        "privileges" => "min",
-      }, op.params_with_defaults)
+                     'email' => 'foo',
+                     'privileges' => 'min'
+                   }, op.params_with_defaults)
     end
 
     def test_it_allows_defaults_to_be_overridden
-      op = ::AdminSignupOp.new(email: "foo", privileges: nil)
+      op = ::AdminSignupOp.new(email: 'foo', privileges: nil)
 
       assert_equal({
-        "email" => "foo",
-        "privileges" => nil
-      }, op.params)
+                     'email' => 'foo',
+                     'privileges' => nil
+                   }, op.params)
 
       assert_equal({
-        "privileges" => "min",
-      }, op.defaults)
+                     'privileges' => 'min'
+                   }, op.defaults)
 
       assert_equal({
-        "email" => "foo",
-        "privileges" => nil,
-      }, op.params_with_defaults)
+                     'email' => 'foo',
+                     'privileges' => nil
+                   }, op.params_with_defaults)
     end
 
     def test_it_overriding_default_does_not_alter_default
-      op = ::AdminSignupOp.new(email: "foo")
-      op.privileges << "bangbang"
+      op = ::AdminSignupOp.new(email: 'foo')
+      op.privileges << 'bangbang'
 
-      op = ::AdminSignupOp.new(email: "foo", privileges: nil)
+      op = ::AdminSignupOp.new(email: 'foo', privileges: nil)
 
       assert_equal({
-                     "email" => "foo",
-                     "privileges" => nil
+                     'email' => 'foo',
+                     'privileges' => nil
                    }, op.params)
 
       assert_equal({
-                     "privileges" => "min",
+                     'privileges' => 'min'
                    }, op.defaults)
 
       assert_equal({
-                     "email" => "foo",
-                     "privileges" => nil,
+                     'email' => 'foo',
+                     'privileges' => nil
                    }, op.params_with_defaults)
     end
 
     def test_it_overrides_defaults_with_nils
-      op = ::AdminSignupOp.new(email: "foo", privileges: nil)
+      op = ::AdminSignupOp.new(email: 'foo', privileges: nil)
       assert_equal({
-        "privileges" => nil,
-        "email" => "foo"
-      }, op.params)
+                     'privileges' => nil,
+                     'email' => 'foo'
+                   }, op.params)
     end
 
     def test_it_casts_params_on_the_way_in
-      op = ::TypeCastOp.new(integer_input: "25")
-      assert_equal(25, op.params_with_defaults["integer_input"])
+      op = ::TypeCastOp.new(integer_input: '25')
+      assert_equal(25, op.params_with_defaults['integer_input'])
 
-      op.decimal_input = "25.3"
-      assert_equal(BigDecimal("25.3"), op.params_with_defaults["decimal_input"])
+      op.decimal_input = '25.3'
+      assert_equal(BigDecimal('25.3'), op.params_with_defaults['decimal_input'])
     end
 
     def test_it_allow_retrival_of_outputs
-      op = ::SignupOp.submit!(:email => 'foo@bar.com', :password => 'password123')
+      op = ::SignupOp.submit!(email: 'foo@bar.com', password: 'password123')
       u = op.created_user
 
-      assert_equal "foo@bar.com", u.email_address
+      assert_equal 'foo@bar.com', u.email_address
     end
 
     def test_it_raises_an_error_if_an_output_is_not_defined_but_is_set
@@ -272,12 +272,11 @@ module Subroutine
         op.submit!
       rescue Exception => e
         found = e.backtrace.detect do |msg|
-          msg =~ /test\/support\/ops\.rb:[\d]+.+foo/
+          msg =~ %r{test/support/ops\.rb:[\d]+.+foo}
         end
 
-        refute_nil found, "Expected backtrace to include original caller of foo"
+        refute_nil found, 'Expected backtrace to include original caller of foo'
       end
     end
-
   end
 end

data/test/subroutine/type_caster_test.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module Subroutine
   class TypeCasterTest < TestCase
-
     def op
       @op ||= TypeCastOp.new
     end
@@ -45,10 +46,10 @@ module Subroutine
       op.string_input = nil
       assert_nil op.string_input
 
-      op.string_input = ""
-      assert_equal '', op.string_input
+      op.string_input = "
+      assert_equal ", op.string_input
 
-      op.string_input = "foo"
+      op.string_input = 'foo'
       assert_equal 'foo', op.string_input
 
       op.string_input = 4
@@ -106,17 +107,17 @@ module Subroutine
       op.object_input = ''
       assert_equal({}, op.object_input)
 
-      op.object_input = [[:a,:b]]
-      assert_equal({"a" => :b}, 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' }
+      assert_equal({ 'foo' => 'bar' }, op.object_input)
 
-      op.object_input = {"foo" => {"bar" => :baz}}
-      assert_equal({"foo" => {"bar" => :baz}}, op.object_input)
+      op.object_input = { 'foo' => { 'bar' => :baz } }
+      assert_equal({ 'foo' => { 'bar' => :baz } }, op.object_input)
     end
 
     def test_array_inputs
@@ -132,15 +133,29 @@ module Subroutine
       op.array_input = ['foo']
       assert_equal ['foo'], op.array_input
 
-      op.array_input = {"bar" => true}
-      assert_equal [{"bar" => true}], op.array_input
+      op.array_input = { 'bar' => true }
+      assert_equal [{ 'bar' => true }], op.array_input
+    end
+
+    def test_typed_array_inputs
+      op.type_array_input = nil
+      assert_nil op.type_array_input
+
+      op.type_array_input = ''
+      assert_equal [], op.type_array_input
+
+      op.type_array_input = '3'
+      assert_equal [3], op.type_array_input
+
+      op.type_array_input = ['3.4']
+      assert_equal [3], op.type_array_input
     end
 
     def test_date_inputs
       op.date_input = nil
       assert_nil op.date_input
 
-      op.date_input = "2022-12-22"
+      op.date_input = '2022-12-22'
       assert_equal ::Date, op.date_input.class
       refute_equal ::DateTime, op.date_input.class
 
@@ -148,7 +163,7 @@ module Subroutine
       assert_equal 12, op.date_input.month
       assert_equal 22, op.date_input.day
 
-      op.date_input = "2023-05-05T10:00:30"
+      op.date_input = '2023-05-05T10:00:30'
       assert_equal ::Date, op.date_input.class
       refute_equal ::DateTime, op.date_input.class
 
@@ -156,7 +171,7 @@ module Subroutine
       assert_equal 5, op.date_input.month
       assert_equal 5, op.date_input.day
 
-      op.date_input = "2020-05-03 13:44:45 -0400"
+      op.date_input = '2020-05-03 13:44:45 -0400'
 
       assert_equal ::Date, op.date_input.class
       refute_equal ::DateTime, op.date_input.class
@@ -169,12 +184,11 @@ module Subroutine
       assert_nil op.date_input
     end
 
-
     def test_time_inputs
       op.time_input = nil
       assert_nil op.time_input
 
-      op.time_input = "2022-12-22"
+      op.time_input = '2022-12-22'
       assert_equal ::Time, op.time_input.class
       refute_equal ::DateTime, op.time_input.class
 
@@ -185,7 +199,7 @@ module Subroutine
       assert_equal 0, op.time_input.min
       assert_equal 0, op.time_input.sec
 
-      op.time_input = "2023-05-05T10:00:30Z"
+      op.time_input = '2023-05-05T10:00:30Z'
       assert_equal ::Time, op.time_input.class
       refute_equal ::DateTime, op.time_input.class
 
@@ -201,41 +215,55 @@ module Subroutine
       op.iso_date_input = nil
       assert_nil op.iso_date_input
 
-      op.iso_date_input = "2022-12-22"
+      op.iso_date_input = '2022-12-22'
       assert_equal ::String, op.iso_date_input.class
-      assert_equal "2022-12-22", op.iso_date_input
+      assert_equal '2022-12-22', op.iso_date_input
 
-      op.iso_date_input = Date.parse("2022-12-22")
+      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
+      assert_equal '2022-12-22', op.iso_date_input
     end
 
     def test_iso_time_inputs
       op.iso_time_input = nil
       assert_nil op.iso_time_input
 
-      op.iso_time_input = "2022-12-22T10:30:24Z"
+      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
+      assert_equal '2022-12-22T10:30:24Z', op.iso_time_input
 
-      op.iso_time_input = Time.parse("2022-12-22T10:30:24Z")
+      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
+      assert_equal '2022-12-22T10:30:24Z', op.iso_time_input
+    end
+
+    def test_file_inputs
+      op.file_input = nil
+      assert_nil op.file_input
+
+      op.file_input = File.new(__FILE__)
+      assert_equal ::File, op.file_input.class
+
+      op.file_input = 'foobarbaz'
+      assert_equal ::Tempfile, op.file_input.class
+      assert_equal 'foobarbaz', op.file_input.read
+    ensure
+      op.file_input.close
+      op.file_input.unlink
     end
 
     def test_field_provided
-      op = ::SignupOp.new()
+      op = ::SignupOp.new
       assert_equal false, op.send(:field_provided?, :email)
 
-      op = ::SignupOp.new(email: "foo")
+      op = ::SignupOp.new(email: 'foo')
       assert_equal true, op.send(:field_provided?, :email)
 
-      op = ::DefaultsOp.new()
+      op = ::DefaultsOp.new
       assert_equal false, op.send(:field_provided?, :foo)
 
-      op = ::DefaultsOp.new(foo: "foo")
+      op = ::DefaultsOp.new(foo: 'foo')
       assert_equal true, op.send(:field_provided?, :foo)
     end
-
   end
 end

data/test/support/ops.rb

@@ -1,5 +1,7 @@
-require "subroutine/auth"
-require "subroutine/association"
+# frozen_string_literal: true
+
+require 'subroutine/auth'
+require 'subroutine/association'
 
 ## Models ##
 
@@ -10,23 +12,21 @@ class User
   attr_accessor :email_address
   attr_accessor :password
 
-  validates :email_address, :presence => true
+  validates :email_address, presence: true
 end
 
 class AdminUser < ::User
-  validates :email_address, :format => {:with => /@admin\.com/, :message => 'has gotta be @admin.com'}
+  validates :email_address, format: { with: /@admin\.com/, message: 'has gotta be @admin.com' }
 end
 
-
 ## Ops ##
 
 class SignupOp < ::Subroutine::Op
-
-  string :email, :aka => :email_address
+  string :email, aka: :email_address
   string :password
 
-  validates :email, :presence => true
-  validates :password, :presence => true
+  validates :email, presence: true
+  validates :password, presence: true
 
   outputs :perform_called
   outputs :perform_finished
@@ -66,42 +66,37 @@ class WhateverSignupOp < ::SignupOp
 end
 
 class AdminSignupOp < ::SignupOp
-
-  field :privileges, :default => 'min'
+  field :privileges, default: 'min'
 
   protected
 
   def user_class
     ::AdminUser
   end
-
 end
 
 class BusinessSignupOp < ::Subroutine::Op
-
   string :business_name
 
   inputs_from ::SignupOp
 end
 
 class DefaultsOp < ::Subroutine::Op
-
-  field :foo, :default => 'foo'
-  field :bar, :default => 'bar'
-  field :baz, :default => false
-
+  field :foo, default: 'foo'
+  field :bar, default: 'bar'
+  field :baz, default: false
 end
 
 class ExceptFooBarOp < ::Subroutine::Op
-  inputs_from ::DefaultsOp, except: %i[foo bar]
+  inputs_from ::DefaultsOp, except: [:foo, :bar]
 end
 
 class OnlyFooBarOp < ::Subroutine::Op
-  inputs_from ::DefaultsOp, only: %i[foo bar]
+  inputs_from ::DefaultsOp, only: [:foo, :bar]
 end
 
 class InheritedDefaultsOp < ::DefaultsOp
-  field :bar, :default => 'barstool'
+  field :bar, default: 'barstool'
 end
 
 class TypeCastOp < ::Subroutine::Op
@@ -111,11 +106,13 @@ class TypeCastOp < ::Subroutine::Op
   string :string_input
   boolean :boolean_input
   date :date_input
-  time :time_input, :default => lambda{ Time.now }
+  time :time_input, default: -> { Time.now }
   iso_date :iso_date_input
   iso_time :iso_time_input
   object :object_input
-  array :array_input, :default => 'foo'
+  array :array_input, default: 'foo'
+  array :type_array_input, of: :integer
+  file :file_input
 end
 
 class OpWithAuth < ::Subroutine::Op
@@ -141,21 +138,17 @@ class NoUserRequirementsOp < OpWithAuth
 end
 
 class CustomAuthorizeOp < OpWithAuth
-
   require_user!
   authorize :authorize_user_is_correct
 
   protected
 
   def authorize_user_is_correct
-    unless current_user.email_address.to_s =~ /example\.com$/
-      unauthorized!
-    end
+    unauthorized! unless current_user.email_address.to_s =~ /example\.com$/
   end
 end
 
 class PolicyOp < OpWithAuth
-
   class FakePolicy
     def user_can_access?
       false
@@ -171,7 +164,6 @@ class PolicyOp < OpWithAuth
 end
 
 class IfConditionalPolicyOp < OpWithAuth
-
   class FakePolicy
     def user_can_access?
       false
@@ -180,7 +172,7 @@ class IfConditionalPolicyOp < OpWithAuth
 
   require_user!
   boolean :check_policy
-  validates :check_policy, inclusion: { in: [true,false] }
+  validates :check_policy, inclusion: { in: [true, false] }
   policy :user_can_access?, if: :check_policy
 
   def policy
@@ -189,7 +181,6 @@ class IfConditionalPolicyOp < OpWithAuth
 end
 
 class UnlessConditionalPolicyOp < OpWithAuth
-
   class FakePolicy
     def user_can_access?
       false
@@ -198,7 +189,7 @@ class UnlessConditionalPolicyOp < OpWithAuth
 
   require_user!
   boolean :unless_check_policy
-  validates :unless_check_policy, inclusion: { in: [true,false] }
+  validates :unless_check_policy, inclusion: { in: [true, false] }
   policy :user_can_access?, unless: :unless_check_policy
 
   def policy
@@ -206,15 +197,12 @@ class UnlessConditionalPolicyOp < OpWithAuth
   end
 end
 
-
 class OpWithAssociation < ::Subroutine::Op
   include ::Subroutine::Association
 end
 
 class SimpleAssociationOp < ::OpWithAssociation
-
   association :user
-
 end
 
 class UnscopedSimpleAssociationOp < ::OpWithAssociation
@@ -226,7 +214,7 @@ class PolymorphicAssociationOp < ::OpWithAssociation
 end
 
 class AssociationWithClassOp < ::OpWithAssociation
-  association :admin, class_name: "AdminUser"
+  association :admin, class_name: 'AdminUser'
 end
 
 class InheritedSimpleAssociation < ::Subroutine::Op
@@ -249,7 +237,7 @@ end
 
 class MissingOutputOp < ::Subroutine::Op
   def perform
-    output :foo, "bar"
+    output :foo, 'bar'
   end
 end
 
@@ -270,19 +258,18 @@ end
 class NoOutputNoSuccessOp < ::Subroutine::Op
   outputs :foo
   def perform
-    errors.add(:foo, "bar")
+    errors.add(:foo, 'bar')
   end
 end
 
 class ErrorTraceOp < ::Subroutine::Op
-
   class SomeObject
     include ::ActiveModel::Model
     include ::ActiveModel::Validations::Callbacks
 
     def foo
-      errors.add(:base, "Failure of things")
-      raise Subroutine::Failure.new(self)
+      errors.add(:base, 'Failure of things')
+      raise Subroutine::Failure, self
     end
 
     def bar

data/test/test_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'subroutine'
 require 'minitest/autorun'
 require 'minitest/unit'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: subroutine
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.7.0
 platform: ruby
 authors:
 - Mike Nelson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-17 00:00:00.000000000 Z
+date: 2019-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel