acts_as_list 0.7.4 → 1.1.0

data/lib/acts_as_list/active_record/acts/no_update.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Acts
+    module List
+      module NoUpdate
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        class ArrayTypeError < ArgumentError
+          def initialize
+            super("The first argument must be an array")
+          end
+        end
+
+        class DisparityClassesError < ArgumentError
+          def initialize
+            super("The first argument should contain ActiveRecord or ApplicationRecord classes")
+          end
+        end
+
+        module ClassMethods
+          # Lets you selectively disable all act_as_list database updates
+          # for the duration of a block.
+          #
+          # ==== Examples
+          #
+          # class TodoList < ActiveRecord::Base
+          #   has_many :todo_items, -> { order(position: :asc) }
+          # end
+          #
+          # class TodoItem < ActiveRecord::Base
+          #   belongs_to :todo_list
+          #
+          #   acts_as_list scope: :todo_list
+          # end
+          #
+          # TodoItem.acts_as_list_no_update do
+          #   TodoList.first.update(position: 2)
+          # end
+          #
+          # You can also pass an array of classes as an argument to disable database updates on just those classes.
+          # It can be any ActiveRecord class that has acts_as_list enabled.
+          #
+          # ==== Examples
+          #
+          # class TodoList < ActiveRecord::Base
+          #   has_many :todo_items, -> { order(position: :asc) }
+          #   acts_as_list
+          # end
+          #
+          # class TodoItem < ActiveRecord::Base
+          #   belongs_to :todo_list
+          #   has_many :todo_attachments, -> { order(position: :asc) }
+          #
+          #   acts_as_list scope: :todo_list
+          # end
+          #
+          # class TodoAttachment < ActiveRecord::Base
+          #   belongs_to :todo_list
+          #   acts_as_list scope: :todo_item
+          # end
+          #
+          # TodoItem.acts_as_list_no_update([TodoAttachment]) do
+          #   TodoItem.find(10).update(position: 2)
+          #   TodoAttachment.find(10).update(position: 1)
+          #   TodoAttachment.find(11).update(position: 2)
+          #   TodoList.find(2).update(position: 3) # For this instance the callbacks will be called because we haven't passed the class as an argument
+          # end
+
+          def acts_as_list_no_update(extra_classes = [], &block)
+            return raise ArrayTypeError unless extra_classes.is_a?(Array)
+
+            extra_classes << self
+
+            return raise DisparityClassesError unless active_record_objects?(extra_classes)
+
+            NoUpdate.apply_to(extra_classes, &block)
+          end
+
+          private
+
+          def active_record_objects?(extra_classes)
+            extra_classes.all? { |klass| klass.ancestors.include? ActiveRecord::Base }
+          end
+        end
+
+        class << self
+          def apply_to(klasses)
+            klasses.map {|klass| add_klass(klass)}
+            yield
+          ensure
+            klasses.map {|klass| remove_klass(klass)}
+          end
+
+          def applied_to?(klass)
+            !(klass.ancestors & extracted_klasses.keys).empty?
+          end
+
+          private
+
+          def extracted_klasses
+            Thread.current[:act_as_list_no_update] ||= {}
+          end
+
+          def add_klass(klass)
+            extracted_klasses[klass] = 0 unless extracted_klasses.key?(klass)
+            extracted_klasses[klass] += 1
+          end
+
+          def remove_klass(klass)
+            extracted_klasses[klass] -= 1
+            extracted_klasses.delete(klass) if extracted_klasses[klass] <= 0
+          end
+        end
+
+        def act_as_list_no_update?
+          NoUpdate.applied_to?(self.class)
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_list/active_record/acts/position_column_method_definer.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module ActiveRecord::Acts::List::PositionColumnMethodDefiner #:nodoc:
+  def self.call(caller_class, position_column, touch_on_update)
+    define_class_methods(caller_class, position_column, touch_on_update)
+    define_instance_methods(caller_class, position_column)
+
+    if mass_assignment_protection_was_used_by_user?(caller_class)
+      protect_attributes_from_mass_assignment(caller_class, position_column)
+    end
+  end
+
+  private
+
+  def self.define_class_methods(caller_class, position_column, touch_on_update)
+    caller_class.class_eval do
+      define_singleton_method :quoted_position_column do
+        @_quoted_position_column ||= connection.quote_column_name(position_column)
+      end
+
+      define_singleton_method :quoted_position_column_with_table_name do
+        @_quoted_position_column_with_table_name ||= "#{caller_class.quoted_table_name}.#{quoted_position_column}"
+      end
+
+      define_singleton_method :decrement_sequentially do
+        pluck(primary_key).each do |id|
+          where(primary_key => id).decrement_all
+        end
+      end
+
+      define_singleton_method :increment_sequentially do
+        pluck(primary_key).each do |id|
+          where(primary_key => id).increment_all
+        end
+      end
+
+      define_singleton_method :decrement_all do
+        update_all_with_touch "#{quoted_position_column} = (#{quoted_position_column_with_table_name} - 1)"
+      end
+
+      define_singleton_method :increment_all do
+        update_all_with_touch "#{quoted_position_column} = (#{quoted_position_column_with_table_name} + 1)"
+      end
+
+      define_singleton_method :update_all_with_touch do |updates|
+        updates += touch_record_sql if touch_on_update
+        update_all(updates)
+      end
+
+      private
+
+      define_singleton_method :touch_record_sql do
+        new.touch_record_sql
+      end
+    end
+  end
+
+  def self.define_instance_methods(caller_class, position_column)
+    caller_class.class_eval do
+      attr_reader :position_changed
+
+      define_method :position_column do
+        position_column
+      end
+
+      define_method :"#{position_column}=" do |position|
+        self[position_column] = position
+        @position_changed = true
+      end
+
+      define_method :touch_record_sql do
+        cached_quoted_now = quoted_current_time_from_proper_timezone
+
+        timestamp_attributes_for_update_in_model.map do |attr|
+          ", #{connection.quote_column_name(attr)} = #{cached_quoted_now}"
+        end.join
+      end
+
+      private
+
+      delegate :connection, to: self
+
+      def quoted_current_time_from_proper_timezone
+        connection.quote(connection.quoted_date(
+          current_time_from_proper_timezone))
+      end
+    end
+  end
+
+  def self.mass_assignment_protection_was_used_by_user?(caller_class)
+    caller_class.class_eval do
+      respond_to?(:accessible_attributes) and accessible_attributes.present?
+    end
+  end
+
+  def self.protect_attributes_from_mass_assignment(caller_class, position_column)
+    caller_class.class_eval do
+      attr_accessible position_column.to_sym
+    end
+  end
+end

