shiftable 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2aee0ddcd18b646324ef8ec890c7fc50aaf2af9c6b630c5267d3ec0143a7dedb
-  data.tar.gz: c6bd0a6a3ddc61517dc9e162c4cf9e9861e23f832baaf8e013c3bbb12e97d868
+  metadata.gz: 62926c718edd257728210a0870ea5eca44aeb35b33a929d87d2efb8a5f902910
+  data.tar.gz: b4c35fcc2a3eff45d992b5260e6d4f2f13d870782f40d06285172eb2f1207f9d
 SHA512:
-  metadata.gz: 6e6b917230a28123480e5032766ee0e26dfc44c887f177d59b6f44fc9c1659eec0695a1513415f126a3de168b4315498eb7b26905e07350c16d72cec6e17234e
-  data.tar.gz: 0f4765f281ec4cf5bd97e874fe6ee63dc171df5f178d028d99a1c89d886e00ea5906931e1f192467ddcd1206c2d473c8a6d738db0a0db3f8b9bd10454f171da1
+  metadata.gz: 8c21a1f0c51b4a3cb715730fe07bb29d562a84d8dd79b558a3ca06c6a7bf20032928225b41aa1e749b4a7a85afe4fdb33cbf9d068b7539ef622665272f1f8115
+  data.tar.gz: d9bc2d54fe6fb3f15f781b33ddf83c6abfa91f7b66e426274bc9ef07595e61a9c6b4f42a2ffe27e6b8cce5453dbcc0221ac07261bddb762a3a9eba3e79d7cef1

data/CHANGELOG.md

@@ -1,10 +1,62 @@
 ## [Unreleased]
 
+## [0.4.0] - 2021-10-27
+
+### Changed
+
+- option :preflight_checks renamed to :precheck
+
+### Added
+
+- Even more 100% spec coverage
+
+## [0.3.0] - 2021-10-26
+
+### Changed
+
+- Internal rewrite to improve maintainability
+- Extreme edge cases involving incorrect configuration will raise slightly different errors.
+
+### Added
+
+- Even more 100% spec coverage
+
+## [0.2.0] - 2021-10-24
+
+### Changed
+
+- option `before_save` is now `before_shift` as originally documented
+
+### Updated
+
+- Github Actions now test all supported Rubies
+- Linting
+- Documentation
+
+## [0.1.1] - 2021-10-23
+
+### Fixed
+
+- Github Actions build
+
+### Updated
+
+- Linting
+
 ## [0.1.0] - 2021-10-23
 
 ### Added
 
 - Initial release
-- feat: supports shifting of records associated as has_one / belongs_to
+- feat: supports shifting of records associated as has_one / belongs_to and has_many / belongs_to, including with STI.
+- 100% test coverage
+
+[0.1.0]: https://github.com/pboling/shiftable/releases/tag/v0.1.0
+
+[0.1.1]: https://github.com/pboling/shiftable/releases/tag/v0.1.1
+
+[0.2.0]: https://github.com/pboling/shiftable/releases/tag/v0.2.0
+
+[0.3.0]: https://github.com/pboling/shiftable/releases/tag/v0.3.0
 
-[0.1.0]: https://github.com/pboling/shiftable/releases/tag/v0.1.0
+[0.4.0]: https://github.com/pboling/shiftable/releases/tag/v0.4.0

data/README.md

@@ -5,12 +5,38 @@ Do your Spaceships belong to Captains, but sometimes a Captain will retire, and
 We've all been there. This gem provides structure around the process of "shifting" your records from one associated
 record to a new record.
 
