cehoffman-acts_as_ferret 0.4.4

data/doc/demo/vendor/plugins/will_paginate/lib/will_paginate/view_helpers.rb

@@ -0,0 +1,95 @@
+module WillPaginate
+  # = Global options for pagination helpers
+  #
+  # Options for pagination helpers are optional and get their default values from the
+  # WillPaginate::ViewHelpers.pagination_options hash. You can write to this hash to
+  # override default options on the global level:
+  #
+  #   WillPaginate::ViewHelpers.pagination_options[:prev_label] = 'Previous page'
+  #
+  # By putting this into your environment.rb you can easily localize link texts to previous
+  # and next pages, as well as override some other defaults to your liking.
+  module ViewHelpers
+    # default options that can be overriden on the global level
+    @@pagination_options = { :class => 'pagination',
+          :prev_label   => '« Previous',
+          :next_label   => 'Next »',
+          :inner_window => 4, # links around the current page
+          :outer_window => 1, # links around beginning and end
+          :separator    => ' ', # single space is friendly to spiders and non-graphic browsers
+          :param_name   => :page
+          }
+    mattr_reader :pagination_options
+
+    # Renders Digg-style pagination. (We know you wanna!)
+    # Returns nil if there is only one page in total (can't paginate that).
+    # 
+    # Options for will_paginate view helper:
+    # 
+    #   class:        CSS class name for the generated DIV (default "pagination")
+    #   prev_label:   default '« Previous',
+    #   next_label:   default 'Next »',
+    #   inner_window: how many links are shown around the current page, defaults to 4
+    #   outer_window: how many links are around the first and the last page, defaults to 1
+    #   separator:    string separator for page HTML elements, default " " (single space)
+    #   param_name:   parameter name for page number in URLs, defaults to "page"
+    #
+    # All extra options are passed to the generated container DIV, so eventually
+    # they become its HTML attributes.
+    #
+    def will_paginate(entries = @entries, options = {})
+      total_pages = entries.page_count
+
+      if total_pages > 1
+        options = options.symbolize_keys.reverse_merge(pagination_options)
+        page, param = entries.current_page, options.delete(:param_name)
+        
+        inner_window, outer_window = options.delete(:inner_window).to_i, options.delete(:outer_window).to_i
+        min = page - inner_window
+        max = page + inner_window
+        # adjust lower or upper limit if other is out of bounds
+        if max > total_pages then min -= max - total_pages
+        elsif min < 1  then max += 1 - min
+        end
+        
+        current   = min..max
+        beginning = 1..(1 + outer_window)
+        tail      = (total_pages - outer_window)..total_pages
+        visible   = [beginning, current, tail].map(&:to_a).flatten.sort.uniq
+        links, prev = [], 0
+
+        visible.each do |n|
+          next if n < 1
+          break if n > total_pages
+
+          unless n - prev > 1
+            prev = n
+            links << page_link_or_span((n != page ? n : nil), 'current', n, param)
+          else
+            # ellipsis represents the gap between windows
+            prev = n - 1
+            links << '...'
+            redo
+          end
+        end
+        
+        # next and previous buttons
+        links.unshift page_link_or_span(entries.previous_page, 'disabled', options.delete(:prev_label), param)
+        links.push    page_link_or_span(entries.next_page,     'disabled', options.delete(:next_label), param)
+        
+        content_tag :div, links.join(options.delete(:separator)), options
+      end
+    end
+    
+  protected
+
+    def page_link_or_span(page, span_class, text, param)
+      unless page
+        content_tag :span, text, :class => span_class
+      else
+        # page links should preserve GET parameters, so we merge params
+        link_to text, params.merge(param.to_sym => (page !=1 ? page : nil))
+      end
+    end
+  end
+end

data/doc/demo/vendor/plugins/will_paginate/test/array_pagination_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/helper'
+require File.dirname(__FILE__) + '/../init'
+
+class ArrayPaginationTest < ActiveRecordTestCase
+  def setup
+    @array = ('a'..'e').to_a
+  end
+  
+  cases = [
+    { :current => 1,  :per_page => 3,  :expected => %w( a b c ) },
+    { :current => 2,  :per_page => 3,  :expected => %w( d e ) },
+    { :current => 1,  :per_page => 5,  :expected => %w( a b c d e ) },
+    { :current => 3,  :per_page => 5,  :expected => [] },
+    { :current => -1, :per_page => 5,  :expected => [] },
+    { :current => 1,  :per_page => -5, :expected => [] }
+  ]
+  
+  cases.each_with_index do |conditions, index|
+    define_method("test_case_#{index}") do
+      assert_equal conditions[:expected], @array.paginate(conditions[:current], conditions[:per_page])
+    end
+  end
+end