data/lib/acts_as_list/active_record/acts/scope_method_definer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+require "active_support/inflector"
+
+module ActiveRecord::Acts::List::ScopeMethodDefiner #:nodoc:
+  extend ActiveSupport::Inflector
+
+  def self.call(caller_class, scope)
+    scope = idify(caller_class, scope) if scope.is_a?(Symbol)
+
+    caller_class.class_eval do
+      define_method :scope_name do
+        scope
+      end
+
+      if scope.is_a?(Symbol)
+        define_method :scope_condition do
+          { scope => send(:"#{scope}") }
+        end
+
+        define_method :scope_changed? do
+          changed.include?(scope_name.to_s)
+        end
+
+        define_method :destroyed_via_scope? do
+          scope == (destroyed_by_association && destroyed_by_association.foreign_key.to_sym)
+        end
+      elsif scope.is_a?(Array)
+        define_method :scope_condition do
+          # The elements of the Array can be symbols, strings, or hashes.
+          # If symbols or strings, they are treated as column names and the current value is looked up.
+          # If hashes, they are treated as fixed values.
+          scope.inject({}) do |hash, column_or_fixed_vals|
+            if column_or_fixed_vals.is_a?(Hash)
+              fixed_vals = column_or_fixed_vals
+              hash.merge!(fixed_vals)
+            else
+              column = column_or_fixed_vals
+              hash.merge!({ column.to_sym => read_attribute(column.to_sym) })
+            end
+          end
+        end
+
+        define_method :scope_changed? do
+          (scope_condition.keys & changed.map(&:to_sym)).any?
+        end
+
+        define_method :destroyed_via_scope? do
+          scope_condition.keys.include? (destroyed_by_association && destroyed_by_association.foreign_key.to_sym)
+        end
+      else
+        define_method :scope_condition do
+          eval "%{#{scope}}"
+        end
+
+        define_method :scope_changed? do
+          false
+        end
+
+        define_method :destroyed_via_scope? do
+          false
+        end
+      end
+
+      self.scope :in_list, lambda { where("#{quoted_position_column_with_table_name} IS NOT NULL") }
+    end
+  end
+
+  def self.idify(caller_class, name)
+    return name if name.to_s =~ /_id$/
+
+    if caller_class.reflections.key?(name.to_s)
+      caller_class.reflections[name.to_s].foreign_key.to_sym
+    else
+      foreign_key(name).to_sym
+    end
+  end
+end

