subroutine 0.9.0 → 0.10.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ab6d4e06e0400af01060d41f08ba6b61695c24a
-  data.tar.gz: c6542be4a9832df325fe8f33ad33f297dfd8912c
+  metadata.gz: 0dbba6e4428e540eddcfb16df3079f0d9c2db2d2
+  data.tar.gz: bd752b132b834c5c35e07fa2434f8d381da3c385
 SHA512:
-  metadata.gz: 6331a42ddc585caf91166eb7871e96637712ff09ece5794735c525c044650cf87fb337aa36edb6bb31f084a21d6655df4198932d79b0d5f64b25c5138b34ac28
-  data.tar.gz: 6d68a2bccecfef89ea3a42689cc565a28b15a4584da2436182fa4ca8cbc25c4e4658e99022b10190622fc57387bfdbd54f028f590a66771a53d9b527f4829d76
+  metadata.gz: 439bce703b933575f763ac2aa4428e65babc620275a5ca45cae8ed255592428966867281d20f6093dea7fd2dde8fbc764d82f57dd5bc81e5e21d2562e5f94db0
+  data.tar.gz: 8e95b71122f2dcabf504c5c0f7674f12a79923175434cf65300161cc7251123b11a0f9a797889b4bd71b4a2d823921e3d6026f43e9200d8ffbb1d75f17a1a3a9

data/lib/subroutine/association.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
+require "active_support/concern"
 
 module Subroutine
   module Association
-    def self.included(base)
-      base.send :extend, ::Subroutine::Association::ClassMethods
-      class << base
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
         alias_method :field_without_associations, :field
         alias_method :field, :field_with_associations
       end
 
-      base.send(:alias_method, :setup_fields_without_association, :setup_fields)
-      base.send(:alias_method, :setup_fields, :setup_fields_with_association)
+      alias_method :setup_fields_without_association, :setup_fields
+      alias_method :setup_fields, :setup_fields_with_association
     end
 
     module ClassMethods
@@ -75,34 +77,28 @@ module Subroutine
 
         integer foreign_key_method
 
-        field_without_associations as, options.merge(association: true)
+        field_without_associations as, options.merge(association: true, field_writer: false, field_reader: false)
 
         class_eval <<-EV, __FILE__, __LINE__ + 1
-          def #{as}_with_association
+          try(:silence_redefinition_of_method, :#{as})
+          def #{as}
             return @#{as} if defined?(@#{as})
-            @#{as} = begin
-              #{as}_without_association ||
-              polymorphic_instance(#{klass.nil? ? foreign_type_method : klass.to_s}, #{foreign_key_method}, #{unscoped.inspect})
-            end
+            @#{as} = polymorphic_instance(#{klass.nil? ? foreign_type_method : klass.to_s}, #{foreign_key_method}, #{unscoped.inspect})
           end
 
-          def #{as}_with_association=(r)
+          try(:silence_redefinition_of_method, :#{as}=)
+          def #{as}=(r)
             @#{as} = r
-            #{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
+            #{poly || klass ? "send('#{foreign_type_method}=', r.nil? ? nil : #{klass.nil? ? 'r.class.name' : klass.to_s.inspect})" : ''}
+            send('#{foreign_key_method}=', r.nil? ? nil : r.id)
             r
           end
 
+          try(:silence_redefinition_of_method, :#{as}_field_provided?)
           def #{as}_field_provided?
             field_provided?('#{foreign_key_method}')#{poly ? "&& field_provided?('#{foreign_type_method}')" : ""}
           end
         EV
-
-        alias_method :"#{as}_without_association", :"#{as}"
-        alias_method :"#{as}", :"#{as}_with_association"
-
-        alias_method :"#{as}_without_association=", :"#{as}="
-        alias_method :"#{as}=", :"#{as}_with_association="
       end
     end
 
@@ -111,6 +107,7 @@ module Subroutine
 
       _fields.each_pair do |field, config|
         next unless config[:association]
+        next if config[:mass_assignable] == false
         next unless @original_params.key?(field)
 
         send("#{field}=", @original_params[field]) # this gets the _id and _type into the params hash

data/lib/subroutine/auth.rb

@@ -98,10 +98,10 @@ module Subroutine
       end
     end
 
-    def initialize(*args)
+    def initialize(*args, &block)
       raise Subroutine::Auth::AuthorizationNotDeclaredError unless self.class.authorization_declared
 
-      super(args.extract_options!)
+      super(args.extract_options!, &block)
       @skip_auth_checks = false
       @current_user = args.shift
 

data/lib/subroutine/fields.rb

@@ -72,81 +72,108 @@ module Subroutine
 
       protected
 
-      def _field(field_name, options = {})
+      def _field(field_name, field_writer: true, field_reader: true, **options)
         self._fields = _fields.merge(field_name.to_sym => options)
 
-        class_eval <<-EV, __FILE__, __LINE__ + 1
-
-          def #{field_name}=(v)
-            config = #{field_name}_config
-            v = ::Subroutine::TypeCaster.cast(v, config)
-            @params["#{field_name}"] = v
-          end
+        if field_writer
+          class_eval <<-EV, __FILE__, __LINE__ + 1
+            try(:silence_redefinition_of_method, :#{field_name}=)
+            def #{field_name}=(v)
+              config = #{field_name}_config
+              @fields_provided["#{field_name}"] = true
+              @params["#{field_name}"] = attempt_cast(v, config) do |e|
+                "Error during assignment of field `#{field_name}`: \#{e}"
+              end
+            end
+          EV
+        end
 
-          def #{field_name}
-            @params.has_key?("#{field_name}") ? @params["#{field_name}"] : @defaults["#{field_name}"]
-          end
+        if field_reader
+          class_eval <<-EV, __FILE__, __LINE__ + 1
+            try(:silence_redefinition_of_method, :#{field_name})
+            def #{field_name}
+              @params["#{field_name}"]
+            end
+          EV
+        end
 
+        class_eval <<-EV, __FILE__, __LINE__ + 1
+          try(:silence_redefinition_of_method, :#{field_name}_config)
           def #{field_name}_config
             _fields[:#{field_name}]
           end
-
         EV
       end
     end
 
     def setup_fields(inputs = {})
       @original_params = inputs.with_indifferent_access
-      @params = sanitize_params(@original_params)
-      @defaults = sanitize_defaults
+      @defaults = build_defaults
+      @fields_provided = {}.with_indifferent_access
+      @params = build_params(@original_params, @defaults)
     end
 
     # check if a specific field was provided
     def field_provided?(key)
       return send(:"#{key}_field_provided?") if respond_to?(:"#{key}_field_provided?", true)
 
-      @params.key?(key)
+      !!@fields_provided[key]
     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)
+    def build_params(inputs, defaults)
       out = {}.with_indifferent_access
+
       _fields.each_pair do |field, config|
-        next unless inputs.key?(field)
 
-        begin
-          out[field] = ::Subroutine::TypeCaster.cast(inputs[field], config)
-        rescue ::Subroutine::TypeCaster::TypeCastError => e
-          raise ::Subroutine::TypeCaster::TypeCastError, "Error for field `#{field}`: #{e}"
+        if config[:mass_assignable] == false && inputs.key?(field)
+          raise ArgumentError, "`#{field}` is not mass assignable"
+        end
+
+        if inputs.key?(field)
+          @fields_provided[field] = true
+          out[field] = attempt_cast(inputs[field], config) do |e|
+            "Error for field `#{field}`: #{e}"
+          end
+        elsif defaults.key?(field)
+          out[field] =  defaults[field]
+        else
+          next
         end
       end
 
       out
     end
 
-    def params_with_defaults
-      @defaults.merge(@params)
-    end
-
-    def sanitize_defaults
-      defaults = {}.with_indifferent_access
+    def build_defaults
+      @defaults = {}.with_indifferent_access
 
       _fields.each_pair do |field, config|
-        next if config[:default].nil?
+        next unless config.key?(:default)
 
         deflt = config[:default]
         if deflt.respond_to?(:call)
           deflt = deflt.call
-        elsif deflt.duplicable? # from active_support
+        elsif deflt.try(: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)
+
+        @defaults[field.to_s] = attempt_cast(deflt, config) do |e|
+          "Error for default `#{field}`: #{e}"
+        end
       end
 
-      defaults
+      @defaults
+    end
+
+    def attempt_cast(value, config)
+      ::Subroutine::TypeCaster.cast(value, config)
+      rescue ::Subroutine::TypeCaster::TypeCastError => e
+      message = block_given? ? yield(e) : e.to_s
+      raise ::Subroutine::TypeCaster::TypeCastError, message, e.backtrace
     end
 
   end

data/lib/subroutine/op.rb

@@ -4,16 +4,15 @@ require "active_model"
 
 require "subroutine/fields"
 require "subroutine/failure"
-require "subroutine/filtered_errors"
 require "subroutine/output_not_set_error"
 require "subroutine/unknown_output_error"
 
 module Subroutine
   class Op
 
-    include ::Subroutine::Fields
-    include ::ActiveModel::Model
+    include ::ActiveModel::Validations
     include ::ActiveModel::Validations::Callbacks
+    include ::Subroutine::Fields
 
     DEFAULT_OUTPUT_OPTIONS = {
       required: true,
@@ -34,14 +33,8 @@ module Subroutine
         end
       end
 
-      def ignore_error(*field_names)
-        field_names.each do |f|
-          _ignore_errors(f)
-        end
-      end
-      alias ignore_errors ignore_error
-
       def submit!(*args)
+        raise ArgumentError, "Blocks cannot be provided to `submit!`" if block_given?
         op = new(*args)
         op.submit!
 
@@ -49,6 +42,7 @@ module Subroutine
       end
 
       def submit(*args)
+        raise ArgumentError, "Blocks cannot be provided to `submit`." if block_given?
         op = new(*args)
         op.submit
         op
@@ -65,15 +59,9 @@ module Subroutine
           end
         end
 
-        _ignore_errors(field_name) if options[:ignore_errors]
-
         result
       end
 
-      def _ignore_errors(field_name)
-        self._error_ignores = _error_ignores.merge(field_name.to_sym => true)
-      end
-
     end
 
     class_attribute :_outputs
@@ -82,16 +70,10 @@ module Subroutine
     class_attribute :_error_map
     self._error_map = {}
 
-    class_attribute :_error_ignores
-    self._error_ignores = {}
-
     def initialize(inputs = {})
       setup_fields(inputs)
       @outputs = {}
-    end
-
-    def errors
-      @filtered_errors ||= Subroutine::FilteredErrors.new(super)
+      yield self if block_given?
     end
 
     def output(name, value)
@@ -175,8 +157,6 @@ module Subroutine
       error_object = error_object.errors if error_object.respond_to?(:errors)
 
       error_object.each do |k, v|
-        next if _error_ignores[k.to_sym]
-
         if respond_to?(k)
           errors.add(k, v)
         elsif _error_map[k.to_sym]

data/lib/subroutine/version.rb

@@ -2,9 +2,9 @@
 
 module Subroutine
   MAJOR = 0
-  MINOR = 9
+  MINOR = 10
   PATCH = 0
-  PRE   = nil
+  PRE   = "beta"
 
   VERSION = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
 end

data/subroutine.gemspec

@@ -26,4 +26,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "minitest-reporters"
   spec.add_development_dependency "mocha"
+  spec.add_development_dependency "byebug"
 end

data/test/subroutine/base_test.rb

@@ -151,33 +151,16 @@ module Subroutine
       assert_equal 'foo@bar.com', op.created_user.email_address
     end
 
-    def test_it_ignores_specific_errors
-      op = ::WhateverSignupOp.submit
-      assert_equal [], op.errors[:whatever]
-    end
-
-    def test_it_does_not_inherit_ignored_errors
-      op = ::WhateverSignupOp.new
-      other = ::SignupOp.new
-      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')
       assert_equal({
-                     'email' => 'foo'
+                     'email' => 'foo',
+                     'privileges' => 'min',
                    }, op.params)
 
       assert_equal({
                      'privileges' => 'min'
                    }, op.defaults)
-
-      assert_equal({
-                     'email' => 'foo',
-                     'privileges' => 'min'
-                   }, op.params_with_defaults)
     end
 
     def test_it_allows_defaults_to_be_overridden
@@ -188,14 +171,7 @@ module Subroutine
                      'privileges' => nil
                    }, op.params)
 
-      assert_equal({
-                     'privileges' => 'min'
-                   }, op.defaults)
-
-      assert_equal({
-                     'email' => 'foo',
-                     'privileges' => nil
-                   }, op.params_with_defaults)
+      assert_equal({"privileges" => "min"}, op.defaults)
     end
 
     def test_it_overriding_default_does_not_alter_default
@@ -212,11 +188,6 @@ module Subroutine
       assert_equal({
                      'privileges' => 'min'
                    }, op.defaults)
-
-      assert_equal({
-                     'email' => 'foo',
-                     'privileges' => nil
-                   }, op.params_with_defaults)
     end
 
     def test_it_overrides_defaults_with_nils
@@ -229,10 +200,10 @@ module Subroutine
 
     def test_it_casts_params_on_the_way_in
       op = ::TypeCastOp.new(integer_input: '25')
-      assert_equal(25, op.params_with_defaults['integer_input'])
+      assert_equal(25, op.params['integer_input'])
 
       op.decimal_input = '25.3'
-      assert_equal(BigDecimal('25.3'), op.params_with_defaults['decimal_input'])
+      assert_equal(BigDecimal('25.3'), op.params['decimal_input'])
     end
 
     def test_it_allow_retrival_of_outputs
@@ -278,5 +249,34 @@ module Subroutine
         refute_nil found, 'Expected backtrace to include original caller of foo'
       end
     end
+
+    def test_a_block_is_accepted_on_instantiation
+      op = ::SignupOp.new do |o|
+        o.email = "foo@bar.com"
+        o.password = "password123!"
+      end
+
+      assert_equal "foo@bar.com", op.email
+      assert_equal "password123!", op.password
+
+      assert_equal true, op.field_provided?(:email)
+      assert_equal true, op.field_provided?(:password)
+    end
+
+    def test_a_block_is_not_accepted_with_submit
+      assert_raises ::ArgumentError do
+        ::SignupOp.submit! do |o|
+          o.email = "foo@bar.com"
+          o.password = "password123!"
+        end
+      end
+
+      assert_raises ::ArgumentError do
+        ::SignupOp.submit do |o|
+          o.email = "foo@bar.com"
+          o.password = "password123!"
+        end
+      end
+    end
   end
 end

data/test/subroutine/fields_test.rb

@@ -14,6 +14,8 @@ module Subroutine
       integer :bar, default: -> { 3 }
       date :baz
 
+      string :protekted, mass_assignable: false
+
       def initialize(options = {})
         setup_fields(options)
       end
@@ -21,10 +23,11 @@ module Subroutine
     end
 
     def test_fields_are_configured
-      assert_equal 3, Whatever._fields.size
+      assert_equal 4, Whatever._fields.size
       assert_equal :string, Whatever._fields[:foo][:type]
       assert_equal :integer, Whatever._fields[:bar][:type]
       assert_equal :date, Whatever._fields[:baz][:type]
+      assert_equal :string, Whatever._fields[:protekted][:type]
     end
 
     def test_field_defaults_are_handled
@@ -43,13 +46,6 @@ module Subroutine
       instance = Whatever.new(foo: "abc")
       assert_equal true, instance.field_provided?(:foo)
       assert_equal false, instance.field_provided?(:bar)
-    end
-
-    def test_field_provided
-
-      instance = Whatever.new(foo: "abc")
-      assert_equal true, instance.field_provided?(:foo)
-      assert_equal false, instance.field_provided?(:bar)
 
       instance = DefaultsOp.new
       assert_equal false, instance.field_provided?(:foo)
@@ -58,18 +54,39 @@ module Subroutine
       assert_equal true, instance.field_provided?(:foo)
     end
 
+    def test_field_provided_include_manual_assigned_fields
+      instance = Whatever.new
+      instance.foo = "bar"
+
+      assert_equal true, instance.field_provided?(:foo)
+      assert_equal false, instance.field_provided?(:bar)
+    end
+
     def test_invalid_typecast
       assert_raises "Error for field `baz`: invalid date" do
         Whatever.new(baz: "2015-13-01")
       end
     end
 
-    def test_params
+    def test_params_include_defaults
       instance = Whatever.new(foo: "abc")
-      assert_equal({ "foo" => "abc" }, instance.params)
-      assert_equal({ "foo" => "abc", "bar" => 3 }, instance.params_with_defaults)
+      assert_equal({ "foo" => "abc", "bar" => 3 }, instance.params)
       assert_equal({ "foo" => "foo", "bar" => 3 }, instance.defaults)
     end
 
+    def test_fields_can_opt_out_of_mass_assignment
+      assert_raises "`protekted` is not mass assignable" do
+        Whatever.new(foo: "abc", protekted: "foo")
+      end
+    end
+
+    def test_non_mass_assignment_fields_can_be_individually_assigned
+      instance = Whatever.new(foo: "abc")
+      instance.protekted = "bar"
+
+      assert_equal "bar", instance.protekted
+      assert_equal true, instance.field_provided?(:protekted)
+    end
+
   end
 end

data/test/support/ops.rb

@@ -64,10 +64,6 @@ class SignupOp < ::Subroutine::Op
     ::User
   end
 end
-class WhateverSignupOp < ::SignupOp
-  string :whatever, ignore_errors: true
-  validates :whatever, presence: true
-end
 
 class AdminSignupOp < ::SignupOp
   field :privileges, default: 'min'

data/test/test_helper.rb

@@ -7,6 +7,8 @@ require 'minitest/unit'
 require 'minitest/reporters'
 require 'mocha/minitest'
 
+require "byebug"
+
 Minitest::Reporters.use!([Minitest::Reporters::DefaultReporter.new])
 
 class TestCase < ::Minitest::Test; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: subroutine
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0.beta
 platform: ruby
 authors:
 - Mike Nelson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-24 00:00:00.000000000 Z
+date: 2019-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: An interface for creating feature-driven operations.
 email:
 - mike@mnelson.io
@@ -134,7 +148,6 @@ files:
 - lib/subroutine/auth.rb
 - lib/subroutine/failure.rb
 - lib/subroutine/fields.rb
-- lib/subroutine/filtered_errors.rb
 - lib/subroutine/op.rb
 - lib/subroutine/output_not_set_error.rb
 - lib/subroutine/type_caster.rb
@@ -163,9 +176,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.14.4

data/lib/subroutine/filtered_errors.rb

@@ -1,11 +0,0 @@
-# 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