data/doc/demo/vendor/plugins/will_paginate/test/boot.rb

@@ -0,0 +1,27 @@
+plugin_root = File.join(File.dirname(__FILE__), '..')
+
+# first look for a symlink to a copy of the framework
+if framework_root = ["#{plugin_root}/rails", "#{plugin_root}/../../rails"].find { |p| File.directory? p }
+  print "found framework root: #{framework_root}"
+  # this allows for a plugin to be tested outside an app
+  $:.unshift "#{framework_root}/activesupport/lib", "#{framework_root}/activerecord/lib", "#{framework_root}/actionpack/lib"
+else
+  # is the plugin installed in an application?
+  app_root = plugin_root + '/../../..'
+
+  if File.directory? app_root + '/config'
+    print 'using config/boot.rb'
+    ENV['RAILS_ENV'] = 'test'
+    require File.expand_path(app_root + '/config/boot')
+  else
+    # simply use installed gems if available
+    print 'using rubygems'
+    require 'rubygems'
+    gem 'actionpack'; gem 'activerecord'
+  end
+end
+
+%w(action_pack active_record active_record/version action_controller active_record/fixtures).each {|f| require f}
+puts "  (ActiveRecord v#{ActiveRecord::VERSION::STRING})"
+
+$:.unshift "#{plugin_root}/lib"

data/doc/demo/vendor/plugins/will_paginate/test/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+libs = []
+dirname = File.dirname(__FILE__)
+
+libs << 'irb/completion'
+libs << File.join(dirname, 'lib', 'load_fixtures')
+libs << File.join(dirname, '..', 'init')
+
+exec "#{irb} #{libs.map{|l| " -r #{l}" }.join} --simple-prompt"

data/doc/demo/vendor/plugins/will_paginate/test/finder_test.rb