+| Project                 |  Shiftable |
+|------------------------ | ----------------------- |
+| gem name                |  [shiftable](https://rubygems.org/gems/shiftable) |
+| license                 |  [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT) |
+| download rank           |  [![Downloads Today](https://img.shields.io/gem/rd/shiftable.svg)](https://github.com/pboling/shiftable) |
+| version                 |  [![Version](https://img.shields.io/gem/v/shiftable.svg)](https://rubygems.org/gems/shiftable) |
+| dependencies            |  [![Depfu](https://badges.depfu.com/badges/0412727b7e3b740b950a683eebc708e2/count.svg)](https://depfu.com/github/pboling/shiftable?project_id=32594) |
+| unit tests              |  [![unit tests](https://github.com/pboling/shiftable/actions/workflows/test.yml/badge.svg)](https://github.com/pboling/shiftable/actions) |
+| lint status             |  [![lint status](https://github.com/pboling/shiftable/actions/workflows/style.yml/badge.svg)](https://github.com/pboling/shiftable/actions) |
+| unsupported status      |  [![unsupported status](https://github.com/pboling/shiftable/actions/workflows/unsupported.yml/badge.svg)](https://github.com/pboling/shiftable/actions) |
+| test coverage           |  [![Test Coverage](https://api.codeclimate.com/v1/badges/a53aa8b7c413b950d519/test_coverage)](https://codeclimate.com/github/pboling/shiftable/test_coverage) |
+| maintainability         |  [![Maintainability](https://api.codeclimate.com/v1/badges/a53aa8b7c413b950d519/maintainability)](https://codeclimate.com/github/pboling/shiftable/maintainability) |
+| code triage             |  [![Open Source Helpers](https://www.codetriage.com/pboling/shiftable/badges/users.svg)](https://www.codetriage.com/pboling/shiftable) |
+| homepage                |  [on Github.com][homepage], [on Railsbling.com][blogpage] |
+| documentation           |  [on RDoc.info][documentation] |
+| Spread ~♡ⓛⓞⓥⓔ♡~      |  [🌏][aboutme], [👼][angelme], [💻][coderme], [![Tweet @ Peter][followme-img]][tweetme], [🌹][politicme] |
+
+## Compatibility
+
+Targeted ruby compatibility is non-EOL versions of Ruby, currently 2.6, 2.7, and 3.0, but may work on older Rubies back
+to 2.0, though it is limited to 2.5 in the gemspec. Feel free to fork if you need something older! Targeted ActiveRecord
+(Rails not required) compatibility follows the same scheme
+as [Rails Security Issue maintenance policy](https://guides.rubyonrails.org/maintenance_policy.html#security-issues),
+currently 6.1, 6.0, 5.2, but it is highly likely that this code will work in any version of ActiveRecord/Rails that runs
+on Ruby 2+.
+
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'shiftable'
+gem "shiftable"
 ```
 
 And then execute:
@@ -61,32 +87,86 @@ But how can you accomplish this? If you used the `shiftable` gem, won't take but
 
 class Spaceship < ActiveRecord::Base
   belongs_to :captain
-  extend Shiftable::Single.new(
-    belongs_to: :captain,
-    has_one: :spaceship,
-    preflight_checks: true,
-    before_shift: ->(shifting:, shift_to:, shift_from:) { shifting.ownership_changes += 1 }
-  )
+  extend Shiftable::Single.new belongs_to: :captain, has_one: :spaceship, precheck: true,
+                               before_shift: ->(shifting:, shift_to:, shift_from:) { shifting.ownership_changes += 1 }
+end
+```
+
+NOTE: It doesn't matter if the extend occurs before or after the association macro `belongs_to`.  In fact, it doesn't matter so much that you can even do this...
+
+```ruby
+
+class Spaceship < ActiveRecord::Base
+  belongs_to :captain
+
+  class << self
+    include Shiftable::Single.new belongs_to: :captain, has_one: :spaceship, precheck: true,
+                                  before_shift: lambda { |shifting:, shift_to:, shift_from:|
+                                    shifting.ownership_changes += 1
+                                  }
+  end
 end
 ```
 
+### Single Table Inheritance
+
+This works as you would expect with STI (single table inheritance) classes, i.e. when defined on a subclass, only the records of that class get shifted.
+
 ### Multiple association on a single class
 
-What if the Captain is really all that though? What if the captain and the spaceship have a boss... the space
-federation!
+What if the captain and the spaceship have a boss... the space
+federation!  And in a run-in with their arch-Nemesis the Plinth-inth,
+all federation spaceships are commandeered!  You are ruined!
 
 ```ruby
 
+class Spaceship < ActiveRecord::Base
+  belongs_to :space_federation
+  extend Shiftable::Collection.new belongs_to: :space_federation, has_one: :spaceship,
+                                   before_shift: lambda do |shifting_rel:, shift_to:, shift_from:|
+    shifting_rel.each { |spaceship| spaceship.federation_changes += 1 }
+  end
+end
+
+class SpaceFederation < ActiveRecord::Base
+  has_many :spaceships
+
+  def all_spaceships_commandeered_by(nemesis_federation)
+    Spaceship.shift_cx(shift_to: nemesis_federation, shift_from: self)
+  end
+end
+```
+
+### Complete example
+
+Putting it all together...
+
+```ruby
+class Captain < ActiveRecord::Base
+  has_one :spaceship
+
+  def sell_spaceship_to(nemesis_captain)
+    Spaceship.shift_single(shift_to: nemesis_captain, shift_from: self)
+  end
+end
+
 class Spaceship < ActiveRecord::Base
   belongs_to :captain
+  extend Shiftable::Single.new belongs_to: :captain, has_one: :spaceship, precheck: true,
+                               before_shift: ->(shifting:, shift_to:, shift_from:) { shifting.ownership_changes += 1 }
+
   belongs_to :space_federation
+  extend Shiftable::Collection.new belongs_to: :space_federation, has_one: :spaceship,
+                                   before_shift: lambda do |shifting_rel:, shift_to:, shift_from:|
+    shifting_rel.each { |spaceship| spaceship.federation_changes += 1 }
+  end
 end
 
 class SpaceFederation < ActiveRecord::Base
   has_many :captains
   has_many :spaceships
 
-  def sell_spaceship_to(nemesis_federation)
+  def all_spaceships_commandeered_by(nemesis_federation)
     Spaceship.shift_cx(shift_to: nemesis_federation, shift_from: self)
   end
 end
@@ -105,12 +185,63 @@ push git commits and the created tag, and push the `.gem` file to [rubygems.org]
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/pboling/shiftable. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/pboling/shiftable/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/pboling/shiftable. This project is intended to
+be a safe, welcoming space for collaboration, and contributors are expected to adhere to
+the [code of conduct](https://github.com/pboling/shiftable/blob/master/CODE_OF_CONDUCT.md).
+
+## Code of Conduct
+
+Everyone interacting in the Shiftable project's codebases, issue trackers, chat rooms and mailing lists is expected to
+follow the [code of conduct](https://github.com/pboling/shiftable/blob/master/CODE_OF_CONDUCT.md).
+
+## Versioning
+
+This library aims to adhere to [Semantic Versioning 2.0.0][semver]. Violations of this scheme should be reported as
+bugs. Specifically, if a minor or patch version is released that breaks backward compatibility, a new version should be
+immediately released that restores compatibility. Breaking changes to the public API will only be introduced with new
+major versions.
+
+As a result of this policy, you can (and should) specify a dependency on this gem using
+the [Pessimistic Version Constraint][pvc] with two digits of precision.
+
+For example:
+
+```ruby
+spec.add_dependency "shiftable", "~> 0.2"
+```
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of
+the [MIT License](https://opensource.org/licenses/MIT) [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+.
 
-## Code of Conduct
+* Copyright (c) 2021 [Peter H. Boling][peterboling] of [Rails Bling][railsbling]
+
+[license]: LICENSE
+
+[semver]: http://semver.org/
+
+[pvc]: http://guides.rubygems.org/patterns/#pessimistic-version-constraint
+
+[railsbling]: http://www.railsbling.com
+
+[peterboling]: http://www.peterboling.com
+
+[aboutme]: https://about.me/peter.boling
+
+[angelme]: https://angel.co/peter-boling
+
+[coderme]:http://coderwall.com/pboling
+
+[followme-img]: https://img.shields.io/twitter/follow/galtzo.svg?style=social&label=Follow
+
+[tweetme]: http://twitter.com/galtzo
+
+[politicme]: https://nationalprogressiveparty.org
+
+[documentation]: http://rdoc.info/github/pboling/shiftable/frames
+
+[homepage]: https://github.com/pboling/shiftable/
 
-Everyone interacting in the Shiftable project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/pboling/shiftable/blob/master/CODE_OF_CONDUCT.md).
+[blogpage]: http://www.railsbling.com/tags/shiftable/

data/lib/shiftable/collection.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-#
 # Usage:
 #
 #   class BlasterRounds < ActiveRecord::Base
@@ -15,74 +14,60 @@
 module Shiftable
   # Inheriting from Module is a powerful pattern. If you like it checkout the debug_logging gem!
   class Collection < Module
-    def initialize(belongs_to:, has_many:, method_prefix: nil, preflight_checks: true, before_save: nil)
+    # associations: belongs_to, has_many
+    # options: method_prefix, before_shift
+    def initialize(belongs_to:, has_many:, method_prefix: nil, before_shift: nil)
+      # Ruby's Module initializer doesn't take any arguments
       super()
-      raise ArgumentError, "belongs_to must be a symbol" unless belongs_to.is_a?(Symbol)
-      raise ArgumentError, "has_many must be a symbol" unless has_many.is_a?(Symbol)
-
-      # For the following, imagine you are a Spaceship Captain, the Spaceship belongs_to you, and it has only one Captain.
-      # But you have to sell it to your nemesis!
-      #
-      # The name of the belongs_to association, defined on the shifting model, e.g. Spaceship
-      # Normally a camel-cased, symbolized, version of the class name.
-      # In the case where Spaceship belongs_to: :captain, this is :captain.
-      @belongs_to = belongs_to
-
-      # The name of the has_one association, defined on the shift_to/shift_from model, e.g. Captain.
-      # Normally a camel-cased, symbolized, version of the class name.
-      # In the case where Captain has_one: :spaceship, this is :spaceship.
-      @has_many = has_many
 
-      @method_prefix = method_prefix
-
-      # will prevent the save if it returns false
-      # allows for any custom logic to be run, such as setting shift_from attributes, prior to the shift is saved.
-      @before_save = before_save
+      @signature = ModSignature.new(
+        # For the following, imagine you are a Space Federation, each Spaceship in the fleet belongs_to you,
+        #   i.e. the federation has_many spaceships.
+        # But you lose the war, and your nemesis commandeers all your ships!
+        associations: {
+          # The name of the belongs_to association, defined on the shifting model, e.g. Spaceship
+          # Normally a camel-cased, symbolized, version of the class name.
+          # In the case where Spaceship belongs_to: :space_federation, this is :space_federation.
+          belongs_to: belongs_to.to_s.to_sym,
+          # The name of the has_many association, defined on the shift_to/shift_from model, e.g. SpaceFederation.
+          # Normally a camel-cased, symbolized, version of the class name.
+          # In the case where SpaceFederation has_many: :spaceships, this is :spaceships.
+          has_many: has_many.to_s.to_sym
+        },
+        options: {
+          method_prefix: method_prefix,
+          # will prevent the save if it returns false
+          # allows for any custom logic to be run, such as setting attributes, prior to the shift (save).
+          before_shift: before_shift
+        },
+        type: :cx
+      )
     end
 
+    # NOTE: Possible difference in how inheritance works when using extend vs include
+    #       with Shiftable::Collection.new
     def extended(base)
-      shift_cx_modulizer = ShiftCollectionModulizer.to_mod(@belongs_to, @has_many, @method_prefix,
-                                                           @before_save)
+      shift_cx_modulizer = ShiftCollectionModulizer.to_mod(@signature.add_base(base))
       base.singleton_class.send(:prepend, shift_cx_modulizer)
     end
 
+    # NOTE: Possible difference in how inheritance works when using extend vs include
+    #       with Shiftable::Collection.new
     def included(base)
-      shift_cx_modulizer = ShiftCollectionModulizer.to_mod(@belongs_to, @has_many, @method_prefix,
-                                                           @before_save)
+      shift_cx_modulizer = ShiftCollectionModulizer.to_mod(@signature.add_base(base))
       base.send(:prepend, shift_cx_modulizer)
     end
 
     # Creates anonymous Ruby Modules, containing dynamically built methods
     module ShiftCollectionModulizer
-      def to_mod(belongs_to, has_many, mepr, before_save)
+      def to_mod(signature)
+        prefix = signature.method_prefix
         Module.new do
-          define_method(:"#{mepr}shift_cx_column") do
-            reflection = reflect_on_association(belongs_to).klass.reflect_on_association(has_many)
-            reflection.foreign_key
+          define_method(:"#{prefix}shift_cx_column") do
+            signature.shift_column
           end
-          define_method(:"#{mepr}shift_cx_relation") do |id|
-            return nil unless id
-
-            where(send("#{mepr}shift_cx_column") => id)
-          end
-          define_method(:"#{mepr}shift_cx_safe_relation") do |shift_to:, shift_from:|
-            return false if shift_from&.id.nil?
-            return false if shift_to&.id.nil?
-
-            send("#{mepr}shift_cx_relation", shift_from.id)
-          end
-          define_method(:"#{mepr}shift_cx") do |shift_to:, shift_from:|
-            shifting_rel = send("#{mepr}shift_cx_safe_relation", shift_to: shift_to, shift_from: shift_from)
-            return false unless shifting_rel && shifting_rel.any?
-
-            shifting_rel.each do |shifting|
-              shifting.send("#{send("#{mepr}shift_cx_column")}=", shift_to.id)
-            end
-            before_save.call(shifting_rel: shifting_rel, shift_to: shift_to, shift_from: shift_from) if before_save
-            shifting_rel.each do |shifting|
-              shifting.save
-            end
-            shifting_rel
+          define_method(:"#{prefix}shift_cx") do |shift_to:, shift_from:|
+            signature.shift_data!(shift_to: shift_to, shift_from: shift_from)
           end
         end
       end

data/lib/shiftable/mod_signature.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Shiftable
+  class ModSignature
+    VALID_TYPES = %i[sg cx].freeze
+    VALID_ASSOCIATIONS = {
+      sg: %i[belongs_to has_one],
+      cx: %i[belongs_to has_many]
+    }.freeze
+    DEFAULT_BEFORE_SHIFT = ->(*_) { true }
+    attr_reader :associations, :options, :type, :base
+
+    # Imagine you are a Spaceship Captain, the Spaceship belongs_to you, and it has only one Captain.
+    # But you have to sell it to your nemesis!
+    def initialize(associations:, type:, options: {})
+      @associations = associations
+      @options = options
+      @type = type
+      # See: https://maximomussini.com/posts/practical-applications-of-the-singleton-class/
+      singleton_class.send(:prepend, Object.const_get("Shiftable::ModSignature::#{type.capitalize}Methods", false))
+      validate
+    end
+
+    def validate
+      raise ArgumentError, "type must be one of: #{VALID_TYPES}, provided: #{type}" if invalid_type?
+      raise ArgumentError, "associations must be symbols" if invalid_association_key_type?
+      raise ArgumentError, "exactly two distinct associations must be provided" if invalid_number_of_associations?
+    end
+
+    def invalid_type?
+      !VALID_TYPES.include?(type)
+    end
+
+    def invalid_association_key_type?
+      associations.keys.detect { |key| !key.is_a?(Symbol) }
+    end
+
+    def invalid_number_of_associations?
+      associations.keys.uniq.length != 2
+    end
+
+    # @note Chainable
+    # @return self
+    def add_base(base)
+      @base = base
+      self
+    end
+
+    def has_rel_name
+      VALID_ASSOCIATIONS[type][1]
+    end
+
+    def validate_relationships
+      bt = base.reflect_on_association(belongs_to)
+      raise ArgumentError, "Unable to find belongs_to: :#{belongs_to} in #{base}" unless bt
+
+      klass = bt.klass
+      hr = klass.reflect_on_association(has_rel)
+      raise ArgumentError, "Unable to find #{has_rel_name}: :#{has_rel} in #{klass}" unless hr
+    end
+
+    module CxMethods
+      def has_many
+        associations[:has_many]
+      end
+
+      alias has_rel has_many
+
+      def shift_data!(shift_to:, shift_from:)
+        validate_relationships
+        shifting_rel = ShiftingRelation.new(
+          to: shift_to,
+          from: shift_from,
+          column: shift_column,
+          base: base
+        )
+        shifting_rel.shift do |result|
+          before_shift&.call(shifting_rel: result, shift_to: shift_to, shift_from: shift_from)
+        end
+      end
+    end
+
+    module SgMethods
+      def has_one
+        associations[:has_one]
+      end
+
+      alias has_rel has_one
+
+      # Do not move record if a record already exists (we are shifting a "has_one" association, after all)
+      def precheck
+        options[:precheck]
+      end
+
+      def shift_data!(shift_to:, shift_from:)
+        validate_relationships
+        shifting = ShiftingRecord.new(
+          to: shift_to,
+          from: shift_from,
+          column: shift_column,
+          base: base
+        ) do
+          !precheck || !shift_to.send(has_one)
+        end
+        shifting.shift do |result|
+          before_shift&.call(shifting: result, shift_to: shift_to, shift_from: shift_from)
+        end
+      end
+    end
+
+    # The name of the belongs_to association, defined on the shifting model, e.g. Spaceship
+    # Normally a camel-cased, symbolized, version of the class name.
+    # In the case where Spaceship belongs_to: :captain, this is :captain.
+    def belongs_to
+      associations[:belongs_to]
+    end
+
+    def method_prefix
+      options[:method_prefix]
+    end
+
+    # will prevent the save if it returns false
+    # allows for any custom logic to be run, such as setting shift_from attributes, prior to the shift is saved.
+    def before_shift
+      options[:before_shift] || DEFAULT_BEFORE_SHIFT
+    end
+
+    def shift_column
+      reflection = base.reflect_on_association(belongs_to).klass.reflect_on_association(has_rel)
+      reflection.foreign_key
+    end
+  end
+end

data/lib/shiftable/shifting.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Shiftable
+  # Gets data to be shifted
+  class Shifting
+    attr_reader :to, :from, :column, :base, :result, :run_save
+
+    def initialize(to:, from:, column:, base:)
+      @to = to
+      @from = from
+      @column = column
+      @base = base
+      validate
+      do_query = block_given? ? yield : true
+      @result = do_query ? query : nil
+      @run_save = true
+    end
+
+    # def found?
+    #   raise "found? must be defined in a subclass"
+    # end
+
+    # def shift
+    #   raise "shift must be defined in a subclass"
+    # end
+
+    private
+
+    def validate
+      raise ArgumentError, "shift_to must have an id (primary key) value, but is: #{to&.id}" unless to&.id
+      raise ArgumentError, "shift_from must have an id (primary key) value, but is: #{from&.id}" unless from&.id
+    end
+
+    # def query
+    #   raise "query must be defined in a subclass"
+    # end
+  end
+end

data/lib/shiftable/shifting_record.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Shiftable
+  # Gets data to be shifted
+  class ShiftingRecord < Shifting
+    def found?
+      !!result
+    end
+
+    # @return true, false
+    def shift
+      return false unless found?
+
+      result.send("#{column}=", to.id)
+      @run_save = yield result if block_given?
+      result.save if run_save
+    end
+
+    private
+
+    def query
+      base.find_by(column => from.id)
+    end
+  end
+end

data/lib/shiftable/shifting_relation.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Shiftable
+  # Gets data to be shifted
+  class ShiftingRelation < Shifting
+    include Enumerable
+
+    def found?
+      result.any?
+    end
+
+    def each(&block)
+      result.each(&block)
+    end
+
+    # @return result (once it is shifted)
+    def shift
+      return false unless found?
+
+      each do |record|
+        record.send("#{column}=", to.id)
+      end
+      @run_save = yield result if block_given?
+      each(&:save) if run_save
+      result
+    end
+
+    private
+
+    def query
+      base.where(column => from.id)
+    end
+  end
+end