shiftable 0.4.1 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7792e05d55078e47ad4fec714ebc5aeed51c6373ba64d31e410ab8cdfe01eb44
-  data.tar.gz: d1435eb2ab87f9e81367d73036d8bf23c270eccb29157cc1eaf364da9ef8fcb2
+  metadata.gz: ae22d0c5730e6bde9ad658ee1b8deddb2ca83e8d09cccc560945faf51c796b6a
+  data.tar.gz: b8ef6d21e4273b247a4287a31059eb02bed5bafaf3941562ddfc78f798fd139a
 SHA512:
-  metadata.gz: 8fc584eefc4ab6e4bbdcbb22a3b856f8baa2dff98daf5eceb149ced8865fa5c1dc020bcf1cde2918df47f3b0545c9c1827e9f369e2131c4bb5498804c1cce37c
-  data.tar.gz: d7970f2f74a80bdd5a657e89846a5eddd54d7396cd000d3022b0ba1782336b464586ea1391a23af6ff8df6b7d6047715c571cdfb43d55145744504f5ced7e4db
+  metadata.gz: 19ab8c6178402cb18788424023d380672a8d4c7597b432703b79f73900950cf353d8fe85702a0fbd09387f3dd61c4276ba69fe0e9e99499bc77b52d8c9bc3b0b
+  data.tar.gz: 66d90707da9952a116619e7421127f2c6bad0f4b74558e24ea0da97d7e5670a17960dfabf92ece49ab9cf10bcc60deb9f556f25fc835df656ba9ad1f0f17aa82

data/CHANGELOG.md

@@ -1,9 +1,45 @@
 ## [Unreleased]
 
-## [0.4.0] - 2021-10-27
+### Added
+
 
 ### Changed
 
+
+### Fixed
+
+
+### Removed
+
+
+## [0.6.1] - 2021-11-14
+### Added
+
+- Support for using save with bang (`save!`) to raise error when ActiveRecord save fails.
+
+## [0.6.0] - 2021-11-12
+### Added
+
+- Support for wrappers/hooks around each record shift, and around the entire set (see examples in specs or README)
+
+## [0.5.1] - 2021-11-12
+### Fixed
+
+- Documentation typos in README
+
+## [0.5.0] - 2021-11-12
+### Added
+
+- Support for Polymorphic associations (see examples in specs or README)
+
+## [0.4.1] - 2021-11-10
+### Fixed
+
+- Documentation typos in README
+
+## [0.4.0] - 2021-10-27
+### Changed
+
 - option :preflight_checks renamed to :precheck
 
 ### Added
@@ -11,7 +47,6 @@
 - Even more 100% spec coverage
 
 ## [0.3.0] - 2021-10-26
-
 ### Changed
 
 - Internal rewrite to improve maintainability
@@ -22,7 +57,6 @@
 - Even more 100% spec coverage
 
 ## [0.2.0] - 2021-10-24
-
 ### Changed
 
 - option `before_save` is now `before_shift` as originally documented
@@ -34,7 +68,6 @@
 - Documentation
 
 ## [0.1.1] - 2021-10-23
-
 ### Fixed
 
 - Github Actions build
@@ -44,7 +77,6 @@
 - Linting
 
 ## [0.1.0] - 2021-10-23
-
 ### Added
 
 - Initial release

data/README.md

@@ -80,7 +80,7 @@ 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, precheck: true,
-                               before_shift: ->(shifting:, shift_to:, shift_from:) { shifting.ownership_changes += 1 }
+                               before_shift: ->(shifting_rel) { shifting_rel.result.ownership_changes += 1 }
 end
 ```
 
@@ -104,18 +104,17 @@ end
 
 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
+### Multiple associations on a single class
 
 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 { |shifting_rel:, shift_to:, shift_from:|
+  extend Shiftable::Collection.new belongs_to: :space_federation, has_many: :spaceships,
+                                   before_shift: lambda { |shifting_rel|
                                      shifting_rel.each { |spaceship| spaceship.federation_changes += 1 }
                                    }
 end
@@ -129,6 +128,112 @@ class SpaceFederation < ActiveRecord::Base
 end
 ```
 