@@ -0,0 +1,219 @@
+require File.dirname(__FILE__) + '/helper'
+require File.dirname(__FILE__) + '/../init'
+
+class FinderTest < ActiveRecordTestCase
+  fixtures :topics, :replies, :users, :projects, :developers_projects, :companies
+
+  def test_new_methods_presence
+    assert_respond_to_all Topic, %w(per_page paginate paginate_by_sql)
+  end
+
+  def test_paginated_collection
+    entries = %w(a b c)
+    collection = WillPaginate::Collection.new 2, 3, 10
+    collection.replace entries
+
+    assert_equal entries, collection
+    assert_respond_to_all collection, %w(page_count each offset size current_page per_page total_entries)
+    assert_equal Array, collection.entries.class
+    assert_equal 3, collection.offset
+  end
+  
+  def test_simple_paginate
+    entries = Topic.paginate :page => nil
+    assert_equal 1, entries.current_page
+    assert_nil entries.previous_page
+    assert_nil entries.next_page
+    assert_equal 1, entries.page_count
+    assert_equal 4, entries.size
+    
+    entries = Topic.paginate :page => 2
+    assert_equal 2, entries.current_page
+    assert_equal 1, entries.previous_page
+    assert_equal 1, entries.page_count
+    assert entries.empty?
+
+    # :page parameter in options is required!
+    assert_raise(ArgumentError){ Topic.paginate }
+    assert_raise(ArgumentError){ Topic.paginate({}) }
+  end
+  
+  def test_paginate_with_per_page
+    entries = Topic.paginate :page => 1, :per_page => 1
+    assert_equal 1, entries.size
+    assert_equal 4, entries.page_count
+
+    # Developer class has explicit per_page at 10
+    entries = Developer.paginate :page => 1
+    assert_equal 10, entries.size
+    assert_equal 2, entries.page_count
+
+    entries = Developer.paginate :page => 1, :per_page => 5
+    assert_equal 11, entries.total_entries
+    assert_equal 5, entries.size
+    assert_equal 3, entries.page_count
+  end
+  
+  def test_paginate_with_order
+    entries = Topic.paginate :page => 1, :order => 'created_at desc'
+    expected = [topics(:futurama), topics(:harvey_birdman), topics(:rails), topics(:ar)].reverse
+    assert_equal expected, entries.to_a
+    assert_equal 1, entries.page_count
+  end
+  
+  def test_paginate_with_conditions
+    entries = Topic.paginate :page => 1, :conditions => ["created_at > ?", 30.minutes.ago]
+    expected = [topics(:rails), topics(:ar)]
+    assert_equal expected, entries.to_a
+    assert_equal 1, entries.page_count
+  end
+
+  def test_paginate_associations
+    dhh = users :david
+    expected_name_ordered = [projects(:action_controller), projects(:active_record)]
+    expected_id_ordered   = [projects(:active_record), projects(:action_controller)]
+
+    # with association-specified order
+    entries = dhh.projects.paginate(:page => 1)
+    assert_equal expected_name_ordered, entries
+    assert_equal 2, entries.total_entries
+
+    # with explicit order
+    entries = dhh.projects.paginate(:page => 1, :order => 'projects.id')
+    assert_equal expected_id_ordered, entries
+    assert_equal 2, entries.total_entries
+
+    assert_nothing_raised { dhh.projects.find(:all, :order => 'projects.id', :limit => 4) }
+    entries = dhh.projects.paginate(:page => 1, :order => 'projects.id', :per_page => 4)
+    assert_equal expected_id_ordered, entries
+
+    # has_many with implicit order
+    topic = Topic.find(1)
+    expected = [replies(:spam), replies(:witty_retort)]
+    assert_equal expected.map(&:id).sort, topic.replies.paginate(:page => 1).map(&:id).sort
+    assert_equal expected.reverse, topic.replies.paginate(:page => 1, :order => 'replies.id ASC')
+  end
+  
+  def test_paginate_with_joins
+    entries = Developer.paginate :page => 1,
+                        :joins => 'LEFT JOIN developers_projects ON users.id = developers_projects.developer_id',
+                        :conditions => 'project_id = 1'        
+    assert_equal 2, entries.size
+    developer_names = entries.map { |d| d.name }
+    assert developer_names.include?('David')
+    assert developer_names.include?('Jamis')
+
+    expected = entries.to_a
+    entries = Developer.paginate :page => 1,
+                        :joins => 'LEFT JOIN developers_projects ON users.id = developers_projects.developer_id',
+                        :conditions => 'project_id = 1', :count => { :select => "users.id" }
+    assert_equal expected, entries.to_a
+  end
+  
+  def test_paginate_with_include_and_order
+    entries = Topic.paginate \
+      :page     => 1, 
+      :include  => :replies,  
+      :order    => 'replies.created_at asc, topics.created_at asc', 
+      :per_page => 10
+
+    expected = Topic.find :all, 
+      :include => 'replies', 
+      :order   => 'replies.created_at asc, topics.created_at asc', 
+      :limit   => 10
+
+    assert_equal expected, entries.to_a
+  end
+
+  def test_paginate_with_group
+    entries = Developer.paginate :page => 1, :per_page => 10, :group => 'salary'
+    expected = [ users(:david), users(:jamis), users(:dev_10), users(:poor_jamis) ].map(&:salary).sort
+    assert_equal expected, entries.map(&:salary).sort
+  end
+
+  def test_paginate_with_dynamic_finder
+    expected = [replies(:witty_retort), replies(:spam)]
+    assert_equal expected, Reply.paginate_all_by_topic_id(1, :page => 1)
+    assert_equal expected, Reply.paginate_by_topic_id(1, :page => 1)
+
+    entries = Developer.paginate :conditions => { :salary => 100000 }, :page => 1, :per_page => 5
+    assert_equal 8, entries.total_entries
+    assert_equal entries, Developer.paginate_by_salary(100000, :page => 1, :per_page => 5)
+
+    # dynamic finder + conditions
+    entries = Developer.paginate_by_salary(100000, :page => 1,
+                                           :conditions => ['id > ?', 6])
+    assert_equal 4, entries.total_entries
+    assert_equal (7..10).to_a, entries.map(&:id)
+
+    assert_raises RuntimeError do
+      Developer.paginate_by_inexistent_attribute 100000, :page => 1
+    end
+  end
+
+  def test_paginate_by_sql
+    assert_respond_to Developer, :paginate_by_sql
+    entries = Developer.paginate_by_sql ['select * from users where salary > ?', 80000],
+      :page => 2, :per_page => 3, :total_entries => 9
+
+    assert_equal (5..7).to_a, entries.map(&:id)
+    assert_equal 9, entries.total_entries
+  end
+
+  def test_count_by_sql
+    entries = Developer.paginate_by_sql ['select * from users where salary > ?', 60000],
+      :page => 2, :per_page => 3
+
+    assert_equal 12, entries.total_entries
+  end
+
+  def test_scoped_paginate
+    entries =
+      Developer.with_poor_ones do
+        Developer.paginate :page => 1
+      end
+
+    assert_equal 2, entries.size
+    assert_equal 2, entries.total_entries
+  end
+
+  def test_edge_case_api_madness
+    # explicit :all should not break anything
+    assert_equal Topic.paginate(:page => nil), Topic.paginate(:all, :page => 1)
+
+    # this is a little weird test for issue #37
+    # the Topic model find and count methods accept an extra option, :foo
+    # this checks if that extra option was intact by our paginating finder
+    entries = Topic.paginate(:foo => 'bar', :page => 1)
+    assert_equal 'bar', entries.first
+    assert_equal 100, entries.total_entries
+
+    # Are we on edge? Find out by testing find_all which was removed in [6998]
+    unless Developer.respond_to? :find_all
+      # AR finders also accept arrays of IDs
+      # (this was broken in Rails before [6912])
+      entries = Developer.paginate((1..8).to_a, :per_page => 3, :page => 2)
+      assert_equal (4..6).to_a, entries.map(&:id)
+      assert_equal 8, entries.total_entries
+    end
+  end
+
+  def test_count_doesnt_use_select_options
+    assert_nothing_raised do
+      Developer.paginate :select => 'users.*', :page => 1
+    end
+  end
+
+  def test_should_use_scoped_finders_if_present
+    companies = Company.paginate_best :all, :page => 1
+    assert_equal 3, companies.total_entries
+  end
+
+protected
+
+  def assert_respond_to_all object, methods
+    methods.each do |method|
+      [method.to_s, method.to_sym].each {|m| assert_respond_to object, m }
+    end
+  end
+end

