acts_as_positioned 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 83b94938abcb3a029732e108e86d077e46d60674
+  data.tar.gz: 445a9a8fd77994dca9df179e796f3208397bd1b1
+SHA512:
+  metadata.gz: 949f19c613d45803c816678b6b6f3dcc00ddf1f67f47b533c4d9e0443285970c41f5f90330e9fbb1f61c3cd7a546354d3bda2859e58bb8b43858ea5a45d3eaa7
+  data.tar.gz: 847050cd223261db55862b04d71113975ddc7057f70a8bc0b0e94e5ec4a3482ba9e62995267189a430dcc5f8dd370544c62d1e9926cd94c5bbeaa1535499d560

data/README.md

@@ -0,0 +1,144 @@
+# ActsAsPositioned (for ActiveRecord 3 or higher)
+
+This gem allows you to have ordered models. It is like the old *acts_as_list*
+gem, but very lightweight and with an optimized SQL syntax.
+
+Suppose you want to order a Post model by position. You need to add a
+`position` column to the table *posts* first.
+
+    class CreatePost < ActiveRecord::Migration
+      def change
+        create_table(:posts) do |t|
+          ...
+          t.integer(:position, null: false)
+        end
+      end
+    end
+
+You can make the `position` column optional: only records with entered
+positions will be ordered. In rare cases, you can also add extra order columns.
+
+To add ordering to a model, do the following:
+
+    class Post < ActiveRecord::Base
+      acts_as_positioned
+    end
+
+You can also order within the scope of other columns, which is useful for
+things like associations:
+
+    class Detail < ActiveRecord::Base
+      belongs_to(:post)
+      acts_as_positioned(scope: :post_id)
+    end
+
+This means the order positions are unique within the scope of `post_id`.
+
+# Examples
+
+Check out the tests (in `test/lib/acts_as_positioned.rb`) to see more
+examples.
+
+Suppose you have these records (for all examples this is the starting point):
+
+    id | position
+    ---+---------
+     1 |        0
+     2 |        1
+     3 |        2
+
+## Insert a new record at position 1
+
+The existing records with position greater than or equal to 1 will have their
+position increased by 1 and the new record (with id 4) is inserted:
+
+    Post.create(position: 2)
+
+    id | position
+    ---+---------
+     1 |        0
+     2 |        2 # moved down
+     3 |        3 # moved down
+     4 |        1 # inserted
+
+## Delete a record at position 1
+
+The existing records with position greater than or equal to 1 will have their
+position decreased by 1 and the record (with id 2) is deleted:
+
+    Post.find(2).destroy
+
+    id | position
+    ---+---------
+     1 |        0
+                  # deleted
+     3 |        1 # moved up
+
+## Move a record down from position 0 to position 1
+
+The existing record with position equal to 1 will have its position decreased
+by 1 and the record (with id 1) is moved down:
+
+    Post.find(1).update(position: 1)
+
+    id | position
+    ---+---------
+     1 |        1 # moved down
+     2 |        0 # moved up
+     3 |        2
+
+## Move a record up from position 2 to position 0
+
+The existing records with position greater than or equal to 0 and less than or
+equal to 1 will have their position increased by 1 and the record (with id 3)
+is moved up:
+
+    Post.find(3).update(position: 0)
+
+    id | position
+    ---+---------
+     1 |        1 # moved down
+     2 |        2 # moved down
+     3 |        0 # moved up
+
+## Insert a new record at position 4
+
+This would create a gap in the positions and is not allowed.
+
+    Post.create(position: 4)
+
+    id | position
+    ---+---------
+     1 |        0
+     2 |        1
+     3 |        2
+     4 |        4 # invalid (thus not saved)
+
+## Insert a new record with an empty position
+
+This will not affect the other records.
+
+    Post.create(position: nil)
+
+    id | position
+    ---+---------
+     1 |        0
+     2 |        1
+     3 |        2
+     4 |      nil # inserted, but without position
+
+## Clear a record's position
+
+Clearing a record's position, is like deleting its position.
+
+    Post.find(1).update(position: nil)
+
+    id | position
+    ---+---------
+     1 |      nil
+     2 |        0 # moved up
+     3 |        1 # moved up
+
+# Copyright
+
+&copy; 2017 Walter Horstman, [IT on Rails](http://itonrails.com)

data/Rakefile

@@ -0,0 +1,7 @@
+begin
+  require('bundler/setup')
+rescue LoadError
+  puts('You must `gem install bundler` and `bundle install` to run rake tasks')
+end
+
+Bundler::GemHelper.install_tasks

data/lib/acts_as_positioned.rb

@@ -0,0 +1,89 @@
+# This module allow models to be positioned (order on a specific column). See the README file for more information.
+module ActsAsPositioned
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # Class methods that will be added to the base class (the class mixing in this module).
+  module ClassMethods
+    def acts_as_positioned(options = {})
+      column = options[:column] || :position
+      scope_columns = Array.wrap(options[:scope])
+
+      after_validation do
+        acts_as_positioned_validation(column, scope_columns)
+      end
+
+      before_create do
+        acts_as_positioned_create(column, scope_columns)
+      end
+
+      before_destroy do
+        acts_as_positioned_destroy(column, scope_columns)
+      end
+
+      before_update do
+        acts_as_positioned_update(column, scope_columns)
+      end
+    end
+  end
+
+  private
+
+  def acts_as_positioned_create(column, scope_columns)
+    scope = acts_as_positioned_scope(column, scope_columns)
+    scope.where(scope.arel_table[column].gteq(send(column))).update_all("#{column} = #{column} + 1")
+  end
+
+  def acts_as_positioned_destroy(column, scope_columns)
+    scope = acts_as_positioned_scope(column, scope_columns, true)
+    scope.where(scope.arel_table[column].gt(send("#{column}_was"))).update_all("#{column} = #{column} - 1")
+  end
+
+  def acts_as_positioned_scope(column, scope_columns, use_old_values = false)
+    scope_columns.reduce(self.class.base_class.where.not(column => nil)) do |scope, scope_column|
+      scope.where(scope_column => use_old_values ? send("#{scope_column}_was") : send(scope_column))
+    end
+  end
+
+  def acts_as_positioned_update(column, scope_columns)
+    if scope_columns.any? { |scope_column| send("#{scope_column}_changed?") }
+      acts_as_positioned_create(column, scope_columns)
+      acts_as_positioned_destroy(column, scope_columns)
+
+    elsif send(:"#{column}_changed?")
+      old_value, new_value = send("#{column}_change")
+
+      # If the new position becomes nil (and thus the old position wasn't), it should destroy a position.
+      if new_value.nil?
+        acts_as_positioned_destroy(column, scope_columns)
+
+      # If the old position was nil (and thus the new position isn't), it should insert a position.
+      elsif old_value.nil?
+        acts_as_positioned_create(column, scope_columns)
+
+      else
+        from, to, sign = old_value < new_value ? [old_value + 1, new_value, '-'] : [new_value, old_value - 1, '+']
+
+        acts_as_positioned_scope(column, scope_columns)
+          .where(column => from.eql?(to) ? from : from..to)
+          .update_all("#{column} = #{column} #{sign} 1")
+      end
+    end
+  end
+
+  def acts_as_positioned_validation(column, scope_columns)
+    return if errors[column].any?
+
+    scope = acts_as_positioned_scope(column, scope_columns)
+    scope = scope.where(scope.arel_table[scope.primary_key].not_eq(id)) unless new_record?
+    options = { attributes: column, allow_nil: true, only_integer: true, greater_than_or_equal_to: 0,
+                less_than_or_equal_to: (scope.maximum(column) || -1) + 1 }
+
+    ActiveModel::Validations::NumericalityValidator.new(options).validate(self)
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  include(ActsAsPositioned)
+end

data/test/lib/acts_as_positioned_test.rb

@@ -0,0 +1,179 @@
+require('active_record')
+require('minitest')
+require('minitest/autorun')
+require('acts_as_positioned')
+
+# Test by running: ruby -Ilib test/lib/acts_as_positioned_test.rb
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: File.dirname(__FILE__) + '/../test.sqlite3')
+
+# Create "posts" table.
+ActiveRecord::Schema.define do
+  create_table(:posts, force: true) do |t|
+    t.string(:text, null: false)
+    t.integer(:position)
+    t.integer(:author_id)
+  end
+end
+
+# Create "animals" table.
+ActiveRecord::Schema.define do
+  create_table(:animals, force: true) do |t|
+    t.string(:type, null: false)
+    t.string(:sound, null: false)
+    t.integer(:ordering)
+  end
+end
+
+class Post < ActiveRecord::Base
+  acts_as_positioned
+end
+
+class PostWithScope < ActiveRecord::Base
+  self.table_name = 'posts'
+  acts_as_positioned(scope: :author_id)
+end
+
+class Animal < ActiveRecord::Base
+  acts_as_positioned(column: :ordering)
+end
+
+class Cat < Animal
+end
+
+class Dog < Animal
+end
+
+class ActsAsPositionedTest < Minitest::Test
+  def setup
+    Post.delete_all
+  end
+
+  def test_insert_record
+    post1 = Post.create(text: '1st post', position: 0)
+    post2 = Post.create(text: '2nd post', position: 1)
+    post3 = Post.create(text: '3rd post', position: 2)
+    post4 = Post.create(text: '4th post', position: 1)
+    assert_equal(post4.position, 1)
+    assert_equal(post1.reload.position, 0)
+    assert_equal(post2.reload.position, 2)
+    assert_equal(post3.reload.position, 3)
+  end
+
+  def test_delete_record
+    post1 = Post.create(text: '1st post', position: 0)
+    post2 = Post.create(text: '2nd post', position: 1)
+    post3 = Post.create(text: '3rd post', position: 2)
+    post2.destroy
+    assert_equal(post1.reload.position, 0)
+    assert_equal(post3.reload.position, 1)
+  end
+
+  def test_move_record_downwards
+    post1 = Post.create(text: '1st post', position: 0)
+    post2 = Post.create(text: '2nd post', position: 1)
+    post3 = Post.create(text: '3rd post', position: 2)
+    post1.update(position: 1)
+    assert_equal(post1.reload.position, 1)
+    assert_equal(post2.reload.position, 0)
+    assert_equal(post3.reload.position, 2)
+  end
+
+  def test_move_record_upwards
+    post1 = Post.create(text: '1st post', position: 0)
+    post2 = Post.create(text: '2nd post', position: 1)
+    post3 = Post.create(text: '3rd post', position: 2)
+    post3.update(position: 0)
+    assert_equal(post1.reload.position, 1)
+    assert_equal(post2.reload.position, 2)
+    assert_equal(post3.reload.position, 0)
+  end
+
+  def test_move_record_downwards_and_upwards
+    post1 = Post.create(text: '1st post', position: 0)
+    post2 = Post.create(text: '2nd post', position: 1)
+    post3 = Post.create(text: '3rd post', position: 2)
+    post1.update(position: 1)
+    post1.update(position: 0)
+    assert_equal(post1.reload.position, 0)
+    assert_equal(post2.reload.position, 1)
+    assert_equal(post3.reload.position, 2)
+  end
+
+  def test_insert_record_without_position_should_do_nothing
+    post1 = Post.create(text: '1st post', position: 0)
+    post2 = Post.create(text: '2nd post', position: 1)
+    post3 = Post.create(text: '3rd post', position: 2)
+    post4 = Post.create(text: '4th post')
+    assert_nil(post4.position)
+    assert_equal(post1.reload.position, 0)
+    assert_equal(post2.reload.position, 1)
+    assert_equal(post3.reload.position, 2)
+  end
+
+  def test_clear_position
+    post1 = Post.create(text: '1st post', position: 0)
+    post2 = Post.create(text: '2nd post', position: 1)
+    post3 = Post.create(text: '3rd post', position: 2)
+    post1.update(position: nil)
+    assert_equal(post2.reload.position, 0)
+    assert_equal(post3.reload.position, 1)
+  end
+
+  def test_fill_position
+    post1 = Post.create(text: '1st post', position: 0)
+    post2 = Post.create(text: '2nd post', position: 1)
+    post3 = Post.create(text: '3rd post', position: 2)
+    post4 = Post.create(text: '4th post')
+    assert_nil(post4.position)
+    assert_equal(post1.reload.position, 0)
+    assert_equal(post2.reload.position, 1)
+    assert_equal(post3.reload.position, 2)
+
+    post4.update(position: 1)
+    assert_equal(post4.position, 1)
+    assert_equal(post1.reload.position, 0)
+    assert_equal(post2.reload.position, 2)
+    assert_equal(post3.reload.position, 3)
+  end
+
+  def test_update_record_without_position_should_do_nothing
+    post = Post.create(text: 'Initial text', position: 0)
+    assert_equal(post.reload.position, 0)
+    post.update(text: 'Changed text')
+    assert_equal(post.reload.position, 0)
+  end
+
+  # First record that gets created, must have position 0.
+  def test_validation
+    post = Post.new(text: 'Post', position: 4)
+    assert_equal(post.valid?, false)
+  end
+
+  def test_insert_record_with_scope_column
+    post1 = PostWithScope.create(text: '1st post', position: 0)
+    post2 = PostWithScope.create(text: '1nd post for author 1', position: 0, author_id: 1)
+    post3 = PostWithScope.create(text: '2nd post for author 1', position: 1, author_id: 1)
+    post4 = PostWithScope.create(text: '3th post for author 1', position: 1, author_id: 1)
+    assert_equal(post4.position, 1)
+    assert_equal(post1.reload.position, 0)
+    assert_equal(post2.reload.position, 0)
+    assert_equal(post3.reload.position, 2)
+  end
+
+  def test_reposition_when_author_changes
+    post1 = PostWithScope.create(text: '1st post', position: 0)
+    post2 = PostWithScope.create(text: '1nd post for author 1', position: 0, author_id: 1)
+    post3 = PostWithScope.create(text: '2nd post for author 1', position: 1, author_id: 1)
+    post2.update(author_id: nil)
+    assert_equal(post2.position, 0)
+    assert_equal(post1.reload.position, 1)
+    assert_equal(post3.reload.position, 0)
+  end
+
+  def test_single_table_inheritance
+    cat = Cat.create(sound: 'Miaow', ordering: 0)
+    dog = Dog.create(sound: 'Bark', ordering: 0)
+    assert_equal(dog.ordering, 0)
+    assert_equal(cat.reload.ordering, 1)
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: acts_as_positioned
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Walter Horstman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem allows you to have ordered models. It is like the old acts_as_list,
+  but very lightweight and with an optimized SQL syntax.
+email:
+- walter.horstman@itonrails.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/acts_as_positioned.rb
+- test/lib/acts_as_positioned_test.rb
+homepage: http://github.com/walterhorstman/acts_as_positioned
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Lightweight ordering of models in ActiveRecord 3 or higher
+test_files:
+- test/lib/acts_as_positioned_test.rb