+### Polymorphism and has_many through
+
+```ruby
+class SpaceTreaty < ActiveRecord::Base
+  has_many :space_treaty_signature
+end
+
+class SpaceTreatySignature < ActiveRecord::Base
+  belongs_to :space_treaty
+  belongs_to :signatory, polymorphic: true
+  # When two space federations assimilate (i.e. merge) to form a single larger federation,
+  #   they become party to (i.e. signatories of) all the treaties that had been signed by either.
+  # In practical terms, this means:
+  #
+  #   surviving_federation = SpaceFederation.find(1)
+  #   assimilated_federation = SpaceFederation.find(2)
+  #   SpaceTreatySignature.where(
+  #     signatory_id: assimilated_federation_id,
+  #     signatory_type: "SpaceFederation"
+  #   ).update_all(
+  #     signatory_id: surviving_federation.id
+  #   )
+  extend Shiftable::Collection.new(
+    belongs_to: :signatory, has_many: :space_treaty_signature,
+    polymorphic: { type: "SpaceFederation", as: :signatory },
+    method_prefix: "space_federation_",
+    before_shift: lambda { |shifting_rel|
+      # Each item in shifting_rel is an instance of the class where Shiftable::Collection is defined,
+      #   in this case: SpaceTreatySignature
+      # And each of them has a signatory which is of type "SpaceFederation",
+      #   because a polymorphic collection only targets one type.
+      # shifting_rel.each { |signature| signature.signatory == "SpaceFederation" }
+    }
+  )
+end
+
+class SpaceFederation < ActiveRecord::Base
+  has_many :space_treaty_signature, as: :signatory
+  has_many :space_treaties, through: :space_treaty_signatures, as: :signatory
+  has_many :treaty_planets, class_name: "Planet", through: :space_treaty_signatures, as: :signatory
+  has_many :treaty_stations, class_name: "SpaceStation", through: :space_treaty_signatures, as: :signatory
+  def assimilate_from(other_federation)
+    SpaceTreatySignature.space_federation_shift_pcx(shift_to: self, shift_from: other_federation)
+  end
+end
+
+# Including Planet and SpaceStation, for completeness of the example as the other "types" of polymorphic signatories
+class Planet < ActiveRecord::Base
+  has_many :space_treaty_signature, as: :signatory
+  has_many :space_treaties, through: :space_treaty_signatures
+  has_many :treaty_federations, class_name: "SpaceFederation", through: :space_treaty_signatures, as: :signatory
+  has_many :treaty_stations, class_name: "SpaceStation", through: :space_treaty_signatures, as: :signatory
+end
+
+class SpaceStation < ActiveRecord::Base
+  has_many :space_treaty_signature, as: :signatory
+  has_many :space_treaties, through: :space_treaty_signatures
+  has_many :treaty_federations, class_name: "SpaceFederation", through: :space_treaty_signatures, as: :signatory
+  has_many :treaty_planets, class_name: "Planet", through: :space_treaty_signatures, as: :signatory
+end
+```
+
+### Wrapping a shift
+
+For example, in a transaction.  Let's update the nemesis foundation example from above with a transaction shift_each_wrapper,
+which we'll pull from the [`activerecord-transactionable`](https://github.com/pboling/activerecord-transactionable) gem, which provides best practice framing around transactions.
+
+```ruby
+class Spaceship < ActiveRecord::Base
+  belongs_to :space_federation
+  extend Shiftable::Collection.new(
+    belongs_to: :space_federation,
+    has_many: :spaceships,
+    before_shift: lambda { |shifting_rel|
+                    shifting_rel.each { |spaceship| spaceship.federation_changes += 1 }
+                  },
+    wrapper: {
+      each: lambda { |record, &block|
+              tresult = record.transaction_wrapper(outside_rescued_errors: ActiveRecord::RecordNotUnique) do
+                puts "melon #{record.name} honey"
+                block.call # does the actual saving!
+              end
+              # NOTE: The value returned by the wrapper will also be returned by the call to `shift_cx`.
+              #       You could return the whole tresult object here, instead of just true/false!
+              tresult.success?
+            },
+      all: lambda { |rel, &block|
+             tresult = Spaceship.transaction_wrapper do
+               puts "can you eat #{rel.count} shoes"
+               block.call
+             end
+             tresult.success?
+           }
+    }
+  )
+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...
@@ -145,23 +250,78 @@ 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 }
+                               before_shift: ->(shifting_rel) { shifting_rel.result.ownership_changes += 1 }
 
   belongs_to :space_federation
-  extend Shiftable::Collection.new belongs_to: :space_federation, has_one: :spaceship,
-                                   before_shift: lambda { |shifting_rel:, shift_to:, shift_from:|
-                                     shifting_rel.each { |spaceship| spaceship.federation_changes += 1 }
-                                   }
+  extend Shiftable::Collection.new(
+    belongs_to: :space_federation,
+    has_many: :spaceships,
+    before_shift: lambda { |shifting_rel|
+      shifting_rel.each { |spaceship| spaceship.federation_changes += 1 }
+    },
+    wrapper: {
+      each: lambda { |record, &block|
+              tresult = record.transaction_wrapper(outside_rescued_errors: ActiveRecord::RecordNotUnique) do
+                puts "melon #{record.name} honey"
+                block.call # does the actual saving!
+              end
+              tresult.success?
+            },
+      all: lambda { |rel, &block|
+             tresult = Spaceship.transaction_wrapper do
+               puts "can you eat #{rel.count} shoes"
+               block.call
+             end
+             tresult.success?
+           }
+    }
+  )
 end
 
 class SpaceFederation < ActiveRecord::Base
   has_many :captains
   has_many :spaceships
+  has_many :space_treaty_signature, as: :signatory
+  has_many :space_treaties, through: :space_treaty_signatures, as: :signatory
+  has_many :treaty_planets, class_name: "Planet", through: :space_treaty_signatures, as: :signatory
+  has_many :treaty_stations, class_name: "SpaceStation", through: :space_treaty_signatures, as: :signatory
+
+  def assimilate_from(other_federation)
+    SpaceTreatySignature.space_federation_shift_cx(shift_to: self, shift_from: other_federation)
+  end
 
   def all_spaceships_commandeered_by(nemesis_federation)
     Spaceship.shift_cx(shift_to: nemesis_federation, shift_from: self)
   end
 end
+class SpaceTreaty < ActiveRecord::Base
+  has_many :space_treaty_signatures
+end
+
+class SpaceTreatySignature < ActiveRecord::Base
+  belongs_to :space_treaty
+  belongs_to :signatory, polymorphic: true
+  extend Shiftable::Collection.new(
+    belongs_to: :signatory, has_many: :space_treaty_signatures,
+    polymorphic: { type: "SpaceFederation", as: :signatory },
+    method_prefix: "space_federation_"
+  )
+end
+
+# Including Planet and SpaceStation, for completeness of the example as the other "types" of polymorphic signatories
+class Planet < ActiveRecord::Base
+  has_many :space_treaty_signatures, as: :signatory
+  has_many :space_treaties, through: :space_treaty_signatures
+  has_many :treaty_federations, class_name: "SpaceFederation", through: :space_treaty_signatures, as: :signatory
+  has_many :treaty_stations, class_name: "SpaceStation", through: :space_treaty_signatures, as: :signatory
+end
+
+class SpaceStation < ActiveRecord::Base
+  has_many :space_treaty_signature, as: :signatory
+  has_many :space_treaties, through: :space_treaty_signatures
+  has_many :treaty_federations, class_name: "SpaceFederation", through: :space_treaty_signatures, as: :signatory
+  has_many :treaty_planets, class_name: "Planet", through: :space_treaty_signatures, as: :signatory
+end
 ```
 
 ... stay tuned!

data/lib/shiftable/collection.rb

@@ -16,7 +16,7 @@ module Shiftable
   class Collection < Module
     # associations: belongs_to, has_many
     # options: method_prefix, before_shift
-    def initialize(belongs_to:, has_many:, method_prefix: nil, before_shift: nil)
+    def initialize(belongs_to:, has_many:, polymorphic: nil, method_prefix: nil, before_shift: nil, wrapper: nil)
       # Ruby's Module initializer doesn't take any arguments
       super()
 
@@ -35,12 +35,18 @@ module Shiftable
           has_many: has_many.to_s.to_sym
         },
         options: {
+          polymorphic: polymorphic,
           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
+          before_shift: before_shift,
+          # wrapper: {
+          #   all: ->() { klass.transaction_wrapper { yield } },
+          #   each: ->() { klass.transaction_wrapper { yield } },
+          # }
+          wrapper: wrapper
         },
-        type: :cx
+        type: polymorphic ? :pcx : :cx
       )
     end
 
@@ -62,12 +68,13 @@ module Shiftable
     module ShiftCollectionModulizer
       def to_mod(signature)
         prefix = signature.method_prefix
+        type = signature.type
         Module.new do
-          define_method(:"#{prefix}shift_cx_column") do
-            signature.shift_column
+          define_method(:"#{prefix}shift_#{type}_column") do
+            signature.send("shift_#{type}_column")
           end
