subroutine 0.10.0.beta10 → 0.10.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70efa6b815728e1b2d8e3117ebc40b629d98f7f150528a1901ff7e03f763fa10
-  data.tar.gz: 28d84cad0e8508b32c0f7ad93d3c79b94a3cdef9b5632c3b933f7f85a04b703b
+  metadata.gz: 86dd43668cfcb0158dd5c20a1fe87f2d1f4aec05359ed86752cffe81b27c2878
+  data.tar.gz: f83554bfd98877f40037fb528edd35fb36820ebe4566977f0d1fde949392a9d3
 SHA512:
-  metadata.gz: 3d2f21c4f6739a3ad32c5915f7f8eb60efece410ceb78b31f76b1f5f522ee65b669c0f42b4d5c43bd5aedf549cefe7643e837879e1cf513676491017aa8a6bf1
-  data.tar.gz: '06698f7f7ddd4993ee0e6651a8f1b38f665fc770be023d532bd7b5671030213f26f58b18cf58c1d569433f6ce41854b98909f94bbd15b1ba8a5261e97a77d512'
+  metadata.gz: '0395205fa3d3ea249e531f5ad21399f53b34a26919ae712c2bf2432c2d611760ed5b72f290f70603a9d8c686f547cc9809d7dc3a7d04ce52848af3a5a226bf57'
+  data.tar.gz: b48edaa5cdca4a844c22536ad75984646e4bb7ac11ebd06758041d90bda67402e594ad9e00025089831fbeffebb09e67d86f58f3aa7772c84056bbef639dfa34

data/README.md

@@ -1,17 +1,17 @@
 # Subroutine
 
-A gem that provides an interface for creating feature-driven operations. You've probably heard at least one of these terms: "service objects", "form objects", or maybe even "commands". Subroutine calls these "ops" and really it's just about enabling clear, concise, testable, and meaningful code.
+A gem that provides an interface for creating feature-driven operations. You've probably heard at least one of these terms: "service objects", "form objects", "intentions", or "commands". Subroutine calls these "ops" and really it's just about enabling clear, concise, testable, and meaningful code.
 
-## Examples
+## Example
 
 So you need to sign up a user? or maybe update one's account? or change a password? or maybe you need to sign up a business along with a user, associate them, send an email, and queue a worker in a single request? Not a problem, create an op for any of these use cases. Here's the signup example.
 
 ```ruby
 class SignupOp < ::Subroutine::Op
 
-  field :name
-  field :email
-  field :password
+  string :name
+  string :email
+  string :password
 
   validates :name, presence: true
   validates :email, presence: true
@@ -28,8 +28,8 @@ class SignupOp < ::Subroutine::Op
     output :signed_up_user, u
   end
 
-  def create_user
-    User.new(params)
+  def create_user!
+    User.create!(params)
   end
 
   def deliver_welcome_email!(u)
@@ -38,433 +38,14 @@ class SignupOp < ::Subroutine::Op
 end
 ```
 
