acts_as_ferret 0.5.2 → 0.5.3

data/doc/demo/vendor/plugins/will_paginate/Rakefile

@@ -1,23 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'Test the will_paginate plugin.'
-Rake::TestTask.new(:test) do |t|
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
-
-desc 'Generate RDoc documentation for the will_paginate plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  files = ['README', 'LICENSE', 'lib/**/*.rb']
-  rdoc.rdoc_files.add(files)
-  rdoc.main = "README" # page to start on
-  rdoc.title = "will_paginate"
-  rdoc.template = File.exists?(t="/Users/chris/ruby/projects/err/rock/template.rb") ? t : "/var/www/rock/template.rb"
-  rdoc.rdoc_dir = 'doc' # rdoc output folder
-  rdoc.options << '--inline-source'
-end

data/doc/demo/vendor/plugins/will_paginate/init.rb

@@ -1,21 +0,0 @@
-require 'will_paginate/core_ext'
-require 'will_paginate/collection'
-require 'will_paginate/finder'
-require 'will_paginate/view_helpers'
-
-ActionView::Base.send   :include, WillPaginate::ViewHelpers
-ActiveRecord::Base.send :include, WillPaginate::Finder
-
-module ActiveRecord::Associations
-  # to support paginating finders on associations, we have to mix in the
-  # method_missing magic from WillPaginate::Finder::ClassMethods to AssociationProxy
-  # subclasses, but in a different way for Rails 1.2.x and 2.0
-  (AssociationCollection.instance_methods.include?(:create!) ?
-    AssociationCollection : AssociationCollection.subclasses.map(&:constantize)
-  ).push(HasManyThroughAssociation).each do |klass|
-    klass.class_eval do
-      include WillPaginate::Finder::ClassMethods
-      alias_method_chain :method_missing, :paginate
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-module WillPaginate
-  # Arrays returned from paginating finds are, in fact, instances of this.
-  # You may think of WillPaginate::Collection as an ordinary array with some
-  # extra properties. Those properites are used by view helpers to generate
-  # correct page links.
-  #
-  class Collection < Array
-    attr_reader :current_page, :per_page
-    attr_accessor :total_entries
-
-    # These collection objects are instantiated by ActiveRecord paginating
-    # finders; there is no need to do it manually.
-    #
-    def initialize(page, per_page, total)
-      @current_page  = page.to_i
-      @per_page      = per_page.to_i
-      @total_entries = total.to_i
-      @total_pages   = (@total_entries / @per_page.to_f).ceil
-    end
-
-    # The total number of pages.
-    def page_count
-      @total_pages
-    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
-    # besides your records: simply start with offset + 1.
-    #
-    def offset
-      (current_page - 1) * per_page
-    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 < page_count ? (current_page + 1) : nil
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-require 'set'
-
-unless Hash.instance_methods.include? '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 Hash.instance_methods.include? 'slice'
-  Hash.class_eval do
-    # Returns a new hash with only the given keys.
-    def slice(*keys)
-      allowed = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
-      reject { |key,| !allowed.include?(key) }
-    end
-
-    # Replaces the hash with only the given keys.
-    def slice!(*keys)
-      replace(slice(*keys))
-    end
-  end
-end
-
-unless Array.instance_methods.include? 'paginate'
-  # http://www.desimcadam.com/archives/8
-  Array.class_eval do
-    def paginate(page = 1, per_page = 15)
-      pagination_array = WillPaginate::Collection.new(page, per_page, size)
-      start_index = pagination_array.offset
-      end_index = start_index + (per_page - 1)
-      array_to_concat = self[start_index..end_index]
-      array_to_concat.nil? ? [] : pagination_array.concat(array_to_concat)
-    end
-  end
-end

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