-          define_method(:"#{prefix}shift_cx") do |shift_to:, shift_from:|
-            signature.shift_data!(shift_to: shift_to, shift_from: shift_from)
+          define_method(:"#{prefix}shift_#{type}") do |shift_to:, shift_from:, bang: false|
+            signature.shift_data!(shift_to: shift_to, shift_from: shift_from, bang: bang)
           end
         end
       end

data/lib/shiftable/mod_signature.rb

@@ -2,8 +2,8 @@
 
 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
+    VALID_ASSOCIATIONS = { sg: %i[belongs_to has_one], cx: %i[belongs_to has_many], pcx: %i[belongs_to has_many] }.freeze
+    VALID_TYPES = VALID_ASSOCIATIONS.keys.dup.freeze
     DEFAULT_BEFORE_SHIFT = ->(*_) { true }
     attr_reader :associations, :options, :type, :base
 
@@ -24,6 +24,18 @@ module Shiftable
       raise ArgumentError, "exactly two distinct associations must be provided" if invalid_number_of_associations?
     end
 
+    def wrapper
+      options[:wrapper] || {}
+    end
+
+    def polymorphic_type
+      options.dig(:polymorphic, :type)
+    end
+
+    def polymorphic_as
+      options.dig(:polymorphic, :as)
+    end
+
     def invalid_type?
       !VALID_TYPES.include?(type)
     end
@@ -48,59 +60,87 @@ module Shiftable
     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
+      bt_reflection = base.reflect_on_association(belongs_to)
+      raise ArgumentError, "Unable to find belongs_to: :#{belongs_to} in #{base}" unless bt_reflection
+      # We can't validate any further if the reflection is polymorphic
+      return true if bt_reflection.polymorphic?
+
+      klass = bt_reflection.klass
+      has_reflection = klass.reflect_on_association(has_rel)
+      raise ArgumentError, "Unable to find #{has_rel_name}: :#{has_rel} in #{klass}" unless has_reflection
     end
 
     module CxMethods
-      def has_many
+      def has_rel
         associations[:has_many]
       end
 
-      alias has_rel has_many
-
-      def shift_data!(shift_to:, shift_from:)
+      def shift_data!(shift_to:, shift_from:, bang: false)
         validate_relationships
         shifting_rel = ShiftingRelation.new(
           to: shift_to,
           from: shift_from,
           column: shift_column,
-          base: base
+          base: base,
+          wrapper: wrapper,
+          bang: bang
         )