-So why is this needed?
-
-1. No insane cluttering of controllers with strong parameters, etc.
-2. No insane cluttering of models with validations, callbacks, and random methods that don't relate to integrity or access of model data.
-3. Insanely testable.
-4. Insanely easy to read and maintain.
-5. Multi-model operations become insanely easy.
-6. Your sanity.
-
-### Connecting it all
-
-```txt
-app/
-  |
-  |- controllers/
-  |  |- users_controller.rb
-  |
-  |- models/
-  |  |- user.rb
-  |
-  |- ops/
-     |- signup_op.rb
-
-```
-
-#### Route
-```ruby
-  resources :users, only: [] do
-    collection do
-      post :signup
-    end
-  end
-```
-
-#### Model
-
-When ops are around, the point of the model is to ensure data validity. That's essentially it.
-So most of your models are a series of validations, common accessors, queries, etc.
-
-```ruby
-class User
-  validates :name,   presence: true
-  validates :email,     email: true
-
-  has_secure_password
-end
-```
-
-#### Controller(s)
-
-I've found that a great way to handle errors with ops is to allow you top level controller to appropriately
-render errors in a consisent way. This is exceptionally easy for api-driven apps.
-
-
-```ruby
-class Api::Controller < ApplicationController
-  rescue_from ::Subroutine::Failure, with: :render_op_failure
-
-  def render_op_failure(e)
-    # however you want to do this, `e` will be similar to an ActiveRecord::RecordInvalid error
-    # e.record.errors, etc
-  end
-end
-```
-
-With ops, your controllers are essentially just connections between routes, operations, and whatever you use to build responses.
-
-```ruby
-class UsersController < ::Api::Controller
-  def sign_up
-
-    # If the op fails, a ::Subroutine::Failure will be raised.
-    op = SignupOp.submit!(params)
-
-    # If the op succeeds, it will be returned so you can access it's information.
-    render json: op.signed_up_user
-  end
-end
-```
-## Op Implementation
-
-Ops have some fluff, but not much. The `Subroutine::Op` class' entire purpose in life is to validate user input and execute
-a series of operations. To enable this we filter input params, type cast params (if desired), and execute validations. Only
-after these things are complete will the `Op` perform it's operation.
-
-#### Input Declaration
-
-Inputs are declared via the `field` method and have just a couple of options:
-
-```ruby
-class MyOp < ::Subroutine::Op
-  field :first_name
-  field :age, type: :integer
-  field :subscribed, type: :boolean, default: false
-  # ...
-end
-```
-
-* **type** - declares the type which the input should be cast to. Available types are declared in `Subroutine::TypeCaster::TYPES`
-* **default** - the default value of the input if not otherwise provided. If the provided default responds to `call` (ie. proc, lambda) the result of that `call` will be used at runtime.
-* **aka** - an alias (or aliases) that is checked when errors are inherited from other objects.
-
-Since we like a clean & simple dsl, you can also declare inputs via the `values` of `Subroutine::TypeCaster::TYPES`. When declared
-this way, the `:type` option is assumed.
-
-```ruby
-class MyOp < ::Subroutine::Op
-  string :first_name
-  date :dob
-  boolean :tos, :default => false
-end
-```
-
-Since ops can use other ops, sometimes it's nice to explicitly state the inputs are valid. To "inherit" all the inputs from another op, simply use `inputs_from`.
-
-```ruby
-class MyOp < ::Subroutine::Op
-  string :token
-  inputs_from MyOtherOp
-
-  protected
-
-  def perform
-    verify_token!
-    MyOtherOp.submit! params.except(:token)
-  end
-
-end
-```
-
-#### Validations
-
-Since Ops include ActiveModel::Model, validations can be used just like any other ActiveModel object.
-
-```ruby
-class MyOp < ::Subroutine::Op
-  field :first_name
-
-  validates :first_name, presence: true
-end
-```
-
-#### Input Usage
-
-Inputs are accessible within the op via public accessors. You can see if an input was provided via the `field_provided?` method.
-
-```ruby
-class MyOp < ::Subroutine::Op
-
-  field :first_name
-  validate :validate_first_name_is_not_bob
-
-  protected
-
-  def perform
-   # whatever this op does
-   true
-  end
-
-  def validate_first_name_is_not_bob
-    if field_provided?(:first_name) && first_name.downcase == 'bob'
-      errors.add(:first_name, 'should not be bob')
-    end
-  end
-end
-```
-
-All **provided** params are accessible via the `params` accessor. All default values are accessible via the `defaults` accessor. The combination of the two is available via `params_with_defaults`.
-
-```ruby
-class MyOp < ::Subroutine::Op
-  string :name
-  string :status, default: "browsing"
-
-  def perform
-    puts params.inspect
-    puts defaults.inspect
-    puts params_with_defaults.inspect
-  end
-end
-
-MyOp.submit(name: "foobar", status: nil)
-# => { name: "foobar" }
-# => { status: "browsing" }
-# => { name: "foobar", status: nil }
-
-MyOp.submit(name: "foobar")
-# => { name: "foobar" }
-# => { status: "browsing" }
-# => { name: "foobar", status: "browsing" }
-```
-
-#### Execution
-
-Every op must implement a `perform` method. This is the method which will be executed if all validations pass.
-When the the `perform` method is complete, the Op determins success based on whether `errors` is empty.
-
-```ruby
-class MyFailingOp < ::Subroutine::Op
-  field :first_name
-  validates :first_name, presence: true
-
-  protected
-
-  def perform
-    errors.add(:base, "This will never succeed")
-  end
-
-end
-```
-
-Notice we do not declare `perform` as a public method. This is to ensure the "public" api of the op remains as `submit` or `submit!`.
-
-#### Errors
-
-Reporting errors is very important in Subroutine Ops since these can be used as form objects. Errors can be reported a couple different ways:
-
-1. `errors.add(:key, :error)` That is, the way you add errors to an ActiveModel object.
-2. `inherit_errors(error_object_or_activemodel_object)` Same as `errors.add`, but it iterates an existing error hash and inherits the errors. As part of this iteration,
-it checks whether the key in the provided error_object matches a field (or alias of a field) in our op. If there is a match, the error will be placed on
-that field, but if there is not, the error will be placed on `:base`.
-
-```ruby
-class MyOp < ::Subroutine::Op
-
-  string :first_name, aka: :firstname
-  string :last_name, aka: [:lastname, :surname]
-
-  protected
-
-  def perform
-
-    if first_name == 'bill'
-      errors.add(:first_name, 'cannot be bill')
-      return
-    end
-
-    if first_name == 'john'
-      errors.add(:first_name, 'cannot be john')
-      return
-    end
-
-    unless _user.valid?
-
-      # if there are :first_name or :firstname errors on _user, they will be added to our :first_name
-      # if there are :last_name, :lastname, or :surname errors on _user, they will be added to our :last_name
-      inherit_errors(_user)
-    end
-  end
-
-  def _user
-    @_user ||= User.new(params)
-  end
-end
-```
-
-
-## Usage
-
-The `Subroutine::Op` class' `submit` and `submit!` methods have identical signatures to the class' constructor, enabling a few different ways to utilize an op:
-
-#### Via the class' `submit` method
+## So why use this?
 
