shiftable 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 769e7ab8e27a7ea4a5ea0e9ea2b7efeda58865f11a15f6504e0e00f6db8f9ce9
-  data.tar.gz: 3caa7d81b477be16f016358e6412a300782688632ea640685bdda70e63df6231
+  metadata.gz: 15d27c7c2706faf797241101fa5229f4bf707b06f4d1b7c839cc66fd7ab2ecf8
+  data.tar.gz: 0fa0fbe15096d109c2d63568101ad0589b4c684775b69b95e831289b8bfdac3d
 SHA512:
-  metadata.gz: 3055e1d7bb53da73830429a6d942c992aea32991412b3c97a281f5559a151a6ed9cf8f11cad868c83a7c329886f97c75db3cd69d4eb7bef5c8cd7114a9b3e894
-  data.tar.gz: e060753ad1c7190ca7047fa12040f6799f43d425762414e0201d424f63291f425c7354b7377fb3cc6fbee662ebc328b54fc63debbcc084fba08b2fcadfbac95c
+  metadata.gz: fa80c525bb2a0cfa99a82350da151412972f86a6699e1091e520d9cec40466f07789e5d1e593f8e3b720cc9e447d742acf28f2c09f5b02c61745cf8ca79084cf
+  data.tar.gz: 4abc0b5c410ba1748646122914ac768829984934e1f57b4d0483db18d0d5985b1976d69deeceabb3bf04fc5b4e3b6307056e3eeae2cffbd89e8099059cb32c07

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [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

data/lib/shiftable/collection.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-#
 # Usage:
 #
 #   class BlasterRounds < ActiveRecord::Base
@@ -15,72 +14,59 @@
 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_shift: 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_shift = before_shift
+      @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_shift)
+      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_shift)
+      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_shift)
+      def to_mod(signature)
         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(:"#{signature.mepr}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_shift&.call(shifting_rel: shifting_rel, shift_to: shift_to, shift_from: shift_from)
-            shifting_rel.each(&:save)
-            shifting_rel
+          define_method(:"#{signature.mepr}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,164 @@
+# 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
+    attr_accessor :associations, :options, :type
+    attr_reader :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}" unless VALID_TYPES.include?(type)
+      raise ArgumentError, "associations must be symbols" if associations.keys.detect { |a| !a.is_a?(Symbol) }
+      raise ArgumentError, "exactly two distinct associations must be provided" unless associations.keys.uniq.length == 2
+
+      invalid_tokens = associations.keys - VALID_ASSOCIATIONS[type]
+      raise ArgumentError, "valid associations: #{VALID_ASSOCIATIONS[type]}, invalid: #{invalid_tokens}" if invalid_tokens.any?
+    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
+
+      hr = bt.klass.reflect_on_association(has_rel)
+      raise ArgumentError, "Unable to find #{has_rel_name}: :#{has_rel} in #{bt.klass}" unless hr
+    end
+
+    module CxMethods
+      def has_many
+        associations[:has_many]
+      end
+
+      alias has_rel has_many
+
+      # returns nil or ActiveRecord::Relation object
+      def data_for_shift(id)
+        base.where(send("shift_column") => id) if super
+      end
+
+      # returns false, nil or ActiveRecord::Relation object
+      def data_for_shift_safe(shift_to:, shift_from:)
+        return false unless super
+
+        data_for_shift(shift_from.id)
+      end
+
+      def shift_data!(shift_to:, shift_from:)
+        validate_relationships
+
+        shifting_rel = data_for_shift_safe(shift_to: shift_to, shift_from: shift_from)
+        return false unless shifting_rel && shifting_rel.any?
+
+        shifting_rel.each do |shifting|
+          shifting.send("#{send(:shift_column)}=", shift_to.id)
+        end
+        before_shift&.call(shifting_rel: shifting_rel, shift_to: shift_to, shift_from: shift_from)
+        shifting_rel.each(&:save)
+        shifting_rel
+      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 preflight_checks
+        options[:preflight_checks]
+      end
+
+      # returns nil or ActiveRecord object
+      def data_for_shift(id)
+        base.find_by(send("shift_column") => id) if super
+      end
+
+      # returns false, nil or ActiveRecord object
+      def data_for_shift_safe(shift_to:, shift_from:)
+        return false unless super
+
+        if preflight_checks
+          already_exists = shift_to.send(has_one)
+          return false if already_exists
+        end
+        data_for_shift(shift_from.id)
+      end
+
+      def shift_data!(shift_to:, shift_from:)
+        validate_relationships
+
+        shifting = data_for_shift_safe(shift_to: shift_to, shift_from: shift_from)
+        return false unless shifting
+
+        shifting.send("#{send(:shift_column)}=", shift_to.id)
+        shifting.save if before_shift.nil? || before_shift.call(shifting: shifting, shift_to: shift_to,
+                                                                shift_from: shift_from)
+      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
+
+    alias mepr 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.
+    def before_shift
+      options[:before_shift]
+    end
+
+    def shift_column
+      reflection = base.reflect_on_association(belongs_to).klass.reflect_on_association(has_rel)
+      reflection.foreign_key
+    end
+
+    # Effect is to short-circuit data_for_shift method prior to executing the ActiveRecord query
+    #   if there is no ID, to avoid a full table scan when no id provided,
+    #   e.g. where(id: nil).
+    def data_for_shift(id)
+      true if id
+    end
+
+    # Effect is to short-circuit data_for_shift_safe method prior to executing the ActiveRecord query
+    #   if there is no ID, to avoid a full table scan when no id provided,
+    #   e.g. where(id: nil).
+    def data_for_shift_safe(shift_to:, shift_from:)
+      true if shift_from&.id && shift_to&.id
+    end
+  end
+end

data/lib/shiftable/single.rb

@@ -22,76 +22,57 @@ 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, preflight_checks: true, 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_one must be a symbol" unless has_one.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_one = has_one
-
-      @method_prefix = method_prefix
-
-      # Do not move record if a record already exists (we are shifting a "has_one" association, after all)
-      @preflight_checks = preflight_checks
-
-      # 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_shift = before_shift
+      @signature = ModSignature.new(
+        # 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!
+        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: :captain, this is :captain.
+          belongs_to: belongs_to.to_s.to_sym,
+          # 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_one: has_one.to_s.to_sym
+        },
+        options: {
+          # Do not move record if a record already exists (we are shifting a "has_one" association, after all)
+          preflight_checks: preflight_checks,
+          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: :sg
+      )
     end
 
+    # NOTE: Possible difference in how inheritance works when using extend vs include
+    #       with Shiftable::Single.new
     def extended(base)
-      shift_single_modulizer = ShiftSingleModulizer.to_mod(@belongs_to, @has_one, @method_prefix, @preflight_checks,
-                                                           @before_shift)
+      shift_single_modulizer = ShiftSingleModulizer.to_mod(@signature.add_base(base))
       base.singleton_class.send(:prepend, shift_single_modulizer)
     end
 
+    # NOTE: Possible difference in how inheritance works when using extend vs include
+    #       with Shiftable::Single.new
     def included(base)
-      shift_single_modulizer = ShiftSingleModulizer.to_mod(@belongs_to, @has_one, @method_prefix, @preflight_checks,
-                                                           @before_shift)
+      shift_single_modulizer = ShiftSingleModulizer.to_mod(@signature.add_base(base))
       base.send(:prepend, shift_single_modulizer)
     end
 
     # Creates anonymous Ruby Modules, containing dynamically built methods
     module ShiftSingleModulizer
-      def to_mod(belongs_to, has_one, mepr, preflight_checks, before_shift)
+      def to_mod(signature)
         Module.new do
-          define_method(:"#{mepr}shift_column") do
-            reflection = reflect_on_association(belongs_to).klass.reflect_on_association(has_one)
-            reflection.foreign_key
-          end
-          define_method(:"#{mepr}shift_find") do |id|
-            return nil unless id
-
-            find_by(send("#{mepr}shift_column") => id)
+          define_method(:"#{signature.mepr}shift_column") do
+            signature.shift_column
           end
-          define_method(:"#{mepr}shift_safe_find") do |shift_to:, shift_from:|
-            return false if shift_from&.id.nil?
-            return false if shift_to&.id.nil?
-
-            if preflight_checks
-              already_exists = shift_to.send(has_one)
-              return false if already_exists
-            end
-
-            send("#{mepr}shift_find", shift_from.id)
-          end
-          define_method(:"#{mepr}shift_single") do |shift_to:, shift_from:|
-            shifting = send("#{mepr}shift_safe_find", shift_to: shift_to, shift_from: shift_from)
-            return false unless shifting
-
-            shifting.send("#{send("#{mepr}shift_column")}=", shift_to.id)
-            shifting.save if before_shift.nil? || before_shift.call(shifting: shifting, shift_to: shift_to,
-                                                                    shift_from: shift_from)
+          define_method(:"#{signature.mepr}shift_single") do |shift_to:, shift_from:|
+            signature.shift_data!(shift_to: shift_to, shift_from: shift_from)
           end
         end
       end

data/lib/shiftable/version.rb

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

data/lib/shiftable.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 require_relative "shiftable/version"
-require_relative "shiftable/single"
+require_relative "shiftable/mod_signature"
 require_relative "shiftable/collection"
+require_relative "shiftable/single"
 
 module Shiftable
   class Error < StandardError; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shiftable
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Peter Boling
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-24 00:00:00.000000000 Z
+date: 2021-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -318,6 +318,7 @@ files:
 - README.md
 - lib/shiftable.rb
 - lib/shiftable/collection.rb
+- lib/shiftable/mod_signature.rb
 - lib/shiftable/single.rb
 - lib/shiftable/version.rb
 homepage: https://railsbling.com/tags/shiftable