-        shifting_rel.shift do |result|
-          before_shift&.call(shifting_rel: result, shift_to: shift_to, shift_from: shift_from)
+        shifting_rel.shift do
+          before_shift&.call(shifting_rel)
+        end
+      end
+    end
+
+    module PcxMethods
+      # This method could be defined for parity, but it is never used.
+      # def has_rel
+      #   associations[:has_many]
+      # end
+
+      def shift_data!(shift_to:, shift_from:, bang: false)
+        validate_relationships
+        shifting_rel = ShiftingPolymorphicRelation.new(
+          to: shift_to,
+          from: shift_from,
+          column: {
+            type: polymorphic_type,
+            as: polymorphic_as,
+            id_column: shift_pcx_column
+          },
+          base: base,
+          wrapper: wrapper,
+          bang: bang
+        )
+        shifting_rel.shift do
+          before_shift&.call(shifting_rel)
         end
       end
     end
 
     module SgMethods
-      def has_one
+      def has_rel
         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:)
+      def shift_data!(shift_to:, shift_from:, bang: false)
         validate_relationships
         shifting = ShiftingRecord.new(
           to: shift_to,
           from: shift_from,
           column: shift_column,
-          base: base
+          base: base,
+          wrapper: wrapper,
+          bang: bang
         ) do
-          !precheck || !shift_to.send(has_one)
+          !precheck || !shift_to.send(has_rel)
         end
-        shifting.shift do |result|
-          before_shift&.call(shifting: result, shift_to: shift_to, shift_from: shift_from)
+        shifting.shift do
+          before_shift&.call(shifting)
         end
       end
     end
@@ -122,9 +162,16 @@ module Shiftable
       options[:before_shift] || DEFAULT_BEFORE_SHIFT
     end
 
+    def shift_pcx_column
+      "#{polymorphic_as}_id"
+    end
+
     def shift_column
       reflection = base.reflect_on_association(belongs_to).klass.reflect_on_association(has_rel)
       reflection.foreign_key
     end
+
+    alias shift_sg_column shift_column
+    alias shift_cx_column shift_column
   end
 end

data/lib/shiftable/shifting.rb

@@ -3,9 +3,13 @@
 module Shiftable
   # Gets data to be shifted
   class Shifting
-    attr_reader :to, :from, :column, :base, :result, :run_save
+    # Public API
+    attr_accessor :result, :bang, :shift_all_wrapper, :shift_each_wrapper
+    attr_reader :to, :from
+    # Internal API
+    attr_reader :column, :base, :run_save
 
-    def initialize(to:, from:, column:, base:)
+    def initialize(to:, from:, column:, base:, wrapper:, bang:)
       @to = to
       @from = from
       @column = column
@@ -14,6 +18,9 @@ module Shiftable
       do_query = block_given? ? yield : true
       @result = do_query ? query : nil
       @run_save = true
+      @shift_all_wrapper = wrapper[:all]
+      @shift_each_wrapper = wrapper[:each]
+      @bang = bang
     end
 
     # def found?
@@ -31,6 +38,28 @@ module Shiftable
       raise ArgumentError, "shift_from must have an id (primary key) value, but is: #{from&.id}" unless from&.id
     end
 
+    def run_save!
+      if shift_all_wrapper
+        shift_all_wrapper.call(self) do
+          do_saves
+        end
+      else
+        do_saves
+      end
+    end
+
+    def do_saves
+      if shift_each_wrapper
+        each do |rec|
+          shift_each_wrapper.call(rec) do
+            bang ? rec.save! : rec.save
+          end
+        end
+      else
+        bang ? each(&:save!) : each(&:save)
+      end
+    end
+
     # def query
     #   raise "query must be defined in a subclass"
     # end

data/lib/shiftable/shifting_polymorphic_relation.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Shiftable
+  # Gets data to be shifted
+  class ShiftingPolymorphicRelation < Shifting
+    include Enumerable
+
+    def polymorphic_id_column
+      column[:id_column]
+    end
+
+    def polymorphic_type_column
+      "#{column[:as]}_type"
+    end
+
+    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("#{polymorphic_id_column}=", to.id)
+      end
+      @run_save = yield if block_given?
+      return result unless run_save
+
+      run_save!
+      result
+    end
+
+    private
+
+    def query
+      base.where(
+        polymorphic_type_column => column[:type],
+        polymorphic_id_column => from.id
+      )
+    end
+  end
+end