-```ruby
-op = MyOp.submit({foo: 'bar'})
-# if the op succeeds it will be returned, otherwise false will be returned.
-```
-
-#### Via the class' `submit!` method
-
-```ruby
-op = MyOp.submit!({foo: 'bar'})
-# if the op succeeds it will be returned, otherwise a ::Subroutine::Failure will be raised.
-```
+- Avoid cluttering models or controllers with logic only applicable to one intention. You also don't need strong parameters because the inputs to the Op are well-defined.
+- Test the Op in isolation
+- Clear and concise intention in a single file
+- Multi-model operations become simple
 
-#### Via the instance's `submit` method
-
-```ruby
-op = MyOp.new({foo: 'bar'})
-val = op.submit
-# if the op succeeds, val will be true, otherwise false
-```
-
-#### Via the instance's `submit!` method
-
-```ruby
-op = MyOp.new({foo: 'bar'})
-op.submit!
-# if the op succeeds nothing will be raised, otherwise a ::Subroutine::Failure will be raised.
-```
-
-## Built-in Extensions
-
-### Subroutine::Association
-
-The `Subroutine::Association` module provides an interface for loading ActiveRecord instances easily.
-
-```ruby
-class UserUpdateOp < ::Subroutine::Op
-  include ::Subroutine::Association
-
-  association :user
-
-  string :first_name, :last_name
-
-  protected
-
-  def perform
-    user.update_attributes(
-      first_name: first_name,
-      last_name: last_name
-    )
-  end
-end
-```
-
-```ruby
-class RecordTouchOp < ::Subroutine::Op
-  include ::Subroutine::Association
-
-  association :record, polymorphic: true
-
-  protected
-
-  def perform
-    record.touch
-  end
-end
-```
-
-### Subroutine::Auth
-
-The `Subroutine::Auth` module provides basic bindings for application authorization. It assumes that, optionally, a `User` will be provided as the first argument to an Op. It forces authorization to be declared on each class it's included in.
-
-```ruby
-class SayHiOp < ::Subroutine::Op
-  include ::Subroutine::Auth
-
-  require_user!
-
-  string :say_what, default: "hi"
-
-  protected
-
-  def perform
-    puts "#{current_user.name} says: #{say_what}"
-  end
-end
-```
-
-```ruby
-user = User.find("john")
-SayHiOp.submit!(user)
-# => John says: hi
-
-SayHiOp.submit!(user, say_what: "hello")
-# => John says: hello
-
-
-SayHiOp.submit!
-# => raises Subroutine::Auth::NotAuthorizedError
-```
-
-There are a handful of authorization configurations:
-
-1. `require_user!` - ensures that a user is provided
-2. `require_no_user!` - ensures that a user is not present
-3. `no_user_requirements!` - explicitly doesn't matter
-
-In addition to these top-level authorization declarations you can provide custom authorizations like so:
-
-```ruby
-class AccountSetSecretOp < ::Subroutine::Op
-  include ::Subroutine::Auth
-
-  require_user!
-  authorize :authorize_first_name_is_john
-  
-  # If you use a policy-based authorization framework like pundit:
-  # `policy` is a shortcut for the following:
-  # authorize -> { unauthorized! unless policy.can_set_secret? }
-  
-  policy :can_set_secret?
-
-  string :secret
-  belongs_to :account
-
-  protected
-
-  def perform
-    account.secret = secret
-    current_user.save!
-  end
-
-  def authorize_first_name_is_john
-    unless current_user.first_name == "john"
-      unauthorized!
-    end
-  end
-
-  def policy
-    ::UserPolicy.new(current_user, current_user)
-  end
-
-end
-```
-
-## Subroutine::Factory
-
-There is a separate gem [subroutine-factory](https://github.com/mnelson/subroutine-factory) which enables you to easily utilize factories and operations to produce
-test data. It's a great replacement to FactoryGirl, as it ensures the data entering your DB is getting there via a real
-world operation.
-
-```ruby
-# support/factories/signups.rb
-Subroutine::Factory.define :signup do
-  op ::SignupOp
-
-  inputs :email, sequence{|n| "foo{n}@example.com" }
-  inputs :password, "password123"
-
-  # by default, the op will be returned when the factory is used.
-  # this `output` returns the value of the `user` output on the resulting op
-  output :user
-end
-
-# signup_test.rb
-user = Subroutine::Factory.create :signup
-user = Subroutine::Factory.create :signup, email: "foo@bar.com"
-```
+[Implementing an Op](https://github.com/guideline-tech/subroutine/wiki/Implementing-an-Op)
+[Using an Op](https://github.com/guideline-tech/subroutine/wiki/Using-an-Op)
+[Errors](https://github.com/guideline-tech/subroutine/wiki/Errors)
+[Basic Usage in Rails](https://github.com/guideline-tech/subroutine/wiki/Rails-Usage)

data/lib/subroutine/association_fields.rb

@@ -105,7 +105,7 @@ module Subroutine
 
       out = params.except(*excepts)
       association_fields.each_pair do |field_name, _config|
-        out[field_name] = send(field_name) if field_provided?(field_name)
+        out[field_name] = get_field(field_name) if field_provided?(field_name)
       end
 
       out
@@ -135,8 +135,8 @@ module Subroutine
         stored_result = association_cache[config.field_name]
         return stored_result unless stored_result.nil?
 
-        fk = send(config.foreign_key_method)
-        type = send(config.foreign_type_method)
+        fk = get_field(config.foreign_key_method)
+        type = config.polymorphic? ? get_field(config.foreign_type_method) : send(config.foreign_type_method)
 
         result = fetch_association_instance(type, fk, config.unscoped?)
         association_cache[config.field_name] = result

data/lib/subroutine/fields/configuration.rb

@@ -7,7 +7,8 @@ module Subroutine
     class Configuration < ::SimpleDelegator
 
       PROTECTED_GROUP_IDENTIFIERS = %i[all original default].freeze
-      INHERITABLE_OPTIONS = %i[mass_assignable field_reader field_writer].freeze
+      INHERITABLE_OPTIONS = %i[mass_assignable field_reader field_writer groups].freeze
+      NO_GROUPS = [].freeze
 
       def self.from(field_name, options)
         case options
@@ -29,6 +30,10 @@ module Subroutine
 
       alias config __getobj__
 
+      def merge(options = {})
+        self.class.new(field_name, config.merge(options))
+      end
+
       def required_modules
         []
       end
@@ -69,12 +74,8 @@ module Subroutine
         config[:field_reader] != false
       end
 
-      def parent_field
-        config[:parent_field]
-      end
-
       def groups
-        config[:groups]
+        config[:groups] || NO_GROUPS
       end
 
       def in_group?(group_name)
@@ -92,7 +93,8 @@ module Subroutine
       def sanitize_options(options)
         opts = (options || {}).to_h.dup
         groups = opts[:group] || opts[:groups]
-        opts[:groups] = Array(groups).map(&:to_sym)
+        groups = nil if groups == false
+        opts[:groups] = Array(groups).map(&:to_sym).presence
         opts.delete(:group)
         opts
       end

data/lib/subroutine/fields.rb

@@ -17,6 +17,9 @@ module Subroutine
     included do
       class_attribute :field_configurations
       self.field_configurations = {}
+
+      class_attribute :field_groups
+      self.field_groups = Set.new
     end
 
     module ClassMethods
@@ -25,35 +28,19 @@ module Subroutine
         config = ::Subroutine::Fields::Configuration.from(field_name, options)
         config.validate!
 
-        config.groups.each do |group_name|
-          _group(group_name)
-        end
-
         self.field_configurations = field_configurations.merge(field_name.to_sym => config)
 
-        if config.field_writer?
-          class_eval <<-EV, __FILE__, __LINE__ + 1
-            try(:silence_redefinition_of_method, :#{field_name}=)
-            def #{field_name}=(v)
-              set_field(:#{field_name}, v)
-            end
-          EV
-        end
+        ensure_field_accessors(config)
 
-        if config.field_reader?
-          class_eval <<-EV, __FILE__, __LINE__ + 1
-            try(:silence_redefinition_of_method, :#{field_name})
-            def #{field_name}
-              get_field(:#{field_name})
-            end
-          EV
+        config.groups.each do |group_name|
+          ensure_group_accessors(group_name)
         end
 
         config
       end
       alias input field
 
-      def inputs_from(*things)
+      def fields_from(*things)
         options = things.extract_options!
         excepts = options.key?(:except) ? Array(options.delete(:except)) : nil
         onlys = options.key?(:only) ? Array(options.delete(:only)) : nil
@@ -67,11 +54,11 @@ module Subroutine
               include mod unless included_modules.include?(mod)
             end
 
-            field(field_name, config)
+            field(field_name, config.merge(options))
           end
         end
       end
-      alias fields_from inputs_from
+      alias inputs_from fields_from
 
       def fields_in_group(group_name)
         field_configurations.each_with_object({}) do |(field_name, config), h|
@@ -103,31 +90,50 @@ module Subroutine
 
       protected
 
-      def _group(group_name)
+      def ensure_group_accessors(group_name)
+        group_name = group_name.to_sym
+        return if field_groups.include?(group_name)
+
+        self.field_groups |= [group_name]
+
         class_eval <<-EV, __FILE__, __LINE__ + 1
-          try(:silence_redefinition_of_method, :#{group_name}_params)
           def #{group_name}_params
             param_groups[:#{group_name}]
           end
 
-          try(:silence_redefinition_of_method, :#{group_name}_default_params)
           def #{group_name}_default_params
             group_field_names = fields_in_group(:#{group_name}).keys
             all_default_params.slice(*group_field_names)
           end
 
-          try(:silence_redefinition_of_method, :#{group_name}_params_with_defaults)
           def #{group_name}_params_with_defaults
             #{group_name}_default_params.merge(param_groups[:#{group_name}])
           end
 
-          try(:silence_redefinition_of_method, :without_#{group_name}_params)
           def without_#{group_name}_params
             all_params.except(*#{group_name}_params.keys)
           end
         EV
       end
 
+      def ensure_field_accessors(config)
+        if config.field_writer? && !instance_methods.include?(:"#{config.field_name}=")
+          class_eval <<-EV, __FILE__, __LINE__ + 1
+            def #{config.field_name}=(v)
+              set_field(:#{config.field_name}, v)
+            end
+          EV
+        end
+
+        if config.field_reader? && !instance_methods.include?(:"#{config.field_name}")
+          class_eval <<-EV, __FILE__, __LINE__ + 1
+            def #{config.field_name}
+              get_field(:#{config.field_name})
+            end
+          EV
+        end
+      end
+
     end
 
     def setup_fields(inputs = {})

data/lib/subroutine/version.rb

@@ -5,7 +5,7 @@ module Subroutine
   MAJOR = 0
   MINOR = 10
   PATCH = 0
-  PRE   = "beta10"
+  PRE   = "rc1"
 
   VERSION = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
 

data/test/subroutine/association_test.rb

@@ -70,7 +70,7 @@ module Subroutine
       assert_equal "AdminUser", op.admin_type
     end
 
-    def test_it_inherits_associations_via_inputs_from
+    def test_it_inherits_associations_via_fields_from
       all_mock = mock
 
       ::User.expects(:all).returns(all_mock)
@@ -82,7 +82,7 @@ module Subroutine
       assert_equal doug.id, op.user_id
     end
 
-    def test_it_inherits_associations_via_inputs_from_and_preserves_options
+    def test_it_inherits_associations_via_fields_from_and_preserves_options
       all_mock = mock
       unscoped_mock = mock
 
@@ -96,7 +96,7 @@ module Subroutine
       assert_equal doug.id, op.user_id
     end
 
-    def test_it_inherits_polymorphic_associations_via_inputs_from
+    def test_it_inherits_polymorphic_associations_via_fields_from
       all_mock = mock
       ::User.expects(:all).never
       ::AdminUser.expects(:all).returns(all_mock)
@@ -210,5 +210,18 @@ module Subroutine
       assert_equal({ "admin" => user }, op.params_with_associations)
     end
 
+    def test_groups_are_preserved_to_association_components
+      user = ::User.new(id: 1)
+      op = GroupedParamAssociationOp.new(user: user)
+      assert_equal({ "user_id" => 1 }, op.params)
+      assert_equal({ "user_id" => 1 }, op.info_params)
+      assert_equal({}, op.without_info_params)
+
+      op = GroupedPolymorphicParamAssociationOp.new(user: user)
+      assert_equal({ "user_id" => 1, "user_type" => "User" }, op.params)
+      assert_equal({ "user_id" => 1, "user_type" => "User" }, op.info_params)
+      assert_equal({}, op.without_info_params)
+    end
+
   end
 end

data/test/subroutine/base_test.rb

@@ -24,7 +24,7 @@ module Subroutine
       refute_equal sid, bid
     end
 
-    def test_inputs_from_inherited_fields_without_inheriting_from_the_class
+    def test_fields_from_inherited_fields_without_inheriting_from_the_class
       refute ::BusinessSignupOp < ::SignupOp
 
       user_fields = ::SignupOp.field_configurations.keys
@@ -35,14 +35,14 @@ module Subroutine
       end
     end
 
-    def test_inputs_from_ignores_except_fields
+    def test_fields_from_ignores_except_fields
       op = ::ExceptFooBarOp.new
       refute op.field_configurations.key?(:foo)
       refute op.field_configurations.key?(:bar)
       assert_equal [:baz], op.field_configurations.keys.sort
     end
 
-    def test_inputs_from_only_fields
+    def test_fields_from_only_fields
       op = ::OnlyFooBarOp.new
       assert op.field_configurations.key?(:foo)
       assert op.field_configurations.key?(:bar)

data/test/subroutine/fields_test.rb

@@ -127,5 +127,16 @@ module Subroutine
       assert_equal({ foo: "bar" }.with_indifferent_access, op.ungrouped_params)
     end
 
+    def test_fields_from_allows_merging_of_config
+      op = GroupedDefaultsOp.new(foo: "foo")
+      assert_equal({ foo: "foo" }.with_indifferent_access, op.params)
+      assert_equal({ foo: "foo" }.with_indifferent_access, op.inherited_params)
+      assert_equal({ foo: "foo", bar: "bar", baz: false }.with_indifferent_access, op.params_with_defaults)
+      assert_equal({ foo: "foo", bar: "bar", baz: false }.with_indifferent_access, op.inherited_params_with_defaults)
+      assert_equal({}.with_indifferent_access, op.without_inherited_params)
+    end
+
+    def test_groups_can_be_removed_via_fields_from; end
+
   end
 end

data/test/support/ops.rb

@@ -107,7 +107,7 @@ class BusinessSignupOp < ::Subroutine::Op
 
   string :business_name
 
-  inputs_from ::SignupOp
+  fields_from ::SignupOp
 
 end
 
@@ -121,13 +121,13 @@ end
 
 class ExceptFooBarOp < ::Subroutine::Op
 
-  inputs_from ::DefaultsOp, except: %i[foo bar]
+  fields_from ::DefaultsOp, except: %i[foo bar]
 
 end
 
 class OnlyFooBarOp < ::Subroutine::Op
 
-  inputs_from ::DefaultsOp, only: %i[foo bar]
+  fields_from ::DefaultsOp, only: %i[foo bar]
 
 end
 
@@ -137,6 +137,12 @@ class InheritedDefaultsOp < ::DefaultsOp
 
 end
 
+class GroupedDefaultsOp < ::Subroutine::Op
+
+  fields_from ::DefaultsOp, group: "inherited"
+
+end
+
 class TypeCastOp < ::Subroutine::Op
 
   integer :integer_input
@@ -298,19 +304,37 @@ end
 
 class InheritedSimpleAssociation < ::Subroutine::Op
 
-  inputs_from SimpleAssociationOp
+  fields_from SimpleAssociationOp
 
 end
 
 class InheritedUnscopedAssociation < ::Subroutine::Op
 
-  inputs_from UnscopedSimpleAssociationOp
+  fields_from UnscopedSimpleAssociationOp
 
 end
 
 class InheritedPolymorphicAssociationOp < ::Subroutine::Op
 
-  inputs_from PolymorphicAssociationOp
+  fields_from PolymorphicAssociationOp
+
+end
+
+class GroupedParamAssociationOp < ::OpWithAssociation
+
+  association :user, group: :info
+
+end
+
+class GroupedPolymorphicParamAssociationOp < ::OpWithAssociation
+
+  association :user, polymorphic: true, group: :info
+
+end
+
+class GroupedInputsFromOp < ::Subroutine::Op
+
+  fields_from GroupedParamAssociationOp, group: :inherited
 
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: subroutine
 version: !ruby/object:Gem::Version
-  version: 0.10.0.beta10
+  version: 0.10.0.rc1
 platform: ruby
 authors:
 - Mike Nelson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-28 00:00:00.000000000 Z
+date: 2020-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel