acts_as_list 0.1.2 → 0.1.3

metadata

@@ -1,67 +1,142 @@
 --- !ruby/object:Gem::Specification 
 name: acts_as_list
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
-- Ryan Bates, Rails Core
+- David Heinemeier Hansson
+- Swanand Pagnis
+- Quinn Chaffee
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-07-21 00:00:00 +02:00
+date: 2011-06-10 00:00:00 +05:30
 default_executable: 
-dependencies: []
-
-description: Gem version of acts_as_list Rails plugin.
-email: ryan (at) railscasts (dot) com
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15571
+        segments: 
+        - 1
+        - 15
+        - 4
+        - 7794
+        version: 1.15.4.7794
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: This "acts_as" extension provides the capabilities for sorting and reordering a number of objects in a list. The class that has this specified needs to have a "position" column defined as an integer on the mapped database table.
+email: 
+- swanand.pagnis@gmail.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- lib/acts_as_list.rb
-- README
-- tasks/deployment.rake
+extra_rdoc_files: []
+
 files: 
-- acts-as-list.gemspec
+- .gemtest
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- acts_as_list.gemspec
+- init.rb
 - lib/acts_as_list.rb
-- Manifest
-- README
-- tasks/deployment.rake
-- test/list_test.rb
+- lib/acts_as_list/active_record/acts/list.rb
+- lib/acts_as_list/version.rb
+- test/helper.rb
+- test/test_list.rb
 has_rdoc: true
-homepage: http://github.com/ryanb/acts-as-list
+homepage: http://github.com/swanandp/acts_as_list
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --line-numbers
-- --inline-source
-- --title
-- Acts-as-list
-- --main
-- README
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
-rubyforge_project: acts-as-list
-rubygems_version: 1.3.4
+rubyforge_project: acts_as_list
+rubygems_version: 1.3.7
 signing_key: 
-specification_version: 2
-summary: Gem version of acts_as_list Rails plugin.
+specification_version: 3
+summary: A gem allowing a active_record model to act_as_list.
 test_files: 
-- test/list_test.rb
+- test/helper.rb
+- test/test_list.rb

data/Manifest

@@ -1,6 +0,0 @@
-acts-as-list.gemspec
-lib/acts_as_list.rb
-Manifest
-README
-tasks/deployment.rake
-test/list_test.rb

data/README

@@ -1,34 +0,0 @@
-ActsAsList
-==========
-
-This acts_as extension provides the capabilities for sorting and reordering a number of objects in a list. The class that has this specified needs to have a +position+ column defined as an integer on the mapped database table.
-
-Install
-=======
-
-Specify it in your Rails config.
-
-	config.gem 'ryanb-acts-as-list', :lib => 'acts_as_list', :source => 'http://gems.github.com'
-
-Then install it.
-
-  rake gems:install
-
-
-Example
-=======
-
-  class TodoList < ActiveRecord::Base
-    has_many :todo_items, :order => "position"
-  end
-
-  class TodoItem < ActiveRecord::Base
-    belongs_to :todo_list
-    acts_as_list :scope => :todo_list
-  end
-
-  todo_list.first.move_to_bottom
-  todo_list.last.move_higher
-
-
-Copyright (c) 2007 David Heinemeier Hansson, released under the MIT license

data/acts-as-list.gemspec