data/lib/shiftable/shifting_record.rb

@@ -12,12 +12,34 @@ module Shiftable
       return false unless found?
 
       result.send("#{column}=", to.id)
-      @run_save = yield result if block_given?
-      result.save if run_save
+      @run_save = yield if block_given?
+      return nil unless run_save
+
+      run_save!
     end
 
     private
 
+    def run_save!
+      if shift_all_wrapper
+        shift_all_wrapper.call(self) do
+          do_save
+        end
+      else
+        do_save
+      end
+    end
+
+    def do_save
+      if shift_each_wrapper
+        shift_each_wrapper.call(result) do
+          bang ? result.save! : result.save
+        end
+      else
+        bang ? result.save! : result.save
+      end
+    end
+
     def query
       base.find_by(column => from.id)
     end

data/lib/shiftable/shifting_relation.rb

@@ -20,8 +20,10 @@ module Shiftable
       each do |record|
         record.send("#{column}=", to.id)
       end
-      @run_save = yield result if block_given?
-      each(&:save) if run_save
+      @run_save = yield if block_given?
+      return result unless run_save
+
+      run_save!
       result
     end
 

data/lib/shiftable/single.rb

@@ -14,14 +14,14 @@
 #             belongs_to: :captain,
 #             has_one: :spaceship,
 #             precheck: true,
-#             before_shift: ->(shifting:, shift_to:, shift_from:) { shifting.ownership_changes += 1 }
+#             before_shift: ->(shifting_rel) { shifting_rel.result..ownership_changes += 1 }
 #           )
 #   end
 #
 module Shiftable
   # Inheriting from Module is a powerful pattern. If you like it checkout the debug_logging gem!
   class Single < Module
-    def initialize(belongs_to:, has_one:, method_prefix: nil, precheck: true, before_shift: nil)
+    def initialize(belongs_to:, has_one:, method_prefix: nil, precheck: true, before_shift: nil, wrapper: nil)
       # Ruby's Module initializer doesn't take any arguments
       super()
 
@@ -44,7 +44,8 @@ module Shiftable
           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
+          before_shift: before_shift,
+          wrapper: wrapper
         },
         type: :sg
       )
@@ -70,10 +71,10 @@ module Shiftable
         prefix = signature.method_prefix
         Module.new do
           define_method(:"#{prefix}shift_column") do
-            signature.shift_column
+            signature.send("shift_#{signature.type}_column")
           end
-          define_method(:"#{prefix}shift_single") do |shift_to:, shift_from:|
-            signature.shift_data!(shift_to: shift_to, shift_from: shift_from)
+          define_method(:"#{prefix}shift_single") do |shift_to:, shift_from:, bang: false|
+            signature.shift_data!(shift_to: shift_to, shift_from: shift_from, bang: bang)
           end
         end
       end

data/lib/shiftable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Shiftable
-  VERSION = "0.4.1"
+  VERSION = "0.6.1"
 end

data/lib/shiftable.rb

@@ -3,6 +3,7 @@
 require_relative "shiftable/version"
 require_relative "shiftable/shifting"
 require_relative "shiftable/shifting_record"
+require_relative "shiftable/shifting_polymorphic_relation"
 require_relative "shiftable/shifting_relation"
 require_relative "shiftable/mod_signature"
 require_relative "shiftable/collection"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shiftable
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.6.1
 platform: ruby
 authors:
 - Peter Boling
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-11-10 00:00:00.000000000 Z
+date: 2021-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5'
+- !ruby/object:Gem::Dependency
+  name: activerecord-transactionable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -136,6 +150,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: silent_stream
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -181,6 +209,7 @@ files:
 - lib/shiftable/collection.rb
 - lib/shiftable/mod_signature.rb
 - lib/shiftable/shifting.rb
+- lib/shiftable/shifting_polymorphic_relation.rb
 - lib/shiftable/shifting_record.rb
 - lib/shiftable/shifting_relation.rb
 - lib/shiftable/single.rb