From 4acbfa29ca932a6b50935f581f2cc2bab2c3bc30 Mon Sep 17 00:00:00 2001 From: Rodrigo Souto Date: Wed, 18 Sep 2013 00:28:35 +0000 Subject: [PATCH] rails3: updating will_paginate library --- vendor/plugins/will_paginate/.rspec | 1 + vendor/plugins/will_paginate/.travis.yml | 26 ++++++++++++++++++++++++++ vendor/plugins/will_paginate/Gemfile | 22 ++++++++++++++++++++++ vendor/plugins/will_paginate/Gemfile.rails-edge | 25 +++++++++++++++++++++++++ vendor/plugins/will_paginate/Gemfile.rails-edge.lock | 107 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/Gemfile.rails3.0 | 19 +++++++++++++++++++ vendor/plugins/will_paginate/Gemfile.rails3.0.lock | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/Gemfile.rails3.1 | 22 ++++++++++++++++++++++ vendor/plugins/will_paginate/Gemfile.rails3.1.lock | 93 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/Gemfile.rails3.2 | 28 ++++++++++++++++++++++++++++ vendor/plugins/will_paginate/Gemfile.rails3.2.lock | 123 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/LICENSE | 18 ++++++++++++++++++ vendor/plugins/will_paginate/README.md | 61 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/init.rb | 18 ++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate.rb | 25 +++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/active_record.rb | 247 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/array.rb | 33 +++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/collection.rb | 136 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/core_ext.rb | 30 ++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/data_mapper.rb | 95 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/deprecation.rb | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/i18n.rb | 22 ++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/mongoid.rb | 46 ++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/page_number.rb | 57 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/per_page.rb | 27 +++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/railtie.rb | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/sequel.rb | 39 +++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/version.rb | 9 +++++++++ vendor/plugins/will_paginate/lib/will_paginate/view_helpers.rb | 162 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/view_helpers/action_view.rb | 148 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/view_helpers/link_renderer.rb | 131 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/view_helpers/link_renderer_base.rb | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/view_helpers/merb.rb | 26 ++++++++++++++++++++++++++ vendor/plugins/will_paginate/lib/will_paginate/view_helpers/sinatra.rb | 41 +++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/script/each-gemfile | 12 ++++++++++++ vendor/plugins/will_paginate/script/test_all | 21 +++++++++++++++++++++ vendor/plugins/will_paginate/spec/collection_spec.rb | 139 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/console | 12 ++++++++++++ vendor/plugins/will_paginate/spec/console_fixtures.rb | 28 ++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/database.yml | 22 ++++++++++++++++++++++ vendor/plugins/will_paginate/spec/fake_rubygems.rb | 18 ++++++++++++++++++ vendor/plugins/will_paginate/spec/finders/active_record_spec.rb | 561 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/finders/activerecord_test_connector.rb | 118 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/finders/data_mapper_spec.rb | 103 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/finders/data_mapper_test_connector.rb | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/finders/mongoid_spec.rb | 140 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/finders/sequel_spec.rb | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/finders/sequel_test_connector.rb | 15 +++++++++++++++ vendor/plugins/will_paginate/spec/fixtures/admin.rb | 3 +++ vendor/plugins/will_paginate/spec/fixtures/developer.rb | 15 +++++++++++++++ vendor/plugins/will_paginate/spec/fixtures/developers_projects.yml | 13 +++++++++++++ vendor/plugins/will_paginate/spec/fixtures/project.rb | 15 +++++++++++++++ vendor/plugins/will_paginate/spec/fixtures/projects.yml | 6 ++++++ vendor/plugins/will_paginate/spec/fixtures/replies.yml | 29 +++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/fixtures/reply.rb | 10 ++++++++++ vendor/plugins/will_paginate/spec/fixtures/schema.rb | 38 ++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/fixtures/topic.rb | 11 +++++++++++ vendor/plugins/will_paginate/spec/fixtures/topics.yml | 30 ++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/fixtures/user.rb | 2 ++ vendor/plugins/will_paginate/spec/fixtures/users.yml | 35 +++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/page_number_spec.rb | 65 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/per_page_spec.rb | 41 +++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/spec_helper.rb | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/view_helpers/action_view_spec.rb | 423 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/view_helpers/base_spec.rb | 142 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/view_helpers/link_renderer_base_spec.rb | 87 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/spec/view_helpers/view_example_group.rb | 121 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/plugins/will_paginate/will_paginate.gemspec | 30 ++++++++++++++++++++++++++++++ 68 files changed, 4612 insertions(+), 0 deletions(-) create mode 100644 vendor/plugins/will_paginate/.rspec create mode 100644 vendor/plugins/will_paginate/.travis.yml create mode 100644 vendor/plugins/will_paginate/Gemfile create mode 100644 vendor/plugins/will_paginate/Gemfile.rails-edge create mode 100644 vendor/plugins/will_paginate/Gemfile.rails-edge.lock create mode 100644 vendor/plugins/will_paginate/Gemfile.rails3.0 create mode 100644 vendor/plugins/will_paginate/Gemfile.rails3.0.lock create mode 100644 vendor/plugins/will_paginate/Gemfile.rails3.1 create mode 100644 vendor/plugins/will_paginate/Gemfile.rails3.1.lock create mode 100644 vendor/plugins/will_paginate/Gemfile.rails3.2 create mode 100644 vendor/plugins/will_paginate/Gemfile.rails3.2.lock create mode 100644 vendor/plugins/will_paginate/LICENSE create mode 100644 vendor/plugins/will_paginate/README.md create mode 100644 vendor/plugins/will_paginate/init.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/active_record.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/array.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/collection.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/core_ext.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/data_mapper.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/deprecation.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/i18n.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/mongoid.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/page_number.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/per_page.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/railtie.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/sequel.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/version.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/view_helpers.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/view_helpers/action_view.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/view_helpers/link_renderer.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/view_helpers/link_renderer_base.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/view_helpers/merb.rb create mode 100644 vendor/plugins/will_paginate/lib/will_paginate/view_helpers/sinatra.rb create mode 100755 vendor/plugins/will_paginate/script/each-gemfile create mode 100755 vendor/plugins/will_paginate/script/test_all create mode 100644 vendor/plugins/will_paginate/spec/collection_spec.rb create mode 100755 vendor/plugins/will_paginate/spec/console create mode 100644 vendor/plugins/will_paginate/spec/console_fixtures.rb create mode 100644 vendor/plugins/will_paginate/spec/database.yml create mode 100644 vendor/plugins/will_paginate/spec/fake_rubygems.rb create mode 100644 vendor/plugins/will_paginate/spec/finders/active_record_spec.rb create mode 100644 vendor/plugins/will_paginate/spec/finders/activerecord_test_connector.rb create mode 100644 vendor/plugins/will_paginate/spec/finders/data_mapper_spec.rb create mode 100644 vendor/plugins/will_paginate/spec/finders/data_mapper_test_connector.rb create mode 100644 vendor/plugins/will_paginate/spec/finders/mongoid_spec.rb create mode 100644 vendor/plugins/will_paginate/spec/finders/sequel_spec.rb create mode 100644 vendor/plugins/will_paginate/spec/finders/sequel_test_connector.rb create mode 100644 vendor/plugins/will_paginate/spec/fixtures/admin.rb create mode 100644 vendor/plugins/will_paginate/spec/fixtures/developer.rb create mode 100644 vendor/plugins/will_paginate/spec/fixtures/developers_projects.yml create mode 100644 vendor/plugins/will_paginate/spec/fixtures/project.rb create mode 100644 vendor/plugins/will_paginate/spec/fixtures/projects.yml create mode 100644 vendor/plugins/will_paginate/spec/fixtures/replies.yml create mode 100644 vendor/plugins/will_paginate/spec/fixtures/reply.rb create mode 100644 vendor/plugins/will_paginate/spec/fixtures/schema.rb create mode 100644 vendor/plugins/will_paginate/spec/fixtures/topic.rb create mode 100644 vendor/plugins/will_paginate/spec/fixtures/topics.yml create mode 100644 vendor/plugins/will_paginate/spec/fixtures/user.rb create mode 100644 vendor/plugins/will_paginate/spec/fixtures/users.yml create mode 100644 vendor/plugins/will_paginate/spec/page_number_spec.rb create mode 100644 vendor/plugins/will_paginate/spec/per_page_spec.rb create mode 100644 vendor/plugins/will_paginate/spec/spec_helper.rb create mode 100644 vendor/plugins/will_paginate/spec/view_helpers/action_view_spec.rb create mode 100644 vendor/plugins/will_paginate/spec/view_helpers/base_spec.rb create mode 100644 vendor/plugins/will_paginate/spec/view_helpers/link_renderer_base_spec.rb create mode 100644 vendor/plugins/will_paginate/spec/view_helpers/view_example_group.rb create mode 100644 vendor/plugins/will_paginate/will_paginate.gemspec diff --git a/vendor/plugins/will_paginate/.rspec b/vendor/plugins/will_paginate/.rspec new file mode 100644 index 0000000..4e1e0d2 --- /dev/null +++ b/vendor/plugins/will_paginate/.rspec @@ -0,0 +1 @@ +--color diff --git a/vendor/plugins/will_paginate/.travis.yml b/vendor/plugins/will_paginate/.travis.yml new file mode 100644 index 0000000..133b268 --- /dev/null +++ b/vendor/plugins/will_paginate/.travis.yml @@ -0,0 +1,26 @@ +bundler_args: "--standalone --binstubs --without development" +script: script/test_all +services: mongodb +before_script: + - mysql -e 'create database will_paginate;' + - psql -c 'create database will_paginate;' -U postgres +rvm: + - 1.8.7 + - 1.9.2 + - 1.9.3 +gemfile: + - Gemfile + - Gemfile.rails3.0 + - Gemfile.rails3.1 + - Gemfile.rails3.2 + - Gemfile.rails-edge +matrix: + exclude: + - rvm: 1.8.7 + gemfile: Gemfile.rails-edge + - rvm: 1.8.7 + gemfile: Gemfile + - rvm: 1.9.2 + gemfile: Gemfile.rails-edge + - rvm: 1.9.2 + gemfile: Gemfile diff --git a/vendor/plugins/will_paginate/Gemfile b/vendor/plugins/will_paginate/Gemfile new file mode 100644 index 0000000..7bb1ded --- /dev/null +++ b/vendor/plugins/will_paginate/Gemfile @@ -0,0 +1,22 @@ +source 'https://rubygems.org' + +rails_version = '~> 4.0.0.rc2' + +gem 'activerecord', rails_version +gem 'actionpack', rails_version + +gem 'rspec', '~> 2.6.0' +gem 'mocha', '~> 0.9.8' + +gem 'sqlite3', '~> 1.3.6' + +group :mysql do + gem 'mysql', '~> 2.9' + gem 'mysql2', '~> 0.3.10' +end +gem 'pg', '~> 0.11', :group => :pg + +group :development do + gem 'ruby-debug', :platforms => :mri_18 + gem 'debugger', :platforms => :mri_19 +end diff --git a/vendor/plugins/will_paginate/Gemfile.rails-edge b/vendor/plugins/will_paginate/Gemfile.rails-edge new file mode 100644 index 0000000..4d6e2a5 --- /dev/null +++ b/vendor/plugins/will_paginate/Gemfile.rails-edge @@ -0,0 +1,25 @@ +source 'https://rubygems.org' + +gem 'activerecord-deprecated_finders', :github => 'rails/activerecord-deprecated_finders', :branch => 'master' +gem 'journey', :github => 'rails/journey', :branch => 'master' + +gem 'activerecord', :github => 'rails/rails', :branch => 'master' +gem 'actionpack', :github => 'rails/rails', :branch => 'master' + +gem 'thread_safe' + +gem 'rspec', '~> 2.6.0' +gem 'mocha', '~> 0.9.8' + +gem 'sqlite3', '~> 1.3.6' + +group :mysql do + gem 'mysql', '~> 2.9' + gem 'mysql2', '~> 0.3.10' +end +gem 'pg', '~> 0.11', :group => :pg + +group :development do + gem 'ruby-debug', :platforms => :mri_18 + gem 'debugger', :platforms => :mri_19 +end diff --git a/vendor/plugins/will_paginate/Gemfile.rails-edge.lock b/vendor/plugins/will_paginate/Gemfile.rails-edge.lock new file mode 100644 index 0000000..6186bb4 --- /dev/null +++ b/vendor/plugins/will_paginate/Gemfile.rails-edge.lock @@ -0,0 +1,107 @@ +GIT + remote: git://github.com/rails/activerecord-deprecated_finders.git + revision: f6ed71d62d47f0f6397b5b3e801271567f30f960 + branch: master + specs: + activerecord-deprecated_finders (1.0.3) + +GIT + remote: git://github.com/rails/journey.git + revision: f0938d664286dc0b47f13092fa5d04a9225038d4 + branch: master + specs: + journey (2.0.0.20120723141804) + +GIT + remote: git://github.com/rails/rails.git + revision: 12fe66b56479abc2ca399c002d38a7e81fce2eb2 + branch: master + specs: + actionpack (4.1.0.beta) + actionview (= 4.1.0.beta) + activesupport (= 4.1.0.beta) + rack (~> 1.5.2) + rack-test (~> 0.6.2) + actionview (4.1.0.beta) + activemodel (= 4.1.0.beta) + activesupport (= 4.1.0.beta) + builder (~> 3.1.0) + erubis (~> 2.7.0) + activemodel (4.1.0.beta) + activesupport (= 4.1.0.beta) + builder (~> 3.1.0) + activerecord (4.1.0.beta) + activemodel (= 4.1.0.beta) + activerecord-deprecated_finders (~> 1.0.2) + activesupport (= 4.1.0.beta) + arel (~> 4.0.0) + activesupport (4.1.0.beta) + i18n (~> 0.6, >= 0.6.4) + json (~> 1.7) + minitest (~> 5.0) + thread_safe (~> 0.1) + tzinfo (~> 0.3.37) + +GEM + remote: https://rubygems.org/ + specs: + arel (4.0.0) + atomic (1.1.9) + builder (3.1.4) + columnize (0.3.6) + debugger (1.6.0) + columnize (>= 0.3.1) + debugger-linecache (~> 1.2.0) + debugger-ruby_core_source (~> 1.2.1) + debugger-linecache (1.2.0) + debugger-ruby_core_source (1.2.2) + diff-lcs (1.1.3) + erubis (2.7.0) + i18n (0.6.4) + json (1.8.0) + linecache (0.46) + rbx-require-relative (> 0.0.4) + minitest (5.0.5) + mocha (0.9.12) + mysql (2.9.1) + mysql2 (0.3.11) + pg (0.15.1) + rack (1.5.2) + rack-test (0.6.2) + rack (>= 1.0) + rbx-require-relative (0.0.9) + rspec (2.6.0) + rspec-core (~> 2.6.0) + rspec-expectations (~> 2.6.0) + rspec-mocks (~> 2.6.0) + rspec-core (2.6.4) + rspec-expectations (2.6.0) + diff-lcs (~> 1.1.2) + rspec-mocks (2.6.0) + ruby-debug (0.10.4) + columnize (>= 0.1) + ruby-debug-base (~> 0.10.4.0) + ruby-debug-base (0.10.4) + linecache (>= 0.3) + sqlite3 (1.3.7) + thread_safe (0.1.0) + atomic + tzinfo (0.3.37) + +PLATFORMS + ruby + +DEPENDENCIES + actionpack! + activerecord! + activerecord-deprecated_finders! + debugger + journey! + mocha (~> 0.9.8) + mysql (~> 2.9) + mysql2 (~> 0.3.10) + pg (~> 0.11) + rspec (~> 2.6.0) + ruby-debug + sqlite3 (~> 1.3.6) + thread_safe diff --git a/vendor/plugins/will_paginate/Gemfile.rails3.0 b/vendor/plugins/will_paginate/Gemfile.rails3.0 new file mode 100644 index 0000000..68de9d9 --- /dev/null +++ b/vendor/plugins/will_paginate/Gemfile.rails3.0 @@ -0,0 +1,19 @@ +source 'http://rubygems.org' + +rails_version = '~> 3.0.0' + +gem 'activerecord', rails_version +gem 'actionpack', rails_version + +gem 'rspec', '~> 2.6.0' +gem 'mocha', '~> 0.9.8' + +gem 'sqlite3', '~> 1.3.3' + +gem 'mysql', '~> 2.8.1', :group => :mysql +gem 'pg', '~> 0.11', :group => :pg + +group :development do + gem 'ruby-debug', :platforms => :mri_18 + gem 'debugger', :platforms => :mri_19 +end diff --git a/vendor/plugins/will_paginate/Gemfile.rails3.0.lock b/vendor/plugins/will_paginate/Gemfile.rails3.0.lock new file mode 100644 index 0000000..83fd353 --- /dev/null +++ b/vendor/plugins/will_paginate/Gemfile.rails3.0.lock @@ -0,0 +1,78 @@ +GEM + remote: http://rubygems.org/ + specs: + abstract (1.0.0) + actionpack (3.0.19) + activemodel (= 3.0.19) + activesupport (= 3.0.19) + builder (~> 2.1.2) + erubis (~> 2.6.6) + i18n (~> 0.5.0) + rack (~> 1.2.5) + rack-mount (~> 0.6.14) + rack-test (~> 0.5.7) + tzinfo (~> 0.3.23) + activemodel (3.0.19) + activesupport (= 3.0.19) + builder (~> 2.1.2) + i18n (~> 0.5.0) + activerecord (3.0.19) + activemodel (= 3.0.19) + activesupport (= 3.0.19) + arel (~> 2.0.10) + tzinfo (~> 0.3.23) + activesupport (3.0.19) + arel (2.0.10) + builder (2.1.2) + columnize (0.3.4) + debugger (1.2.2) + columnize (>= 0.3.1) + debugger-linecache (~> 1.1.1) + debugger-ruby_core_source (~> 1.1.5) + debugger-linecache (1.1.2) + debugger-ruby_core_source (>= 1.1.1) + debugger-ruby_core_source (1.1.5) + diff-lcs (1.1.2) + erubis (2.6.6) + abstract (>= 1.0.0) + i18n (0.5.0) + linecache (0.46) + rbx-require-relative (> 0.0.4) + mocha (0.9.12) + mysql (2.8.1) + pg (0.11.0) + rack (1.2.6) + rack-mount (0.6.14) + rack (>= 1.0.0) + rack-test (0.5.7) + rack (>= 1.0) + rbx-require-relative (0.0.5) + rspec (2.6.0) + rspec-core (~> 2.6.0) + rspec-expectations (~> 2.6.0) + rspec-mocks (~> 2.6.0) + rspec-core (2.6.4) + rspec-expectations (2.6.0) + diff-lcs (~> 1.1.2) + rspec-mocks (2.6.0) + ruby-debug (0.10.4) + columnize (>= 0.1) + ruby-debug-base (~> 0.10.4.0) + ruby-debug-base (0.10.4) + linecache (>= 0.3) + sqlite3 (1.3.4) + tzinfo (0.3.35) + +PLATFORMS + ruby + +DEPENDENCIES + actionpack (~> 3.0.0) + activerecord (~> 3.0.0) + debugger + mocha (~> 0.9.8) + mysql (~> 2.8.1) + pg (~> 0.11) + rspec (~> 2.6.0) + ruby-debug + sqlite3 (~> 1.3.3) diff --git a/vendor/plugins/will_paginate/Gemfile.rails3.1 b/vendor/plugins/will_paginate/Gemfile.rails3.1 new file mode 100644 index 0000000..fba6cde --- /dev/null +++ b/vendor/plugins/will_paginate/Gemfile.rails3.1 @@ -0,0 +1,22 @@ +source 'http://rubygems.org' + +rails_version = '~> 3.1.0' + +gem 'activerecord', rails_version +gem 'actionpack', rails_version + +gem 'rspec', '~> 2.6.0' +gem 'mocha', '~> 0.9.8' + +gem 'sqlite3', '~> 1.3.3' + +group :mysql do + gem 'mysql', '~> 2.8.1' + gem 'mysql2', '>= 0.3.6' +end +gem 'pg', '~> 0.11', :group => :pg + +group :development do + gem 'ruby-debug', :platforms => :mri_18 + gem 'debugger', :platforms => :mri_19 +end diff --git a/vendor/plugins/will_paginate/Gemfile.rails3.1.lock b/vendor/plugins/will_paginate/Gemfile.rails3.1.lock new file mode 100644 index 0000000..1987891 --- /dev/null +++ b/vendor/plugins/will_paginate/Gemfile.rails3.1.lock @@ -0,0 +1,93 @@ +GEM + remote: http://rubygems.org/ + specs: + actionpack (3.1.12) + activemodel (= 3.1.12) + activesupport (= 3.1.12) + builder (~> 3.0.0) + erubis (~> 2.7.0) + i18n (~> 0.6) + rack (~> 1.3.6) + rack-cache (~> 1.2) + rack-mount (~> 0.8.2) + rack-test (~> 0.6.1) + sprockets (~> 2.0.4) + activemodel (3.1.12) + activesupport (= 3.1.12) + builder (~> 3.0.0) + i18n (~> 0.6) + activerecord (3.1.12) + activemodel (= 3.1.12) + activesupport (= 3.1.12) + arel (~> 2.2.3) + tzinfo (~> 0.3.29) + activesupport (3.1.12) + multi_json (~> 1.0) + arel (2.2.3) + builder (3.0.4) + columnize (0.3.6) + debugger (1.2.2) + columnize (>= 0.3.1) + debugger-linecache (~> 1.1.1) + debugger-ruby_core_source (~> 1.1.5) + debugger-linecache (1.1.2) + debugger-ruby_core_source (>= 1.1.1) + debugger-ruby_core_source (1.1.5) + diff-lcs (1.1.3) + erubis (2.7.0) + hike (1.2.3) + i18n (0.6.4) + linecache (0.46) + rbx-require-relative (> 0.0.4) + mocha (0.9.12) + multi_json (1.7.7) + mysql (2.8.1) + mysql2 (0.3.11) + pg (0.12.0) + rake-compiler (~> 0.7) + rack (1.3.10) + rack-cache (1.2) + rack (>= 0.4) + rack-mount (0.8.3) + rack (>= 1.0.0) + rack-test (0.6.2) + rack (>= 1.0) + rake (0.9.2.2) + rake-compiler (0.7.9) + rake + rbx-require-relative (0.0.5) + rspec (2.6.0) + rspec-core (~> 2.6.0) + rspec-expectations (~> 2.6.0) + rspec-mocks (~> 2.6.0) + rspec-core (2.6.4) + rspec-expectations (2.6.0) + diff-lcs (~> 1.1.2) + rspec-mocks (2.6.0) + ruby-debug (0.10.4) + columnize (>= 0.1) + ruby-debug-base (~> 0.10.4.0) + ruby-debug-base (0.10.4) + linecache (>= 0.3) + sprockets (2.0.4) + hike (~> 1.2) + rack (~> 1.0) + tilt (~> 1.1, != 1.3.0) + sqlite3 (1.3.5) + tilt (1.4.1) + tzinfo (0.3.37) + +PLATFORMS + ruby + +DEPENDENCIES + actionpack (~> 3.1.0) + activerecord (~> 3.1.0) + debugger + mocha (~> 0.9.8) + mysql (~> 2.8.1) + mysql2 (>= 0.3.6) + pg (~> 0.11) + rspec (~> 2.6.0) + ruby-debug + sqlite3 (~> 1.3.3) diff --git a/vendor/plugins/will_paginate/Gemfile.rails3.2 b/vendor/plugins/will_paginate/Gemfile.rails3.2 new file mode 100644 index 0000000..3ace7e0 --- /dev/null +++ b/vendor/plugins/will_paginate/Gemfile.rails3.2 @@ -0,0 +1,28 @@ +source 'http://rubygems.org' + +rails_version = '~> 3.2.0' + +gem 'activerecord', rails_version +gem 'actionpack', rails_version + +gem 'rspec', '~> 2.6.0' +gem 'mocha', '~> 0.9.8' + +gem 'sequel', '~> 3.8' +gem 'sqlite3', '~> 1.3.3' +gem 'dm-core' +gem 'dm-aggregates' +gem 'dm-migrations' +gem 'dm-sqlite-adapter' +gem 'mongoid' + +group :mysql do + gem 'mysql', '~> 2.8.1' + gem 'mysql2', '>= 0.3.6' +end +gem 'pg', '~> 0.11', :group => :pg + +group :development do + gem 'ruby-debug', :platforms => :mri_18 + gem 'debugger', :platforms => :mri_19 +end diff --git a/vendor/plugins/will_paginate/Gemfile.rails3.2.lock b/vendor/plugins/will_paginate/Gemfile.rails3.2.lock new file mode 100644 index 0000000..fc4bf3c --- /dev/null +++ b/vendor/plugins/will_paginate/Gemfile.rails3.2.lock @@ -0,0 +1,123 @@ +GEM + remote: http://rubygems.org/ + specs: + actionpack (3.2.13) + activemodel (= 3.2.13) + activesupport (= 3.2.13) + builder (~> 3.0.0) + erubis (~> 2.7.0) + journey (~> 1.0.4) + rack (~> 1.4.5) + rack-cache (~> 1.2) + rack-test (~> 0.6.1) + sprockets (~> 2.2.1) + activemodel (3.2.13) + activesupport (= 3.2.13) + builder (~> 3.0.0) + activerecord (3.2.13) + activemodel (= 3.2.13) + activesupport (= 3.2.13) + arel (~> 3.0.2) + tzinfo (~> 0.3.29) + activesupport (3.2.13) + i18n (= 0.6.1) + multi_json (~> 1.0) + addressable (2.2.6) + arel (3.0.2) + bson (1.6.4) + builder (3.0.4) + columnize (0.3.5) + data_objects (0.10.7) + addressable (~> 2.1) + debugger (1.2.2) + columnize (>= 0.3.1) + debugger-linecache (~> 1.1.1) + debugger-ruby_core_source (~> 1.1.5) + debugger-linecache (1.1.2) + debugger-ruby_core_source (>= 1.1.1) + debugger-ruby_core_source (1.1.5) + diff-lcs (1.1.3) + dm-aggregates (1.2.0) + dm-core (~> 1.2.0) + dm-core (1.2.0) + addressable (~> 2.2.6) + dm-do-adapter (1.2.0) + data_objects (~> 0.10.6) + dm-core (~> 1.2.0) + dm-migrations (1.2.0) + dm-core (~> 1.2.0) + dm-sqlite-adapter (1.2.0) + dm-do-adapter (~> 1.2.0) + do_sqlite3 (~> 0.10.6) + do_sqlite3 (0.10.7) + data_objects (= 0.10.7) + erubis (2.7.0) + hike (1.2.3) + i18n (0.6.1) + journey (1.0.4) + linecache (0.46) + rbx-require-relative (> 0.0.4) + mocha (0.9.12) + mongo (1.6.2) + bson (~> 1.6.2) + mongoid (2.4.11) + activemodel (~> 3.1) + mongo (<= 1.6.2) + tzinfo (~> 0.3.22) + multi_json (1.7.7) + mysql (2.8.1) + mysql2 (0.3.11) + pg (0.12.0) + rake-compiler (~> 0.7) + rack (1.4.5) + rack-cache (1.2) + rack (>= 0.4) + rack-test (0.6.2) + rack (>= 1.0) + rake (0.9.2.2) + rake-compiler (0.7.9) + rake + rbx-require-relative (0.0.5) + rspec (2.6.0) + rspec-core (~> 2.6.0) + rspec-expectations (~> 2.6.0) + rspec-mocks (~> 2.6.0) + rspec-core (2.6.4) + rspec-expectations (2.6.0) + diff-lcs (~> 1.1.2) + rspec-mocks (2.6.0) + ruby-debug (0.10.4) + columnize (>= 0.1) + ruby-debug-base (~> 0.10.4.0) + ruby-debug-base (0.10.4) + linecache (>= 0.3) + sequel (3.30.0) + sprockets (2.2.2) + hike (~> 1.2) + multi_json (~> 1.0) + rack (~> 1.0) + tilt (~> 1.1, != 1.3.0) + sqlite3 (1.3.5) + tilt (1.4.1) + tzinfo (0.3.37) + +PLATFORMS + ruby + +DEPENDENCIES + actionpack (~> 3.2.0) + activerecord (~> 3.2.0) + debugger + dm-aggregates + dm-core + dm-migrations + dm-sqlite-adapter + mocha (~> 0.9.8) + mongoid + mysql (~> 2.8.1) + mysql2 (>= 0.3.6) + pg (~> 0.11) + rspec (~> 2.6.0) + ruby-debug + sequel (~> 3.8) + sqlite3 (~> 1.3.3) diff --git a/vendor/plugins/will_paginate/LICENSE b/vendor/plugins/will_paginate/LICENSE new file mode 100644 index 0000000..44c52a6 --- /dev/null +++ b/vendor/plugins/will_paginate/LICENSE @@ -0,0 +1,18 @@ +Copyright (c) 2009 Mislav Marohnić + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vendor/plugins/will_paginate/README.md b/vendor/plugins/will_paginate/README.md new file mode 100644 index 0000000..1a5ac51 --- /dev/null +++ b/vendor/plugins/will_paginate/README.md @@ -0,0 +1,61 @@ +# will_paginate + +will_paginate is a pagination library that integrates with Ruby on Rails, Sinatra, Merb, DataMapper and Sequel. + +Installation: + +``` ruby +## Gemfile for Rails 3, Sinatra, and Merb +gem 'will_paginate', '~> 3.0' +``` + +See [installation instructions][install] on the wiki for more info. + + +## Basic will_paginate use + +``` ruby +## perform a paginated query: +@posts = Post.paginate(:page => params[:page]) + +# or, use an explicit "per page" limit: +Post.paginate(:page => params[:page], :per_page => 30) + +## render page links in the view: +<%= will_paginate @posts %> +``` + +And that's it! You're done. You just need to add some CSS styles to [make those pagination links prettier][css]. + +You can customize the default "per_page" value: + +``` ruby +# for the Post model +class Post + self.per_page = 10 +end + +# set per_page globally +WillPaginate.per_page = 10 +``` + +New in Active Record 3: + +``` ruby +# paginate in Active Record now returns a Relation +Post.where(:published => true).paginate(:page => params[:page]).order('id DESC') + +# the new, shorter page() method +Post.page(params[:page]).order('created_at DESC') +``` + +See [the wiki][wiki] for more documentation. [Ask on the group][group] if you have usage questions. [Report bugs][issues] on GitHub. + +Happy paginating. + + +[wiki]: https://github.com/mislav/will_paginate/wiki +[install]: https://github.com/mislav/will_paginate/wiki/Installation "will_paginate installation" +[group]: http://groups.google.com/group/will_paginate "will_paginate discussion and support group" +[issues]: https://github.com/mislav/will_paginate/issues +[css]: http://mislav.uniqpath.com/will_paginate/ diff --git a/vendor/plugins/will_paginate/init.rb b/vendor/plugins/will_paginate/init.rb new file mode 100644 index 0000000..dcaead0 --- /dev/null +++ b/vendor/plugins/will_paginate/init.rb @@ -0,0 +1,18 @@ +require 'will_paginate' + +# This is all duplication of what Railtie does, but is necessary because +# the initializer defined by the Railtie won't ever run when loaded as plugin. + +if defined? ActiveRecord::Base + require 'will_paginate/active_record' +end + +if defined? ActionController::Base + WillPaginate::Railtie.setup_actioncontroller +end + +if defined? ActionView::Base + require 'will_paginate/view_helpers/action_view' +end + +WillPaginate::Railtie.add_locale_path config diff --git a/vendor/plugins/will_paginate/lib/will_paginate.rb b/vendor/plugins/will_paginate/lib/will_paginate.rb new file mode 100644 index 0000000..5821d34 --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate.rb @@ -0,0 +1,25 @@ +# You will paginate! +module WillPaginate +end + +if defined?(Rails::Railtie) + require 'will_paginate/railtie' +elsif defined?(Rails::Initializer) + raise "will_paginate 3.0 is not compatible with Rails 2.3 or older" +end + +if defined?(Merb::AbstractController) + require 'will_paginate/view_helpers/merb' + + Merb::BootLoader.before_app_loads do + adapters = { :datamapper => 'data_mapper', :activerecord => 'active_record', :sequel => 'sequel' } + # auto-load the right ORM adapter + if adapter = adapters[Merb.orm] + require "will_paginate/#{adapter}" + end + end +end + +if defined?(Sinatra) and Sinatra.respond_to? :register + require 'will_paginate/view_helpers/sinatra' +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/active_record.rb b/vendor/plugins/will_paginate/lib/will_paginate/active_record.rb new file mode 100644 index 0000000..9c14e81 --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/active_record.rb @@ -0,0 +1,247 @@ +require 'will_paginate/per_page' +require 'will_paginate/page_number' +require 'will_paginate/collection' +require 'active_record' + +module WillPaginate + # = Paginating finders for ActiveRecord models + # + # WillPaginate adds +paginate+, +per_page+ and other methods to + # ActiveRecord::Base class methods and associations. + # + # In short, paginating finders are equivalent to ActiveRecord finders; the + # only difference is that we start with "paginate" instead of "find" and + # that :page is required parameter: + # + # @posts = Post.paginate :all, :page => params[:page], :order => 'created_at DESC' + # + module ActiveRecord + # makes a Relation look like WillPaginate::Collection + module RelationMethods + include WillPaginate::CollectionMethods + + attr_accessor :current_page + attr_writer :total_entries, :wp_count_options + + def per_page(value = nil) + if value.nil? then limit_value + else limit(value) + end + end + + # TODO: solve with less relation clones and code dups + def limit(num) + rel = super + if rel.current_page + rel.offset rel.current_page.to_offset(rel.limit_value).to_i + else + rel + end + end + + # dirty hack to enable `first` after `limit` behavior above + def first(*args) + if current_page + rel = clone + rel.current_page = nil + rel.first(*args) + else + super + end + end + + # fix for Rails 3.0 + def find_last + if !loaded? and offset_value || limit_value + @last ||= to_a.last + else + super + end + end + + def offset(value = nil) + if value.nil? then offset_value + else super(value) + end + end + + def total_entries + @total_entries ||= begin + if loaded? and size < limit_value and (current_page == 1 or size > 0) + offset_value + size + else + @total_entries_queried = true + result = count + result = result.size if result.respond_to?(:size) and !result.is_a?(Integer) + result + end + end + end + + def count + if limit_value + excluded = [:order, :limit, :offset, :reorder] + excluded << :includes unless eager_loading? + rel = self.except(*excluded) + # TODO: hack. decide whether to keep + rel = rel.apply_finder_options(@wp_count_options) if defined? @wp_count_options + rel.count + else + super + end + end + + # workaround for Active Record 3.0 + def size + if !loaded? and limit_value and group_values.empty? + [super, limit_value].min + else + super + end + end + + # overloaded to be pagination-aware + def empty? + if !loaded? and offset_value + result = count + result = result.size if result.respond_to?(:size) and !result.is_a?(Integer) + result <= offset_value + else + super + end + end + + def clone + copy_will_paginate_data super + end + + # workaround for Active Record 3.0 + def scoped(options = nil) + copy_will_paginate_data super + end + + def to_a + if current_page.nil? then super # workaround for Active Record 3.0 + else + ::WillPaginate::Collection.create(current_page, limit_value) do |col| + col.replace super + col.total_entries ||= total_entries + end + end + end + + private + + def copy_will_paginate_data(other) + other.current_page = current_page unless other.current_page + other.total_entries = nil if defined? @total_entries_queried + other.wp_count_options = @wp_count_options if defined? @wp_count_options + other + end + end + + module Pagination + def paginate(options) + options = options.dup + pagenum = options.fetch(:page) { raise ArgumentError, ":page parameter required" } + per_page = options.delete(:per_page) || self.per_page + total = options.delete(:total_entries) + + count_options = options.delete(:count) + options.delete(:page) + + rel = limit(per_page.to_i).page(pagenum) + rel = rel.apply_finder_options(options) if options.any? + rel.wp_count_options = count_options if count_options + rel.total_entries = total.to_i unless total.blank? + rel + end + + def page(num) + rel = if ::ActiveRecord::Relation === self + self + elsif !defined?(::ActiveRecord::Scoping) or ::ActiveRecord::Scoping::ClassMethods.method_defined? :with_scope + # Active Record 3 + scoped + else + # Active Record 4 + all + end + + rel = rel.extending(RelationMethods) + pagenum = ::WillPaginate::PageNumber(num.nil? ? 1 : num) + per_page = rel.limit_value || self.per_page + rel = rel.offset(pagenum.to_offset(per_page).to_i) + rel = rel.limit(per_page) unless rel.limit_value + rel.current_page = pagenum + rel + end + end + + module BaseMethods + # Wraps +find_by_sql+ by simply adding LIMIT and OFFSET to your SQL string + # based on the params otherwise used by paginating finds: +page+ and + # +per_page+. + # + # Example: + # + # @developers = Developer.paginate_by_sql ['select * from developers where salary > ?', 80000], + # :page => params[:page], :per_page => 3 + # + # A query for counting rows will automatically be generated if you don't + # supply :total_entries. If you experience problems with this + # generated SQL, you might want to perform the count manually in your + # application. + # + def paginate_by_sql(sql, options) + pagenum = options.fetch(:page) { raise ArgumentError, ":page parameter required" } || 1 + per_page = options[:per_page] || self.per_page + total = options[:total_entries] + + WillPaginate::Collection.create(pagenum, per_page, total) do |pager| + query = sanitize_sql(sql.dup) + original_query = query.dup + oracle = self.connection.adapter_name =~ /^(oracle|oci$)/i + + # add limit, offset + if oracle + query = <<-SQL + SELECT * FROM ( + SELECT rownum rnum, a.* FROM (#{query}) a + WHERE rownum <= #{pager.offset + pager.per_page} + ) WHERE rnum >= #{pager.offset} + SQL + else + query << " LIMIT #{pager.per_page} OFFSET #{pager.offset}" + end + + # perfom the find + pager.replace find_by_sql(query) + + unless pager.total_entries + count_query = original_query.sub /\bORDER\s+BY\s+[\w`,\s.]+$/mi, '' + count_query = "SELECT COUNT(*) FROM (#{count_query})" + count_query << ' AS count_table' unless oracle + # perform the count query + pager.total_entries = count_by_sql(count_query) + end + end + end + end + + # mix everything into Active Record + ::ActiveRecord::Base.extend PerPage + ::ActiveRecord::Base.extend Pagination + ::ActiveRecord::Base.extend BaseMethods + + klasses = [::ActiveRecord::Relation] + if defined? ::ActiveRecord::Associations::CollectionProxy + klasses << ::ActiveRecord::Associations::CollectionProxy + else + klasses << ::ActiveRecord::Associations::AssociationCollection + end + + # support pagination on associations and scopes + klasses.each { |klass| klass.send(:include, Pagination) } + end +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/array.rb b/vendor/plugins/will_paginate/lib/will_paginate/array.rb new file mode 100644 index 0000000..e3dbf6c --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/array.rb @@ -0,0 +1,33 @@ +require 'will_paginate/collection' + +class Array + # Paginates a static array (extracting a subset of it). The result is a + # WillPaginate::Collection instance, which is an array with a few more + # properties about its paginated state. + # + # Parameters: + # * :page - current page, defaults to 1 + # * :per_page - limit of items per page, defaults to 30 + # * :total_entries - total number of items in the array, defaults to + # array.length (obviously) + # + # Example: + # arr = ['a', 'b', 'c', 'd', 'e'] + # paged = arr.paginate(:per_page => 2) #-> ['a', 'b'] + # paged.total_entries #-> 5 + # arr.paginate(:page => 2, :per_page => 2) #-> ['c', 'd'] + # arr.paginate(:page => 3, :per_page => 2) #-> ['e'] + # + # This method was originally {suggested by Desi + # McAdam}[http://www.desimcadam.com/archives/8] and later proved to be the + # most useful method of will_paginate library. + def paginate(options = {}) + page = options[:page] || 1 + per_page = options[:per_page] || WillPaginate.per_page + total = options[:total_entries] || self.length + + WillPaginate::Collection.create(page, per_page, total) do |pager| + pager.replace self[pager.offset, pager.per_page].to_a + end + end +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/collection.rb b/vendor/plugins/will_paginate/lib/will_paginate/collection.rb new file mode 100644 index 0000000..720c722 --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/collection.rb @@ -0,0 +1,136 @@ +require 'will_paginate/per_page' +require 'will_paginate/page_number' + +module WillPaginate + # Any will_paginate-compatible collection should have these methods: + # + # current_page, per_page, offset, total_entries, total_pages + # + # It can also define some of these optional methods: + # + # out_of_bounds?, previous_page, next_page + # + # This module provides few of these methods. + module CollectionMethods + def total_pages + total_entries.zero? ? 1 : (total_entries / per_page.to_f).ceil + end + + # current_page - 1 or nil if there is no previous page + def previous_page + current_page > 1 ? (current_page - 1) : nil + end + + # current_page + 1 or nil if there is no next page + def next_page + current_page < total_pages ? (current_page + 1) : nil + end + + # Helper method that is true when someone tries to fetch a page with a + # larger number than the last page. Can be used in combination with flashes + # and redirecting. + def out_of_bounds? + current_page > total_pages + end + end + + # = The key to pagination + # Arrays returned from paginating finds are, in fact, instances of this little + # class. You may think of WillPaginate::Collection as an ordinary array with + # some extra properties. Those properties are used by view helpers to generate + # correct page links. + # + # WillPaginate::Collection also assists in rolling out your own pagination + # solutions: see +create+. + # + # If you are writing a library that provides a collection which you would like + # to conform to this API, you don't have to copy these methods over; simply + # make your plugin/gem dependant on this library and do: + # + # require 'will_paginate/collection' + # # WillPaginate::Collection is now available for use + class Collection < Array + include CollectionMethods + + attr_reader :current_page, :per_page, :total_entries + + # Arguments to the constructor are the current page number, per-page limit + # and the total number of entries. The last argument is optional because it + # is best to do lazy counting; in other words, count *conditionally* after + # populating the collection using the +replace+ method. + def initialize(page, per_page = WillPaginate.per_page, total = nil) + @current_page = WillPaginate::PageNumber(page) + @per_page = per_page.to_i + self.total_entries = total if total + end + + # Just like +new+, but yields the object after instantiation and returns it + # afterwards. This is very useful for manual pagination: + # + # @entries = WillPaginate::Collection.create(1, 10) do |pager| + # result = Post.find(:all, :limit => pager.per_page, :offset => pager.offset) + # # inject the result array into the paginated collection: + # pager.replace(result) + # + # unless pager.total_entries + # # the pager didn't manage to guess the total count, do it manually + # pager.total_entries = Post.count + # end + # end + # + # The possibilities with this are endless. For another example, here is how + # WillPaginate used to define pagination for Array instances: + # + # Array.class_eval do + # def paginate(page = 1, per_page = 15) + # WillPaginate::Collection.create(page, per_page, size) do |pager| + # pager.replace self[pager.offset, pager.per_page].to_a + # end + # end + # end + # + # The Array#paginate API has since then changed, but this still serves as a + # fine example of WillPaginate::Collection usage. + def self.create(page, per_page, total = nil) + pager = new(page, per_page, total) + yield pager + pager + end + + # Current offset of the paginated collection. If we're on the first page, + # it is always 0. If we're on the 2nd page and there are 30 entries per page, + # the offset is 30. This property is useful if you want to render ordinals + # side by side with records in the view: simply start with offset + 1. + def offset + current_page.to_offset(per_page).to_i + end + + def total_entries=(number) + @total_entries = number.to_i + end + + # This is a magic wrapper for the original Array#replace method. It serves + # for populating the paginated collection after initialization. + # + # Why magic? Because it tries to guess the total number of entries judging + # by the size of given array. If it is shorter than +per_page+ limit, then we + # know we're on the last page. This trick is very useful for avoiding + # unnecessary hits to the database to do the counting after we fetched the + # data for the current page. + # + # However, after using +replace+ you should always test the value of + # +total_entries+ and set it to a proper value if it's +nil+. See the example + # in +create+. + def replace(array) + result = super + + # The collection is shorter then page limit? Rejoice, because + # then we know that we are on the last page! + if total_entries.nil? and length < per_page and (current_page == 1 or length > 0) + self.total_entries = offset + length + end + + result + end + end +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/core_ext.rb b/vendor/plugins/will_paginate/lib/will_paginate/core_ext.rb new file mode 100644 index 0000000..7de066c --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/core_ext.rb @@ -0,0 +1,30 @@ +require 'set' + +# copied from ActiveSupport so we don't depend on it + +unless Hash.method_defined? :except + Hash.class_eval do + # Returns a new hash without the given keys. + def except(*keys) + rejected = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys) + reject { |key,| rejected.include?(key) } + end + + # Replaces the hash without only the given keys. + def except!(*keys) + replace(except(*keys)) + end + end +end + +unless String.method_defined? :underscore + String.class_eval do + def underscore + self.to_s.gsub(/::/, '/'). + gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2'). + gsub(/([a-z\d])([A-Z])/,'\1_\2'). + tr("-", "_"). + downcase + end + end +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/data_mapper.rb b/vendor/plugins/will_paginate/lib/will_paginate/data_mapper.rb new file mode 100644 index 0000000..13f4364 --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/data_mapper.rb @@ -0,0 +1,95 @@ +require 'dm-core' +require 'dm-aggregates' +require 'will_paginate/per_page' +require 'will_paginate/page_number' +require 'will_paginate/collection' + +module WillPaginate + module DataMapper + module Pagination + def page(num) + pagenum = ::WillPaginate::PageNumber(num.nil? ? 1 : num) + per_page = query.limit || self.per_page + options = {:offset => pagenum.to_offset(per_page).to_i} + options[:limit] = per_page unless query.limit + col = new_collection(query.merge(options)) + col.current_page = pagenum + col + end + + def paginate(options) + options = options.dup + pagenum = options.fetch(:page) { raise ArgumentError, ":page parameter required" } + per_page = options.delete(:per_page) || self.per_page + + options.delete(:page) + options[:limit] = per_page.to_i + + all(options).page(pagenum) + end + end + + module CollectionMethods + include WillPaginate::CollectionMethods + + attr_accessor :current_page + + def paginated? + !current_page.nil? + end + + def per_page + query.limit || model.per_page + end + + def offset + query.offset + end + + def total_entries + @total_entries ||= begin + if loaded? and @array.size < per_page and (current_page == 1 or @array.size > 0) + offset + @array.size + else + # :reload prevents Collection.filter from being run, which + # would cause a stack overflow + clean_query = query.merge(:reload => true) + # seems like the only way + clean_query.instance_variable_set('@limit', nil) + clean_query.instance_variable_set('@offset', 0) + new_collection(clean_query).count + end + end + end + + def to_a + if paginated? + ::WillPaginate::Collection.create(current_page, per_page) do |col| + col.replace super + col.total_entries ||= total_entries + end + else + super + end + end + + private + + def new_collection(query, resources = nil) + col = super + col.current_page = self.current_page + col + end + + def initialize_copy(original) + super + @total_entries = nil + end + end + + ::DataMapper::Model.append_extensions PerPage + ::DataMapper::Model.append_extensions Pagination + ::DataMapper::Collection.send(:include, Pagination) + ::DataMapper::Collection.send(:include, CollectionMethods) + end +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/deprecation.rb b/vendor/plugins/will_paginate/lib/will_paginate/deprecation.rb new file mode 100644 index 0000000..aa66e6a --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/deprecation.rb @@ -0,0 +1,55 @@ +module WillPaginate::Deprecation + class << self + def warn(message, stack = caller) + offending_line = origin_of_call(stack) + full_message = "DEPRECATION WARNING: #{message} (called from #{offending_line})" + logger = rails_logger || Kernel + logger.warn full_message + end + + private + + def rails_logger + defined?(Rails) && Rails.logger + end + + def origin_of_call(stack) + lib_root = File.expand_path('../../..', __FILE__) + stack.find { |line| line.index(lib_root) != 0 } || stack.first + end + end + + class Hash < ::Hash + def initialize(values = {}) + super() + update values + @deprecated = {} + end + + def []=(key, value) + check_deprecated(key, value) + super + end + + def deprecate_key(*keys) + message = block_given? ? Proc.new : keys.pop + Array(keys).each { |key| @deprecated[key] = message } + end + + def merge(another) + to_hash.update(another) + end + + def to_hash + ::Hash.new.update(self) + end + + private + + def check_deprecated(key, value) + if msg = @deprecated[key] and (!msg.respond_to?(:call) or (msg = msg.call(key, value))) + WillPaginate::Deprecation.warn(msg) + end + end + end +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/i18n.rb b/vendor/plugins/will_paginate/lib/will_paginate/i18n.rb new file mode 100644 index 0000000..3443caf --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/i18n.rb @@ -0,0 +1,22 @@ +module WillPaginate + module I18n + def self.locale_dir + File.expand_path('../locale', __FILE__) + end + + def self.load_path + Dir["#{locale_dir}/*.{rb,yml}"] + end + + def will_paginate_translate(keys, options = {}) + if defined? ::I18n + defaults = Array(keys).dup + defaults << Proc.new if block_given? + ::I18n.translate(defaults.shift, options.merge(:default => defaults, :scope => :will_paginate)) + else + key = Array === keys ? keys.first : keys + yield key, options + end + end + end +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/mongoid.rb b/vendor/plugins/will_paginate/lib/will_paginate/mongoid.rb new file mode 100644 index 0000000..5792412 --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/mongoid.rb @@ -0,0 +1,46 @@ +require 'mongoid' +require 'will_paginate/collection' + +module WillPaginate + module Mongoid + module CriteriaMethods + def paginate(options = {}) + extend CollectionMethods + @current_page = WillPaginate::PageNumber(options[:page] || @current_page || 1) + @page_multiplier = current_page - 1 + pp = (options[:per_page] || per_page || WillPaginate.per_page).to_i + limit(pp).skip(@page_multiplier * pp) + end + + def per_page(value = :non_given) + if value == :non_given + options[:limit] == 0 ? nil : options[:limit] # in new Mongoid versions a nil limit is saved as 0 + else + limit(value) + end + end + + def page(page) + paginate(:page => page) + end + end + + module CollectionMethods + attr_reader :current_page + + def total_entries + @total_entries ||= count + end + + def total_pages + (total_entries / per_page.to_f).ceil + end + + def offset + @page_multiplier * per_page + end + end + + ::Mongoid::Criteria.send(:include, CriteriaMethods) + end +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/page_number.rb b/vendor/plugins/will_paginate/lib/will_paginate/page_number.rb new file mode 100644 index 0000000..7883b12 --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/page_number.rb @@ -0,0 +1,57 @@ +require 'delegate' +require 'forwardable' + +module WillPaginate + # a module that page number exceptions are tagged with + module InvalidPage; end + + # integer representing a page number + class PageNumber < DelegateClass(Integer) + # a value larger than this is not supported in SQL queries + BIGINT = 9223372036854775807 + + extend Forwardable + + def initialize(value, name) + value = Integer(value) + if 'offset' == name ? (value < 0 or value > BIGINT) : value < 1 + raise RangeError, "invalid #{name}: #{value.inspect}" + end + @name = name + super(value) + rescue ArgumentError, TypeError, RangeError => error + error.extend InvalidPage + raise error + end + + alias_method :to_i, :__getobj__ + + def inspect + "#{@name} #{to_i}" + end + + def to_offset(per_page) + PageNumber.new((to_i - 1) * per_page.to_i, 'offset') + end + + def kind_of?(klass) + super || to_i.kind_of?(klass) + end + alias is_a? kind_of? + end + + # Ultrahax: makes `Fixnum === current_page` checks pass + Numeric.extend Module.new { + def ===(obj) + obj.instance_of? PageNumber or super + end + } + + # An idemptotent coercion method + def self.PageNumber(value, name = 'page') + case value + when PageNumber then value + else PageNumber.new(value, name) + end + end +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/per_page.rb b/vendor/plugins/will_paginate/lib/will_paginate/per_page.rb new file mode 100644 index 0000000..29303e1 --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/per_page.rb @@ -0,0 +1,27 @@ +module WillPaginate + module PerPage + def per_page + defined?(@per_page) ? @per_page : WillPaginate.per_page + end + + def per_page=(limit) + @per_page = limit.to_i + end + + def self.extended(base) + base.extend Inheritance if base.is_a? Class + end + + module Inheritance + def inherited(subclass) + super + subclass.per_page = self.per_page + end + end + end + + extend PerPage + + # default number of items per page + self.per_page = 30 +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/railtie.rb b/vendor/plugins/will_paginate/lib/will_paginate/railtie.rb new file mode 100644 index 0000000..72137fd --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/railtie.rb @@ -0,0 +1,68 @@ +require 'will_paginate' +require 'will_paginate/page_number' +require 'will_paginate/collection' +require 'will_paginate/i18n' + +module WillPaginate + class Railtie < Rails::Railtie + initializer "will_paginate" do |app| + ActiveSupport.on_load :active_record do + require 'will_paginate/active_record' + end + + ActiveSupport.on_load :action_controller do + WillPaginate::Railtie.setup_actioncontroller + end + + ActiveSupport.on_load :action_view do + require 'will_paginate/view_helpers/action_view' + end + + self.class.add_locale_path config + + # early access to ViewHelpers.pagination_options + require 'will_paginate/view_helpers' + end + + def self.setup_actioncontroller + ( defined?(ActionDispatch::ExceptionWrapper) ? + ActionDispatch::ExceptionWrapper : ActionDispatch::ShowExceptions + ).send :include, ShowExceptionsPatch + ActionController::Base.extend ControllerRescuePatch + end + + def self.add_locale_path(config) + config.i18n.railties_load_path.unshift(*WillPaginate::I18n.load_path) + end + + # Extending the exception handler middleware so it properly detects + # WillPaginate::InvalidPage regardless of it being a tag module. + module ShowExceptionsPatch + extend ActiveSupport::Concern + included { alias_method_chain :status_code, :paginate } + def status_code_with_paginate(exception = @exception) + if exception.is_a?(WillPaginate::InvalidPage) or + (exception.respond_to?(:original_exception) && + exception.original_exception.is_a?(WillPaginate::InvalidPage)) + Rack::Utils.status_code(:not_found) + else + original_method = method(:status_code_without_paginate) + if original_method.arity != 0 + original_method.call(exception) + else + original_method.call() + end + end + end + end + + module ControllerRescuePatch + def rescue_from(*args, &block) + if idx = args.index(WillPaginate::InvalidPage) + args[idx] = args[idx].name + end + super(*args, &block) + end + end + end +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/sequel.rb b/vendor/plugins/will_paginate/lib/will_paginate/sequel.rb new file mode 100644 index 0000000..07f794d --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/sequel.rb @@ -0,0 +1,39 @@ +require 'sequel' +require 'sequel/extensions/pagination' +require 'will_paginate/collection' + +module WillPaginate + # Sequel already supports pagination; we only need to make the + # resulting dataset look a bit more like WillPaginate::Collection + module SequelMethods + include WillPaginate::CollectionMethods + + def total_pages + page_count + end + + def per_page + page_size + end + + def size + current_page_record_count + end + alias length size + + def total_entries + pagination_record_count + end + + def out_of_bounds? + current_page > total_pages + end + + # Current offset of the paginated collection + def offset + (current_page - 1) * per_page + end + end + + Sequel::Dataset::Pagination.send(:include, SequelMethods) +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/version.rb b/vendor/plugins/will_paginate/lib/will_paginate/version.rb new file mode 100644 index 0000000..6084a4a --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/version.rb @@ -0,0 +1,9 @@ +module WillPaginate #:nodoc: + module VERSION #:nodoc: + MAJOR = 3 + MINOR = 0 + TINY = 4 + + STRING = [MAJOR, MINOR, TINY].join('.') + end +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/view_helpers.rb b/vendor/plugins/will_paginate/lib/will_paginate/view_helpers.rb new file mode 100644 index 0000000..089f5bf --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/view_helpers.rb @@ -0,0 +1,162 @@ +# encoding: utf-8 +require 'will_paginate/core_ext' +require 'will_paginate/i18n' +require 'will_paginate/deprecation' + +module WillPaginate + # = Will Paginate view helpers + # + # The main view helper is +will_paginate+. It renders the pagination links + # for the given collection. The helper itself is lightweight and serves only + # as a wrapper around LinkRenderer instantiation; the renderer then does + # all the hard work of generating the HTML. + module ViewHelpers + class << self + # Write to this hash to override default options on the global level: + # + # WillPaginate::ViewHelpers.pagination_options[:page_links] = false + # + attr_accessor :pagination_options + end + + # default view options + self.pagination_options = Deprecation::Hash.new \ + :class => 'pagination', + :previous_label => nil, + :next_label => nil, + :inner_window => 4, # links around the current page + :outer_window => 1, # links around beginning and end + :link_separator => ' ', # single space is friendly to spiders and non-graphic browsers + :param_name => :page, + :params => nil, + :page_links => true, + :container => true + + label_deprecation = Proc.new { |key, value| + "set the 'will_paginate.#{key}' key in your i18n locale instead of editing pagination_options" if defined? Rails + } + pagination_options.deprecate_key(:previous_label, :next_label, &label_deprecation) + pagination_options.deprecate_key(:renderer) { |key, _| "pagination_options[#{key.inspect}] shouldn't be set globally" } + + include WillPaginate::I18n + + # Returns HTML representing page links for a WillPaginate::Collection-like object. + # In case there is no more than one page in total, nil is returned. + # + # ==== Options + # * :class -- CSS class name for the generated DIV (default: "pagination") + # * :previous_label -- default: "« Previous" + # * :next_label -- default: "Next »" + # * :inner_window -- how many links are shown around the current page (default: 4) + # * :outer_window -- how many links are around the first and the last page (default: 1) + # * :link_separator -- string separator for page HTML elements (default: single space) + # * :param_name -- parameter name for page number in URLs (default: :page) + # * :params -- additional parameters when generating pagination links + # (eg. :controller => "foo", :action => nil) + # * :renderer -- class name, class or instance of a link renderer (default in Rails: + # WillPaginate::ActionView::LinkRenderer) + # * :page_links -- when false, only previous/next links are rendered (default: true) + # * :container -- toggles rendering of the DIV container for pagination links, set to + # false only when you are rendering your own pagination markup (default: true) + # + # All options not recognized by will_paginate will become HTML attributes on the container + # element for pagination links (the DIV). For example: + # + # <%= will_paginate @posts, :style => 'color:blue' %> + # + # will result in: + # + # + # + def will_paginate(collection, options = {}) + # early exit if there is nothing to render + return nil unless collection.total_pages > 1 + + options = WillPaginate::ViewHelpers.pagination_options.merge(options) + + options[:previous_label] ||= will_paginate_translate(:previous_label) { '← Previous' } + options[:next_label] ||= will_paginate_translate(:next_label) { 'Next →' } + + # get the renderer instance + renderer = case options[:renderer] + when nil + raise ArgumentError, ":renderer not specified" + when String + klass = if options[:renderer].respond_to? :constantize then options[:renderer].constantize + else Object.const_get(options[:renderer]) # poor man's constantize + end + klass.new + when Class then options[:renderer].new + else options[:renderer] + end + # render HTML for pagination + renderer.prepare collection, options, self + output = renderer.to_html + output = output.html_safe if output.respond_to?(:html_safe) + output + end + + # Renders a message containing number of displayed vs. total entries. + # + # <%= page_entries_info @posts %> + # #-> Displaying posts 6 - 12 of 26 in total + # + # The default output contains HTML. Use ":html => false" for plain text. + def page_entries_info(collection, options = {}) + model = options[:model] + model = collection.first.class unless model or collection.empty? + model ||= 'entry' + model_key = if model.respond_to? :model_name + model.model_name.i18n_key # ActiveModel::Naming + else + model.to_s.underscore + end + + if options.fetch(:html, true) + b, eb = '', '' + sp = ' ' + html_key = '_html' + else + b = eb = html_key = '' + sp = ' ' + end + + model_count = collection.total_pages > 1 ? 5 : collection.size + defaults = ["models.#{model_key}"] + defaults << Proc.new { |_, opts| + if model.respond_to? :model_name + model.model_name.human(:count => opts[:count]) + else + name = model_key.to_s.tr('_', ' ') + raise "can't pluralize model name: #{model.inspect}" unless name.respond_to? :pluralize + opts[:count] == 1 ? name : name.pluralize + end + } + model_name = will_paginate_translate defaults, :count => model_count + + if collection.total_pages < 2 + i18n_key = :"page_entries_info.single_page#{html_key}" + keys = [:"#{model_key}.#{i18n_key}", i18n_key] + + will_paginate_translate keys, :count => collection.total_entries, :model => model_name do |_, opts| + case opts[:count] + when 0; "No #{opts[:model]} found" + when 1; "Displaying #{b}1#{eb} #{opts[:model]}" + else "Displaying #{b}all#{sp}#{opts[:count]}#{eb} #{opts[:model]}" + end + end + else + i18n_key = :"page_entries_info.multi_page#{html_key}" + keys = [:"#{model_key}.#{i18n_key}", i18n_key] + params = { + :model => model_name, :count => collection.total_entries, + :from => collection.offset + 1, :to => collection.offset + collection.length + } + will_paginate_translate keys, params do |_, opts| + %{Displaying %s #{b}%d#{sp}-#{sp}%d#{eb} of #{b}%d#{eb} in total} % + [ opts[:model], opts[:from], opts[:to], opts[:count] ] + end + end + end + end +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/action_view.rb b/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/action_view.rb new file mode 100644 index 0000000..6fa2929 --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/action_view.rb @@ -0,0 +1,148 @@ +require 'will_paginate/view_helpers' +require 'will_paginate/view_helpers/link_renderer' + +module WillPaginate + # = ActionView helpers + # + # This module serves for availability in ActionView templates. It also adds a new + # view helper: +paginated_section+. + # + # == Using the helper without arguments + # If the helper is called without passing in the collection object, it will + # try to read from the instance variable inferred by the controller name. + # For example, calling +will_paginate+ while the current controller is + # PostsController will result in trying to read from the @posts + # variable. Example: + # + # <%= will_paginate :id => true %> + # + # ... will result in @post collection getting paginated: + # + # + # + module ActionView + include ViewHelpers + + def will_paginate(collection = nil, options = {}) #:nodoc: + options, collection = collection, nil if collection.is_a? Hash + collection ||= infer_collection_from_controller + + options = options.symbolize_keys + options[:renderer] ||= LinkRenderer + + super(collection, options) + end + + def page_entries_info(collection = nil, options = {}) #:nodoc: + options, collection = collection, nil if collection.is_a? Hash + collection ||= infer_collection_from_controller + + super(collection, options.symbolize_keys) + end + + # Wrapper for rendering pagination links at both top and bottom of a block + # of content. + # + # <% paginated_section @posts do %> + #
    + # <% for post in @posts %> + #
  1. ...
  2. + # <% end %> + #