@@ -1,58 +0,0 @@
-
-# Gem::Specification for Acts-as-list-0.1.2
-# Originally generated by Echoe
-
-Gem::Specification.new do |s|
-  s.name = %q{acts_as_list}
-  s.version = "0.1.2"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Ryan Bates, Rails Core"]
-  s.date = %q{2008-07-21}
-  s.description = %q{Gem version of acts_as_list Rails plugin.}
-  s.email = %q{ryan (at) railscasts (dot) com}
-  s.extra_rdoc_files = ["lib/acts_as_list.rb", "README", "tasks/deployment.rake"]
-  s.files = ["acts-as-list.gemspec", "lib/acts_as_list.rb", "Manifest", "README", "tasks/deployment.rake", "test/list_test.rb"]
-  s.has_rdoc = true
-  s.homepage = %q{http://github.com/ryanb/acts-as-list}
-  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Acts-as-list", "--main", "README"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{acts-as-list}
-  s.rubygems_version = %q{1.2.0}
-  s.summary = %q{Gem version of acts_as_list Rails plugin.}
-  s.test_files = ["test/list_test.rb"]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
-
-    if current_version >= 3 then
-    else
-    end
-  else
-  end
-end
-
-
-# # Original Rakefile source (requires the Echoe gem):
-# 
-# require 'rubygems'
-# require 'rake'
-#  
-# begin
-#   require 'echoe'
-# 
-#   Echoe.new('acts-as-list', '0.1.2') do |p|
-#     p.summary        = "Gem version of acts_as_list Rails plugin."
-#     p.description    = "Gem version of acts_as_list Rails plugin."
-#     p.url            = "http://github.com/ryanb/acts-as-list"
-#     p.author         = ['Ryan Bates', 'Rails Core']
-#     p.email          = "ryan (at) railscasts (dot) com"
-#   end
-# 
-# rescue LoadError => boom
-#   puts "You are missing a dependency required for meta-operations on this gem."
-#   puts "#{boom.to_s.capitalize}."
-# end
-# 
-# Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }

data/tasks/deployment.rake

@@ -1,2 +0,0 @@
-desc "Build the manifest and gemspec files."
-task :build => [:build_manifest, :build_gemspec]

data/test/list_test.rb

@@ -1,369 +0,0 @@
-require 'test/unit'
-
-require 'rubygems'
-gem 'activerecord', '>= 1.15.4.7794'
-require 'active_record'
-
-require "#{File.dirname(__FILE__)}/../lib/acts_as_list"
-
-ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
-
-def setup_db
-  ActiveRecord::Schema.define(:version => 1) do
-    create_table :mixins do |t|
-      t.column :pos, :integer
-      t.column :parent_id, :integer
-      t.column :created_at, :datetime      
-      t.column :updated_at, :datetime
-    end
-  end
-end
-
-def teardown_db
-  ActiveRecord::Base.connection.tables.each do |table|
-    ActiveRecord::Base.connection.drop_table(table)
-  end
-end
-
-class Mixin < ActiveRecord::Base
-end
-
-class ListMixin < Mixin
-  acts_as_list :column => "pos", :scope => :parent
-
-  def self.table_name() "mixins" end
-end
-
-class ListMixinSub1 < ListMixin
-end
-
-class ListMixinSub2 < ListMixin
-end
-
-class ListWithStringScopeMixin < ActiveRecord::Base
-  acts_as_list :column => "pos", :scope => 'parent_id = #{parent_id}'
-
-  def self.table_name() "mixins" end
-end
-
-
-class ListTest < Test::Unit::TestCase
-
-  def setup
-    setup_db
-    (1..4).each { |counter| ListMixin.create! :pos => counter, :parent_id => 5 }
-  end
-
-  def teardown
-    teardown_db
-  end
-
-  def test_reordering
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-  end
-
-  def test_move_to_bottom_with_next_to_last_item
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-    ListMixin.find(3).move_to_bottom
-    assert_equal [1, 2, 4, 3], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-  end
-
-  def test_next_prev
-    assert_equal ListMixin.find(2), ListMixin.find(1).lower_item
-    assert_nil ListMixin.find(1).higher_item
-    assert_equal ListMixin.find(3), ListMixin.find(4).higher_item
-    assert_nil ListMixin.find(4).lower_item
-  end
-
-  def test_injection
-    item = ListMixin.new(:parent_id => 1)
-    assert_equal "parent_id = 1", item.scope_condition
-    assert_equal "pos", item.position_column
-  end
-
-  def test_insert
-    new = ListMixin.create(:parent_id => 20)
-    assert_equal 1, new.pos
-    assert new.first?
-    assert new.last?
-
-    new = ListMixin.create(:parent_id => 20)
-    assert_equal 2, new.pos
-    assert !new.first?
-    assert new.last?
-
-    new = ListMixin.create(:parent_id => 20)
-    assert_equal 3, new.pos
-    assert !new.first?
-    assert new.last?
-
-    new = ListMixin.create(:parent_id => 0)
-    assert_equal 1, new.pos
-    assert new.first?
-    assert new.last?
-  end
-
-  def test_insert_at
-    new = ListMixin.create(:parent_id => 20)
-    assert_equal 1, new.pos
-
-    new = ListMixin.create(:parent_id => 20)
-    assert_equal 2, new.pos
-
-    new = ListMixin.create(:parent_id => 20)
-    assert_equal 3, new.pos
-
-    new4 = ListMixin.create(:parent_id => 20)
-    assert_equal 4, new4.pos
-
-    new4.insert_at(3)
-    assert_equal 3, new4.pos
-
-    new.reload
-    assert_equal 4, new.pos
-
-    new.insert_at(2)
-    assert_equal 2, new.pos
-
-    new4.reload
-    assert_equal 4, new4.pos
-
-    new5 = ListMixin.create(:parent_id => 20)
-    assert_equal 5, new5.pos
-
-    new5.insert_at(1)
-    assert_equal 1, new5.pos
-
-    new4.reload
-    assert_equal 5, new4.pos
-  end
-
-  def test_delete_middle
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).destroy
-
-    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    assert_equal 1, ListMixin.find(1).pos
-    assert_equal 2, ListMixin.find(3).pos
-    assert_equal 3, ListMixin.find(4).pos
-
-    ListMixin.find(1).destroy
-
-    assert_equal [3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    assert_equal 1, ListMixin.find(3).pos
-    assert_equal 2, ListMixin.find(4).pos
-  end
-
-  def test_with_string_based_scope
-    new = ListWithStringScopeMixin.create(:parent_id => 500)
-    assert_equal 1, new.pos
-    assert new.first?
-    assert new.last?
-  end
-
-  def test_nil_scope
-    new1, new2, new3 = ListMixin.create, ListMixin.create, ListMixin.create
-    new2.move_higher
-    assert_equal [new2, new1, new3], ListMixin.find(:all, :conditions => 'parent_id IS NULL', :order => 'pos')
-  end
-  
-  
-  def test_remove_from_list_should_then_fail_in_list? 
-    assert_equal true, ListMixin.find(1).in_list?
-    ListMixin.find(1).remove_from_list
-    assert_equal false, ListMixin.find(1).in_list?
-  end 
-  
-  def test_remove_from_list_should_set_position_to_nil 
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-  
-    ListMixin.find(2).remove_from_list 
-  
-    assert_equal [2, 1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-  
-    assert_equal 1,   ListMixin.find(1).pos
-    assert_equal nil, ListMixin.find(2).pos
-    assert_equal 2,   ListMixin.find(3).pos
-    assert_equal 3,   ListMixin.find(4).pos
-  end 
-  
-  def test_remove_before_destroy_does_not_shift_lower_items_twice 
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-  
-    ListMixin.find(2).remove_from_list 
-    ListMixin.find(2).destroy 
-  
-    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-  
-    assert_equal 1, ListMixin.find(1).pos
-    assert_equal 2, ListMixin.find(3).pos
-    assert_equal 3, ListMixin.find(4).pos
-  end 
-  
-  # special thanks to openhood on github
-  def test_delete_middle_with_holes
-    # first we check everything is at expected place
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    # then we create a hole in the list, say you're working with existing data in which you already have holes
-    # or your scope is very complex
-    ListMixin.delete(2)
-
-    # we ensure the hole is really here
-    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-    assert_equal 1, ListMixin.find(1).pos
-    assert_equal 3, ListMixin.find(3).pos
-    assert_equal 4, ListMixin.find(4).pos
-
-    # can we retrieve lower item despite the hole?
-    assert_equal 3, ListMixin.find(1).lower_item.id
-
-    # can we move an item lower jumping more than one position?
-    ListMixin.find(1).move_lower
-    assert_equal [3, 1, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-    assert_equal 2, ListMixin.find(3).pos
-    assert_equal 3, ListMixin.find(1).pos
-    assert_equal 4, ListMixin.find(4).pos
-
-    # create another hole
-    ListMixin.delete(1)
-
-    # can we retrieve higher item despite the hole?
-    assert_equal 3, ListMixin.find(4).higher_item.id
-
-    # can we move an item higher jumping more than one position?
-    ListMixin.find(4).move_higher
-    assert_equal [4, 3], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-    assert_equal 2, ListMixin.find(4).pos
-    assert_equal 3, ListMixin.find(3).pos
-  end
-end
-
-class ListSubTest < Test::Unit::TestCase
-
-  def setup
-    setup_db
-    (1..4).each { |i| ((i % 2 == 1) ? ListMixinSub1 : ListMixinSub2).create! :pos => i, :parent_id => 5000 }
-  end
-
-  def teardown
-    teardown_db
-  end
-
-  def test_reordering
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-
-    ListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-
-    ListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-
-    ListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-  end
-
-  def test_move_to_bottom_with_next_to_last_item
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-    ListMixin.find(3).move_to_bottom
-    assert_equal [1, 2, 4, 3], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-  end
-
-  def test_next_prev
-    assert_equal ListMixin.find(2), ListMixin.find(1).lower_item
-    assert_nil ListMixin.find(1).higher_item
-    assert_equal ListMixin.find(3), ListMixin.find(4).higher_item
-    assert_nil ListMixin.find(4).lower_item
-  end
-
-  def test_injection
-    item = ListMixin.new("parent_id"=>1)
-    assert_equal "parent_id = 1", item.scope_condition
-    assert_equal "pos", item.position_column
-  end
-
-  def test_insert_at
-    new = ListMixin.create("parent_id" => 20)
-    assert_equal 1, new.pos
-
-    new = ListMixinSub1.create("parent_id" => 20)
-    assert_equal 2, new.pos
-
-    new = ListMixinSub2.create("parent_id" => 20)
-    assert_equal 3, new.pos
-
-    new4 = ListMixin.create("parent_id" => 20)
-    assert_equal 4, new4.pos
-
-    new4.insert_at(3)
-    assert_equal 3, new4.pos
-
-    new.reload
-    assert_equal 4, new.pos
-
-    new.insert_at(2)
-    assert_equal 2, new.pos
-
-    new4.reload
-    assert_equal 4, new4.pos
-
-    new5 = ListMixinSub1.create("parent_id" => 20)
-    assert_equal 5, new5.pos
-
-    new5.insert_at(1)
-    assert_equal 1, new5.pos
-
-    new4.reload
-    assert_equal 5, new4.pos
-  end
-
-  def test_delete_middle
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).destroy
-
-    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-
-    assert_equal 1, ListMixin.find(1).pos
-    assert_equal 2, ListMixin.find(3).pos
-    assert_equal 3, ListMixin.find(4).pos
-
-    ListMixin.find(1).destroy
-
-    assert_equal [3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-
-    assert_equal 1, ListMixin.find(3).pos
-    assert_equal 2, ListMixin.find(4).pos
-  end
-
-end