@@ -1,159 +0,0 @@
-module WillPaginate
-  # A mixin for ActiveRecord::Base. Provides `per_page` class method
-  # and makes `paginate` finders possible with some method_missing magic.
-  #
-  # Find out more in WillPaginate::Finder::ClassMethods
-  #
-  module Finder
-    def self.included(base)
-      base.extend ClassMethods
-      class << base
-        alias_method_chain :method_missing, :paginate
-        define_method(:per_page) { 30 } unless respond_to?(:per_page)
-      end
-    end
-
-    # = Paginating finders for ActiveRecord models
-    # 
-    # WillPaginate doesn't really add extra methods to your ActiveRecord models (except +per_page+
-    # unless it's already available). It simply intercepts
-    # the calls to paginating finders such as +paginate+, +paginate_by_user_id+ (and so on) and
-    # translates them to ordinary finders: +find+, +find_by_user_id+, etc. It does so with some
-    # method_missing magic, but you don't need to care for that. You simply use paginating finders
-    # same way you used ordinary ones. You only need to tell them what page you want in options.
-    #
-    #   @topics = Topic.paginate :all, :page => params[:page]
-    # 
-    # In paginating finders, "all" is implicit. No sense in paginating a single record, right? So:
-    # 
-    #   Post.paginate                  => Post.find :all
-    #   Post.paginate_all_by_something => Post.find_all_by_something
-    #   Post.paginate_by_something     => Post.find_all_by_something
-    #
-    # Knowing that, the above example can be written simply as:
-    #
-    #   @topics = Topic.paginate :page => params[:page]
-    #
-    # Don't forget to pass the +page+ parameter! Without it, paginating finders will raise an error.
-    #
-    # == Options
-    # Options for paginating finders are:
-    # 
-    #   page           REQUIRED, but defaults to 1 if false or nil
-    #   per_page       (default is read from the model, which is 30 if not overriden)
-    #   total entries  not needed unless you want to count the records yourself somehow
-    #   count          hash of options that are used only for the call to count
-    # 
-    module ClassMethods
-      # This methods 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
-      # 
-      def paginate_by_sql(sql, options)
-        options, page, per_page = wp_parse_options!(options)
-        sanitized_query = sanitize_sql(sql)
-        total_entries = options[:total_entries] || count_by_sql("SELECT COUNT(*) FROM (#{sanitized_query}) AS count_table")
-
-        returning WillPaginate::Collection.new(page, per_page, total_entries) do |pager|
-          options.update :offset => pager.offset, :limit => pager.per_page
-          add_limit! sanitized_query, options
-          pager.replace find_by_sql(sanitized_query)
-        end
-      end
-
-      def respond_to?(method, include_priv = false)
-        case method.to_sym
-        when :paginate, :paginate_by_sql
-          true
-        else
-          super(method.to_s.sub(/^paginate/, 'find'), include_priv)
-        end
-      end
-
-    protected
-      
-      def method_missing_with_paginate(method, *args, &block)
-        # did somebody tried to paginate? if not, let them be
-        unless method.to_s.index('paginate') == 0
-          return method_missing_without_paginate(method, *args, &block) 
-        end
-
-        options, page, per_page = wp_parse_options!(args.pop)
-        # paginate finders are really just find_* with limit and offset
-        finder = method.to_s.sub /^paginate/, 'find'
-        # magic counting for user convenience
-        total_entries = wp_count!(options, args, finder)
-
-        # :all is implicit
-        if finder == 'find'
-          args.unshift(:all) if args.empty?
-        elsif finder.index('find_by_') == 0
-          finder.sub! /^find/, 'find_all'
-        end
-
-        ::Object.returning WillPaginate::Collection.new(page, per_page, total_entries) do |pager|
-          args << options.update(:offset => pager.offset, :limit => pager.per_page)
-          pager.replace send(finder, *args)
-        end
-      end
-
-      def wp_count!(options, args, finder)
-        # :total_entries and :count are mutually exclusive!
-        unless options[:total_entries]
-          unless args.first.is_a? Array
-            # count expects (almost) the same options as find
-            count_options = options.except :count, :order, :select
-            
-            # merge the hash found in :count
-            # this allows you to specify :select, :order, or anything else just for the count query
-            count_options.update(options.delete(:count)) if options.key? :count
-            # extract the conditions from calls like "paginate_by_foo_and_bar"
-            conditions = wp_extract_finder_conditions(finder, args, count_options)
-
-            # scope_out adds a 'with_finder' method which acts like with_scope, if it's present
-            # then execute the count with the scoping provided by the with_finder  
-            count = nil
-            counter = Proc.new { count = count(count_options) }
-            
-            if respond_to?(scoper = finder.sub(/^find/, 'with'))
-              send(scoper, &counter)
-            else
-              with_scope(:find => { :conditions => conditions }, &counter)
-            end
-
-            count.respond_to?(:length) ? count.length : count
-          else
-            # array of IDs was passed, so its size is the total number
-            args.first.size
-          end
-        else
-          options.delete(:total_entries)
-        end
-      end
-
-      def wp_parse_options!(options)
-        raise ArgumentError, 'hash parameters expected' unless options.respond_to? :symbolize_keys!
-        options.symbolize_keys!
-        raise ArgumentError, ':page parameter required' unless options.key? :page
-        page = options.delete(:page) || 1
-        per_page = options.delete(:per_page) || self.per_page
-        [options, page, per_page]
-      end
-
-    private
-
-      # thanks to active record for making us duplicate this code
-      def wp_extract_finder_conditions(finder, arguments, count_options)
-        return unless match = /^find_(all_by|by)_([_a-zA-Z]\w*)$/.match(finder.to_s)
-
-        attribute_names = extract_attribute_names_from_match(match)
-        raise "I can't make sense of #{finder}" unless all_attributes_exists?(attribute_names)
-        construct_attributes_from_arguments(attribute_names, arguments)
-      end
-    end
-  end
-end

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

@@ -1,95 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,10 +0,0 @@
-#!/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"