data/doc/demo/vendor/plugins/will_paginate/test/fixtures/admin.rb

@@ -0,0 +1,3 @@
+class Admin < User
+  has_many :companies, :finder_sql => 'SELECT * FROM companies'
+end

data/doc/demo/vendor/plugins/will_paginate/test/fixtures/companies.yml

@@ -0,0 +1,24 @@
+thirty_seven_signals:
+  id: 1
+  name: 37Signals
+  rating: 4
+
+TextDrive:
+  id: 2
+  name: TextDrive
+  rating: 3
+
+PlanetArgon:
+  id: 3
+  name: Planet Argon
+  rating: 3
+
+Google:
+  id: 4
+  name: Google
+  rating: 5
+  
+Ionist:
+  id: 5
+  name: Ioni.st
+  rating: 4

data/doc/demo/vendor/plugins/will_paginate/test/fixtures/company.rb

@@ -0,0 +1,23 @@
+class Company < ActiveRecord::Base
+  attr_protected :rating
+  set_sequence_name :companies_nonstd_seq
+
+  validates_presence_of :name
+  def validate
+    errors.add('rating', 'rating should not be 2') if rating == 2
+  end  
+
+  def self.with_best
+    with_scope :find => { :conditions => ['companies.rating > ?', 3] } do
+      yield
+    end
+  end
+
+  def self.find_best(*args)
+    with_best { find(*args) }
+  end
+
+  def self.calculate_best(*args)
+    with_best { calculate(*args) }
+  end
+end

data/doc/demo/vendor/plugins/will_paginate/test/fixtures/developer.rb

@@ -0,0 +1,11 @@
+class Developer < User
+  has_and_belongs_to_many :projects, :include => :topics, :order => 'projects.name'
+
+  def self.with_poor_ones(&block)
+    with_scope :find => { :conditions => ['salary <= ?', 80000], :order => 'salary' } do
+      yield
+    end
+  end
+
+  def self.per_page() 10 end
+end