cehoffman-acts_as_ferret 0.4.4

data/doc/demo/test/unit/shared_index2_test.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class SharedIndex2Test < Test::Unit::TestCase
+  fixtures :shared_index2s, :shared_index1s
+
+  def setup
+    SharedIndex1.rebuild_index
+  end
+
+  def test_query_for_record
+    assert_match /SharedIndex2/, shared_index2s(:first).query_for_record.to_s
+  end
+end

data/doc/demo/test/unit/sort_test.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class SortTest < Test::Unit::TestCase
+  include Ferret::Search
+
+  def test_sort_marshalling
+    [ Sort.new,
+      Sort.new( [], :reverse => true) ,
+      Sort.new([ Ferret::Search::SortField.new(:id, :reverse => true), 
+                 Ferret::Search::SortField::SCORE,
+                 Ferret::Search::SortField::DOC_ID ],
+               :reverse => true),
+      Sort.new([ Ferret::Search::SortField.new(:id), 
+                 Ferret::Search::SortField::SCORE_REV,
+                 Ferret::Search::SortField::DOC_ID_REV ])
+    ].each do |sort|
+      assert_equal sort.to_s, Sort._load(sort._dump(0)).to_s
+    end 
+  end
+
+end

data/doc/demo/test/unit/special_content_test.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class SpecialContentTest < Test::Unit::TestCase
+  include Ferret::Index
+  include Ferret::Search
+  fixtures :contents, :comments
+
+  def setup
+    ContentBase.rebuild_index
+    Comment.rebuild_index
+  end
+  
+  def test_class_index_dir
+    assert SpecialContent.aaf_configuration[:index_dir] =~ %r{^#{RAILS_ROOT}/index/test/content_base}
+  end
+
+  def test_find_with_ferret
+    contents_from_ferret = SpecialContent.find_with_ferret('single table')
+    assert_equal 1, contents_from_ferret.size
+    assert_equal ContentBase.find(3), contents_from_ferret.first
+    contents_from_ferret = SpecialContent.find_with_ferret('title')
+    assert contents_from_ferret.empty?
+    
+  end
+end

data/doc/demo/vendor/plugins/will_paginate/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2007 PJ Hyett and 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.

data/doc/demo/vendor/plugins/will_paginate/README

@@ -0,0 +1,108 @@
+= WillPaginate
+
+Quick quiz: Where does pagination logic belong?
+
+  a) in the model;
+  b) in the controller;
+  c) in views;
+  d) all of the above.
+
+We think you know the answer (if you think hard enough).
+
+This plugin makes magic happen. You *will* paginate!
+
+
+== Example usage:
+
+Use a paginate finder in the controller:
+
+    @posts = Post.paginate_by_board_id @board.id, :page => params[:page]
+
+Yeah, +paginate+ works just like +find+ -- it just doesn't fetch all the records.
+Just don't forget to tell it which page you want!
+
+Render the posts in your view like you would normally do. When you need to render
+pagination, just stick this in:
+
+    <%= will_paginate @posts %>
+
+You're done. (Copy and paste the example fancy CSS styles from the bottom.)
+
+How does it know how much items to fetch per page? It asks your model by calling
++Post.per_page+. You can define it like this:
+
+    class Post < ActiveRecord::Base
+      cattr_reader :per_page
+      @@per_page = 50
+    end
+
+... or like this:
+
+    class Post < ActiveRecord::Base
+      def self.per_page
+        50
+      end
+    end
+
+... or don't worry about it at all. (WillPaginate defines it to be 30 if missing.)
+You can also specify the count explicitly when calling +paginate+:
+
+    @posts = Post.paginate :page => params[:page], :per_page => 50
+
+The +paginate+ finder wraps the original finder and returns your resultset that now has
+some new properties. You can use the collection as you would with any ActiveRecord
+resultset, but WillPaginate view helpers also need that object to be able to render pagination:
+
+    <ol>
+      <% for post in @posts -%>
+        <li>Render `post` in some nice way.</li>
+      <% end -%>
+    </ol>
+
+    <p>Now let's render us some pagination!</p>
+    <%= will_paginate @posts %>
+
+
+== Authors, credits
+
+  Ruby port by:           PJ Hyett, Mislav Marohnić (Sulien)
+  Contributors:           K. Adam Christensen, Chris Wanstrath, Dr. Nic Williams
+  Original announcement:  http://errtheblog.com/post/929 
+  Original PHP source:    http://www.strangerstudios.com/sandbox/pagination/diggstyle.php
+
+REPORT BUGS on Lighthouse: http://err.lighthouseapp.com/projects/466-plugins/overview
+
+
+== Want Digg style?
+
+Copy the following css into your stylesheet for a good start:
+
+  .pagination {
+    padding: 3px;
+    margin: 3px;
+  }
+  .pagination a {
+    padding: 2px 5px 2px 5px;
+    margin: 2px;
+    border: 1px solid #aaaadd;
+    text-decoration: none;
+    color: #000099;
+  }
+  .pagination a:hover, .pagination a:active {
+    border: 1px solid #000099;
+    color: #000;
+  }
+  .pagination span.current {
+    padding: 2px 5px 2px 5px;
+    margin: 2px;
+    border: 1px solid #000099;
+    font-weight: bold;
+    background-color: #000099;
+    color: #FFF;
+  }
+  .pagination span.disabled {
+    padding: 2px 5px 2px 5px;
+    margin: 2px;
+    border: 1px solid #eee;
+    color: #ddd;
+  }

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

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

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

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

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

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