data/lib/acts_as_list/active_record/acts/sequential_updates_method_definer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveRecord::Acts::List::SequentialUpdatesMethodDefiner #:nodoc:
+  def self.call(caller_class, column, sequential_updates_option)
+    caller_class.class_eval do
+      define_method :sequential_updates? do
+        if !defined?(@sequential_updates)
+          if sequential_updates_option.nil?
+            table_exists =
+              if active_record_version_is?('>= 5')
+                caller_class.connection.data_source_exists?(caller_class.table_name)
+              else
+                caller_class.connection.table_exists?(caller_class.table_name)
+              end
+            index_exists = caller_class.connection.index_exists?(caller_class.table_name, column, unique: true)
+            @sequential_updates = table_exists && index_exists
+          else
+            @sequential_updates = sequential_updates_option
+          end
+        else
+          @sequential_updates
+        end
+      end
+
+      private :sequential_updates?
+    end
+  end
+end

data/lib/acts_as_list/active_record/acts/top_of_list_method_definer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord::Acts::List::TopOfListMethodDefiner #:nodoc:
+  def self.call(caller_class, top_of_list)
+    caller_class.class_eval do
+      define_singleton_method :acts_as_list_top do
+        top_of_list.to_i
+      end
+
+      define_method :acts_as_list_top do
+        top_of_list.to_i
+      end
+    end
+  end
+end

data/lib/acts_as_list/version.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Acts
     module List
-      VERSION = '0.7.4'
+      VERSION = '1.1.0'
     end
   end
 end

data/lib/acts_as_list.rb

@@ -1,15 +1,12 @@
-require 'acts_as_list/active_record/acts/list'
+# frozen_string_literal: true
 
-module ActsAsList
-  if defined?(Rails::Railtie)
-    class Railtie < Rails::Railtie
-      initializer 'acts_as_list.insert_into_active_record' do
-        ActiveSupport.on_load :active_record do
-          ActiveRecord::Base.send(:include, ActiveRecord::Acts::List)
-        end
-      end
-    end
-  else
-    ActiveRecord::Base.send(:include, ActiveRecord::Acts::List) if defined?(ActiveRecord)
-  end
-end
+require "acts_as_list/active_record/acts/list"
+require "acts_as_list/active_record/acts/position_column_method_definer"
+require "acts_as_list/active_record/acts/scope_method_definer"
+require "acts_as_list/active_record/acts/top_of_list_method_definer"
+require "acts_as_list/active_record/acts/add_new_at_method_definer"
+require "acts_as_list/active_record/acts/aux_method_definer"
+require "acts_as_list/active_record/acts/callback_definer"
+require "acts_as_list/active_record/acts/no_update"
+require "acts_as_list/active_record/acts/sequential_updates_method_definer"
+require "acts_as_list/active_record/acts/active_record"

data/test/database.yml

@@ -0,0 +1,18 @@
+sqlite:
+  adapter: sqlite3
+  database: "file:memdb1?mode=memory&cache=shared"
+
+mysql:
+  adapter: mysql2
+  host: 127.0.0.1
+  username: root
+  password:
+  database: acts_as_list
+
+postgresql:
+  adapter: postgresql
+  host: localhost
+  username: postgres
+  password: postgres
+  database: acts_as_list
+  min_messages: ERROR

data/test/helper.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# $DEBUG = true
+
 require "rubygems"
 require "bundler/setup"
 begin
@@ -9,13 +13,57 @@ rescue Bundler::BundlerError => e
 end
 require "active_record"
 require "minitest/autorun"
+require "mocha/minitest"
 require "#{File.dirname(__FILE__)}/../init"
 
 if defined?(ActiveRecord::VERSION) &&
-  ActiveRecord::VERSION::MAJOR > 4 ||
-  (ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR >= 2)
+  ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR >= 2
 
+  # Was removed in Rails 5 and is effectively true.
   ActiveRecord::Base.raise_in_transactional_callbacks = true
 end
 
+db_config = YAML.load_file(File.expand_path("../database.yml", __FILE__)).fetch(ENV["DB"] || "sqlite")
+ActiveRecord::Base.establish_connection(db_config)
+ActiveRecord::Schema.verbose = false
+
+def teardown_db
+  if ActiveRecord::VERSION::MAJOR >= 5
+    tables = ActiveRecord::Base.connection.data_sources
+  else
+    tables = ActiveRecord::Base.connection.tables
+  end
+
+  tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
 require "shared"