+ # <% end %> + # + # will result in: + # + # + #
    + # ... + #
+ # + # + # Arguments are passed to a will_paginate call, so the same options + # apply. Don't use the :id option; otherwise you'll finish with two + # blocks of pagination links sharing the same ID (which is invalid HTML). + def paginated_section(*args, &block) + pagination = will_paginate(*args) + if pagination + pagination + capture(&block) + pagination + else + capture(&block) + end + end + + def will_paginate_translate(keys, options = {}) + if respond_to? :translate + if Array === keys + defaults = keys.dup + key = defaults.shift + else + defaults = nil + key = keys + end + translate(key, options.merge(:default => defaults, :scope => :will_paginate)) + else + super + end + end + + protected + + def infer_collection_from_controller + collection_name = "@#{controller.controller_name}" + collection = instance_variable_get(collection_name) + raise ArgumentError, "The #{collection_name} variable appears to be empty. Did you " + + "forget to pass the collection object for will_paginate?" if collection.nil? + collection + end + + class LinkRenderer < ViewHelpers::LinkRenderer + protected + + def default_url_params + {} + end + + def url(page) + @base_url_params ||= begin + url_params = merge_get_params(default_url_params) + merge_optional_params(url_params) + end + + url_params = @base_url_params.dup + add_current_page_param(url_params, page) + + @template.url_for(url_params) + end + + def merge_get_params(url_params) + if @template.respond_to? :request and @template.request and @template.request.get? + symbolized_update(url_params, @template.params) + end + url_params + end + + def merge_optional_params(url_params) + symbolized_update(url_params, @options[:params]) if @options[:params] + url_params + end + + def add_current_page_param(url_params, page) + unless param_name.index(/[^\w-]/) + url_params[param_name.to_sym] = page + else + page_param = parse_query_parameters("#{param_name}=#{page}") + symbolized_update(url_params, page_param) + end + end + + private + + def parse_query_parameters(params) + Rack::Utils.parse_nested_query(params) + end + end + + ::ActionView::Base.send :include, self + end +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/link_renderer.rb b/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/link_renderer.rb new file mode 100644 index 0000000..d1745f8 --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/link_renderer.rb @@ -0,0 +1,131 @@ +require 'cgi' +require 'will_paginate/core_ext' +require 'will_paginate/view_helpers' +require 'will_paginate/view_helpers/link_renderer_base' + +module WillPaginate + module ViewHelpers + # This class does the heavy lifting of actually building the pagination + # links. It is used by +will_paginate+ helper internally. + class LinkRenderer < LinkRendererBase + + # * +collection+ is a WillPaginate::Collection instance or any other object + # that conforms to that API + # * +options+ are forwarded from +will_paginate+ view helper + # * +template+ is the reference to the template being rendered + def prepare(collection, options, template) + super(collection, options) + @template = template + @container_attributes = @base_url_params = nil + end + + # Process it! This method returns the complete HTML string which contains + # pagination links. Feel free to subclass LinkRenderer and change this + # method as you see fit. + def to_html + html = pagination.map do |item| + item.is_a?(Fixnum) ? + page_number(item) : + send(item) + end.join(@options[:link_separator]) + + @options[:container] ? html_container(html) : html + end + + # Returns the subset of +options+ this instance was initialized with that + # represent HTML attributes for the container element of pagination links. + def container_attributes + @container_attributes ||= @options.except(*(ViewHelpers.pagination_options.keys + [:renderer] - [:class])) + end + + protected + + def page_number(page) + unless page == current_page + link(page, page, :rel => rel_value(page)) + else + tag(:em, page, :class => 'current') + end + end + + def gap + text = @template.will_paginate_translate(:page_gap) { '…' } + %(#{text}) + end + + def previous_page + num = @collection.current_page > 1 && @collection.current_page - 1 + previous_or_next_page(num, @options[:previous_label], 'previous_page') + end + + def next_page + num = @collection.current_page < total_pages && @collection.current_page + 1 + previous_or_next_page(num, @options[:next_label], 'next_page') + end + + def previous_or_next_page(page, text, classname) + if page + link(text, page, :class => classname) + else + tag(:span, text, :class => classname + ' disabled') + end + end + + def html_container(html) + tag(:div, html, container_attributes) + end + + # Returns URL params for +page_link_or_span+, taking the current GET params + # and :params option into account. + def url(page) + raise NotImplementedError + end + + private + + def param_name + @options[:param_name].to_s + end + + def link(text, target, attributes = {}) + if target.is_a? Fixnum + attributes[:rel] = rel_value(target) + target = url(target) + end + attributes[:href] = target + tag(:a, text, attributes) + end + + def tag(name, value, attributes = {}) + string_attributes = attributes.inject('') do |attrs, pair| + unless pair.last.nil? + attrs << %( #{pair.first}="#{CGI::escapeHTML(pair.last.to_s)}") + end + attrs + end + "<#{name}#{string_attributes}>#{value}" + end + + def rel_value(page) + case page + when @collection.current_page - 1; 'prev' + (page == 1 ? ' start' : '') + when @collection.current_page + 1; 'next' + when 1; 'start' + end + end + + def symbolized_update(target, other) + other.each do |key, value| + key = key.to_sym + existing = target[key] + + if value.is_a?(Hash) and (existing.is_a?(Hash) or existing.nil?) + symbolized_update(existing || (target[key] = {}), value) + else + target[key] = value + end + end + end + end + end +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/link_renderer_base.rb b/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/link_renderer_base.rb new file mode 100644 index 0000000..385b1b2 --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/link_renderer_base.rb @@ -0,0 +1,77 @@ +module WillPaginate + module ViewHelpers + # This class does the heavy lifting of actually building the pagination + # links. It is used by +will_paginate+ helper internally. + class LinkRendererBase + + # * +collection+ is a WillPaginate::Collection instance or any other object + # that conforms to that API + # * +options+ are forwarded from +will_paginate+ view helper + def prepare(collection, options) + @collection = collection + @options = options + + # reset values in case we're re-using this instance + @total_pages = nil + end + + def pagination + items = @options[:page_links] ? windowed_page_numbers : [] + items.unshift :previous_page + items.push :next_page + end + + protected + + # Calculates visible page numbers using the :inner_window and + # :outer_window options. + def windowed_page_numbers + inner_window, outer_window = @options[:inner_window].to_i, @options[:outer_window].to_i + window_from = current_page - inner_window + window_to = current_page + inner_window + + # adjust lower or upper limit if other is out of bounds + if window_to > total_pages + window_from -= window_to - total_pages + window_to = total_pages + end + if window_from < 1 + window_to += 1 - window_from + window_from = 1 + window_to = total_pages if window_to > total_pages + end + + # these are always visible + middle = window_from..window_to + + # left window + if outer_window + 3 < middle.first # there's a gap + left = (1..(outer_window + 1)).to_a + left << :gap + else # runs into visible pages + left = 1...middle.first + end + + # right window + if total_pages - outer_window - 2 > middle.last # again, gap + right = ((total_pages - outer_window)..total_pages).to_a + right.unshift :gap + else # runs into visible pages + right = (middle.last + 1)..total_pages + end + + left.to_a + middle.to_a + right.to_a + end + + private + + def current_page + @collection.current_page + end + + def total_pages + @total_pages ||= @collection.total_pages + end + end + end +end diff --git a/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/merb.rb b/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/merb.rb new file mode 100644 index 0000000..d9b3a6b --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/merb.rb @@ -0,0 +1,26 @@ +require 'will_paginate/core_ext' +require 'will_paginate/view_helpers' +require 'will_paginate/view_helpers/link_renderer' + +module WillPaginate + module Merb + include ViewHelpers + + def will_paginate(collection, options = {}) #:nodoc: + options = options.merge(:renderer => LinkRenderer) unless options[:renderer] + super(collection, options) + end + + class LinkRenderer < ViewHelpers::LinkRenderer + protected + + def url(page) + params = @template.request.params.except(:action, :controller).merge(param_name => page) + @template.url(:this, params) + end + end + + ::Merb::AbstractController.send(:include, self) + end +end + diff --git a/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/sinatra.rb b/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/sinatra.rb new file mode 100644 index 0000000..2ba17f8 --- /dev/null +++ b/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/sinatra.rb @@ -0,0 +1,41 @@ +require 'sinatra/base' +require 'will_paginate/view_helpers' +require 'will_paginate/view_helpers/link_renderer' + +module WillPaginate + module Sinatra + module Helpers + include ViewHelpers + + def will_paginate(collection, options = {}) #:nodoc: + options = options.merge(:renderer => LinkRenderer) unless options[:renderer] + super(collection, options) + end + end + + class LinkRenderer < ViewHelpers::LinkRenderer + protected + + def url(page) + str = File.join(request.script_name.to_s, request.path_info) + params = request.GET.merge(param_name.to_s => page.to_s) + params.update @options[:params] if @options[:params] + str << '?' << build_query(params) + end + + def request + @template.request + end + + def build_query(params) + Rack::Utils.build_nested_query params + end + end + + def self.registered(app) + app.helpers Helpers + end + + ::Sinatra.register self + end +end diff --git a/vendor/plugins/will_paginate/script/each-gemfile b/vendor/plugins/will_paginate/script/each-gemfile new file mode 100755 index 0000000..09bd47f --- /dev/null +++ b/vendor/plugins/will_paginate/script/each-gemfile @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +set -e + +if [ -z "$1" ]; then + echo "Usage: script/each-bundle COMMAND []" >&2 + exit 1 +fi + +for gemfile in $(ls Gemfile* | grep -v lock); do + printf "\e[31m[%s]\e[0m\n" $gemfile + BUNDLE_GEMFILE=$gemfile "$@" +done diff --git a/vendor/plugins/will_paginate/script/test_all b/vendor/plugins/will_paginate/script/test_all new file mode 100755 index 0000000..c8db215 --- /dev/null +++ b/vendor/plugins/will_paginate/script/test_all @@ -0,0 +1,21 @@ +#!/usr/bin/env bash +status=0 + +run_all(){ + spec_files="spec" + [[ $DB != "sqlite3" ]] && spec_files="spec/finders/active_record_spec.rb" + set -x + rspec -r fake_rubygems $spec_files + set +x +} + +export PATH="${PWD}/bin:$PATH" + +for db in sqlite3 mysql mysql2 postgres; do + if ! [[ $db = "mysql2" && $BUNDLE_GEMFILE =~ "rails3.0" ]]; then + printf "\e[1;33m[DB] ${db}\e[m\n" + DB=$db run_all || status=1 + fi +done + +exit $status diff --git a/vendor/plugins/will_paginate/spec/collection_spec.rb b/vendor/plugins/will_paginate/spec/collection_spec.rb new file mode 100644 index 0000000..d561e83 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/collection_spec.rb @@ -0,0 +1,139 @@ +require 'will_paginate/array' +require 'spec_helper' + +describe WillPaginate::Collection do + + before :all do + @simple = ('a'..'e').to_a + end + + it "should be a subset of original collection" do + @simple.paginate(:page => 1, :per_page => 3).should == %w( a b c ) + end + + it "can be shorter than per_page if on last page" do + @simple.paginate(:page => 2, :per_page => 3).should == %w( d e ) + end + + it "should include whole collection if per_page permits" do + @simple.paginate(:page => 1, :per_page => 5).should == @simple + end + + it "should be empty if out of bounds" do + @simple.paginate(:page => 2, :per_page => 5).should be_empty + end + + it "should default to 1 as current page and 30 per-page" do + result = (1..50).to_a.paginate + result.current_page.should == 1 + result.size.should == 30 + end + + it "should give total_entries precedence over actual size" do + %w(a b c).paginate(:total_entries => 5).total_entries.should == 5 + end + + it "should be an augmented Array" do + entries = %w(a b c) + collection = create(2, 3, 10) do |pager| + pager.replace(entries).should == entries + end + + collection.should == entries + for method in %w(total_pages each offset size current_page per_page total_entries) + collection.should respond_to(method) + end + collection.should be_kind_of(Array) + collection.entries.should be_instance_of(Array) + # TODO: move to another expectation: + collection.offset.should == 3 + collection.total_pages.should == 4 + collection.should_not be_out_of_bounds + end + + describe "previous/next pages" do + it "should have previous_page nil when on first page" do + collection = create(1, 1, 3) + collection.previous_page.should be_nil + collection.next_page.should == 2 + end + + it "should have both prev/next pages" do + collection = create(2, 1, 3) + collection.previous_page.should == 1 + collection.next_page.should == 3 + end + + it "should have next_page nil when on last page" do + collection = create(3, 1, 3) + collection.previous_page.should == 2 + collection.next_page.should be_nil + end + end + + describe "out of bounds" do + it "is out of bounds when page number is too high" do + create(2, 3, 2).should be_out_of_bounds + end + + it "isn't out of bounds when inside collection" do + create(1, 3, 2).should_not be_out_of_bounds + end + + it "isn't out of bounds when the collection is empty" do + collection = create(1, 3, 0) + collection.should_not be_out_of_bounds + collection.total_pages.should == 1 + end + end + + describe "guessing total count" do + it "can guess when collection is shorter than limit" do + collection = create { |p| p.replace array } + collection.total_entries.should == 8 + end + + it "should allow explicit total count to override guessed" do + collection = create(2, 5, 10) { |p| p.replace array } + collection.total_entries.should == 10 + end + + it "should not be able to guess when collection is same as limit" do + collection = create { |p| p.replace array(5) } + collection.total_entries.should be_nil + end + + it "should not be able to guess when collection is empty" do + collection = create { |p| p.replace array(0) } + collection.total_entries.should be_nil + end + + it "should be able to guess when collection is empty and this is the first page" do + collection = create(1) { |p| p.replace array(0) } + collection.total_entries.should == 0 + end + end + + it "should not respond to page_count anymore" do + Proc.new { create.page_count }.should raise_error(NoMethodError) + end + + it "inherits per_page from global value" do + collection = described_class.new(1) + collection.per_page.should == 30 + end + + private + + def create(page = 2, limit = 5, total = nil, &block) + if block_given? + described_class.create(page, limit, total, &block) + else + described_class.new(page, limit, total) + end + end + + def array(size = 3) + Array.new(size) + end +end diff --git a/vendor/plugins/will_paginate/spec/console b/vendor/plugins/will_paginate/spec/console new file mode 100755 index 0000000..4c64785 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/console @@ -0,0 +1,12 @@ +#!/usr/bin/env ruby +irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb' +opts = %w[ --simple-prompt -rirb/completion ] +if ARGV.include? '-dm' + opts << '-rwill_paginate/data_mapper' << '-rfinders/data_mapper_test_connector' +elsif ARGV.include? '-seq' + opts << '-rwill_paginate/sequel' << '-rfinders/sequel_test_connector' +else + opts << '-rconsole_fixtures' +end + +exec 'bundle', 'exec', irb, '-Ilib:spec', *opts diff --git a/vendor/plugins/will_paginate/spec/console_fixtures.rb b/vendor/plugins/will_paginate/spec/console_fixtures.rb new file mode 100644 index 0000000..40b41d1 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/console_fixtures.rb @@ -0,0 +1,28 @@ +require 'bundler' +Bundler.setup + +require 'will_paginate/active_record' +require 'finders/activerecord_test_connector' + +ActiverecordTestConnector.setup + +windows = RUBY_PLATFORM =~ /(:?mswin|mingw)/ +# used just for the `color` method +log_subscriber = ActiveSupport::LogSubscriber.log_subscribers.first + +IGNORE_SQL = /\b(sqlite_master|sqlite_version)\b|^(CREATE TABLE|PRAGMA)\b/ + +ActiveSupport::Notifications.subscribe(/^sql\./) do |*args| + data = args.last + unless data[:name] =~ /^Fixture/ or data[:sql] =~ IGNORE_SQL + if windows + puts data[:sql] + else + puts log_subscriber.send(:color, data[:sql], :cyan) + end + end +end + +# load all fixtures +ActiverecordTestConnector::Fixtures.create_fixtures \ + ActiverecordTestConnector::FIXTURES_PATH, ActiveRecord::Base.connection.tables diff --git a/vendor/plugins/will_paginate/spec/database.yml b/vendor/plugins/will_paginate/spec/database.yml new file mode 100644 index 0000000..87ca11b --- /dev/null +++ b/vendor/plugins/will_paginate/spec/database.yml @@ -0,0 +1,22 @@ +sqlite3: + database: ":memory:" + adapter: sqlite3 + timeout: 500 + +mysql: + adapter: mysql + database: will_paginate + username: + encoding: utf8 + +mysql2: + adapter: mysql2 + database: will_paginate + username: + encoding: utf8 + +postgres: + adapter: postgresql + database: will_paginate + username: postgres + min_messages: warning diff --git a/vendor/plugins/will_paginate/spec/fake_rubygems.rb b/vendor/plugins/will_paginate/spec/fake_rubygems.rb new file mode 100644 index 0000000..04df569 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/fake_rubygems.rb @@ -0,0 +1,18 @@ +# Makes the test suite compatible with Bundler standalone mode (used in CI) +# because Active Record uses `gem` for loading adapters. +Kernel.module_eval do + + remove_method :gem if 'method' == defined? gem + + def gem(*args) + return if $VERBOSE.nil? + $stderr << "warning: gem(#{args.map {|o| o.inspect }.join(', ')}) ignored" + $stderr << "; called from:\n " << caller[0,5].join("\n ") if $DEBUG + $stderr << "\n" + end + + private :gem + +end + +$" << "rubygems.rb" diff --git a/vendor/plugins/will_paginate/spec/finders/active_record_spec.rb b/vendor/plugins/will_paginate/spec/finders/active_record_spec.rb new file mode 100644 index 0000000..c3a6c11 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/finders/active_record_spec.rb @@ -0,0 +1,561 @@ +require 'spec_helper' +require 'will_paginate/active_record' +require File.expand_path('../activerecord_test_connector', __FILE__) + +ActiverecordTestConnector.setup +abort unless ActiverecordTestConnector.able_to_connect + +describe WillPaginate::ActiveRecord do + + extend ActiverecordTestConnector::FixtureSetup + + fixtures :topics, :replies, :users, :projects, :developers_projects + + it "should integrate with ActiveRecord::Base" do + ActiveRecord::Base.should respond_to(:paginate) + end + + it "should paginate" do + lambda { + users = User.paginate(:page => 1, :per_page => 5).to_a + users.length.should == 5 + }.should run_queries(2) + end + + it "should fail when encountering unknown params" do + lambda { + User.paginate :foo => 'bar', :page => 1, :per_page => 4 + }.should raise_error(ArgumentError) + end + + describe "relation" do + it "should return a relation" do + rel = nil + lambda { + rel = Developer.paginate(:page => 1) + rel.per_page.should == 10 + rel.current_page.should == 1 + }.should run_queries(0) + + lambda { + rel.total_pages.should == 2 + }.should run_queries(1) + end + + it "should keep per-class per_page number" do + rel = Developer.order('id').paginate(:page => 1) + rel.per_page.should == 10 + end + + it "should be able to change per_page number" do + rel = Developer.order('id').paginate(:page => 1).limit(5) + rel.per_page.should == 5 + end + + it "remembers pagination in sub-relations" do + rel = Topic.paginate(:page => 2, :per_page => 3) + lambda { + rel.total_entries.should == 4 + }.should run_queries(1) + rel = rel.mentions_activerecord + rel.current_page.should == 2 + rel.per_page.should == 3 + lambda { + rel.total_entries.should == 1 + }.should run_queries(1) + end + + it "supports the page() method" do + rel = Developer.page('1').order('id') + rel.current_page.should == 1 + rel.per_page.should == 10 + rel.offset.should == 0 + + rel = rel.limit(5).page(2) + rel.per_page.should == 5 + rel.offset.should == 5 + end + + it "raises on invalid page number" do + lambda { + Developer.page('foo') + }.should raise_error(ArgumentError) + end + + it "supports first limit() then page()" do + rel = Developer.limit(3).page(3) + rel.offset.should == 6 + end + + it "supports first page() then limit()" do + rel = Developer.page(3).limit(3) + rel.offset.should == 6 + end + + it "supports #first" do + rel = Developer.order('id').page(2).per_page(4) + rel.first.should == users(:dev_5) + rel.first(2).should == users(:dev_5, :dev_6) + end + + it "supports #last" do + rel = Developer.order('id').page(2).per_page(4) + rel.last.should == users(:dev_8) + rel.last(2).should == users(:dev_7, :dev_8) + rel.page(3).last.should == users(:poor_jamis) + end + + it "keeps pagination data after 'scoped'" do + rel = Developer.page(2).scoped + rel.per_page.should == 10 + rel.offset.should == 10 + rel.current_page.should == 2 + end + end + + describe "counting" do + it "should guess the total count" do + lambda { + topics = Topic.paginate :page => 2, :per_page => 3 + topics.total_entries.should == 4 + }.should run_queries(1) + end + + it "should guess that there are no records" do + lambda { + topics = Topic.where(:project_id => 999).paginate :page => 1, :per_page => 3 + topics.total_entries.should == 0 + }.should run_queries(1) + end + + it "forgets count in sub-relations" do + lambda { + topics = Topic.paginate :page => 1, :per_page => 3 + topics.total_entries.should == 4 + topics.where('1 = 1').total_entries.should == 4 + }.should run_queries(2) + end + + it "remembers custom count options in sub-relations" do + topics = Topic.paginate :page => 1, :per_page => 3, :count => {:conditions => "title LIKE '%futurama%'"} + topics.total_entries.should == 1 + topics.length.should == 3 + lambda { + topics.order('id').total_entries.should == 1 + }.should run_queries(1) + end + + it "supports empty? method" do + topics = Topic.paginate :page => 1, :per_page => 3 + lambda { + topics.should_not be_empty + }.should run_queries(1) + end + + it "support empty? for grouped queries" do + topics = Topic.group(:project_id).paginate :page => 1, :per_page => 3 + lambda { + topics.should_not be_empty + }.should run_queries(1) + end + + it "supports `size` for grouped queries" do + topics = Topic.group(:project_id).paginate :page => 1, :per_page => 3 + lambda { + topics.size.should == {nil=>2, 1=>2} + }.should run_queries(1) + end + + it "overrides total_entries count with a fixed value" do + lambda { + topics = Topic.paginate :page => 1, :per_page => 3, :total_entries => 999 + topics.total_entries.should == 999 + # value is kept even in sub-relations + topics.where('1 = 1').total_entries.should == 999 + }.should run_queries(0) + end + + it "supports a non-int for total_entries" do + topics = Topic.paginate :page => 1, :per_page => 3, :total_entries => "999" + topics.total_entries.should == 999 + end + + it "removes :include for count" do + lambda { + developers = Developer.paginate(:page => 1, :per_page => 1).includes(:projects) + developers.total_entries.should == 11 + $query_sql.last.should_not =~ /\bJOIN\b/ + }.should run_queries(1) + end + + it "keeps :include for count when they are referenced in :conditions" do + developers = Developer.paginate(:page => 1, :per_page => 1).includes(:projects) + with_condition = developers.where('projects.id > 1') + with_condition.total_entries.should == 1 + + $query_sql.last.should =~ /\bJOIN\b/ + end + + it "should count with group" do + Developer.group(:salary).page(1).total_entries.should == 4 + end + + it "removes :reorder for count with group" do + Project.group(:id).reorder(:id).page(1).total_entries + $query_sql.last.should_not =~ /\ORDER\b/ + end + + it "should not have zero total_pages when the result set is empty" do + Developer.where("1 = 2").page(1).total_pages.should == 1 + end + end + + it "should not ignore :select parameter when it says DISTINCT" do + users = User.select('DISTINCT salary').paginate :page => 2 + users.total_entries.should == 5 + end + + describe "paginate_by_sql" do + it "should respond" do + User.should respond_to(:paginate_by_sql) + end + + it "should paginate" do + lambda { + sql = "select content from topics where content like '%futurama%'" + topics = Topic.paginate_by_sql sql, :page => 1, :per_page => 1 + topics.total_entries.should == 1 + topics.first.attributes.has_key?('title').should be_false + }.should run_queries(2) + end + + it "should respect total_entries setting" do + lambda { + sql = "select content from topics" + topics = Topic.paginate_by_sql sql, :page => 1, :per_page => 1, :total_entries => 999 + topics.total_entries.should == 999 + }.should run_queries(1) + end + + it "defaults to page 1" do + sql = "select content from topics" + topics = Topic.paginate_by_sql sql, :page => nil, :per_page => 1 + topics.current_page.should == 1 + topics.size.should == 1 + end + + it "should strip the order when counting" do + lambda { + sql = "select id, title, content from topics order by topics.title" + topics = Topic.paginate_by_sql sql, :page => 1, :per_page => 2 + topics.first.should == topics(:ar) + }.should run_queries(2) + + $query_sql.last.should include('COUNT') + $query_sql.last.should_not include('order by topics.title') + end + + it "shouldn't change the original query string" do + query = 'select * from topics where 1 = 2' + original_query = query.dup + Topic.paginate_by_sql(query, :page => 1) + query.should == original_query + end + end + + it "doesn't mangle options" do + options = { :page => 1 } + options.expects(:delete).never + options_before = options.dup + + Topic.paginate(options) + options.should == options_before + end + + it "should get first page of Topics with a single query" do + lambda { + result = Topic.paginate :page => nil + result.to_a # trigger loading of records + result.current_page.should == 1 + result.total_pages.should == 1 + result.size.should == 4 + }.should run_queries(1) + end + + it "should get second (inexistent) page of Topics, requiring 2 queries" do + lambda { + result = Topic.paginate :page => 2 + result.total_pages.should == 1 + result.should be_empty + }.should run_queries(2) + end + + it "should paginate with :order" do + result = Topic.paginate :page => 1, :order => 'created_at DESC' + result.should == topics(:futurama, :harvey_birdman, :rails, :ar).reverse + result.total_pages.should == 1 + end + + it "should paginate with :conditions" do + result = Topic.paginate :page => 1, :order => 'id ASC', + :conditions => ["created_at > ?", 30.minutes.ago] + result.should == topics(:rails, :ar) + result.total_pages.should == 1 + end + + it "should paginate with :include and :conditions" do + result = Topic.paginate \ + :page => 1, + :include => :replies, + :conditions => "replies.content LIKE 'Bird%' ", + :per_page => 10 + + expected = Topic.find :all, + :include => 'replies', + :conditions => "replies.content LIKE 'Bird%' ", + :limit => 10 + + result.should == expected + result.total_entries.should == 1 + end + + it "should paginate with :include and :order" do + result = nil + lambda { + result = Topic.paginate(:page => 1, :include => :replies, :per_page => 10, + :order => 'replies.created_at asc, topics.created_at asc').to_a + }.should run_queries(2) + + expected = Topic.find :all, + :include => 'replies', + :order => 'replies.created_at asc, topics.created_at asc', + :limit => 10 + + result.should == expected + result.total_entries.should == 4 + end + + describe "associations" do + it "should paginate with include" do + project = projects(:active_record) + + result = project.topics.paginate \ + :page => 1, + :include => :replies, + :conditions => ["replies.content LIKE ?", 'Nice%'], + :per_page => 10 + + expected = Topic.find :all, + :include => 'replies', + :conditions => ["project_id = ? AND replies.content LIKE ?", project.id, 'Nice%'], + :limit => 10 + + result.should == expected + end + + it "should paginate" do + dhh = users(:david) + expected_name_ordered = projects(:action_controller, :active_record) + expected_id_ordered = projects(:active_record, :action_controller) + + lambda { + # with association-specified order + result = ignore_deprecation { dhh.projects.paginate(:page => 1) } + result.should == expected_name_ordered + result.total_entries.should == 2 + }.should run_queries(2) + + # with explicit order + result = dhh.projects.paginate(:page => 1).reorder('projects.id') + result.should == expected_id_ordered + result.total_entries.should == 2 + + lambda { + dhh.projects.find(:all, :order => 'projects.id', :limit => 4) + }.should_not raise_error + + result = dhh.projects.paginate(:page => 1, :per_page => 4).reorder('projects.id') + result.should == expected_id_ordered + + # has_many with implicit order + topic = Topic.find(1) + expected = replies(:spam, :witty_retort) + # FIXME: wow, this is ugly + topic.replies.paginate(:page => 1).map(&:id).sort.should == expected.map(&:id).sort + topic.replies.paginate(:page => 1).reorder('replies.id ASC').should == expected.reverse + end + + it "should paginate through association extension" do + project = Project.order('id').first + expected = [replies(:brave)] + + lambda { + result = project.replies.only_recent.paginate(:page => 1) + result.should == expected + }.should run_queries(1) + end + end + + it "should paginate with joins" do + result = nil + join_sql = 'LEFT JOIN developers_projects ON users.id = developers_projects.developer_id' + + lambda { + result = Developer.paginate(:page => 1, :joins => join_sql, :conditions => 'project_id = 1') + result.to_a # trigger loading of records + result.size.should == 2 + developer_names = result.map(&:name) + developer_names.should include('David') + developer_names.should include('Jamis') + }.should run_queries(1) + + lambda { + expected = result.to_a + result = Developer.paginate(:page => 1, :joins => join_sql, + :conditions => 'project_id = 1', :count => { :select => "users.id" }).to_a + result.should == expected + result.total_entries.should == 2 + }.should run_queries(1) + end + + it "should paginate with group" do + result = nil + lambda { + result = Developer.paginate(:page => 1, :per_page => 10, + :group => 'salary', :select => 'salary', :order => 'salary').to_a + }.should run_queries(1) + + expected = users(:david, :jamis, :dev_10, :poor_jamis).map(&:salary).sort + result.map(&:salary).should == expected + end + + it "should not paginate with dynamic finder" do + lambda { + Developer.paginate_by_salary(100000, :page => 1, :per_page => 5) + }.should raise_error(NoMethodError) + end + + it "should paginate with_scope" do + result = Developer.with_poor_ones { Developer.paginate :page => 1 } + result.size.should == 2 + result.total_entries.should == 2 + end + + describe "scopes" do + it "should paginate" do + result = Developer.poor.paginate :page => 1, :per_page => 1 + result.size.should == 1 + result.total_entries.should == 2 + end + + it "should paginate on habtm association" do + project = projects(:active_record) + lambda { + result = ignore_deprecation { project.developers.poor.paginate :page => 1, :per_page => 1 } + result.size.should == 1 + result.total_entries.should == 1 + }.should run_queries(2) + end + + it "should paginate on hmt association" do + project = projects(:active_record) + expected = [replies(:brave)] + + lambda { + result = project.replies.recent.paginate :page => 1, :per_page => 1 + result.should == expected + result.total_entries.should == 1 + }.should run_queries(2) + end + + it "should paginate on has_many association" do + project = projects(:active_record) + expected = [topics(:ar)] + + lambda { + result = project.topics.mentions_activerecord.paginate :page => 1, :per_page => 1 + result.should == expected + result.total_entries.should == 1 + }.should run_queries(2) + end + end + + it "should paginate with :readonly option" do + lambda { + Developer.paginate :readonly => true, :page => 1 + }.should_not raise_error + end + + it "should not paginate an array of IDs" do + lambda { + Developer.paginate((1..8).to_a, :per_page => 3, :page => 2, :order => 'id') + }.should raise_error(ArgumentError) + end + + it "errors out for invalid values" do |variable| + lambda { + # page that results in an offset larger than BIGINT + Project.page(307445734561825862) + }.should raise_error(WillPaginate::InvalidPage, "invalid offset: 9223372036854775830") + end + + protected + + def ignore_deprecation + ActiveSupport::Deprecation.silence { yield } + end + + def run_queries(num) + QueryCountMatcher.new(num) + end + + def show_queries(&block) + counter = QueryCountMatcher.new(nil) + counter.run block + ensure + queries = counter.performed_queries + if queries.any? + puts queries + else + puts "no queries" + end + end + +end + +class QueryCountMatcher + def initialize(num) + @expected_count = num + end + + def matches?(block) + run(block) + + if @expected_count.respond_to? :include? + @expected_count.include? @count + else + @count == @expected_count + end + end + + def run(block) + $query_count = 0 + $query_sql = [] + block.call + ensure + @queries = $query_sql.dup + @count = $query_count + end + + def performed_queries + @queries + end + + def failure_message + "expected #{@expected_count} queries, got #{@count}\n#{@queries.join("\n")}" + end + + def negative_failure_message + "expected query count not to be #{@expected_count}" + end +end diff --git a/vendor/plugins/will_paginate/spec/finders/activerecord_test_connector.rb b/vendor/plugins/will_paginate/spec/finders/activerecord_test_connector.rb new file mode 100644 index 0000000..5328acd --- /dev/null +++ b/vendor/plugins/will_paginate/spec/finders/activerecord_test_connector.rb @@ -0,0 +1,118 @@ +require 'active_record' +require 'active_record/fixtures' +require 'active_support/multibyte' # needed for Ruby 1.9.1 + +$query_count = 0 +$query_sql = [] + +ignore_sql = / + ^( + PRAGMA | SHOW\ max_identifier_length | + SELECT\ (currval|CAST|@@IDENTITY|@@ROWCOUNT) | + SHOW\ (FIELDS|TABLES) + )\b | + \bFROM\ (sqlite_master|pg_tables|pg_attribute)\b + /x + +ActiveSupport::Notifications.subscribe(/^sql\./) do |*args| + payload = args.last + unless payload[:name] =~ /^Fixture/ or payload[:sql] =~ ignore_sql + $query_count += 1 + $query_sql << payload[:sql] + end +end + +module ActiverecordTestConnector + extend self + + attr_accessor :able_to_connect + attr_accessor :connected + + FIXTURES_PATH = File.expand_path('../../fixtures', __FILE__) + + Fixtures = defined?(ActiveRecord::FixtureSet) ? ActiveRecord::FixtureSet : + defined?(ActiveRecord::Fixtures) ? ActiveRecord::Fixtures : + ::Fixtures + + # Set our defaults + self.connected = false + self.able_to_connect = true + + def setup + unless self.connected || !self.able_to_connect + setup_connection + load_schema + add_load_path FIXTURES_PATH + self.connected = true + end + rescue Exception => e # errors from ActiveRecord setup + $stderr.puts "\nSkipping ActiveRecord tests: #{e}\n\n" + self.able_to_connect = false + end + + private + + def add_load_path(path) + dep = defined?(ActiveSupport::Dependencies) ? ActiveSupport::Dependencies : ::Dependencies + dep.autoload_paths.unshift path + end + + def setup_connection + db = ENV['DB'].blank?? 'sqlite3' : ENV['DB'] + + configurations = YAML.load_file(File.expand_path('../../database.yml', __FILE__)) + raise "no configuration for '#{db}'" unless configurations.key? db + configuration = configurations[db] + + # ActiveRecord::Base.logger = Logger.new(STDOUT) if $0 == 'irb' + puts "using #{configuration['adapter']} adapter" + + ActiveRecord::Base.configurations = { db => configuration } + ActiveRecord::Base.establish_connection(db) + ActiveRecord::Base.default_timezone = :utc + end + + def load_schema + silencer = ActiveRecord::Base.method(:silence) + silence_args = [] + silence_args << :stdout if silencer.arity != 0 + silencer.call(*silence_args) do + ActiveRecord::Migration.verbose = false + load File.join(FIXTURES_PATH, 'schema.rb') + end + end + + module FixtureSetup + def fixtures(*tables) + table_names = tables.map { |t| t.to_s } + + fixtures = Fixtures.create_fixtures ActiverecordTestConnector::FIXTURES_PATH, table_names + @@loaded_fixtures = {} + @@fixture_cache = {} + + unless fixtures.nil? + if fixtures.instance_of?(Fixtures) + @@loaded_fixtures[fixtures.table_name] = fixtures + else + fixtures.each { |f| @@loaded_fixtures[f.table_name] = f } + end + end + + table_names.each do |table_name| + define_method(table_name) do |*fixtures| + @@fixture_cache[table_name] ||= {} + + instances = fixtures.map do |fixture| + if @@loaded_fixtures[table_name][fixture.to_s] + @@fixture_cache[table_name][fixture] ||= @@loaded_fixtures[table_name][fixture.to_s].find + else + raise StandardError, "No fixture with name '#{fixture}' found for table '#{table_name}'" + end + end + + instances.size == 1 ? instances.first : instances + end + end + end + end +end diff --git a/vendor/plugins/will_paginate/spec/finders/data_mapper_spec.rb b/vendor/plugins/will_paginate/spec/finders/data_mapper_spec.rb new file mode 100644 index 0000000..c04074f --- /dev/null +++ b/vendor/plugins/will_paginate/spec/finders/data_mapper_spec.rb @@ -0,0 +1,103 @@ +require 'spec_helper' + +begin + require 'will_paginate/data_mapper' + require File.expand_path('../data_mapper_test_connector', __FILE__) +rescue LoadError => error + warn "Error running DataMapper specs: #{error.message}" + datamapper_loaded = false +else + datamapper_loaded = true +end + +describe WillPaginate::DataMapper do + + it "has per_page" do + Animal.per_page.should == 30 + begin + Animal.per_page = 10 + Animal.per_page.should == 10 + + subclass = Class.new(Animal) + subclass.per_page.should == 10 + ensure + Animal.per_page = 30 + end + end + + it "doesn't make normal collections appear paginated" do + Animal.all.should_not be_paginated + end + + it "paginates to first page by default" do + animals = Animal.paginate(:page => nil) + + animals.should be_paginated + animals.current_page.should == 1 + animals.per_page.should == 30 + animals.offset.should == 0 + animals.total_entries.should == 3 + animals.total_pages.should == 1 + end + + it "paginates to first page, explicit limit" do + animals = Animal.paginate(:page => 1, :per_page => 2) + + animals.current_page.should == 1 + animals.per_page.should == 2 + animals.total_entries.should == 3 + animals.total_pages.should == 2 + animals.map {|a| a.name }.should == %w[ Dog Cat ] + end + + it "paginates to second page" do + animals = Animal.paginate(:page => 2, :per_page => 2) + + animals.current_page.should == 2 + animals.offset.should == 2 + animals.map {|a| a.name }.should == %w[ Lion ] + end + + it "paginates a collection" do + friends = Animal.all(:notes.like => '%friend%') + friends.paginate(:page => 1).per_page.should == 30 + friends.paginate(:page => 1, :per_page => 1).total_entries.should == 2 + end + + it "paginates a limited collection" do + animals = Animal.all(:limit => 2).paginate(:page => 1) + animals.per_page.should == 2 + end + + it "has page() method" do + Animal.page(2).per_page.should == 30 + Animal.page(2).offset.should == 30 + Animal.page(2).current_page.should == 2 + Animal.all(:limit => 2).page(2).per_page.should == 2 + end + + it "has total_pages at 1 for empty collections" do + Animal.all(:conditions => ['1=2']).page(1).total_pages.should == 1 + end + + it "can iterate and then call WP methods" do + animals = Animal.all(:limit => 2).page(1) + animals.each { |a| } + animals.total_entries.should == 3 + end + + it "augments to_a to return a WP::Collection" do + animals = Animal.all(:limit => 2).page(1) + array = animals.to_a + array.size.should == 2 + array.should be_kind_of(WillPaginate::Collection) + array.current_page.should == 1 + array.per_page.should == 2 + end + + it "doesn't have a problem assigning has-one-through relationship" do + human = Human.create :name => "Mislav" + human.pet = Animal.first + end + +end if datamapper_loaded diff --git a/vendor/plugins/will_paginate/spec/finders/data_mapper_test_connector.rb b/vendor/plugins/will_paginate/spec/finders/data_mapper_test_connector.rb new file mode 100644 index 0000000..9d7453f --- /dev/null +++ b/vendor/plugins/will_paginate/spec/finders/data_mapper_test_connector.rb @@ -0,0 +1,54 @@ +require 'sqlite3' +require 'dm-core' +require 'dm-core/support/logger' +require 'dm-migrations' + +DataMapper.setup :default, 'sqlite3::memory:' + +# Define models +class Animal + include DataMapper::Resource + property :id, Serial + property :name, String + property :notes, Text + + def self.setup + Animal.create(:name => 'Dog', :notes => "Man's best friend") + Animal.create(:name => 'Cat', :notes => "Woman's best friend") + Animal.create(:name => 'Lion', :notes => 'King of the Jungle') + end +end + +class Ownership + include DataMapper::Resource + + belongs_to :animal, :key => true + belongs_to :human, :key => true + + def self.setup + end +end + +class Human + include DataMapper::Resource + + property :id, Serial + property :name, String + + has n, :ownerships + has 1, :pet, :model => 'Animal', :through => :ownerships, :via => :animal + + def self.setup + end +end + +# Load fixtures +[Animal, Ownership, Human].each do |klass| + klass.auto_migrate! + klass.setup +end + +if 'irb' == $0 + DataMapper.logger.set_log($stdout, :debug) + DataMapper.logger.auto_flush = true +end diff --git a/vendor/plugins/will_paginate/spec/finders/mongoid_spec.rb b/vendor/plugins/will_paginate/spec/finders/mongoid_spec.rb new file mode 100644 index 0000000..88571f8 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/finders/mongoid_spec.rb @@ -0,0 +1,140 @@ +require 'spec_helper' + +begin + require 'will_paginate/mongoid' +rescue LoadError => error + warn "Error running Sequel specs: #{error.message}" + mongoid_loaded = false +else + Mongoid.database = Mongo::Connection.new.db('will_paginate_test') + + class MongoidModel + include Mongoid::Document + end + + mongoid_loaded = true +end + +describe WillPaginate::Mongoid do + before(:all) do + MongoidModel.delete_all + 4.times { MongoidModel.create! } + end + + let(:criteria) { MongoidModel.criteria } + + describe "#page" do + it "should forward to the paginate method" do + criteria.expects(:paginate).with(:page => 2).returns("itself") + criteria.page(2).should == "itself" + end + + it "should not override per_page if set earlier in the chain" do + criteria.paginate(:per_page => 10).page(1).per_page.should == 10 + criteria.paginate(:per_page => 20).page(1).per_page.should == 20 + end + end + + describe "#per_page" do + it "should set the limit if given an argument" do + criteria.per_page(10).options[:limit].should == 10 + end + + it "should return the current limit if no argument is given" do + criteria.per_page.should == nil + criteria.per_page(10).per_page.should == 10 + end + + it "should be interchangable with limit" do + criteria.limit(15).per_page.should == 15 + end + + it "should be nil'able" do + criteria.per_page(nil).per_page.should be_nil + end + end + + describe "#paginate" do + it "should use criteria" do + criteria.paginate.should be_instance_of(::Mongoid::Criteria) + end + + it "should not override page number if set earlier in the chain" do + criteria.page(3).paginate.current_page.should == 3 + end + + it "should limit according to per_page parameter" do + criteria.paginate(:per_page => 10).options.should include(:limit => 10) + end + + it "should skip according to page and per_page parameters" do + criteria.paginate(:page => 2, :per_page => 5).options.should include(:skip => 5) + end + + specify "first fallback value for per_page option is the current limit" do + criteria.limit(12).paginate.options.should include(:limit => 12) + end + + specify "second fallback value for per_page option is WillPaginate.per_page" do + criteria.paginate.options.should include(:limit => WillPaginate.per_page) + end + + specify "page should default to 1" do + criteria.paginate.options.should include(:skip => 0) + end + + it "should convert strings to integers" do + criteria.paginate(:page => "2", :per_page => "3").options.should include(:limit => 3, :limit => 3) + end + + describe "collection compatibility" do + describe "#total_count" do + it "should be calculated correctly" do + criteria.paginate(:per_page => 1).total_entries.should == 4 + criteria.paginate(:per_page => 3).total_entries.should == 4 + end + + it "should be cached" do + criteria.expects(:count).once.returns(123) + criteria.paginate + 2.times { criteria.total_entries.should == 123 } + end + end + + it "should calculate total_pages" do + criteria.paginate(:per_page => 1).total_pages.should == 4 + criteria.paginate(:per_page => 3).total_pages.should == 2 + criteria.paginate(:per_page => 10).total_pages.should == 1 + end + + it "should return per_page" do + criteria.paginate(:per_page => 1).per_page.should == 1 + criteria.paginate(:per_page => 5).per_page.should == 5 + end + + describe "#current_page" do + it "should return current_page" do + criteria.paginate(:page => 1).current_page.should == 1 + criteria.paginate(:page => 3).current_page.should == 3 + end + + it "should be casted to PageNumber" do + criteria.paginate(:page => 1).current_page.should be_instance_of(WillPaginate::PageNumber) + end + end + + it "should return offset" do + criteria.paginate(:page => 1).offset.should == 0 + criteria.paginate(:page => 2, :per_page => 5).offset.should == 5 + criteria.paginate(:page => 3, :per_page => 10).offset.should == 20 + end + + it "should not pollute plain mongoid criterias" do + %w(total_entries total_pages current_page).each do |method| + criteria.should_not respond_to(method) + end + criteria.offset.should be_nil # this is already a criteria method + end + end + end +end if mongoid_loaded diff --git a/vendor/plugins/will_paginate/spec/finders/sequel_spec.rb b/vendor/plugins/will_paginate/spec/finders/sequel_spec.rb new file mode 100644 index 0000000..720c06a --- /dev/null +++ b/vendor/plugins/will_paginate/spec/finders/sequel_spec.rb @@ -0,0 +1,67 @@ +require 'spec_helper' + +begin + require 'will_paginate/sequel' + require File.expand_path('../sequel_test_connector', __FILE__) +rescue LoadError, ArgumentError => error + warn "Error running Sequel specs: #{error.message}" + sequel_loaded = false +else + sequel_loaded = true +end + +describe Sequel::Dataset::Pagination, 'extension' do + + class Car < Sequel::Model + end + + it "should have the #paginate method" do + Car.should respond_to(:paginate) + end + + it "should NOT have the #paginate_by_sql method" do + Car.should_not respond_to(:paginate_by_sql) + end + + describe 'pagination' do + before(:all) do + Car.create(:name => 'Shelby', :notes => "Man's best friend") + Car.create(:name => 'Aston Martin', :notes => "Woman's best friend") + Car.create(:name => 'Corvette', :notes => 'King of the Jungle') + end + + it "should imitate WillPaginate::Collection" do + result = Car.paginate(1, 2) + + result.should_not be_empty + result.size.should == 2 + result.length.should == 2 + result.total_entries.should == 3 + result.total_pages.should == 2 + result.per_page.should == 2 + result.current_page.should == 1 + end + + it "should perform" do + Car.paginate(1, 2).all.should == [Car[1], Car[2]] + end + + it "should be empty" do + result = Car.paginate(3, 2) + result.should be_empty + end + + it "should perform with #select and #order" do + result = Car.select("name as foo".lit).order(:name).paginate(1, 2).all + result.size.should == 2 + result.first.values[:foo].should == "Aston Martin" + end + + it "should perform with #filter" do + results = Car.filter(:name => 'Shelby').paginate(1, 2).all + results.size.should == 1 + results.first.should == Car.find(:name => 'Shelby') + end + end + +end if sequel_loaded diff --git a/vendor/plugins/will_paginate/spec/finders/sequel_test_connector.rb b/vendor/plugins/will_paginate/spec/finders/sequel_test_connector.rb new file mode 100644 index 0000000..d7c69b6 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/finders/sequel_test_connector.rb @@ -0,0 +1,15 @@ +require 'sequel' + +Symbol.class_eval do + # Active Record calculations tries `as` on some objects but chokes when that + # object was a Symbol and it gets a Sequel::SQL::AliasedExpression. + undef as if method_defined? :as +end + +db = Sequel.sqlite + +db.create_table :cars do + primary_key :id, :integer, :auto_increment => true + column :name, :text + column :notes, :text +end diff --git a/vendor/plugins/will_paginate/spec/fixtures/admin.rb b/vendor/plugins/will_paginate/spec/fixtures/admin.rb new file mode 100644 index 0000000..1d5e7f3 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/fixtures/admin.rb @@ -0,0 +1,3 @@ +class Admin < User + has_many :companies, :finder_sql => 'SELECT * FROM companies' +end diff --git a/vendor/plugins/will_paginate/spec/fixtures/developer.rb b/vendor/plugins/will_paginate/spec/fixtures/developer.rb new file mode 100644 index 0000000..4c55bc9 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/fixtures/developer.rb @@ -0,0 +1,15 @@ +class Developer < User + has_and_belongs_to_many :projects, :include => :topics, :order => 'projects.name', :join_table => 'developers_projects' + + def self.with_poor_ones(&block) + with_scope :find => { :conditions => ['salary <= ?', 80000], :order => 'salary' } do + yield + end + end + + scope :poor, lambda { + where(['salary <= ?', 80000]).order('salary') + } + + def self.per_page() 10 end +end diff --git a/vendor/plugins/will_paginate/spec/fixtures/developers_projects.yml b/vendor/plugins/will_paginate/spec/fixtures/developers_projects.yml new file mode 100644 index 0000000..cee359c --- /dev/null +++ b/vendor/plugins/will_paginate/spec/fixtures/developers_projects.yml @@ -0,0 +1,13 @@ +david_action_controller: + developer_id: 1 + project_id: 2 + joined_on: 2004-10-10 + +david_active_record: + developer_id: 1 + project_id: 1 + joined_on: 2004-10-10 + +jamis_active_record: + developer_id: 2 + project_id: 1 \ No newline at end of file diff --git a/vendor/plugins/will_paginate/spec/fixtures/project.rb b/vendor/plugins/will_paginate/spec/fixtures/project.rb new file mode 100644 index 0000000..d421981 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/fixtures/project.rb @@ -0,0 +1,15 @@ +class Project < ActiveRecord::Base + has_and_belongs_to_many :developers, :uniq => true, :join_table => 'developers_projects' + + has_many :topics + # :finder_sql => 'SELECT * FROM topics WHERE (topics.project_id = #{id})', + # :counter_sql => 'SELECT COUNT(*) FROM topics WHERE (topics.project_id = #{id})' + + has_many :replies, :through => :topics do + def only_recent(params = {}) + scoped.where(['replies.created_at > ?', 15.minutes.ago]) + end + end + + has_many :unique_replies, :through => :topics, :source => :replies, :uniq => true +end diff --git a/vendor/plugins/will_paginate/spec/fixtures/projects.yml b/vendor/plugins/will_paginate/spec/fixtures/projects.yml new file mode 100644 index 0000000..4104a3d --- /dev/null +++ b/vendor/plugins/will_paginate/spec/fixtures/projects.yml @@ -0,0 +1,6 @@ +active_record: + id: 1 + name: Active Record +action_controller: + id: 2 + name: Action Controller diff --git a/vendor/plugins/will_paginate/spec/fixtures/replies.yml b/vendor/plugins/will_paginate/spec/fixtures/replies.yml new file mode 100644 index 0000000..25fff58 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/fixtures/replies.yml @@ -0,0 +1,29 @@ +witty_retort: + id: 1 + topic_id: 1 + content: Birdman is better! + created_at: <%= 6.hours.ago.utc.to_s(:db) %> + +another: + id: 2 + topic_id: 2 + content: Nuh uh! + created_at: <%= 1.hour.ago.utc.to_s(:db) %> + +spam: + id: 3 + topic_id: 1 + content: Nice site! + created_at: <%= 1.hour.ago.utc.to_s(:db) %> + +decisive: + id: 4 + topic_id: 4 + content: "I'm getting to the bottom of this" + created_at: <%= 30.minutes.ago.utc.to_s(:db) %> + +brave: + id: 5 + topic_id: 4 + content: "AR doesn't scare me a bit" + created_at: <%= 10.minutes.ago.utc.to_s(:db) %> diff --git a/vendor/plugins/will_paginate/spec/fixtures/reply.rb b/vendor/plugins/will_paginate/spec/fixtures/reply.rb new file mode 100644 index 0000000..5f09fba --- /dev/null +++ b/vendor/plugins/will_paginate/spec/fixtures/reply.rb @@ -0,0 +1,10 @@ +class Reply < ActiveRecord::Base + belongs_to :topic, :include => [:replies] + + scope :recent, lambda { + where(['replies.created_at > ?', 15.minutes.ago]). + order('replies.created_at DESC') + } + + validates_presence_of :content +end diff --git a/vendor/plugins/will_paginate/spec/fixtures/schema.rb b/vendor/plugins/will_paginate/spec/fixtures/schema.rb new file mode 100644 index 0000000..8831aad --- /dev/null +++ b/vendor/plugins/will_paginate/spec/fixtures/schema.rb @@ -0,0 +1,38 @@ +ActiveRecord::Schema.define do + + create_table "users", :force => true do |t| + t.column "name", :text + t.column "salary", :integer, :default => 70000 + t.column "created_at", :datetime + t.column "updated_at", :datetime + t.column "type", :text + end + + create_table "projects", :force => true do |t| + t.column "name", :text + end + + create_table "developers_projects", :id => false, :force => true do |t| + t.column "developer_id", :integer, :null => false + t.column "project_id", :integer, :null => false + t.column "joined_on", :date + t.column "access_level", :integer, :default => 1 + end + + create_table "topics", :force => true do |t| + t.column "project_id", :integer + t.column "title", :string + t.column "subtitle", :string + t.column "content", :text + t.column "created_at", :datetime + t.column "updated_at", :datetime + end + + create_table "replies", :force => true do |t| + t.column "content", :text + t.column "created_at", :datetime + t.column "updated_at", :datetime + t.column "topic_id", :integer + end + +end diff --git a/vendor/plugins/will_paginate/spec/fixtures/topic.rb b/vendor/plugins/will_paginate/spec/fixtures/topic.rb new file mode 100644 index 0000000..ea5a39b --- /dev/null +++ b/vendor/plugins/will_paginate/spec/fixtures/topic.rb @@ -0,0 +1,11 @@ +class Topic < ActiveRecord::Base + has_many :replies, :dependent => :destroy, :order => 'replies.created_at DESC' + belongs_to :project + + scope :mentions_activerecord, lambda { + where(['topics.title LIKE ?', '%ActiveRecord%']) + } + scope :distinct, lambda { + select("DISTINCT #{table_name}.*") + } +end diff --git a/vendor/plugins/will_paginate/spec/fixtures/topics.yml b/vendor/plugins/will_paginate/spec/fixtures/topics.yml new file mode 100644 index 0000000..f93cf48 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/fixtures/topics.yml @@ -0,0 +1,30 @@ +futurama: + id: 1 + title: Isnt futurama awesome? + subtitle: It really is, isnt it. + content: I like futurama + created_at: <%= 1.day.ago.utc.to_s(:db) %> + updated_at: + +harvey_birdman: + id: 2 + title: Harvey Birdman is the king of all men + subtitle: yup + content: He really is + created_at: <%= 2.hours.ago.utc.to_s(:db) %> + updated_at: + +rails: + id: 3 + project_id: 1 + title: Rails is nice + subtitle: It makes me happy + content: except when I have to hack internals to fix pagination. even then really. + created_at: <%= 20.minutes.ago.utc.to_s(:db) %> + +ar: + id: 4 + project_id: 1 + title: ActiveRecord sometimes freaks me out + content: "I mean, what's the deal with eager loading?" + created_at: <%= 15.minutes.ago.utc.to_s(:db) %> diff --git a/vendor/plugins/will_paginate/spec/fixtures/user.rb b/vendor/plugins/will_paginate/spec/fixtures/user.rb new file mode 100644 index 0000000..4a57cf0 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/fixtures/user.rb @@ -0,0 +1,2 @@ +class User < ActiveRecord::Base +end diff --git a/vendor/plugins/will_paginate/spec/fixtures/users.yml b/vendor/plugins/will_paginate/spec/fixtures/users.yml new file mode 100644 index 0000000..ed2c03a --- /dev/null +++ b/vendor/plugins/will_paginate/spec/fixtures/users.yml @@ -0,0 +1,35 @@ +david: + id: 1 + name: David + salary: 80000 + type: Developer + +jamis: + id: 2 + name: Jamis + salary: 150000 + type: Developer + +<% for digit in 3..10 %> +dev_<%= digit %>: + id: <%= digit %> + name: fixture_<%= digit %> + salary: 100000 + type: Developer +<% end %> + +poor_jamis: + id: 11 + name: Jamis + salary: 9000 + type: Developer + +admin: + id: 12 + name: admin + type: Admin + +goofy: + id: 13 + name: Goofy + type: Admin diff --git a/vendor/plugins/will_paginate/spec/page_number_spec.rb b/vendor/plugins/will_paginate/spec/page_number_spec.rb new file mode 100644 index 0000000..1287116 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/page_number_spec.rb @@ -0,0 +1,65 @@ +require 'spec_helper' +require 'will_paginate/page_number' + +describe WillPaginate::PageNumber do + describe "valid" do + subject { described_class.new('12', 'page') } + + it { should eq(12) } + its(:inspect) { should eq('page 12') } + it { should be_a(WillPaginate::PageNumber) } + it { should be_instance_of(WillPaginate::PageNumber) } + it { should be_a(Numeric) } + it { should be_a(Fixnum) } + it { should_not be_instance_of(Fixnum) } + + it "passes the PageNumber=== type check" do |variable| + (WillPaginate::PageNumber === subject).should be + end + + it "passes the Numeric=== type check" do |variable| + (Numeric === subject).should be + (Fixnum === subject).should be + end + end + + describe "invalid" do + def create(value, name = 'page') + described_class.new(value, name) + end + + it "errors out on non-int values" do + lambda { create(nil) }.should raise_error(WillPaginate::InvalidPage) + lambda { create('') }.should raise_error(WillPaginate::InvalidPage) + lambda { create('Schnitzel') }.should raise_error(WillPaginate::InvalidPage) + end + + it "errors out on zero or less" do + lambda { create(0) }.should raise_error(WillPaginate::InvalidPage) + lambda { create(-1) }.should raise_error(WillPaginate::InvalidPage) + end + + it "doesn't error out on zero for 'offset'" do + lambda { create(0, 'offset') }.should_not raise_error + lambda { create(-1, 'offset') }.should raise_error(WillPaginate::InvalidPage) + end + end + + describe "coercion method" do + it "defaults to 'page' name" do + num = WillPaginate::PageNumber(12) + num.inspect.should eq('page 12') + end + + it "accepts a custom name" do + num = WillPaginate::PageNumber(12, 'monkeys') + num.inspect.should eq('monkeys 12') + end + + it "doesn't affect PageNumber instances" do + num = WillPaginate::PageNumber(12) + num2 = WillPaginate::PageNumber(num) + num2.object_id.should eq(num.object_id) + end + end +end diff --git a/vendor/plugins/will_paginate/spec/per_page_spec.rb b/vendor/plugins/will_paginate/spec/per_page_spec.rb new file mode 100644 index 0000000..ece303f --- /dev/null +++ b/vendor/plugins/will_paginate/spec/per_page_spec.rb @@ -0,0 +1,41 @@ +require 'spec_helper' +require 'will_paginate/per_page' + +describe WillPaginate::PerPage do + + class MyModel + extend WillPaginate::PerPage + end + + it "has the default value" do + MyModel.per_page.should == 30 + + WillPaginate.per_page = 10 + begin + MyModel.per_page.should == 10 + ensure + WillPaginate.per_page = 30 + end + end + + it "casts values to int" do + WillPaginate.per_page = '10' + begin + MyModel.per_page.should == 10 + ensure + WillPaginate.per_page = 30 + end + end + + it "has an explicit value" do + MyModel.per_page = 12 + begin + MyModel.per_page.should == 12 + subclass = Class.new(MyModel) + subclass.per_page.should == 12 + ensure + MyModel.send(:remove_instance_variable, '@per_page') + end + end + +end diff --git a/vendor/plugins/will_paginate/spec/spec_helper.rb b/vendor/plugins/will_paginate/spec/spec_helper.rb new file mode 100644 index 0000000..ca5853a --- /dev/null +++ b/vendor/plugins/will_paginate/spec/spec_helper.rb @@ -0,0 +1,71 @@ +require 'rspec' +require 'view_helpers/view_example_group' +begin + require 'ruby-debug' +rescue LoadError + # no debugger available +end + +RSpec.configure do |config| + config.include Module.new { + protected + + def include_phrase(string) + PhraseMatcher.new(string) + end + + def have_deprecation(msg) + DeprecationMatcher.new(msg) + end + } + + config.mock_with :mocha +end + +class PhraseMatcher + def initialize(string) + @string = string + @pattern = /\b#{Regexp.escape string}\b/ + end + + def matches?(actual) + @actual = actual.to_s + @actual =~ @pattern + end + + def failure_message + "expected #{@actual.inspect} to contain phrase #{@string.inspect}" + end + + def negative_failure_message + "expected #{@actual.inspect} not to contain phrase #{@string.inspect}" + end +end + +require 'stringio' + +class DeprecationMatcher + def initialize(message) + @message = message + end + + def matches?(block) + @actual = hijack_stderr(&block) + PhraseMatcher.new("DEPRECATION WARNING: #{@message}").matches?(@actual) + end + + def failure_message + "expected deprecation warning #{@message.inspect}, got #{@actual.inspect}" + end + + private + + def hijack_stderr + err = $stderr + $stderr = StringIO.new + yield + $stderr.string.rstrip + ensure + $stderr = err + end +end diff --git a/vendor/plugins/will_paginate/spec/view_helpers/action_view_spec.rb b/vendor/plugins/will_paginate/spec/view_helpers/action_view_spec.rb new file mode 100644 index 0000000..1cda184 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/view_helpers/action_view_spec.rb @@ -0,0 +1,423 @@ +require 'spec_helper' +require 'active_support/rescuable' # needed for Ruby 1.9.1 +require 'action_controller' +require 'will_paginate/view_helpers/action_view' +require 'will_paginate/collection' + +Routes = ActionDispatch::Routing::RouteSet.new + +Routes.draw do + get 'dummy/page/:page' => 'dummy#index' + get 'dummy/dots/page.:page' => 'dummy#dots' + get 'ibocorp(/:page)' => 'ibocorp#index', + :constraints => { :page => /\d+/ }, :defaults => { :page => 1 } + + get ':controller(/:action(/:id(.:format)))' +end + +describe WillPaginate::ActionView do + + before(:all) do + I18n.load_path.concat WillPaginate::I18n.load_path + end + + before(:each) do + I18n.reload! + end + + before(:each) do + @assigns = {} + @controller = DummyController.new + @request = @controller.request + @template = '<%= will_paginate collection, options %>' + end + + attr_reader :assigns, :controller, :request + + def render(locals) + @view = ActionView::Base.new([], @assigns, @controller) + @view.request = @request + @view.singleton_class.send(:include, @controller._routes.url_helpers) + @view.render(:inline => @template, :locals => locals) + end + + ## basic pagination ## + + it "should render" do + paginate do |pagination| + assert_select 'a[href]', 3 do |elements| + validate_page_numbers [2,3,2], elements + assert_select elements.last, ':last-child', "Next →" + end + assert_select 'span', 1 + assert_select 'span.disabled:first-child', '← Previous' + assert_select 'em.current', '1' + pagination.first.inner_text.should == '← Previous 1 2 3 Next →' + end + end + + it "should render nothing when there is only 1 page" do + paginate(:per_page => 30).should be_empty + end + + it "should paginate with options" do + paginate({ :page => 2 }, :class => 'will_paginate', :previous_label => 'Prev', :next_label => 'Next') do + assert_select 'a[href]', 4 do |elements| + validate_page_numbers [1,1,3,3], elements + # test rel attribute values: + assert_select elements[1], 'a', '1' do |link| + link.first['rel'].should == 'prev start' + end + assert_select elements.first, 'a', "Prev" do |link| + link.first['rel'].should == 'prev start' + end + assert_select elements.last, 'a', "Next" do |link| + link.first['rel'].should == 'next' + end + end + assert_select '.current', '2' + end + end + + it "should paginate using a custom renderer class" do + paginate({}, :renderer => AdditionalLinkAttributesRenderer) do + assert_select 'a[default=true]', 3 + end + end + + it "should paginate using a custom renderer instance" do + renderer = WillPaginate::ActionView::LinkRenderer.new + def renderer.gap() '~~' end + + paginate({ :per_page => 2 }, :inner_window => 0, :outer_window => 0, :renderer => renderer) do + assert_select 'span.my-gap', '~~' + end + + renderer = AdditionalLinkAttributesRenderer.new(:title => 'rendered') + paginate({}, :renderer => renderer) do + assert_select 'a[title=rendered]', 3 + end + end + + it "should have classnames on previous/next links" do + paginate do |pagination| + assert_select 'span.disabled.previous_page:first-child' + assert_select 'a.next_page[href]:last-child' + end + end + + it "should match expected markup" do + paginate + expected = <<-HTML + + HTML + expected.strip!.gsub!(/\s{2,}/, ' ') + expected_dom = HTML::Document.new(expected).root + + html_document.root.should == expected_dom + end + + it "should output escaped URLs" do + paginate({:page => 1, :per_page => 1, :total_entries => 2}, + :page_links => false, :params => { :tag => '
' }) + + assert_select 'a[href]', 1 do |links| + query = links.first['href'].split('?', 2)[1] + query.split('&').sort.should == %w(page=2 tag=%3Cbr%3E) + end + end + + ## advanced options for pagination ## + + it "should be able to render without container" do + paginate({}, :container => false) + assert_select 'div.pagination', 0, 'main DIV present when it shouldn\'t' + assert_select 'a[href]', 3 + end + + it "should be able to render without page links" do + paginate({ :page => 2 }, :page_links => false) do + assert_select 'a[href]', 2 do |elements| + validate_page_numbers [1,3], elements + end + end + end + + ## other helpers ## + + it "should render a paginated section" do + @template = <<-ERB + <%= paginated_section collection, options do %> + <%= content_tag :div, '', :id => "developers" %> + <% end %> + ERB + + paginate + assert_select 'div.pagination', 2 + assert_select 'div.pagination + div#developers', 1 + end + + it "should not render a paginated section with a single page" do + @template = <<-ERB + <%= paginated_section collection, options do %> + <%= content_tag :div, '', :id => "developers" %> + <% end %> + ERB + + paginate(:total_entries => 1) + assert_select 'div.pagination', 0 + assert_select 'div#developers', 1 + end + + ## parameter handling in page links ## + + it "should preserve parameters on GET" do + request.params :foo => { :bar => 'baz' } + paginate + assert_links_match /foo\[bar\]=baz/ + end + + it "should not preserve parameters on POST" do + request.post + request.params :foo => 'bar' + paginate + assert_no_links_match /foo=bar/ + end + + it "should add additional parameters to links" do + paginate({}, :params => { :foo => 'bar' }) + assert_links_match /foo=bar/ + end + + it "should add anchor parameter" do + paginate({}, :params => { :anchor => 'anchor' }) + assert_links_match /#anchor$/ + end + + it "should remove arbitrary parameters" do + request.params :foo => 'bar' + paginate({}, :params => { :foo => nil }) + assert_no_links_match /foo=bar/ + end + + it "should override default route parameters" do + paginate({}, :params => { :controller => 'baz', :action => 'list' }) + assert_links_match %r{\Wbaz/list\W} + end + + it "should paginate with custom page parameter" do + paginate({ :page => 2 }, :param_name => :developers_page) do + assert_select 'a[href]', 4 do |elements| + validate_page_numbers [1,1,3,3], elements, :developers_page + end + end + end + + it "should paginate with complex custom page parameter" do + request.params :developers => { :page => 2 } + + paginate({ :page => 2 }, :param_name => 'developers[page]') do + assert_select 'a[href]', 4 do |links| + assert_links_match /\?developers\[page\]=\d+$/, links + validate_page_numbers [1,1,3,3], links, 'developers[page]' + end + end + end + + it "should paginate with custom route page parameter" do + request.symbolized_path_parameters.update :controller => 'dummy', :action => nil + paginate :per_page => 2 do + assert_select 'a[href]', 6 do |links| + assert_links_match %r{/page/(\d+)$}, links, [2, 3, 4, 5, 6, 2] + end + end + end + + it "should paginate with custom route with dot separator page parameter" do + request.symbolized_path_parameters.update :controller => 'dummy', :action => 'dots' + paginate :per_page => 2 do + assert_select 'a[href]', 6 do |links| + assert_links_match %r{/page\.(\d+)$}, links, [2, 3, 4, 5, 6, 2] + end + end + end + + it "should paginate with custom route and first page number implicit" do + request.symbolized_path_parameters.update :controller => 'ibocorp', :action => nil + paginate :page => 2, :per_page => 2 do + assert_select 'a[href]', 7 do |links| + assert_links_match %r{/ibocorp(?:/(\d+))?$}, links, [nil, nil, 3, 4, 5, 6, 3] + end + end + # Routes.recognize_path('/ibocorp/2').should == {:page=>'2', :action=>'index', :controller=>'ibocorp'} + # Routes.recognize_path('/ibocorp/foo').should == {:action=>'foo', :controller=>'ibocorp'} + end + + ## internal hardcore stuff ## + + it "should be able to guess the collection name" do + collection = mock + collection.expects(:total_pages).returns(1) + + @template = '<%= will_paginate options %>' + controller.controller_name = 'developers' + assigns['developers'] = collection + + paginate(nil) + end + + it "should fail if the inferred collection is nil" do + @template = '<%= will_paginate options %>' + controller.controller_name = 'developers' + + lambda { + paginate(nil) + }.should raise_error(ActionView::TemplateError, /@developers/) + end + + ## i18n + + it "is able to translate previous/next labels" do + translation :will_paginate => { + :previous_label => 'Go back', + :next_label => 'Load more' + } + + paginate do |pagination| + assert_select 'span.disabled:first-child', 'Go back' + assert_select 'a[rel=next]', 'Load more' + end + end + + it "renders using ActionView helpers on a custom object" do + helper = Object.new + class << helper + attr_reader :controller + include ActionView::Helpers::UrlHelper + include Routes.url_helpers + include WillPaginate::ActionView + end + helper.default_url_options[:controller] = 'dummy' + + collection = WillPaginate::Collection.new(2, 1, 3) + @render_output = helper.will_paginate(collection) + + assert_select 'a[href]', 4 do |links| + urls = links.map {|l| l['href'] }.uniq + urls.should == ['/dummy/page/1', '/dummy/page/3'] + end + end + + it "renders using ActionDispatch helper on a custom object" do + helper = Object.new + class << helper + include ActionDispatch::Routing::UrlFor + include Routes.url_helpers + include WillPaginate::ActionView + end + helper.default_url_options[:host] = 'example.com' + helper.default_url_options[:controller] = 'dummy' + # helper.default_url_options[:only_path] = true + + collection = WillPaginate::Collection.new(2, 1, 3) + @render_output = helper.will_paginate(collection) + + assert_select 'a[href]', 4 do |links| + urls = links.map {|l| l['href'] }.uniq + urls.should == ['http://example.com/dummy/page/1', 'http://example.com/dummy/page/3'] + end + end + + private + + def translation(data) + I18n.available_locales # triggers loading existing translations + I18n.backend.store_translations(:en, data) + end +end + +class AdditionalLinkAttributesRenderer < WillPaginate::ActionView::LinkRenderer + def initialize(link_attributes = nil) + super() + @additional_link_attributes = link_attributes || { :default => 'true' } + end + + def link(text, target, attributes = {}) + super(text, target, attributes.merge(@additional_link_attributes)) + end +end + +class DummyController + attr_reader :request + attr_accessor :controller_name + + include ActionController::UrlFor + include Routes.url_helpers + + def initialize + @request = DummyRequest.new + end + + def params + @request.params + end + + def env + {} + end + + def _prefixes + [] + end +end + +class IbocorpController < DummyController +end + +class DummyRequest + attr_accessor :symbolized_path_parameters + + def initialize + @get = true + @params = {} + @symbolized_path_parameters = { :controller => 'foo', :action => 'bar' } + end + + def get? + @get + end + + def post + @get = false + end + + def relative_url_root + '' + end + + def script_name + '' + end + + def params(more = nil) + @params.update(more) if more + @params + end + + def host_with_port + 'example.com' + end + alias host host_with_port + + def optional_port + '' + end + + def protocol + 'http:' + end +end diff --git a/vendor/plugins/will_paginate/spec/view_helpers/base_spec.rb b/vendor/plugins/will_paginate/spec/view_helpers/base_spec.rb new file mode 100644 index 0000000..5fd97f1 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/view_helpers/base_spec.rb @@ -0,0 +1,142 @@ +require 'spec_helper' +require 'will_paginate/view_helpers' +require 'will_paginate/array' +require 'active_support' +require 'active_support/core_ext/string/inflections' +require 'active_support/inflections' + +describe WillPaginate::ViewHelpers do + + before(:all) do + # make sure default translations aren't loaded + I18n.load_path.clear + end + + before(:each) do + I18n.reload! + end + + include WillPaginate::ViewHelpers + + describe "will_paginate" do + it "should render" do + collection = WillPaginate::Collection.new(1, 2, 4) + renderer = mock 'Renderer' + renderer.expects(:prepare).with(collection, instance_of(Hash), self) + renderer.expects(:to_html).returns('') + + will_paginate(collection, :renderer => renderer).should == '' + end + + it "should return nil for single-page collections" do + collection = mock 'Collection', :total_pages => 1 + will_paginate(collection).should be_nil + end + + it "should call html_safe on result" do + collection = WillPaginate::Collection.new(1, 2, 4) + + html = mock 'HTML' + html.expects(:html_safe).returns(html) + renderer = mock 'Renderer' + renderer.stubs(:prepare) + renderer.expects(:to_html).returns(html) + + will_paginate(collection, :renderer => renderer).should eql(html) + end + end + + describe "pagination_options" do + let(:pagination_options) { WillPaginate::ViewHelpers.pagination_options } + + it "deprecates setting :renderer" do + begin + lambda { + pagination_options[:renderer] = 'test' + }.should have_deprecation("pagination_options[:renderer] shouldn't be set") + ensure + pagination_options.delete :renderer + end + end + end + + describe "page_entries_info" do + before :all do + @array = ('a'..'z').to_a + end + + def info(params, options = {}) + collection = Hash === params ? @array.paginate(params) : params + page_entries_info collection, {:html => false}.merge(options) + end + + it "should display middle results and total count" do + info(:page => 2, :per_page => 5).should == "Displaying strings 6 - 10 of 26 in total" + end + + it "uses translation if available" do + translation :will_paginate => { + :page_entries_info => {:multi_page => 'Showing %{from} - %{to}'} + } + info(:page => 2, :per_page => 5).should == "Showing 6 - 10" + end + + it "uses specific translation if available" do + translation :will_paginate => { + :page_entries_info => {:multi_page => 'Showing %{from} - %{to}'}, + :string => { :page_entries_info => {:multi_page => 'Strings %{from} to %{to}'} } + } + info(:page => 2, :per_page => 5).should == "Strings 6 to 10" + end + + it "should output HTML by default" do + info({ :page => 2, :per_page => 5 }, :html => true).should == + "Displaying strings 6 - 10 of 26 in total" + end + + it "should display shortened end results" do + info(:page => 7, :per_page => 4).should include_phrase('strings 25 - 26') + end + + it "should handle longer class names" do + collection = @array.paginate(:page => 2, :per_page => 5) + model = stub('Class', :name => 'ProjectType', :to_s => 'ProjectType') + collection.first.stubs(:class).returns(model) + info(collection).should include_phrase('project types') + end + + it "should adjust output for single-page collections" do + info(('a'..'d').to_a.paginate(:page => 1, :per_page => 5)).should == "Displaying all 4 strings" + info(['a'].paginate(:page => 1, :per_page => 5)).should == "Displaying 1 string" + end + + it "should display 'no entries found' for empty collections" do + info([].paginate(:page => 1, :per_page => 5)).should == "No entries found" + end + + it "uses model_name.human when available" do + name = stub('model name', :i18n_key => :flower_key) + name.expects(:human).with(:count => 1).returns('flower') + model = stub('Class', :model_name => name) + collection = [1].paginate(:page => 1) + + info(collection, :model => model).should == "Displaying 1 flower" + end + + it "uses custom translation instead of model_name.human" do + name = stub('model name', :i18n_key => :flower_key) + name.expects(:human).never + model = stub('Class', :model_name => name) + translation :will_paginate => {:models => {:flower_key => 'tulip'}} + collection = [1].paginate(:page => 1) + + info(collection, :model => model).should == "Displaying 1 tulip" + end + + private + + def translation(data) + I18n.backend.store_translations(:en, data) + end + end +end diff --git a/vendor/plugins/will_paginate/spec/view_helpers/link_renderer_base_spec.rb b/vendor/plugins/will_paginate/spec/view_helpers/link_renderer_base_spec.rb new file mode 100644 index 0000000..cdf5f9b --- /dev/null +++ b/vendor/plugins/will_paginate/spec/view_helpers/link_renderer_base_spec.rb @@ -0,0 +1,87 @@ +require 'spec_helper' +require 'will_paginate/view_helpers/link_renderer_base' +require 'will_paginate/collection' + +describe WillPaginate::ViewHelpers::LinkRendererBase do + + before do + @renderer = described_class.new + end + + it "should raise error when unprepared" do + lambda { + @renderer.pagination + }.should raise_error + end + + it "should prepare with collection and options" do + prepare({}) + @renderer.send(:current_page).should == 1 + end + + it "should have total_pages accessor" do + prepare :total_pages => 42 + @renderer.send(:total_pages).should == 42 + end + + it "should clear old cached values when prepared" do + prepare(:total_pages => 1) + @renderer.send(:total_pages).should == 1 + # prepare with different object: + prepare(:total_pages => 2) + @renderer.send(:total_pages).should == 2 + end + + it "should have pagination definition" do + prepare({ :total_pages => 1 }, :page_links => true) + @renderer.pagination.should == [:previous_page, 1, :next_page] + end + + describe "visible page numbers" do + it "should calculate windowed visible links" do + prepare({ :page => 6, :total_pages => 11 }, :inner_window => 1, :outer_window => 1) + showing_pages 1, 2, :gap, 5, 6, 7, :gap, 10, 11 + end + + it "should eliminate small gaps" do + prepare({ :page => 6, :total_pages => 11 }, :inner_window => 2, :outer_window => 1) + # pages 4 and 8 appear instead of the gap + showing_pages 1..11 + end + + it "should support having no windows at all" do + prepare({ :page => 4, :total_pages => 7 }, :inner_window => 0, :outer_window => 0) + showing_pages 1, :gap, 4, :gap, 7 + end + + it "should adjust upper limit if lower is out of bounds" do + prepare({ :page => 1, :total_pages => 10 }, :inner_window => 2, :outer_window => 1) + showing_pages 1, 2, 3, 4, 5, :gap, 9, 10 + end + + it "should adjust lower limit if upper is out of bounds" do + prepare({ :page => 10, :total_pages => 10 }, :inner_window => 2, :outer_window => 1) + showing_pages 1, 2, :gap, 6, 7, 8, 9, 10 + end + + def showing_pages(*pages) + pages = pages.first.to_a if Array === pages.first or Range === pages.first + @renderer.send(:windowed_page_numbers).should == pages + end + end + + protected + + def collection(params = {}) + if params[:total_pages] + params[:per_page] = 1 + params[:total_entries] = params[:total_pages] + end + WillPaginate::Collection.new(params[:page] || 1, params[:per_page] || 30, params[:total_entries]) + end + + def prepare(collection_options, options = {}) + @renderer.prepare(collection(collection_options), options) + end + +end diff --git a/vendor/plugins/will_paginate/spec/view_helpers/view_example_group.rb b/vendor/plugins/will_paginate/spec/view_helpers/view_example_group.rb new file mode 100644 index 0000000..b9c3509 --- /dev/null +++ b/vendor/plugins/will_paginate/spec/view_helpers/view_example_group.rb @@ -0,0 +1,121 @@ +require 'active_support' +begin + require 'minitest/unit' +rescue LoadError + # Fails on Ruby 1.8, but it's OK since we only need MiniTest::Assertions + # on Rails 4 which doesn't support 1.8 anyway. +end +require 'action_dispatch/testing/assertions' +require 'will_paginate/array' + +module ViewExampleGroup + + include ActionDispatch::Assertions::SelectorAssertions + include MiniTest::Assertions if defined? MiniTest + + def assert(value, message) + raise message unless value + end + + def paginate(collection = {}, options = {}, &block) + if collection.instance_of? Hash + page_options = { :page => 1, :total_entries => 11, :per_page => 4 }.merge(collection) + collection = [1].paginate(page_options) + end + + locals = { :collection => collection, :options => options } + + @render_output = render(locals) + @html_document = nil + + if block_given? + classname = options[:class] || WillPaginate::ViewHelpers.pagination_options[:class] + assert_select("div.#{classname}", 1, 'no main DIV', &block) + end + + @render_output + end + + def html_document + @html_document ||= HTML::Document.new(@render_output, true, false) + end + + def response_from_page_or_rjs + html_document.root + end + + def validate_page_numbers(expected, links, param_name = :page) + param_pattern = /\W#{Regexp.escape(param_name.to_s)}=([^&]*)/ + + links.map { |el| + unescape_href(el) =~ param_pattern + $1 ? $1.to_i : $1 + }.should == expected + end + + def assert_links_match(pattern, links = nil, numbers = nil) + links ||= assert_select 'div.pagination a[href]' do |elements| + elements + end + + pages = [] if numbers + + links.each do |el| + href = unescape_href(el) + href.should =~ pattern + if numbers + href =~ pattern + pages << ($1.nil?? nil : $1.to_i) + end + end + + pages.should == numbers if numbers + end + + def assert_no_links_match(pattern) + assert_select 'div.pagination a[href]' do |elements| + elements.each do |el| + unescape_href(el).should_not =~ pattern + end + end + end + + def unescape_href(el) + CGI.unescape CGI.unescapeHTML(el['href']) + end + + def build_message(message, pattern, *args) + built_message = pattern.dup + for value in args + built_message.sub! '?', value.inspect + end + built_message + end + +end + +RSpec.configure do |config| + config.include ViewExampleGroup, :type => :view, :example_group => { + :file_path => %r{spec/view_helpers/} + } +end + +module HTML + Node.class_eval do + def inner_text + children.map(&:inner_text).join('') + end + end + + Text.class_eval do + def inner_text + self.to_s + end + end + + Tag.class_eval do + def inner_text + childless?? '' : super + end + end +end diff --git a/vendor/plugins/will_paginate/will_paginate.gemspec b/vendor/plugins/will_paginate/will_paginate.gemspec new file mode 100644 index 0000000..cac7b6c --- /dev/null +++ b/vendor/plugins/will_paginate/will_paginate.gemspec @@ -0,0 +1,30 @@ +# encoding: utf-8 +require 'rbconfig' +require File.expand_path('../lib/will_paginate/version', __FILE__) + +Gem::Specification.new do |s| + s.name = 'will_paginate' + s.version = WillPaginate::VERSION::STRING + + s.summary = "Pagination plugin for web frameworks and other apps" + s.description = "will_paginate provides a simple API for performing paginated queries with Active Record, DataMapper and Sequel, and includes helpers for rendering pagination links in Rails, Sinatra and Merb web apps." + + s.authors = ['Mislav Marohnić'] + s.email = 'mislav.marohnic@gmail.com' + s.homepage = 'https://github.com/mislav/will_paginate/wiki' + s.license = 'MIT' + + s.rdoc_options = ['--main', 'README.md', '--charset=UTF-8'] + s.extra_rdoc_files = ['README.md', 'LICENSE'] + + s.files = Dir['Rakefile', '{bin,lib,test,spec}/**/*', 'README*', 'LICENSE*'] + + # include only files in version control + git_dir = File.expand_path('../.git', __FILE__) + void = defined?(File::NULL) ? File::NULL : + RbConfig::CONFIG['host_os'] =~ /msdos|mswin|djgpp|mingw/ ? 'NUL' : '/dev/null' + + if File.directory?(git_dir) and system "git --version >>#{void} 2>&1" + s.files &= `git --git-dir='#{git_dir}' ls-files -z`.split("\0") + end +end -- libgit2 0.21.2