+
+# require 'logger'
+# ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+def assert_equal_or_nil(a, b)
+  if a.nil?
+    assert_nil b
+  else
+    assert_equal a, b
+  end
+end
+
+def assert_no_deprecation_warning_raised_by(failure_message = 'ActiveRecord deprecation warning raised when we didn\'t expect it', pass_message = 'No ActiveRecord deprecation raised')
+  original_behavior = ActiveSupport::Deprecation.behavior
+  ActiveSupport::Deprecation.behavior = :raise
+  begin
+    yield
+  rescue ActiveSupport::DeprecationException => e
+    flunk "#{failure_message}: #{e}"
+  rescue
+    raise
+  else
+    pass pass_message
+  end
+ensure
+  ActiveSupport::Deprecation.behavior = original_behavior
+end

data/test/shared.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Common shared behaviour.
 module Shared
   autoload :List,           'shared_list'
@@ -6,4 +8,5 @@ module Shared
   autoload :ArrayScopeList, 'shared_array_scope_list'
   autoload :TopAddition,    'shared_top_addition'
   autoload :NoAddition,     'shared_no_addition'
+  autoload :Quoting,        'shared_quoting'
 end

data/test/shared_array_scope_list.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Shared
   module ArrayScopeList
     def setup
@@ -25,7 +27,7 @@ module Shared
 
       ArrayScopeListMixin.where(id: 4).first.move_to_top
       assert_equal [4, 1, 3, 2], ArrayScopeListMixin.where(parent_id: 5, parent_type: 'ParentClass').order('pos').map(&:id)
-      
+
       ArrayScopeListMixin.where(id: 4).first.insert_at(4)
       assert_equal [1, 3, 2, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: 'ParentClass').order('pos').map(&:id)
       assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: 'ParentClass').order('pos').map(&:pos)
@@ -60,6 +62,11 @@ module Shared
       assert !new.first?
       assert new.last?
 
+      new = ArrayScopeListMixin.acts_as_list_no_update { ArrayScopeListMixin.create(parent_id: 20, parent_type: 'ParentClass') }
+      assert_equal_or_nil $default_position,new.pos
+      assert_equal $default_position.is_a?(Integer), new.first?
+      assert !new.last?
+
       new = ArrayScopeListMixin.create(parent_id: 20, parent_type: 'ParentClass')
       assert_equal 3, new.pos
       assert !new.first?
@@ -81,6 +88,9 @@ module Shared
       new = ArrayScopeListMixin.create(parent_id: 20, parent_type: 'ParentClass')
       assert_equal 3, new.pos
 
+      new_noup = ArrayScopeListMixin.acts_as_list_no_update { ArrayScopeListMixin.create(parent_id: 20, parent_type: 'ParentClass') }
+      assert_equal_or_nil $default_position,new_noup.pos
+
       new4 = ArrayScopeListMixin.create(parent_id: 20, parent_type: 'ParentClass')
       assert_equal 4, new4.pos
 
@@ -104,6 +114,9 @@ module Shared
 
       new4.reload
       assert_equal 5, new4.pos
+
+      new_noup.reload
+      assert_equal_or_nil $default_position, new_noup.pos
     end
 
     def test_delete_middle
@@ -123,6 +136,12 @@ module Shared
 
       assert_equal 1, ArrayScopeListMixin.where(id: 3).first.pos
       assert_equal 2, ArrayScopeListMixin.where(id: 4).first.pos
+
+      ArrayScopeListMixin.acts_as_list_no_update { ArrayScopeListMixin.where(id: 3).first.destroy }
+
+      assert_equal [4], ArrayScopeListMixin.where(parent_id: 5, parent_type: 'ParentClass').order('pos').map(&:id)
+
+      assert_equal 2, ArrayScopeListMixin.where(id: 4).first.pos
     end
 
     def test_remove_from_list_should_then_fail_in_list?
@@ -136,10 +155,8 @@ module Shared
 
       ArrayScopeListMixin.where(id: 2).first.remove_from_list
 
-      assert_equal [2, 1, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: 'ParentClass').order('pos').map(&:id)
-
       assert_equal 1,   ArrayScopeListMixin.where(id: 1).first.pos
-      assert_equal nil, ArrayScopeListMixin.where(id: 2).first.pos
+      assert_nil        ArrayScopeListMixin.where(id: 2).first.pos
       assert_equal 2,   ArrayScopeListMixin.where(id: 3).first.pos
       assert_equal 3,   ArrayScopeListMixin.where(id: 4).first.pos
     end