Merge branch 'master' of ../brauliobos-noosfero

Braulio Bhavamitra
2 parents 4c3e514f 0498b3b8
Showing 224 changed files with 9052 additions and 3861 deletions Show diff stats
HACKING
INSTALL
Rakefile
app/controllers/my_profile/profile_members_controller.rb
app/controllers/public/browse_controller.rb
app/controllers/public/profile_search_controller.rb
app/controllers/public/search_controller.rb
app/helpers/search_helper.rb
app/models/article.rb
app/models/category_finder.rb
app/models/enterprise.rb
app/models/environment_finder.rb
app/models/region.rb
config/solr.yml.dist
debian/control
debian/ferret_server.yml
debian/noosfero.install
debian/noosfero.links
debian/solr.yml
etc/init.d/noosfero
@@ -38,6 +38,9 @@ commands and make sure you understand what you are doing):
  cp config/database.yml.sqlite3 config/database.yml
  # create tmp directory if it doesn't exist
  mkdir tmp
+ # download and start Solr
+ rake solr:download
+ rake solr:start
  # create the development database
  rake db:schema:load
  # run pending migrations
@@ -13,7 +13,7 @@ You need to install some packages Noosfero depends on.  On Debian GNU/Linux or
 Debian-based systems, all of these packages are available through the Debian
 archive. You can install them with the following command:
  
- # apt-get install ruby rake po4a libgettext-ruby-util libgettext-ruby-data libgettext-ruby1.8 libsqlite3-ruby rcov librmagick-ruby libredcloth-ruby libwill-paginate-ruby iso-codes libfeedparser-ruby libferret-ruby libdaemons-ruby mongrel mongrel-cluster tango-icon-theme libhpricot-ruby
+ # apt-get install ruby rake po4a libgettext-ruby-util libgettext-ruby-data libgettext-ruby1.8 libsqlite3-ruby rcov librmagick-ruby libredcloth-ruby libwill-paginate-ruby iso-codes libfeedparser-ruby openjdk-6-jre libdaemons-ruby mongrel mongrel-cluster tango-icon-theme libhpricot-ruby
  
 On other systems, they may or may not be available through your regular package
 management system. Below are the links to their homepages.
@@ -24,7 +24,7 @@ management system. Below are the links to their homepages.
 * Ruby-GetText: http://www.yotabanana.com/hiki/ruby-gettext.html?ruby-gettext (at least version 1.9.0)
 * Ruby-sqlite3: http://rubyforge.org/projects/sqlite-ruby
 * rcov: http://eigenclass.org/hiki/rcov
-* Ferret: http://ferret.davebalmain.com/trac
+* Solr: http://lucene.apache.org/solr
 * RMagick: http://rmagick.rubyforge.org/
 * RedCloth: http://redcloth.org/
 * will_paginate: http://github.com/mislav/will_paginate/wikis
@@ -115,8 +115,11 @@ $ tar -zxvf noosfero-0.27.1.tar.gz
 $ ln -s noosfero-0.27.1 current
 $ cd current
  
-Copy config/ferret_server.yml.dist to config/ferret_server.yml. You will
+Copy config/solr.yml.dist to config/solr.yml. You will
 probably not need to customize this configuration, but have a look at it.
+Then you'll need to download Solr into noosfero:
+
+$ rake solr:download
  
 Create the mongrel configuration file:
  
@@ -237,6 +240,10 @@ Create the database structure:
  
 $ RAILS_ENV=production rake db:schema:load
  
+Run Solr:
+
+$ rake solr:start
+
 Now we have to create some initial data. To create your default environment
 (the first one), run the command below:
  
@@ -7,4 +7,6 @@ require &#39;rake&#39;
 require 'rake/testtask'
 require 'rake/rdoctask'
  
+ACTS_AS_SEARCHABLE_ENABLED = false if Rake.application.top_level_tasks.detect{|t| t == 'db:data:minimal'}
+
 require 'tasks/rails'
@@ -126,11 +126,11 @@ class ProfileMembersController &lt; MyProfileController
     if !params[:query] || params[:query].length <= 2
       @users_found = []
     elsif params[:scope] == 'all_users'
-      @users_found = Person.find_by_contents(params[:query] + '*').select {|user| !profile.members.include?(user)}
+      @users_found = Person.find_by_contents(params[:query] + '*')[:results].select {|user| !profile.members.include?(user)}
       @button_alt = _('Add member')
       @add_action = {:action => 'add_member'}
     elsif params[:scope] == 'new_admins'
-      @users_found = Person.find_by_contents(params[:query] + '*').select {|user| profile.members.include?(user) && !profile.admins.include?(user)}
+      @users_found = Person.find_by_contents(params[:query] + '*')[:results].select {|user| profile.members.include?(user) && !profile.admins.include?(user)}
       @button_alt = _('Add member')
       @add_action = {:action => 'add_admin'}
     end
@@ -19,7 +19,7 @@ class BrowseController &lt; PublicController
     @results = @environment.people.visible.send(@filter)
  
     if !params[:query].blank?
-      @results = @results.find_by_contents(params[:query])
+      @results = @results.find_by_contents(params[:query])[:results]
     end
     @results = @results.compact.paginate(:per_page => per_page, :page => params[:page])
   end
@@ -31,7 +31,7 @@ class BrowseController &lt; PublicController
     @results = @environment.communities.visible.send(@filter)
  
     if !params[:query].blank?
-      @results = @results.find_by_contents(params[:query])
+      @results = @results.find_by_contents(params[:query])[:results]
     end
     @results = @results.compact.paginate(:per_page => per_page, :page => params[:page])
   end
@@ -8,11 +8,10 @@ class ProfileSearchController &lt; PublicController
   def index
     @q = params[:q]
     unless @q.blank?
-      @filtered_query = remove_stop_words(@q)
       if params[:where] == 'environment'
         redirect_to :controller => 'search', :query => @q
       else
-        @results = profile.articles.published.find_by_contents(@filtered_query).paginate(:per_page => 10, :page => params[:page])
+        @results = profile.articles.published.find_by_contents(@q)[:results].paginate(:per_page => 10, :page => params[:page])
       end
     end
   end
@@ -89,7 +89,8 @@ class SearchController &lt; PublicController
     # REFACTOR DUPLICATED CODE inner loop doing the same thing that outter loop
  
     if !@query.blank? || @region && !params[:radius].blank?
-      @result_ids = @noosfero_finder.find(asset, @filtered_query, calculate_find_options(asset, nil, params[:page], @product_category, @region, params[:radius], params[:year], params[:month]).merge({:limit => :all}))
+      ret = @noosfero_finder.find(asset, @query, calculate_find_options(asset, nil, params[:page], @product_category, @region, params[:radius], params[:year], params[:month]).merge({:limit => :all}))
+      @result_ids = ret.is_a?(Hash) ? ret[:results] : ret
     end
  
   end
@@ -149,7 +150,6 @@ class SearchController &lt; PublicController
  
   def index
     @query = params[:query] || ''
-    @filtered_query = remove_stop_words(@query)
     @product_category = ProductCategory.find(params[:product_category]) if params[:product_category]
  
     @region = City.find_by_id(params[:city]) if !params[:city].blank? && params[:city] =~ /^\d+$/
@@ -158,12 +158,16 @@ class SearchController &lt; PublicController
     number_of_result_assets = @searching.values.select{|v| v}.size
  
     @results = {}
+    @facets = {}
     @order = []
     @names = {}
  
     where_to_search.select { |key,description| @searching[key]  }.each do |key, description|
       @order << key
-      @results[key] = @noosfero_finder.find(key, @filtered_query, calculate_find_options(key, limit, params[:page], @product_category, @region, params[:radius], params[:year], params[:month]))
+      find_options = calculate_find_options(key, limit, params[:page], @product_category, @region, params[:radius], params[:year], params[:month]);
+      ret = @noosfero_finder.find(key, @query, find_options)
+      @results[key] = ret.is_a?(Hash) ? ret[:results] : ret
+      @facets[key] = ret.is_a?(Hash) ? ret[:facets] : {}
       @names[key] = getterm(description)
     end
  
@@ -3,21 +3,12 @@ module SearchHelper
   # FIXME remove it after search_controler refactored
   include EventsHelper
  
-  STOP_WORDS = {
-    'pt_BR' => Ferret::Analysis::FULL_PORTUGUESE_STOP_WORDS,
-    'en'    => Ferret::Analysis::FULL_ENGLISH_STOP_WORDS,
-  }
-  
   def relevance_for(hit)
     n = (hit.ferret_score if hit.respond_to?(:ferret_score))
     n ||= 1.0
     (n * 100.0).round
   end
  
-  def remove_stop_words(query)
-    (query.downcase.scan(/"[^"]*"?|'[^']*'?|[^'"\s]+/) - (STOP_WORDS[locale] || [])).join(' ')
-  end
-
   def display_results(use_map = true)
  
     unless use_map && GoogleMaps.enabled?(environment.default_hostname)
@@ -388,7 +388,7 @@ class Article &lt; ActiveRecord::Base
   end
  
   def comments_updated
-    ferret_update
+    solr_save
   end
  
   def accept_category?(cat)
@@ -28,10 +28,12 @@ class CategoryFinder
     end
  
     if query.blank?
+      options.delete(:facets)
       asset_class(asset).send(finder_method, :all, options_for_find(asset_class(asset), {:order => "#{asset_table(asset)}.name"}.merge(options), date_range))
     else
-      ferret_options = {:page => options.delete(:page), :per_page => options.delete(:per_page)}
-      asset_class(asset).find_by_contents(query, ferret_options, options_for_find(asset_class(asset), options, date_range))
+      pg_options = {:page => options.delete(:page), :per_page => options.delete(:per_page)}
+      solr_options = {:facets => options.delete(:facets)}
+      asset_class(asset).find_by_contents(query, pg_options, solr_options, options_for_find(asset_class(asset), options, date_range))[:results]
     end
   end
  
@@ -71,7 +71,7 @@ class Enterprise &lt; Organization
   end
  
   def product_updated
-    ferret_update
+    solr_save
   end
  
   after_save do |e|
@@ -22,6 +22,8 @@ class EnvironmentFinder
     end
  
     if query.blank?
+      options.delete(:facets)
+
       # FIXME this test is in more than one place
       if finder_method == 'paginate'
         options = {:order => "#{asset_table(asset)}.name"}.merge(options)
@@ -48,14 +50,20 @@ class EnvironmentFinder
         end
       end
     else
-      ferret_options = {:page => options.delete(:page), :per_page => options.delete(:per_page)}
+      pg_options = {:page => options.delete(:page), :per_page => options.delete(:per_page)}
+      solr_options = {:facets => options.delete(:facets)}
       if product_category && asset == :products
         # SECURITY no risk of SQL injection, since product_category_ids comes from trusted source
-        @environment.send(asset).find_by_contents(query, ferret_options, options.merge({:include => 'product_categorizations', :conditions => 'product_categorizations.category_id = (%s)' % product_category.id }))
+        ret = @environment.send(asset).find_by_contents(query, pg_options, solr_options, options.merge({:include => 'product_categorizations', :conditions => 'product_categorizations.category_id = (%s)' % product_category.id }))
       elsif product_category && asset == :enterprises
-        @environment.send(asset).find_by_contents(query, ferret_options, options.merge(:joins => 'inner join product_categorizations on (product_categorizations.product_id = products.id)', :include => 'products', :conditions => "product_categorizations.category_id = (#{product_category.id})"))
+        ret = @environment.send(asset).find_by_contents(query, pg_options, solr_options, options.merge(:joins => 'inner join product_categorizations on (product_categorizations.product_id = products.id)', :include => 'products', :conditions => "product_categorizations.category_id = (#{product_category.id})"))
+      else
+        ret = @environment.send(asset).find_by_contents(query, pg_options, solr_options, options)
+      end
+      if solr_options[:facets].nil?
+        ret[:results]
       else
-        @environment.send(asset).find_by_contents(query, ferret_options, options)
+        ret
       end
     end
   end
@@ -5,10 +5,9 @@ class Region &lt; Category
   require_dependency 'enterprise' # enterprises can also be validators
  
   # searches for organizations that could become validators for this region.
-  # <tt>search</tt> is passed as is to ferret's find_by_contents on Organizatio
-  # find_by_contents on Organization class.
+  # <tt>search</tt> is passed as is to find_by_contents on Organization.
   def search_possible_validators(search)
-    Organization.find_by_contents(search).reject {|item| self.validator_ids.include?(item.id) }
+    Organization.find_by_contents(search)[:results].reject {|item| self.validator_ids.include?(item.id) }
   end
  
   def has_validator?
@@ -0,0 +1,17 @@
+# Config file for the acts_as_solr plugin.
+#
+# If you change the host or port number here, make sure you update 
+# them in your Solr config file
+
+development:
+  url: http://0.0.0.0:8982/solr
+  jvm_options: -server -Xmx64M -Xms16M
+  
+production:
+  url: http://127.0.0.1:8983/solr
+  jvm_options: -server -Xmx512M -Xms64M
+
+test:
+  url: http://0.0.0.0:8981/solr
+  jvm_options: -server -Xmx32M -Xms16M
+
@@ -11,7 +11,7 @@ Vcs-Browser: http://git.colivre.coop.br/?p=noosfero.git
  
 Package: noosfero
 Architecture: all
-Depends: rails, ruby1.8, ruby, rake, libgettext-ruby-data, libsqlite3-ruby, libpgsql-ruby, libmysql-ruby, librmagick-ruby, libredcloth-ruby, libwill-paginate-ruby, iso-codes, libfeedparser-ruby, libferret-ruby, libdaemons-ruby, rcov, mongrel, mongrel-cluster, tango-icon-theme, libhpricot-ruby, iso-codes, memcached, debconf, dbconfig-common, postgresql, adduser, ${misc:Depends}
+Depends: rails, ruby1.8, ruby, rake, libgettext-ruby-data, libsqlite3-ruby, libpgsql-ruby, libmysql-ruby, librmagick-ruby, libredcloth-ruby, libwill-paginate-ruby, iso-codes, libfeedparser-ruby, openjdk-6-jre, libdaemons-ruby, rcov, mongrel, mongrel-cluster, tango-icon-theme, libhpricot-ruby, iso-codes, memcached, debconf, dbconfig-common, postgresql, adduser, ${misc:Depends}
 Recommends: postgresql-client
 Description: free web-based platform for social networks
  Noosfero is a web platform for social and solidarity economy networks with
@@ -1,4 +0,0 @@
-production:
-  host: localhost
-  port: 51000
-  pid_file: tmp/pids/ferret.production.pid
@@ -28,7 +28,7 @@ public                            usr/share/noosfero
 debian/default/noosfero           etc/default
 etc/init.d/noosfero               etc/init.d
 debian/mongrel_cluster.yml        etc/noosfero
-debian/ferret_server.yml          etc/noosfero
+debian/solr.yml                   etc/noosfero
 etc/logrotate.d/noosfero          etc/logrotate.d
 debian/noosfero.yml               etc/noosfero
  
@@ -3,7 +3,7 @@ var/tmp/noosfero                                    usr/share/noosfero/tmp
 var/log/noosfero                                    usr/share/noosfero/log
 etc/noosfero/database.yml                           usr/share/noosfero/config/database.yml
 etc/noosfero/mongrel_cluster.yml                    usr/share/noosfero/config/mongrel_cluster.yml
-etc/noosfero/ferret_server.yml                      usr/share/noosfero/config/ferret_server.yml
+etc/noosfero/solr.yml                               usr/share/noosfero/config/solr.yml
 etc/noosfero/plugins                                usr/share/noosfero/config/plugins
 etc/noosfero/noosfero.yml                           usr/share/noosfero/config/noosfero.yml
 etc/noosfero/local.rb                               usr/share/noosfero/config/local.rb
@@ -0,0 +1,9 @@
+# Config file for the acts_as_solr plugin.
+#
+# If you change the host or port number here, make sure you update 
+# them in your Solr config file
+
+production:
+  url: http://127.0.0.1:8983/solr
+  jvm_options: -server -Xmx512M -Xms64M
+
@@ -43,14 +43,14 @@ if [ -z &quot;$NOOSFERO_DIR&quot; ] || [ -z &quot;$NOOSFERO_USER&quot; ]; then
 fi
  
 ######################
-FERRET_PID_FILE=$NOOSFERO_DIR/tmp/pids/ferret.production.pid
+SOLR_PID_FILE=$NOOSFERO_DIR/tmp/pids/solr.production.pid
  
 main_script() {
   cd $NOOSFERO_DIR
   if [ "$NOOSFERO_USER" != "$USER" ]; then
-    su $NOOSFERO_USER -l -c "./script/production $1"
+    su $NOOSFERO_USER -l -c "SOLR_DATA_PATH=/var/lib/noosfero-data/index ./script/production $1"
   else
-    ./script/production $1
+    SOLR_DATA_PATH=/var/lib/noosfero-data/index ./script/production $1
   fi
 }
  
@@ -76,6 +76,13 @@ do_setup() {
     chmod 750 /var/tmp/noosfero
   fi
  
+  # Solr directory
+  if [ ! -d /var/tmp/noosfero/solr ]; then
+    mkdir -p /var/tmp/noosfero/solr
+    chown $NOOSFERO_USER:root /var/tmp/noosfero/solr
+    chmod 750 /var/tmp/noosfero/solr
+  fi
+
   # symlink the directories into Noosfero directory
   if [ ! -e $NOOSFERO_DIR/tmp ]; then
     ln -s /var/tmp/noosfero $NOOSFERO_DIR/tmp
@@ -90,8 +97,8 @@ do_setup() {
  
 do_start() {
  
-  # FIXME should not test for ferret only
-  if [ -e $FERRET_PID_FILE ]; then
+  # FIXME should not test for solr only
+  if [ -e $SOLR_PID_FILE ]; then
     echo 'noosfero already running, cannot start.'
     exit 2
   fi
@@ -104,8 +111,8 @@ do_start() {
  
 do_stop() {
  
-  # FIXME should not test for ferret only
-  if [ ! -e $FERRET_PID_FILE ]; then
+  # FIXME should not test for solr only
+  if [ ! -e $SOLR_PID_FILE ]; then
     echo 'noosfero not running, cannot stop'
     exit 2
   fi
 module ActsAsSearchable
  
   module ClassMethods
+    ACTS_AS_SEARCHABLE_ENABLED = true unless defined? ACTS_AS_SEARCHABLE_ENABLED
+
     def acts_as_searchable(options = {})
-      if Noosfero::MultiTenancy.on? and ActiveRecord::Base.postgresql?
-        options[:additional_fields] ||= {}
-        options[:additional_fields] = Hash[*options[:additional_fields].collect{ |v| [v, {}] }.flatten] if options[:additional_fields].is_a?(Array)
-        options[:additional_fields].merge!(:schema_name => { :index => :untokenized })
+      if ACTS_AS_SEARCHABLE_ENABLED
+        if (!options[:fields])
+          options[:additional_fields] |= [{:schema_name => :string}]
+        else
+          options[:fields] << {:schema_name => :string}
+        end
+        acts_as_solr options
+        extend FindByContents
+        send :include, InstanceMethods
       end
-      acts_as_ferret({ :remote => true }.merge(options))
-      extend FindByContents
-      send :include, InstanceMethods
     end
  
     module InstanceMethods
       def schema_name
-        ActiveRecord::Base.connection.schema_search_path
+        (Noosfero::MultiTenancy.on? and ActiveRecord::Base.postgresql?) ? ActiveRecord::Base.connection.schema_search_path : ''
       end
     end
  
     module FindByContents
  
       def schema_name
-        ActiveRecord::Base.connection.schema_search_path
+        (Noosfero::MultiTenancy.on? and ActiveRecord::Base.postgresql?) ? ActiveRecord::Base.connection.schema_search_path : ''
       end
  
-      def find_by_contents(query, ferret_options = {}, db_options = {})
-        pg_options = {}
-        if ferret_options[:page]
-          pg_options[:page] = ferret_options.delete(:page)
-        end
-        if ferret_options[:per_page]
-          pg_options[:per_page] = ferret_options.delete(:per_page)
-        end
+      def find_by_contents(query, pg_options = {}, options = {}, db_options = {})
+        pg_options[:page] ||= 1
+        pg_options[:per_page] ||= 20
+        options[:limit] = pg_options[:per_page].to_i*pg_options[:page].to_i
+        options[:scores] = true;
  
-        ferret_options[:limit] = :all
+        query = !schema_name.empty? ? "+schema_name:\"#{schema_name}\" AND #{query}" : query
+        solr_result = find_by_solr(query, options)
+        if solr_result.nil?
+          results = facets = []
+        else
+          facets = options.include?(:facets) ? solr_result.facets : []
  
-        ferret_query = (Noosfero::MultiTenancy.on? and ActiveRecord::Base.postgresql?) ? "+schema_name:\"#{schema_name}\" AND #{query}" : query
-        # FIXME this is a HORRIBLE HACK
-        ids = find_ids_with_ferret(ferret_query, ferret_options)[1][0..8000].map{|r|r[:id].to_i}
+          if db_options.empty?
+            results = solr_result.results
+          else
+            ids = solr_result.results.map{|r|r[:id].to_i}
+            if ids.empty?
+              ids << -1
+            end
  
-        if ids.empty?
-          ids << -1
-        end
+            if db_options[:conditions]
+              db_options[:conditions] = sanitize_sql_for_conditions(db_options[:conditions]) + " and #{table_name}.id in (#{ids.join(', ')})"
+            else
+              db_options[:conditions] = "#{table_name}.id in (#{ids.join(', ')})"
+            end
  
-        if db_options[:conditions]
-          db_options[:conditions] = sanitize_sql_for_conditions(db_options[:conditions]) + " and #{table_name}.id in (#{ids.join(', ')})"
-        else
-          db_options[:conditions] = "#{table_name}.id in (#{ids.join(', ')})"
+            results = find(:all, db_options)
+          end
+
+          results = results.paginate(pg_options.merge(:total_entries => solr_result.total))
         end
  
-        pg_options[:page] ||= 1
-        result = find(:all, db_options)
-        result.paginate(pg_options)
+        {:results => results, :facets => facets}
       end
     end
   end
 class CreateThumbnailsJob < Struct.new(:class_name, :file_id)
   def perform
     return unless class_name.constantize.exists?(file_id)
-    Article.disable_ferret # acts_as_ferret sucks
     file = class_name.constantize.find(file_id)
     file.create_thumbnails
-    Article.enable_ferret # acts_as_ferret sucks
   end
 end
@@ -8,10 +8,22 @@ task :package =&gt; &#39;package:clobber&#39; do
     puts "** The `package` task only works from within #{Noosfero::PROJECT}'s git repository."
     fail
   end
+  begin
+    sh 'test -f vendor/plugins/acts_as_solr/solr/start.jar'
+  rescue
+    puts "** The `package` task needs Solr installed within #{Noosfero::PROJECT}. Run 'rake solr:download'."
+    fail
+  end
   release = "#{Noosfero::PROJECT}-#{Noosfero::VERSION}"
   target = "pkg/#{release}"
   mkdir_p target
   sh "git archive HEAD | (cd #{target} && tar x)"
+
+  #solr inclusion
+  cp_r "vendor/plugins/acts_as_solr/solr", "#{target}/vendor/plugins/acts_as_solr", :verbose => true
+  rm_r "#{target}/vendor/plugins/acts_as_solr/solr/work"
+  mkdir_p "#{target}/vendor/plugins/acts_as_solr/solr/work"
+
   sh "cd pkg && tar czf #{release}.tar.gz #{release}"
 end
  
@@ -7,6 +7,10 @@ else
 end
  
 task :test do
+  ENV['RAILS_ENV'] = 'test'
+  Rake::Task['solr:stop'].invoke
+  Rake::Task['solr:download'].invoke
+  Rake::Task['solr:start'].invoke
   errors = %w(test:units test:functionals test:integration cucumber selenium).collect do |task|
     begin
       Rake::Task[task].invoke
@@ -15,6 +19,7 @@ task :test do
       task
     end
   end.compact
+  Rake::Task['solr:stop'].invoke
   abort "Errors running #{errors.to_sentence}!" if errors.any?
 end
  
 #!/bin/sh
  
+export RAILS_ENV=development
+
 stop() {
   ./script/delayed_job stop
   ./script/feed-updater stop
+  rake -s solr:stop
 }
  
 start() {
   ./script/feed-updater start
   ./script/delayed_job start
+  rake -s solr:download
+  rake -s solr:start
   trap stop INT TERM
   ./script/server $@
 }
@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-
-begin
-  require File.join(File.dirname(__FILE__), '../vendor/plugins/acts_as_ferret/lib/server_manager')
-rescue LoadError
-  # try the gem
-  require 'rubygems'
-  gem 'acts_as_ferret'
-  require 'server_manager'
-end
@@ -22,7 +22,7 @@ do_start() {
   fi
  
   clear_cache
-  ./script/ferret_server -e $RAILS_ENV start
+  rake -s solr:start
   environments_loop
   mongrel_rails cluster::start
 }
@@ -31,7 +31,7 @@ do_stop() {
   mongrel_rails cluster::stop
   ./script/delayed_job stop
   ./script/feed-updater stop
-  ./script/ferret_server -e $RAILS_ENV stop
+  rake -s solr:stop
 }
  
 environments_loop() {
@@ -22,7 +22,7 @@ module Noosfero::Factory
       end
     end
     if options[:search]
-      obj.ferret_create
+      obj.solr_save
     end
     obj
   end
@@ -6,6 +6,7 @@ class ProfileSearchController; def rescue_action(e) raise e end; end
  
 class ProfileSearchControllerTest < Test::Unit::TestCase
   def setup
+    Test::Unit::TestCase::setup
     @controller = ProfileSearchController.new
     @request    = ActionController::TestRequest.new
     @response   = ActionController::TestResponse.new
@@ -14,14 +15,6 @@ class ProfileSearchControllerTest &lt; Test::Unit::TestCase
   end
   attr_reader :person
  
-  should 'filter stop words' do
-    @controller.expects(:locale).returns('en').at_least_once
-    get 'index', :profile => person.identifier, :q => 'an article about something'
-    assert_response :success
-    assert_template 'index'
-    assert_equal 'article something', assigns('filtered_query')
-  end
-
   should 'espape xss attack' do
     @controller.expects(:profile).returns(person).at_least_once
     get 'index', :profile => person.identifier, :q => '<wslite>'
@@ -41,8 +34,8 @@ class ProfileSearchControllerTest &lt; Test::Unit::TestCase
   end
  
   should 'display search results' do
-    article1 = fast_create(Article, :body => '<p>Article to test profile search</p>', :profile_id => person.id)
-    article2 = fast_create(Article, :body => '<p>Another article to test profile search</p>', :profile_id => person.id)
+    article1 = fast_create(Article, {:body => '<p>Article to test profile search</p>', :profile_id => person.id}, :search => true)
+    article2 = fast_create(Article, {:body => '<p>Another article to test profile search</p>', :profile_id => person.id}, :search => true)
  
     get 'index', :profile => person.identifier, :q => 'article'
  
@@ -6,6 +6,7 @@ class SearchController; def rescue_action(e) raise e end; end
  
 class SearchControllerTest < Test::Unit::TestCase
   def setup
+    Test::Unit::TestCase::setup
     @controller = SearchController.new
     @request    = ActionController::TestRequest.new
     @response   = ActionController::TestResponse.new
@@ -35,21 +36,6 @@ class SearchControllerTest &lt; Test::Unit::TestCase
     assert_valid_xhtml
   end
  
-  should 'filter stop words' do
-    @controller.expects(:locale).returns('pt_BR').at_least_once
-    get 'index', :query => 'a carne da vaca'
-    assert_response :success
-    assert_template 'index'
-    assert_equal 'carne vaca', assigns('filtered_query')
-  end
-
-  should 'search with filtered query' do
-    @controller.expects(:locale).returns('pt_BR').at_least_once
-    get 'index', :query => 'a carne da vaca'
-
-    assert_equal 'carne vaca', assigns('filtered_query')
-  end
-
   should 'espape xss attack' do
     get 'index', :query => '<wslite>'
     assert_no_tag :tag => 'wslite'
@@ -47,6 +47,11 @@ class Test::Unit::TestCase
   include AuthenticatedTestHelper
  
   fixtures :environments, :roles
+
+  def self.setup
+    # clean up index db before each test
+    ActsAsSolr::Post.execute(Solr::Request::Delete.new(:query => '*:*'))
+  end
  
   def self.all_fixtures
     Dir.glob(File.join(RAILS_ROOT, 'test', 'fixtures', '*.yml')).each do |item|
@@ -190,7 +195,6 @@ class Test::Unit::TestCase
     adapter.any_instance.stubs(:adapter_name).returns('PostgreSQL')
     adapter.any_instance.stubs(:schema_search_path).returns(schema_name)
     Noosfero::MultiTenancy.stubs(:on?).returns(true)
-    reload_for_ferret
   end
  
   def uses_sqlite
@@ -199,20 +203,6 @@ class Test::Unit::TestCase
     Noosfero::MultiTenancy.stubs(:on?).returns(false)
   end
  
-  def reload_for_ferret
-    ActsAsFerret.send(:remove_const, :DEFAULT_FIELD_OPTIONS)
-    load File.join(RAILS_ROOT, 'lib', 'acts_as_searchable.rb')
-    load File.join(RAILS_ROOT, 'vendor', 'plugins', 'acts_as_ferret', 'lib', 'acts_as_ferret.rb')
-    [Article, Profile, Product].each do |clazz|
-      inst_meth = clazz.instance_methods.reject{ |m| m =~ /_to_ferret$/ }
-      clazz.stubs(:instance_methods).returns(inst_meth)
-    end
-    #FIXME Is there a way to avoid this replication from model code?
-    Article.acts_as_searchable :additional_fields => [ :comment_data ]
-    Profile.acts_as_searchable :additional_fields => [ :extra_data_for_index ]
-    Product.acts_as_searchable :fields => [ :name, :description, :category_full_name ]
-  end
-
 end
  
 module NoosferoTestHelper
@@ -5,6 +5,7 @@ class ArticleTest &lt; Test::Unit::TestCase
   fixtures :environments
  
   def setup
+    Test::Unit::TestCase::setup
     @profile = create_user('testing').person
   end
   attr_reader :profile
@@ -356,7 +357,7 @@ class ArticleTest &lt; Test::Unit::TestCase
  
   should 'reindex when comments are changed' do
     a = Article.new
-    a.expects(:ferret_update)
+    a.expects(:solr_save)
     a.comments_updated
   end
  
@@ -365,7 +366,7 @@ class ArticleTest &lt; Test::Unit::TestCase
     art = owner.articles.build(:name => 'ytest'); art.save!
     c1 = art.comments.build(:title => 'a nice comment', :body => 'anything', :author => owner); c1.save!
  
-    assert_includes Article.find_by_contents('nice'), art
+    assert_includes Article.find_by_contents('nice')[:results], art
   end
  
   should 'index comments body together with article' do
@@ -373,7 +374,7 @@ class ArticleTest &lt; Test::Unit::TestCase
     art = owner.articles.build(:name => 'ytest'); art.save!
     c1 = art.comments.build(:title => 'test comment', :body => 'anything', :author => owner); c1.save!
  
-    assert_includes Article.find_by_contents('anything'), art
+    assert_includes Article.find_by_contents('anything')[:results], art
   end
  
   should 'cache children count' do
@@ -1506,24 +1507,24 @@ class ArticleTest &lt; Test::Unit::TestCase
   should 'index by schema name when database is postgresql' do
     uses_postgresql 'schema_one'
     art1 = Article.create!(:name => 'some thing', :profile_id => @profile.id)
-    assert_equal Article.find_by_contents('thing'), [art1]
+    assert_equal Article.find_by_contents('thing')[:results], [art1]
     uses_postgresql 'schema_two'
     art2 = Article.create!(:name => 'another thing', :profile_id => @profile.id)
-    assert_not_includes Article.find_by_contents('thing'), art1
-    assert_includes Article.find_by_contents('thing'), art2
+    assert_not_includes Article.find_by_contents('thing')[:results], art1
+    assert_includes Article.find_by_contents('thing')[:results], art2
     uses_postgresql 'schema_one'
-    assert_includes Article.find_by_contents('thing'), art1
-    assert_not_includes Article.find_by_contents('thing'), art2
+    assert_includes Article.find_by_contents('thing')[:results], art1
+    assert_not_includes Article.find_by_contents('thing')[:results], art2
     uses_sqlite
   end
  
   should 'not index by schema name when database is not postgresql' do
     uses_sqlite
     art1 = Article.create!(:name => 'some thing', :profile_id => @profile.id)
-    assert_equal Article.find_by_contents('thing'), [art1]
+    assert_equal Article.find_by_contents('thing')[:results], [art1]
     art2 = Article.create!(:name => 'another thing', :profile_id => @profile.id)
-    assert_includes Article.find_by_contents('thing'), art1
-    assert_includes Article.find_by_contents('thing'), art2
+    assert_includes Article.find_by_contents('thing')[:results], art1
+    assert_includes Article.find_by_contents('thing')[:results], art2
   end
  
   should 'get images paths in article body' do
@@ -3,11 +3,12 @@ require File.dirname(__FILE__) + &#39;/../test_helper&#39;
 class CategoryFinderTest < ActiveSupport::TestCase
  
   def setup
+    Test::Unit::TestCase::setup
     @category = Category.create!(:name => 'my category', :environment => Environment.default)
     @finder = CategoryFinder.new(@category)
     @product_category = fast_create(ProductCategory, :name => 'Products')
  
-    Profile.rebuild_index
+    Profile.rebuild_solr_index
   end
  
   should 'search for articles in a specific category' do
@@ -4,6 +4,7 @@ class EnterpriseTest &lt; Test::Unit::TestCase
   fixtures :profiles, :environments, :users
  
   def setup
+    Test::Unit::TestCase::setup
     @product_category = fast_create(ProductCategory, :name => 'Products')
   end
  
@@ -91,7 +92,7 @@ class EnterpriseTest &lt; Test::Unit::TestCase
  
     ent2 = fast_create(Enterprise, :name => 'test2', :identifier => 'test2')
  
-    result = Enterprise.find_by_contents(prod_cat.name)
+    result = Enterprise.find_by_contents(prod_cat.name)[:results]
  
     assert_includes result, ent1
     assert_not_includes result, ent2
@@ -105,7 +106,7 @@ class EnterpriseTest &lt; Test::Unit::TestCase
  
     ent2 = fast_create(Enterprise, :name => 'test2', :identifier => 'test2')
  
-    result = Enterprise.find_by_contents(prod_cat.name)
+    result = Enterprise.find_by_contents(prod_cat.name)[:results]
  
     assert_includes result, ent1
     assert_not_includes result, ent2
@@ -406,6 +407,12 @@ class EnterpriseTest &lt; Test::Unit::TestCase
  
     assert_equal product.inputs, enterprise.inputs
   end
+  
+  should 'reindex when products are changed' do
+    a = Enterprise.new
+    a.expects(:solr_save)
+    a.product_updated
+  end
  
   should "the followed_by? be true only to members" do
     e = fast_create(Enterprise)
@@ -3,6 +3,7 @@ require File.dirname(__FILE__) + &#39;/../test_helper&#39;
 class EnvironmentFinderTest < ActiveSupport::TestCase
  
   def setup
+    Test::Unit::TestCase::setup
     @product_category = fast_create(ProductCategory, :name => 'Products')
   end
  
@@ -77,10 +78,10 @@ class EnvironmentFinderTest &lt; ActiveSupport::TestCase
     finder = EnvironmentFinder.new(Environment.default)
  
     region = fast_create(Region, :name => 'r-test', :environment_id => Environment.default.id, :lat => 45.0, :lng => 45.0)
-    ent1 = fast_create(Enterprise, :name => 'test 1', :identifier => 'test1', :lat => 45.0, :lng => 45.0)
+    ent1 = fast_create(Enterprise, {:name => 'test 1', :identifier => 'test1', :lat => 45.0, :lng => 45.0}, :search => true)
     p1 = create_user('test2').person
     p1.name = 'test 2'; p1.lat = 45.0; p1.lng = 45.0; p1.save!
-    ent2 = fast_create(Enterprise, :name => 'test 3', :identifier => 'test3', :lat => 30.0, :lng => 30.0)
+    ent2 = fast_create(Enterprise, {:name => 'test 3', :identifier => 'test3', :lat => 30.0, :lng => 30.0}, :search => true)
     p2 = create_user('test4').person
     p2.name = 'test 4'; p2.lat = 30.0; p2.lng = 30.0; p2.save!
  
@@ -3,6 +3,10 @@ require File.dirname(__FILE__) + &#39;/../test_helper&#39;
 class EnvironmentTest < Test::Unit::TestCase
   fixtures :environments
  
+  def setup
+    Test::Unit::TestCase::setup
+  end
+
   def test_exists_default_and_it_is_unique
     Environment.delete_all
     vc = Environment.new(:name => 'Test Community')
@@ -442,7 +446,7 @@ class EnvironmentTest &lt; Test::Unit::TestCase
   should 'find by contents from articles' do
     environment = fast_create(Environment)
     assert_nothing_raised do
-      environment.articles.find_by_contents('')
+      environment.articles.find_by_contents('')[:results]
     end
   end
  
@@ -559,7 +563,7 @@ class EnvironmentTest &lt; Test::Unit::TestCase
       Enterprise.create!(:name => 'test ' + n, :identifier => 'test_' + n)
     end
  
-    assert_equal 20, env.enterprises.find_by_contents('test').total_entries
+    assert_equal 20, env.enterprises.find_by_contents('test')[:results].total_entries
   end
  
   should 'set replace_enterprise_template_when_enable on environment' do
@@ -2,6 +2,10 @@ require File.dirname(__FILE__) + &#39;/../test_helper&#39;
  
 class EventTest < ActiveSupport::TestCase
  
+  def setup
+    Test::Unit::TestCase::setup
+  end
+
   should 'be an article' do
     assert_kind_of Article, Event.new
   end
@@ -59,13 +63,13 @@ class EventTest &lt; ActiveSupport::TestCase
   should 'be indexed by title' do
     profile = create_user('testuser').person
     e = Event.create!(:name => 'my surprisingly nice event', :start_date => Date.new(2008, 06, 06), :profile => profile)
-    assert_includes Event.find_by_contents('surprisingly'), e
+    assert_includes Event.find_by_contents('surprisingly')[:results], e
   end
  
   should 'be indexed by body' do
     profile = create_user('testuser').person
     e = Event.create!(:name => 'bli', :start_date => Date.new(2008, 06, 06), :profile => profile, :body => 'my surprisingly long description about my freaking nice event')
-    assert_includes Event.find_by_contents('surprisingly'), e
+    assert_includes Event.find_by_contents('surprisingly')[:results], e
   end
  
   should 'use its own icon' do
@@ -50,14 +50,14 @@ class ForumHelperTest &lt; Test::Unit::TestCase
     some_post.comments << Comment.new(:title => 'test', :body => 'test', :author => a2)
     c = Comment.last
     assert_equal 2, some_post.comments.count
-    assert_match /#{c.created_at.to_s} ago by <a href='[^']+'>a2<\/a>/, last_topic_update(some_post)
+    assert_match(/#{Regexp.escape(c.created_at.to_s)} ago by <a href='[^']+'>a2<\/a>/, last_topic_update(some_post))
   end
  
   should "return last comment author's name from unauthenticated user" do
     some_post = TextileArticle.create!(:name => 'First post', :profile => profile, :parent => forum, :published => true)
     some_post.comments << Comment.new(:name => 'John', :email => 'lenon@example.com', :title => 'test', :body => 'test')
     c = Comment.last
-    assert_match /#{c.created_at.to_s} ago by John/m, last_topic_update(some_post)
+    assert_match(/#{Regexp.escape(c.created_at.to_s)} ago by John/m, last_topic_update(some_post))
   end
  
   protected
@@ -3,6 +3,7 @@ require File.dirname(__FILE__) + &#39;/../test_helper&#39;
 class ProductTest < Test::Unit::TestCase
  
   def setup
+    Test::Unit::TestCase::setup
     @product_category = fast_create(ProductCategory, :name => 'Products')
   end
  
@@ -92,7 +93,7 @@ class ProductTest &lt; Test::Unit::TestCase
     p.stubs(:category_full_name).returns('interesting category')
     p.save!
  
-    assert_includes Product.find_by_contents('interesting'), p
+    assert_includes Product.find_by_contents('interesting')[:results], p
   end
  
   should 'have same lat and lng of its enterprise' do
@@ -362,24 +363,24 @@ class ProductTest &lt; Test::Unit::TestCase
   should 'index by schema name when database is postgresql' do
     uses_postgresql 'schema_one'
     p1 = Product.create!(:name => 'some thing', :product_category => @product_category)
-    assert_equal Product.find_by_contents('thing'), [p1]
+    assert_equal Product.find_by_contents('thing')[:results], [p1]
     uses_postgresql 'schema_two'
     p2 = Product.create!(:name => 'another thing', :product_category => @product_category)
-    assert_not_includes Product.find_by_contents('thing'), p1
-    assert_includes Product.find_by_contents('thing'), p2
+    assert_not_includes Product.find_by_contents('thing')[:results], p1
+    assert_includes Product.find_by_contents('thing')[:results], p2
     uses_postgresql 'schema_one'
-    assert_includes Product.find_by_contents('thing'), p1
-    assert_not_includes Product.find_by_contents('thing'), p2
+    assert_includes Product.find_by_contents('thing')[:results], p1
+    assert_not_includes Product.find_by_contents('thing')[:results], p2
     uses_sqlite
   end
  
   should 'not index by schema name when database is not postgresql' do
     uses_sqlite
     p1 = Product.create!(:name => 'some thing', :product_category => @product_category)
-    assert_equal Product.find_by_contents('thing'), [p1]
+    assert_equal Product.find_by_contents('thing')[:results], [p1]
     p2 = Product.create!(:name => 'another thing', :product_category => @product_category)
-    assert_includes Product.find_by_contents('thing'), p1
-    assert_includes Product.find_by_contents('thing'), p2
+    assert_includes Product.find_by_contents('thing')[:results], p1
+    assert_includes Product.find_by_contents('thing')[:results], p2
   end
  
 end
@@ -3,6 +3,10 @@ require File.dirname(__FILE__) + &#39;/../test_helper&#39;
 class ProfileTest < Test::Unit::TestCase
   fixtures :profiles, :environments, :users, :roles, :domains
  
+  def setup
+    Test::Unit::TestCase::setup
+  end
+
   def test_identifier_validation
     p = Profile.new
     p.valid?
@@ -100,8 +104,8 @@ class ProfileTest &lt; Test::Unit::TestCase
   def test_find_by_contents
     p = create(Profile, :name => 'wanted')
  
-    assert Profile.find_by_contents('wanted').include?(p)
-    assert ! Profile.find_by_contents('not_wanted').include?(p)
+    assert Profile.find_by_contents('wanted')[:results].include?(p)
+    assert ! Profile.find_by_contents('not_wanted')[:results].include?(p)
   end
  
   should 'remove pages when removing profile' do
@@ -192,10 +196,10 @@ class ProfileTest &lt; Test::Unit::TestCase
     small = create(Profile, :name => 'A small profile for testing')
     big = create(Profile, :name => 'A big profile for testing')
  
-    assert Profile.find_by_contents('small').include?(small)
-    assert Profile.find_by_contents('big').include?(big)
+    assert Profile.find_by_contents('small')[:results].include?(small)
+    assert Profile.find_by_contents('big')[:results].include?(big)
  
-    both = Profile.find_by_contents('profile testing')
+    both = Profile.find_by_contents('profile testing')[:results]
     assert both.include?(small)
     assert both.include?(big)
   end
@@ -517,18 +521,18 @@ class ProfileTest &lt; Test::Unit::TestCase
   should 'actually index by results of extra_data_for_index' do
     profile = TestingExtraDataForIndex.create!(:name => 'testprofile', :identifier => 'testprofile')
  
-    assert_includes TestingExtraDataForIndex.find_by_contents('sample'), profile
+    assert_includes TestingExtraDataForIndex.find_by_contents('sample')[:results], profile
   end
  
   should 'index profile identifier for searching' do
     Profile.destroy_all
     p = create(Profile, :identifier => 'lalala')
-    assert_includes Profile.find_by_contents('lalala'), p
+    assert_includes Profile.find_by_contents('lalala')[:results], p
   end
  
   should 'index profile name for searching' do
     p = create(Profile, :name => 'Interesting Profile')
-    assert_includes Profile.find_by_contents('interesting'), p
+    assert_includes Profile.find_by_contents('interesting')[:results], p
   end
  
   should 'enabled by default on creation' do
@@ -1665,24 +1669,24 @@ class ProfileTest &lt; Test::Unit::TestCase
   should 'index by schema name when database is postgresql' do
     uses_postgresql 'schema_one'
     p1 = Profile.create!(:name => 'some thing', :identifier => 'some-thing')
-    assert_equal Profile.find_by_contents('thing'), [p1]
+    assert_equal Profile.find_by_contents('thing')[:results], [p1]
     uses_postgresql 'schema_two'
     p2 = Profile.create!(:name => 'another thing', :identifier => 'another-thing')
-    assert_not_includes Profile.find_by_contents('thing'), p1
-    assert_includes Profile.find_by_contents('thing'), p2
+    assert_not_includes Profile.find_by_contents('thing')[:results], p1
+    assert_includes Profile.find_by_contents('thing')[:results], p2
     uses_postgresql 'schema_one'
-    assert_includes Profile.find_by_contents('thing'), p1
-    assert_not_includes Profile.find_by_contents('thing'), p2
+    assert_includes Profile.find_by_contents('thing')[:results], p1
+    assert_not_includes Profile.find_by_contents('thing')[:results], p2
     uses_sqlite
   end
  
   should 'not index by schema name when database is not postgresql' do
     uses_sqlite
     p1 = Profile.create!(:name => 'some thing', :identifier => 'some-thing')
-    assert_equal Profile.find_by_contents('thing'), [p1]
+    assert_equal Profile.find_by_contents('thing')[:results], [p1]
     p2 = Profile.create!(:name => 'another thing', :identifier => 'another-thing')
-    assert_includes Profile.find_by_contents('thing'), p1
-    assert_includes Profile.find_by_contents('thing'), p2
+    assert_includes Profile.find_by_contents('thing')[:results], p1
+    assert_includes Profile.find_by_contents('thing')[:results], p2
   end
  
   should 'know if url is the profile homepage' do
@@ -3,7 +3,8 @@ require File.dirname(__FILE__) + &#39;/../test_helper&#39;
 class TinyMceArticleTest < Test::Unit::TestCase
  
   def setup
-    Article.rebuild_index
+    Test::Unit::TestCase::setup
+    Article.rebuild_solr_index
     @profile = create_user('zezinho').person
   end
   attr_reader :profile
@@ -23,8 +24,8 @@ class TinyMceArticleTest &lt; Test::Unit::TestCase
  
   should 'be found when searching for articles by query' do
     tma = TinyMceArticle.create!(:name => 'test tinymce article', :body => '---', :profile => profile)
-    assert_includes TinyMceArticle.find_by_contents('article'), tma
-    assert_includes Article.find_by_contents('article'), tma
+    assert_includes TinyMceArticle.find_by_contents('article')[:results], tma
+    assert_includes Article.find_by_contents('article')[:results], tma
   end
  
   should 'not sanitize target attribute' do
@@ -1,20 +0,0 @@
-Copyright (c) 2006 Kasper Weibel, Jens Kraemer
-
-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.
@@ -1,53 +0,0 @@
-= acts_as_ferret
-
-This ActiveRecord mixin adds full text search capabilities to any Rails model.
-
-It is heavily based on the original acts_as_ferret plugin done by
-Kasper Weibel and a modified version done by Thomas Lockney, which 
-both can be found on http://ferret.davebalmain.com/trac/wiki/FerretOnRails
-
-== Installation
-
-=== Installation inside your Rails project via script/plugin
-
-script/plugin install svn://projects.jkraemer.net/acts_as_ferret/trunk/plugin/acts_as_ferret
-
-Aaf is is also available via git from Rubyforge:
-git clone git://rubyforge.org/actsasferret.git
-
-=== System-wide installation with Rubygems
-
-<tt>sudo gem install acts_as_ferret</tt>
-
-To use acts_as_ferret in your project, add the following line to your
-project's config/environment.rb:
-
-<tt>require 'acts_as_ferret'</tt>
-
-Call the aaf_install script inside your project directory to install the sample
-config file and the drb server start/stop script.
-
-
-== Usage
-
-include the following in your model class (specifiying the fields you want to get indexed):
-
-<tt>acts_as_ferret :fields => [ :title, :description ]</tt>
-
-now you can use ModelClass.find_by_contents(query) to find instances of your model
-whose indexed fields match a given query. All query terms are required by default, 
-but explicit OR queries are possible. This differs from the ferret default, but 
-imho is the more often needed/expected behaviour (more query terms result in 
-less results).
-
-Please see ActsAsFerret::ActMethods#acts_as_ferret for more information.
-
-== License
-
-Released under the MIT license.
-
-== Authors
-
-* Kasper Weibel Nielsen-Refs (original author)
-* Jens Kraemer <jk@jkraemer.net> (current maintainer)
-
@@ -1,23 +0,0 @@
-# acts_as_ferret gem install script
-# Use inside the root of your Rails project
-require 'fileutils'
-
-@basedir = File.join(File.dirname(__FILE__), '..')
-
-def install(dir, file, executable=false)
-  puts "Installing: #{file}"
-  target = File.join('.', dir, file)
-  if File.exists?(target)
-    puts "#{target} already exists, skipping"
-  else
-    FileUtils.cp File.join(@basedir, dir, file), target
-    FileUtils.chmod 0755, target if executable
-  end
-end
-
-
-install 'script', 'ferret_server', true
-install 'config', 'ferret_server.yml'
-
-puts IO.read(File.join(@basedir, 'README'))
-
@@ -1,24 +0,0 @@
-# configuration for the acts_as_ferret DRb server
-# host: where to reach the DRb server (used by application processes to contact the server)
-# port: which port the server should listen on
-# socket: where the DRb server should create the socket (absolute path), this setting overrides host:port configuration
-# pid_file: location of the server's pid file (relative to RAILS_ROOT)
-# log_file: log file (default: RAILS_ROOT/log/ferret_server.log
-# log_level: log level for the server's logger
-production:
-  host: localhost
-  port: 9010
-  pid_file: log/ferret.pid
-  log_file: log/ferret_server.log
-  log_level: warn
-
-# aaf won't try to use the DRb server in environments that are not 
-# configured here.
-#development:
-#  host: localhost
-#  port: 9010
-#  pid_file: log/ferret.pid
-#test:
-#  host: localhost
-#  port: 9009
-#  pid_file: log/ferret.pid
@@ -1,23 +0,0 @@
-Credits
-=======
-
-The Win32 service support scripts have been written by
-Herryanto Siatono <herryanto@pluitsolutions.com>. 
-
-See his accompanying blog posting at
-http://www.pluitsolutions.com/2007/07/30/acts-as-ferret-drbserver-win32-service/
-
-
-Usage
-=====
-
-There are two scripts:
-
-script/ferret_service is used to install/remove/start/stop the win32 service.
-
-script/ferret_daemon is to be called by Win32 service to start/stop the
-DRbServer.
-
-Run 'ruby script/ferret_service -h' for more info.
-
-
@@ -1,22 +0,0 @@
-# monit configuration snippet to watch the Ferret DRb server shipped with
-# acts_as_ferret
-check process ferret with pidfile /path/to/ferret.pid
-
-    # username is the user the drb server should be running as (It's good practice
-    # to run such services as a non-privileged user)
-    start program = "/bin/su -c 'cd /path/to/your/app/current/ && script/ferret_server -e production start' username"
-    stop program = "/bin/su -c 'cd /path/to/your/app/current/ && script/ferret_server -e production stop' username"
-
-    # cpu usage boundaries
-    if cpu > 60% for 2 cycles then alert
-    if cpu > 90% for 5 cycles then restart
-
-    # memory usage varies with index size and usage scenarios, so check how
-    # much memory your DRb server uses up usually and add some spare to that
-    # before enabling this rule:
-    # if totalmem > 50.0 MB for 5 cycles then restart
-
-    # adjust port numbers according to your setup:
-    if failed port 9010 then alert
-    if failed port 9010 for 2 cycles then restart
-    group ferret
@@ -1,24 +0,0 @@
-# Copyright (c) 2006 Kasper Weibel Nielsen-Refs, Thomas Lockney, Jens Krämer
-#
-# 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.
-
-require 'acts_as_ferret'
-
-config.after_initialize { ActsAsFerret::load_config }
-config.to_prepare       { ActsAsFerret::load_config }
@@ -1,18 +0,0 @@
-# acts_as_ferret install script
-require 'fileutils'
-
-def install(file)
-  puts "Installing: #{file}"
-  target = File.join(File.dirname(__FILE__), '..', '..', '..', file)
-  if File.exists?(target)
-    puts "target #{target} already exists, skipping"
-  else
-    FileUtils.cp File.join(File.dirname(__FILE__), file), target
-  end
-end
-
-install File.join( 'script', 'ferret_server' )
-install File.join( 'config', 'ferret_server.yml' )
-
-puts IO.read(File.join(File.dirname(__FILE__), 'README'))
-
@@ -1,155 +0,0 @@
-module ActsAsFerret #:nodoc:
-
-  # This module defines the acts_as_ferret method and is included into 
-  # ActiveRecord::Base
-  module ActMethods
-          
-    
-    def reloadable?; false end
-    
-    # declares a class as ferret-searchable. 
-    #
-    # ====options:
-    # fields:: names all fields to include in the index. If not given,
-    #          all attributes of the class will be indexed. You may also give
-    #          symbols pointing to instance methods of your model here, i.e. 
-    #          to retrieve and index data from a related model. 
-    #
-    # additional_fields:: names fields to include in the index, in addition 
-    #                     to those derived from the db scheme. use if you want 
-    #                     to add custom fields derived from methods to the db 
-    #                     fields (which will be picked by aaf). This option will 
-    #                     be ignored when the fields option is given, in that 
-    #                     case additional fields get specified there.
-    #
-    # if:: Can be set to a block that will be called with the record in question
-    #      to determine if it should be indexed or not.
-    #
-    # index_dir:: declares the directory where to put the index for this class.
-    #             The default is RAILS_ROOT/index/RAILS_ENV/CLASSNAME. 
-    #             The index directory will be created if it doesn't exist.
-    #
-    # reindex_batch_size:: reindexing is done in batches of this size, default is 1000
-    # mysql_fast_batches:: set this to false to disable the faster mysql batching
-    #                      algorithm if this model uses a non-integer primary key named
-    #                      'id' on MySQL.
-    #
-    # ferret:: Hash of Options that directly influence the way the Ferret engine works. You 
-    #          can use most of the options the Ferret::I class accepts here, too. Among the 
-    #          more useful are:
-    #
-    #     or_default:: whether query terms are required by
-    #                  default (the default, false), or not (true)
-    # 
-    #     analyzer:: the analyzer to use for query parsing (default: nil,
-    #                which means the ferret StandardAnalyzer gets used)
-    #
-    #     default_field:: use to set one or more fields that are searched for query terms
-    #                     that don't have an explicit field list. This list should *not*
-    #                     contain any untokenized fields. If it does, you're asking
-    #                     for trouble (i.e. not getting results for queries having
-    #                     stop words in them). Aaf by default initializes the default field 
-    #                     list to contain all tokenized fields. If you use :single_index => true, 
-    #                     you really should set this option specifying your default field
-    #                     list (which should be equal in all your classes sharing the index).
-    #                     Otherwise you might get incorrect search results and you won't get 
-    #                     any lazy loading of stored field data.
-    #
-    # For downwards compatibility reasons you can also specify the Ferret options in the 
-    # last Hash argument.
-    def acts_as_ferret(options={})
-
-      extend ClassMethods
-
-      include InstanceMethods
-      include MoreLikeThis::InstanceMethods
-
-      if options[:rdig]
-        cattr_accessor :rdig_configuration
-        self.rdig_configuration = options[:rdig]
-        require 'rdig_adapter'
-        include ActsAsFerret::RdigAdapter
-      end
-
-      unless included_modules.include?(ActsAsFerret::WithoutAR)
-        # set up AR hooks
-        after_create  :ferret_create
-        after_update  :ferret_update
-        after_destroy :ferret_destroy      
-      end
-
-      cattr_accessor :aaf_configuration
-
-      # apply default config for rdig based models
-      if options[:rdig]
-        options[:fields] ||= { :title   => { :boost => 3, :store => :yes },
-                               :content => { :store => :yes } }
-      end
-
-      # name of this index
-      index_name = options.delete(:index) || self.name.underscore
-
-      index = ActsAsFerret::register_class_with_index(self, index_name, options)
-      self.aaf_configuration = index.index_definition.dup
-      logger.debug "configured index for class #{self.name}:\n#{aaf_configuration.inspect}"
-
-      # update our copy of the global index config with options local to this class
-      aaf_configuration[:class_name] ||= self.name
-      aaf_configuration[:if] ||= options[:if]
-
-      # add methods for retrieving field values
-      add_fields options[:fields]
-      add_fields options[:additional_fields]
-      add_fields aaf_configuration[:fields]
-      add_fields aaf_configuration[:additional_fields]
-
-      # not good at class level, index might get initialized too early
-      #if options[:remote]
-      #  aaf_index.ensure_index_exists
-      #end
-    end
-
-
-    protected
-    
-
-    # helper to defines a method which adds the given field to a ferret 
-    # document instance
-    def define_to_field_method(field, options = {})
-      method_name = "#{field}_to_ferret"
-      return if instance_methods.include?(method_name) # already defined
-      aaf_configuration[:defined_fields] ||= {}
-      aaf_configuration[:defined_fields][field] = options
-      dynamic_boost = options[:boost] if options[:boost].is_a?(Symbol)
-      via = options[:via] || field
-      define_method(method_name.to_sym) do
-        val = begin
-          content_for_field_name(field, via, dynamic_boost)
-        rescue
-          logger.warn("Error retrieving value for field #{field}: #{$!}")
-          ''
-        end
-        logger.debug("Adding field #{field} with value '#{val}' to index")
-        val
-      end
-    end
-
-    def add_fields(field_config)
-      # TODO
-        #field_config.each do |*args| 
-        #  define_to_field_method *args
-        #end                
-      if field_config.is_a? Hash
-        field_config.each_pair do |field, options|
-          define_to_field_method field, options
-        end
-      elsif field_config.respond_to?(:each)
-        field_config.each do |field| 
-          define_to_field_method field
-        end                
-      end
-    end
-
-  end
-
-end
@@ -1,567 +0,0 @@
-# Copyright (c) 2006 Kasper Weibel Nielsen-Refs, Thomas Lockney, Jens Krämer
-#
-# 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.
-
-require 'active_support'
-require 'active_record'
-require 'set'
-require 'enumerator'
-require 'ferret'
-
-require 'ferret_find_methods'
-require 'remote_functions'
-require 'blank_slate'
-require 'bulk_indexer'
-require 'ferret_extensions'
-require 'act_methods'
-require 'search_results'
-require 'class_methods'
-require 'ferret_result'
-require 'instance_methods'
-require 'without_ar'
-
-require 'multi_index'
-require 'remote_multi_index'
-require 'more_like_this'
-
-require 'index'
-require 'local_index'
-require 'remote_index'
-
-require 'ferret_server'
-
-require 'rdig_adapter'
-
-# The Rails ActiveRecord Ferret Mixin.
-#
-# This mixin adds full text search capabilities to any Rails model.
-#
-# The current version emerged from on the original acts_as_ferret plugin done by
-# Kasper Weibel and a modified version done by Thomas Lockney, which  both can be 
-# found on the Ferret Wiki: http://ferret.davebalmain.com/trac/wiki/FerretOnRails.
-#
-# basic usage:
-# include the following in your model class (specifiying the fields you want to get indexed):
-# acts_as_ferret :fields => [ :title, :description ]
-#
-# now you can use ModelClass.find_by_contents(query) to find instances of your model
-# whose indexed fields match a given query. All query terms are required by default, but 
-# explicit OR queries are possible. This differs from the ferret default, but imho is the more
-# often needed/expected behaviour (more query terms result in less results).
-#
-# Released under the MIT license.
-#
-# Authors: 
-# Kasper Weibel Nielsen-Refs (original author)
-# Jens Kraemer <jk@jkraemer.net> (active maintainer since 2006)
-#
-#
-# == Global properties
-#
-# raise_drb_errors:: Set this to true if you want aaf to raise Exceptions
-#                    in case the DRb server cannot be reached (in other word - behave like
-#                    versions up to 0.4.3). Defaults to false so DRb exceptions
-#                    are logged but not raised. Be sure to set up some
-#                    monitoring so you still detect when your DRb server died for
-#                    whatever reason.
-#
-# remote:: Set this to false to force acts_as_ferret into local (non-DRb) mode even if
-#          config/ferret_server.yml contains a section for the current RAILS_ENV
-#          Usually you won't need to touch this option - just configure DRb for
-#          production mode in ferret_server.yml.
-#
-module ActsAsFerret
-
-  class ActsAsFerretError < StandardError; end
-  class IndexNotDefined < ActsAsFerretError; end
-  class IndexAlreadyDefined < ActsAsFerretError; end
-
-  # global Hash containing all multi indexes created by all classes using the plugin
-  # key is the concatenation of alphabetically sorted names of the classes the
-  # searcher searches.
-  @@multi_indexes = Hash.new
-  def self.multi_indexes; @@multi_indexes end
-
-  # global Hash containing the ferret indexes of all classes using the plugin
-  # key is the index name.
-  @@ferret_indexes = Hash.new
-  def self.ferret_indexes; @@ferret_indexes end
-
-  # mapping from class name to index name
-  @@index_using_classes = {}
-
-  @@logger = Logger.new "#{RAILS_ROOT}/log/acts_as_ferret.log"
-  @@logger.level = ActiveRecord::Base.logger.level rescue Logger::DEBUG
-  mattr_accessor :logger
-
-    
-  # Default ferret configuration for index fields
-  DEFAULT_FIELD_OPTIONS = {
-    :store       => :no, 
-    :highlight   => :yes, 
-    :index       => :yes, 
-    :term_vector => :with_positions_offsets,
-    :boost       => 1.0
-  }
-
-  @@raise_drb_errors = false
-  mattr_writer :raise_drb_errors
-  def self.raise_drb_errors?; @@raise_drb_errors end
-  
-  @@remote = nil
-  mattr_accessor :remote
-  def self.remote?
-    if @@remote.nil?
-      if ENV["FERRET_USE_LOCAL_INDEX"] || ActsAsFerret::Remote::Server.running
-        @@remote = false
-      else
-        @@remote = ActsAsFerret::Remote::Config.new.uri rescue false
-      end
-      if @@remote
-        logger.info "Will use remote index server which should be available at #{@@remote}"
-      else
-        logger.info "Will use local index."
-      end
-    end
-    @@remote
-  end
-  remote?
-
-
-  # Globally declares an index.
-  #
-  # This method is also used to implicitly declare an index when you use the
-  # acts_as_ferret call in your class. Returns the created index instance.
-  #
-  # === Options are:
-  #
-  # +models+:: Hash of model classes and their per-class option hashes which should
-  #            use this index. Any models mentioned here will automatically use
-  #            the index, there is no need to explicitly call +acts_as_ferret+ in the
-  #            model class definition.
-  def self.define_index(name, options = {})
-    name = name.to_sym
-    pending_classes = nil
-    if ferret_indexes.has_key?(name)
-      # seems models have been already loaded. remove that index for now,
-      # re-register any already loaded classes later on.
-      idx = get_index(name)
-      pending_classes = idx.index_definition[:registered_models]
-      pending_classes_configs = idx.registered_models_config
-      idx.close
-      ferret_indexes.delete(name)
-    end
-
-    index_definition = {
-      :index_dir => "#{ActsAsFerret::index_dir}/#{name}",
-      :name => name,
-      :single_index => false,
-      :reindex_batch_size => 1000,
-      :ferret => {},
-      :ferret_fields => {},             # list of indexed fields that will be filled later
-      :enabled => true,                 # used for class-wide disabling of Ferret
-      :mysql_fast_batches => true,      # turn off to disable the faster, id based batching mechanism for MySQL
-      :raise_drb_errors => false        # handle DRb connection errors by default
-    }.update( options )
-
-    index_definition[:registered_models] = []
-    
-    # build ferret configuration
-    index_definition[:ferret] = {
-      :or_default          => false, 
-      :handle_parse_errors => true,
-      :default_field       => nil,              # will be set later on
-      #:max_clauses => 512,
-      #:analyzer => Ferret::Analysis::StandardAnalyzer.new,
-      # :wild_card_downcase => true
-    }.update( options[:ferret] || {} )
-
-    index_definition[:user_default_field] = index_definition[:ferret][:default_field]
-
-    unless remote?
-      ActsAsFerret::ensure_directory index_definition[:index_dir] 
-      index_definition[:index_base_dir] = index_definition[:index_dir]
-      index_definition[:index_dir] = find_last_index_version(index_definition[:index_dir])
-      logger.debug "using index in #{index_definition[:index_dir]}"
-    end
-    
-    # these properties are somewhat vital to the plugin and shouldn't
-    # be overwritten by the user:
-    index_definition[:ferret].update(
-      :key               => ((Noosfero::MultiTenancy.on? and ActiveRecord::Base.postgresql?) ? [:id, :class_name, :schema_name] : [:id, :class_name]),
-      :path              => index_definition[:index_dir],
-      :auto_flush        => true, # slower but more secure in terms of locking problems TODO disable when running in drb mode?
-      :create_if_missing => true
-    )
-
-    # field config
-    index_definition[:ferret_fields] = build_field_config( options[:fields] )
-    index_definition[:ferret_fields].update build_field_config( options[:additional_fields] )
-
-    idx = ferret_indexes[name] = create_index_instance( index_definition )
-
-    # re-register early loaded classes
-    if pending_classes
-      pending_classes.each { |clazz| idx.register_class clazz, { :force_re_registration => true }.merge(pending_classes_configs[clazz]) }
-    end
-
-    if models = options[:models]
-      models.each do |clazz, config|
-        clazz.send :include, ActsAsFerret::WithoutAR unless clazz.respond_to?(:acts_as_ferret)
-        clazz.acts_as_ferret config.merge(:index => name)
-      end
-    end
-
-    return idx
-  end
- 
-  # called internally by the acts_as_ferret method
-  #
-  # returns the index
-  def self.register_class_with_index(clazz, index_name, options = {})
-    index_name = index_name.to_sym
-    @@index_using_classes[clazz.name] = index_name
-    unless index = ferret_indexes[index_name]
-      # index definition on the fly
-      # default to all attributes of this class
-      options[:fields] ||= clazz.new.attributes.keys.map { |k| k.to_sym }
-      index = define_index index_name, options
-    end
-    index.register_class(clazz, options)
-    return index
-  end
-
-  def self.load_config
-    # using require_dependency to make the reloading in dev mode work.
-    require_dependency "#{RAILS_ROOT}/config/aaf.rb"
-    ActsAsFerret::logger.info "loaded configuration file aaf.rb"
-  rescue LoadError
-  ensure
-    @aaf_config_loaded = true
-  end
-
-  # returns the index with the given name.
-  def self.get_index(name)
-    name = name.to_sym rescue nil
-    unless ferret_indexes.has_key?(name)
-      if @aaf_config_loaded
-        raise IndexNotDefined.new(name.to_s)
-      else
-        load_config and return get_index name
-      end
-    end
-    ferret_indexes[name]
-  end
-
-  # count hits for a query with multiple models
-  def self.total_hits(query, models, options = {})
-    find_index(models).total_hits query, options.merge( :models => models )
-  end
-
-  # find ids of records with multiple models
-  # TODO pagination logic?
-  def self.find_ids(query, models, options = {}, &block)
-    find_index(models).find_ids query, options.merge( :models => models ), &block
-  end
-
-  def self.find_index(models_or_index_name)
-    case models_or_index_name
-    when Symbol
-      get_index models_or_index_name
-    when String
-      get_index models_or_index_name.to_sym
-    #when Array
-    #  get_index_for models_or_index_name
-    else
-      get_index_for models_or_index_name
-    end
-  end
-
-  def self.find(query, models_or_index_name, options = {}, ar_options = {})
-    # TODO generalize local/remote index so we can remove the workaround below
-    # (replace logic in class_methods#find_with_ferret)
-    # maybe put pagination stuff in a module to be included by all index
-    # implementations
-    models = [ models_or_index_name ] if Class === models_or_index_name
-    if models && models.size == 1
-      return models.shift.find_with_ferret query, options, ar_options
-    end
-    index = find_index(models_or_index_name)
-    multi = (MultiIndex === index or index.shared?)
-    if options[:per_page]
-      options[:page] = options[:page] ? options[:page].to_i : 1
-      limit = options[:per_page]
-      offset = (options[:page] - 1) * limit
-      if ar_options[:conditions] && !multi
-        ar_options[:limit] = limit
-        ar_options[:offset] = offset
-        options[:limit] = :all
-        options.delete :offset
-      else
-        # do pagination with ferret (or after everything is done in the case
-        # of multi_search)
-        options[:limit] = limit
-        options[:offset] = offset
-      end
-    elsif ar_options[:conditions]
-      if multi
-        # multisearch ignores find_options limit and offset
-        options[:limit] ||= ar_options.delete(:limit)
-        options[:offset] ||= ar_options.delete(:offset)
-      else
-        # let the db do the limiting and offsetting for single-table searches
-        unless options[:limit] == :all
-          ar_options[:limit] ||= options.delete(:limit)
-        end
-        ar_options[:offset] ||= options.delete(:offset)
-        options[:limit] = :all
-      end
-    end
-
-    total_hits, result = index.find_records query, options.merge(:models => models), ar_options
-    logger.debug "Query: #{query}\ntotal hits: #{total_hits}, results delivered: #{result.size}"
-    SearchResults.new(result, total_hits, options[:page], options[:per_page])
-  end
-
-  # returns the index used by the given class.
-  #
-  # If multiple classes are given, either the single index shared by these
-  # classes, or a multi index (to be used for search only) across the indexes
-  # of all models, is returned.
-  def self.get_index_for(*classes)
-    classes.flatten!
-    raise ArgumentError.new("no class specified") unless classes.any?
-    classes.map!(&:constantize) unless Class === classes.first
-    logger.debug "index_for #{classes.inspect}"
-    index = if classes.size > 1
-      indexes = classes.map { |c| get_index_for c }.uniq
-      indexes.size > 1 ? multi_index(indexes) : indexes.first
-    else
-      clazz = classes.first
-      clazz = clazz.superclass while clazz && !@@index_using_classes.has_key?(clazz.name)
-      get_index @@index_using_classes[clazz.name]
-    end
-    raise IndexNotDefined.new("no index found for class: #{classes.map(&:name).join(',')}") if index.nil?
-    return index
-  end
-
-
-  # creates a new Index instance.
-  def self.create_index_instance(definition)
-    (remote? ? RemoteIndex : LocalIndex).new(definition)
-  end
-
-  def self.rebuild_index(name)
-    get_index(name).rebuild_index
-  end
-
-  def self.change_index_dir(name, new_dir)
-    get_index(name).change_index_dir new_dir
-  end
-
-  # find the most recent version of an index
-  def self.find_last_index_version(basedir)
-    # check for versioned index
-    versions = Dir.entries(basedir).select do |f| 
-      dir = File.join(basedir, f)
-      File.directory?(dir) && File.file?(File.join(dir, 'segments')) && f =~ /^\d+(_\d+)?$/
-    end
-    if versions.any?
-      # select latest version
-      versions.sort!
-      File.join basedir, versions.last
-    else
-      basedir
-    end
-  end
-
-  # returns a MultiIndex instance operating on a MultiReader
-  def self.multi_index(indexes)
-    index_names = indexes.dup
-    index_names = index_names.map(&:to_s) if Symbol === index_names.first
-    if String === index_names.first
-      indexes = index_names.map{ |name| get_index name }
-    else
-      index_names = index_names.map{ |i| i.index_name.to_s }
-    end
-    key = index_names.sort.join(",")
-    ActsAsFerret::multi_indexes[key] ||= (remote? ? ActsAsFerret::RemoteMultiIndex : ActsAsFerret::MultiIndex).new(indexes)
-  end
-
-  # check for per-model conditions and return these if provided
-  def self.conditions_for_model(model, conditions = {})
-    if Hash === conditions
-      key = model.name.underscore.to_sym
-      conditions = conditions[key]
-    end
-    return conditions
-  end
-
-  # retrieves search result records from a data structure like this:
-  # { 'Model1' => { '1' => [ rank, score ], '2' => [ rank, score ] }
-  #
-  # TODO: in case of STI AR will filter out hits from other 
-  # classes for us, but this
-  # will lead to less results retrieved --> scoping of ferret query
-  # to self.class is still needed.
-  # from the ferret ML (thanks Curtis Hatter)
-  # > I created a method in my base STI class so I can scope my query. For scoping
-  # > I used something like the following line:
-  # > 
-  # > query << " role:#{self.class.eql?(Contents) '*' : self.class}"
-  # > 
-  # > Though you could make it more generic by simply asking
-  # > "self.descends_from_active_record?" which is how rails decides if it should
-  # > scope your "find" query for STI models. You can check out "base.rb" in
-  # > activerecord to see that.
-  # but maybe better do the scoping in find_ids_with_ferret...
-  def self.retrieve_records(id_arrays, find_options = {})
-    result = []
-    # get objects for each model
-    id_arrays.each do |model, id_array|
-      next if id_array.empty?
-      model_class = model.constantize
-
-      # merge conditions
-      conditions = conditions_for_model model_class, find_options[:conditions]
-      conditions = combine_conditions([ "#{model_class.table_name}.#{model_class.primary_key} in (?)", 
-                                        id_array.keys ], 
-                                      conditions)
-
-      # check for include association that might only exist on some models in case of multi_search
-      filtered_include_options = []
-      if include_options = find_options[:include]
-        include_options = [ include_options ] unless include_options.respond_to?(:each)
-        include_options.each do |include_option|
-          filtered_include_options << include_option if model_class.reflections.has_key?(include_option.is_a?(Hash) ? include_option.keys[0].to_sym : include_option.to_sym)
-        end
-      end
-      filtered_include_options = nil if filtered_include_options.empty?
-
-      # fetch
-      tmp_result = model_class.find(:all, find_options.merge(:conditions => conditions, 
-                                                             :include    => filtered_include_options))
-
-      # set scores and rank
-      tmp_result.each do |record|
-        record.ferret_rank, record.ferret_score = id_array[record.id.to_s]
-      end
-      # merge with result array
-      result += tmp_result
-    end
-    
-    # order results as they were found by ferret, unless an AR :order
-    # option was given
-    result.sort! { |a, b| a.ferret_rank <=> b.ferret_rank } unless find_options[:order]
-    return result
-  end
-  
-  # combine our conditions with those given by user, if any
-  def self.combine_conditions(conditions, additional_conditions = [])
-    returning conditions do
-      if additional_conditions && additional_conditions.any?
-        cust_opts = (Array === additional_conditions) ? additional_conditions.dup : [ additional_conditions ]
-        logger.debug "cust_opts: #{cust_opts.inspect}"
-        conditions.first << " and " << cust_opts.shift
-        conditions.concat(cust_opts)
-      end
-    end
-  end
-
-  def self.build_field_config(fields)
-    field_config = {}
-    case fields
-    when Array
-      fields.each { |name| field_config[name] = field_config_for name }
-    when Hash
-      fields.each { |name, options| field_config[name] = field_config_for name, options }
-    else raise InvalidArgumentError.new(":fields option must be Hash or Array")
-    end if fields
-    return field_config
-  end
-
-  def self.ensure_directory(dir)
-    FileUtils.mkdir_p dir unless (File.directory?(dir) || File.symlink?(dir))
-  end
-
-  
-  # make sure the default index base dir exists. by default, all indexes are created
-  # under RAILS_ROOT/index/RAILS_ENV
-  def self.init_index_basedir
-    index_base = "#{RAILS_ROOT}/index"
-    @@index_dir = "#{index_base}/#{RAILS_ENV}"
-  end
-  
-  mattr_accessor :index_dir
-  init_index_basedir
-  
-  def self.append_features(base)
-    super
-    base.extend(ClassMethods)
-  end
-  
-  # builds a FieldInfos instance for creation of an index
-  def self.field_infos(index_definition)
-    # default attributes for fields
-    fi = Ferret::Index::FieldInfos.new(:store => :no, 
-                                        :index => :yes, 
-                                        :term_vector => :no,
-                                        :boost => 1.0)
-    # primary key
-    fi.add_field(:id, :store => :yes, :index => :untokenized) 
-    # class_name
-    fi.add_field(:class_name, :store => :yes, :index => :untokenized)
-
-    # other fields
-    index_definition[:ferret_fields].each_pair do |field, options|
-      options = options.dup
-      options.delete :via
-      options.delete :boost if options[:boost].is_a?(Symbol) # dynamic boost
-      fi.add_field(field, options)
-    end
-    return fi
-  end
-
-  def self.close_multi_indexes
-    # close combined index readers, just in case
-    # this seems to fix a strange test failure that seems to relate to a
-    # multi_index looking at an old version of the content_base index.
-    multi_indexes.each_pair do |key, index|
-      # puts "#{key} -- #{self.name}"
-      # TODO only close those where necessary (watch inheritance, where
-      # self.name is base class of a class where key is made from)
-      index.close #if key =~ /#{self.name}/
-    end
-    multi_indexes.clear
-  end
-
-  protected
-
-  def self.field_config_for(fieldname, options = {})
-    config = DEFAULT_FIELD_OPTIONS.merge options
-    config[:via] ||= fieldname
-    config[:term_vector] = :no if config[:index] == :no
-    return config
-  end
-
-end
-
-# include acts_as_ferret method into ActiveRecord::Base
-ActiveRecord::Base.extend ActsAsFerret::ActMethods
-
@@ -1,41 +0,0 @@
-# Source: http://pastie.caboo.se/154842
-#
-# in /etc/my.cnf on the MySQL server, you can set the interactive-timeout parameter,
-# for example, 12 hours = 28800 sec
-# interactive-timeout=28800
-
-# in ActiveRecord, setting the verification_timeout to something less than
-# the interactive-timeout parameter; 14400 sec = 6 hours
-ActiveRecord::Base.verification_timeout = 14400
-ActiveRecord::Base.establish_connection
-
-# Below is a monkey patch for keeping ActiveRecord connections alive.
-# http://www.sparecycles.org/2007/7/2/saying-goodbye-to-lost-connections-in-rails
-
-module ActiveRecord
-  module ConnectionAdapters
-    class MysqlAdapter
-      def execute(sql, name = nil) #:nodoc:
-        reconnect_lost_connections = true
-        begin
-          log(sql, name) { @connection.query(sql) }
-        rescue ActiveRecord::StatementInvalid => exception
-          if reconnect_lost_connections and exception.message =~ /(Lost connection to MySQL server during query
-|MySQL server has gone away)/
-            reconnect_lost_connections = false
-            reconnect!
-            retry
-          elsif exception.message.split(":").first =~ /Packets out of order/
-            raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database.
- Please update your mysql bindings (gem install mysql) and read http://dev.mysql.com/doc/mysql/en/password-hash
-ing.html for more information.  If you're on Windows, use the Instant Rails installer to get the updated mysql 
-bindings." 
-          else
-            raise
-          end
-        end
-      end
-    end
-  end
-end
-
@@ -1,53 +0,0 @@
-if defined?(BlankSlate)
-  # Rails 2.x has it already
-  module ActsAsFerret
-    class BlankSlate < ::BlankSlate
-    end
-  end
-else
-  module ActsAsFerret
-    # 'backported' for Rails pre 2.0
-    #
-    #--
-    # Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
-    # All rights reserved.
-
-    # Permission is granted for use, copying, modification, distribution,
-    # and distribution of modified versions of this work as long as the
-    # above copyright notice is included.
-    #++
-
-    ######################################################################
-    # BlankSlate provides an abstract base class with no predefined
-    # methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
-    # BlankSlate is useful as a base class when writing classes that
-    # depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
-    #
-    class BlankSlate
-      class << self
-        # Hide the method named +name+ in the BlankSlate class.  Don't
-        # hide +instance_eval+ or any method beginning with "__".
-        def hide(name)
-          if instance_methods.include?(name.to_s) and name !~ /^(__|instance_eval|methods)/
-            @hidden_methods ||= {}
-            @hidden_methods[name.to_sym] = instance_method(name)
-            undef_method name
-          end
-        end
-
-        # Redefine a previously hidden method so that it may be called on a blank
-        # slate object.
-        #
-        # no-op here since we don't hide the methods we reveal where this is
-        # used in this implementation
-        def reveal(name)
-        end
-      end
-
-      instance_methods.each { |m| hide(m) }
-
-    end
-  end
-
-end
-
@@ -1,35 +0,0 @@
-module ActsAsFerret
-  class BulkIndexer
-    def initialize(args = {})
-      @batch_size = args[:batch_size] || 1000
-      @logger = args[:logger]
-      @model = args[:model]
-      @work_done = 0
-      @index = args[:index]
-      if args[:reindex]
-        @reindex = true
-        @model_count  = @model.count.to_f
-      else
-        @model_count = args[:total]
-      end
-    end
-
-    def index_records(records, offset)
-      batch_time = measure_time {
-        records.each { |rec| @index.add_document(rec.to_doc, rec.ferret_analyzer) if rec.ferret_enabled?(true) }
-      }.to_f
-      @work_done = offset.to_f / @model_count * 100.0 if @model_count > 0
-      remaining_time = ( batch_time / @batch_size ) * ( @model_count - offset + @batch_size )
-      @logger.info "#{@reindex ? 're' : 'bulk '}index model #{@model.name} : #{'%.2f' % @work_done}% complete : #{'%.2f' % remaining_time} secs to finish"
-
-    end
-
-    def measure_time
-      t1 = Time.now
-      yield
-      Time.now - t1
-    end
-
-  end
-
-end
@@ -1,295 +0,0 @@
-module ActsAsFerret
-        
-  module ClassMethods
-
-    # Disables ferret index updates for this model. When a block is given,
-    # Ferret will be re-enabled again after executing the block.
-    def disable_ferret
-      aaf_configuration[:enabled] = false
-      if block_given?
-        yield
-        enable_ferret
-      end
-    end
-
-    def enable_ferret
-      aaf_configuration[:enabled] = true
-    end
-
-    def ferret_enabled?
-      aaf_configuration[:enabled]
-    end
-
-    # rebuild the index from all data stored for this model, and any other
-    # model classes associated with the same index.
-    # This is called automatically when no index exists yet.
-    #
-    def rebuild_index
-      aaf_index.rebuild_index
-    end
-
-    # re-index a number records specified by the given ids. Use for large
-    # indexing jobs i.e. after modifying a lot of records with Ferret disabled.
-    # Please note that the state of Ferret (enabled or disabled at class or
-    # record level) is not checked by this method, so if you need to do so
-    # (e.g. because of a custom ferret_enabled? implementation), you have to do
-    # so yourself.
-    def bulk_index(*ids)
-      options = Hash === ids.last ? ids.pop : {}
-      ids = ids.first if ids.size == 1 && ids.first.is_a?(Enumerable)
-      aaf_index.bulk_index(self.name, ids, options)
-    end
-
-    # true if our db and table appear to be suitable for the mysql fast batch
-    # hack (see
-    # http://weblog.jamisbuck.org/2007/4/6/faking-cursors-in-activerecord)
-    def use_fast_batches?
-      if connection.class.name =~ /Mysql/ && primary_key == 'id' && aaf_configuration[:mysql_fast_batches]
-        logger.info "using mysql specific batched find :all. Turn off with  :mysql_fast_batches => false if you encounter problems (i.e. because of non-integer UUIDs in the id column)"
-        true
-      end
-    end
-
-    # Returns all records modified or created after the specified time.
-    # Used by the rake rebuild task to find models that need to be updated in
-    # the index after the rebuild finished because they changed while the
-    # rebuild was running.
-    # Override if your models don't stick to the created_at/updated_at
-    # convention.
-    def records_modified_since(time)
-      condition = []
-      %w(updated_at created_at).each do |col|
-        condition << "#{col} >= ?" if column_names.include? col
-      end
-      if condition.empty?
-        logger.warn "#{self.name}: Override records_modified_since(time) to keep the index up to date with records changed during rebuild."
-        []
-      else
-        find :all, :conditions => [ condition.join(' AND '), *([time]*condition.size) ]
-      end
-    end
-
-    # runs across all records yielding those to be indexed when the index is rebuilt
-    def records_for_rebuild(batch_size = 1000)
-      transaction do
-        if use_fast_batches?
-          offset = 0
-          while (rows = find :all, :conditions => [ "#{table_name}.id > ?", offset ], :limit => batch_size).any?
-            offset = rows.last.id
-            yield rows, offset
-          end
-        else
-          order = "#{primary_key} ASC" # fixes #212
-          0.step(self.count, batch_size) do |offset|
-            yield find( :all, :limit => batch_size, :offset => offset, :order => order ), offset
-          end
-        end
-      end
-    end
-
-    # yields the records with the given ids, in batches of batch_size
-    def records_for_bulk_index(ids, batch_size = 1000)
-      transaction do
-        offset = 0
-        ids.each_slice(batch_size) do |id_slice|
-          records = find( :all, :conditions => ["id in (?)", id_slice] )
-          #yield records, offset
-          yield find( :all, :conditions => ["id in (?)", id_slice] ), offset
-          offset += batch_size
-        end
-      end
-    end
-
-    # Retrieve the index instance for this model class. This can either be a
-    # LocalIndex, or a RemoteIndex instance.
-    # 
-    def aaf_index
-      @index ||= ActsAsFerret::get_index(aaf_configuration[:name])
-    end 
-    
-    # Finds instances by searching the Ferret index. Terms are ANDed by default, use 
-    # OR between terms for ORed queries. Or specify +:or_default => true+ in the
-    # +:ferret+ options hash of acts_as_ferret.
-    #
-    # You may either use the +offset+ and +limit+ options to implement your own
-    # pagination logic, or use the +page+ and +per_page+ options to use the
-    # built in pagination support which is compatible with will_paginate's view
-    # helpers. If +page+ and +per_page+ are given, +offset+ and +limit+ will be
-    # ignored.
-    #
-    # == options:
-    # page::        page of search results to retrieve
-    # per_page::    number of search results that are displayed per page
-    # offset::      first hit to retrieve (useful for paging)
-    # limit::       number of hits to retrieve, or :all to retrieve
-    #               all results
-    # lazy::        Array of field names whose contents should be read directly
-    #               from the index. Those fields have to be marked 
-    #               +:store => :yes+ in their field options. Give true to get all
-    #               stored fields. Note that if you have a shared index, you have 
-    #               to explicitly state the fields you want to fetch, true won't
-    #               work here)
-    #
-    # +find_options+ is a hash passed on to active_record's find when
-    # retrieving the data from db, useful to i.e. prefetch relationships with
-    # :include or to specify additional filter criteria with :conditions.
-    #
-    # This method returns a +SearchResults+ instance, which really is an Array that has 
-    # been decorated with a total_hits attribute holding the total number of hits.
-    # Additionally, SearchResults is compatible with the pagination helper
-    # methods of the will_paginate plugin.
-    #
-    # Please keep in mind that the number of results delivered might be less than 
-    # +limit+ if you specify any active record conditions that further limit 
-    # the result. Use +limit+ and +offset+ as AR find_options instead.
-    # +page+ and +per_page+ are supposed to work regardless of any 
-    # +conitions+ present in +find_options+.
-    def find_with_ferret(q, options = {}, find_options = {})
-      aaf_index.register_class(self, {})
-
-      if respond_to?(:scope) && scope(:find, :conditions)
-        if find_options[:conditions]
-          find_options[:conditions] = "(#{find_options[:conditions]}) AND (#{scope(:find, :conditions)})"
-        else
-          find_options[:conditions] = scope(:find, :conditions)
-        end
-      end
-
-      if options[:per_page]
-        options[:page] = options[:page] ? options[:page].to_i : 1
-        limit = options[:per_page]
-        offset = (options[:page] - 1) * limit
-        if find_options[:conditions]
-          find_options[:limit] = limit
-          find_options[:offset] = offset
-          options[:limit] = :all
-          options.delete :offset
-        else
-          # do pagination with ferret
-          options[:limit] = limit
-          options[:offset] = offset
-        end
-      elsif find_options[:conditions]
-        find_options[:limit] ||= options.delete(:limit) unless options[:limit] == :all
-        find_options[:offset] ||= options.delete(:offset)
-        options[:limit] = :all
-      end
-
-      total_hits, result = aaf_index.find_records q, options.merge(:models => [self]), find_options
-      logger.debug "Query: #{q}\ntotal hits: #{total_hits}, results delivered: #{result.size}"
-      SearchResults.new(result, total_hits, options[:page], options[:per_page])
-    end 
-
-
-    # Returns the total number of hits for the given query 
-    #
-    # Note that since we don't query the database here, this method won't deliver 
-    # the expected results when used on an AR association.
-    #
-    def total_hits(q, options={})
-      aaf_index.total_hits(q, options)
-    end
-
-    # Finds instance model name, ids and scores by contents. 
-    # Useful e.g. if you want to search across models or do not want to fetch
-    # all result records (yet).
-    #
-    # Options are the same as for find_by_contents
-    #
-    # A block can be given too, it will be executed with every result:
-    # find_ids_with_ferret(q, options) do |model, id, score|
-    #    id_array << id
-    #    scores_by_id[id] = score 
-    # end
-    # NOTE: in case a block is given, only the total_hits value will be returned
-    # instead of the [total_hits, results] array!
-    # 
-    def find_ids_with_ferret(q, options = {}, &block)
-      aaf_index.find_ids(q, options, &block)
-    end
-
-    
-    protected
-
-#    def find_records_lazy_or_not(q, options = {}, find_options = {})
-#      if options[:lazy]
-#        logger.warn "find_options #{find_options} are ignored because :lazy => true" unless find_options.empty?
-#        lazy_find_by_contents q, options
-#      else
-#        ar_find_by_contents q, options, find_options
-#      end
-#    end
-#
-#    def ar_find_by_contents(q, options = {}, find_options = {})
-#      result_ids = {}
-#      total_hits = find_ids_with_ferret(q, options) do |model, id, score, data|
-#        # stores ids, index and score of each hit for later ordering of
-#        # results
-#        result_ids[id] = [ result_ids.size + 1, score ]
-#      end
-#
-#      result = ActsAsFerret::retrieve_records( { self.name => result_ids }, find_options )
-#      
-#      # count total_hits via sql when using conditions or when we're called
-#      # from an ActiveRecord association.
-#      if find_options[:conditions] or caller.find{ |call| call =~ %r{active_record/associations} }
-#        # chances are the ferret result count is not our total_hits value, so
-#        # we correct this here.
-#        if options[:limit] != :all || options[:page] || options[:offset] || find_options[:limit] || find_options[:offset]
-#          # our ferret result has been limited, so we need to re-run that
-#          # search to get the full result set from ferret.
-#          result_ids = {}
-#          find_ids_with_ferret(q, options.update(:limit => :all, :offset => 0)) do |model, id, score, data|
-#            result_ids[id] = [ result_ids.size + 1, score ]
-#          end
-#          # Now ask the database for the total size of the final result set.
-#          total_hits = count_records( { self.name => result_ids }, find_options )
-#        else
-#          # what we got from the database is our full result set, so take
-#          # it's size
-#          total_hits = result.length
-#        end
-#      end
-#
-#      [ total_hits, result ]
-#    end
-#
-#    def lazy_find_by_contents(q, options = {})
-#      logger.debug "lazy_find_by_contents: #{q}"
-#      result = []
-#      rank   = 0
-#      total_hits = find_ids_with_ferret(q, options) do |model, id, score, data|
-#        logger.debug "model: #{model}, id: #{id}, data: #{data}"
-#        result << FerretResult.new(model, id, score, rank += 1, data)
-#      end
-#      [ total_hits, result ]
-#    end
-
-
-    def model_find(model, id, find_options = {})
-      model.constantize.find(id, find_options)
-    end
-
-
-#    def count_records(id_arrays, find_options = {})
-#      count_options = find_options.dup
-#      count_options.delete :limit
-#      count_options.delete :offset
-#      count = 0
-#      id_arrays.each do |model, id_array|
-#        next if id_array.empty?
-#        model = model.constantize
-#        # merge conditions
-#        conditions = ActsAsFerret::combine_conditions([ "#{model.table_name}.#{model.primary_key} in (?)", id_array.keys ], 
-#                                        find_options[:conditions])
-#        opts = find_options.merge :conditions => conditions
-#        opts.delete :limit; opts.delete :offset
-#        count += model.count opts
-#      end
-#      count
-#    end
-
-  end
-  
-end
-
@@ -1,115 +0,0 @@
-module Ferret
-
-  module Analysis
-  
-    # = PerFieldAnalyzer
-    #
-    # This PerFieldAnalyzer is a workaround to a memory leak in 
-    # ferret 0.11.4. It does basically do the same as the original
-    # Ferret::Analysis::PerFieldAnalyzer, but without the leak :)
-    # 
-    # http://ferret.davebalmain.com/api/classes/Ferret/Analysis/PerFieldAnalyzer.html
-    #
-    # Thanks to Ben from omdb.org for tracking this down and creating this
-    # workaround.
-    # You can read more about the issue there:
-    # http://blog.omdb-beta.org/2007/7/29/tracking-down-a-memory-leak-in-ferret-0-11-4
-    class PerFieldAnalyzer < ::Ferret::Analysis::Analyzer
-      def initialize( default_analyzer = StandardAnalyzer.new )
-        @analyzers = {}
-        @default_analyzer = default_analyzer
-      end
-            
-      def add_field( field, analyzer )
-        @analyzers[field] = analyzer
-      end
-      alias []= add_field
-                
-      def token_stream(field, string)
-        @analyzers.has_key?(field) ? @analyzers[field].token_stream(field, string) : 
-          @default_analyzer.token_stream(field, string)
-      end
-    end
-  end
-
-  class Index::Index
-    attr_accessor :batch_size, :logger
-
-    def index_models(models)
-      models.each { |model| index_model model }
-      flush
-      optimize
-      close
-      ActsAsFerret::close_multi_indexes
-    end
-
-    def index_model(model)
-      bulk_indexer = ActsAsFerret::BulkIndexer.new(:batch_size => @batch_size, :logger => logger, 
-                                                   :model => model, :index => self, :reindex => true)
-      logger.info "reindexing model #{model.name}"
-
-      model.records_for_rebuild(@batch_size) do |records, offset|
-        bulk_indexer.index_records(records, offset)
-      end
-    end
-
-    def bulk_index(model, ids, options = {})
-      options.reverse_merge! :optimize => true
-      orig_flush = @auto_flush
-      @auto_flush = false
-      bulk_indexer = ActsAsFerret::BulkIndexer.new(:batch_size => @batch_size, :logger => logger, 
-                                                   :model => model, :index => self, :total => ids.size)
-      model.records_for_bulk_index(ids, @batch_size) do |records, offset|
-        logger.debug "#{model} bulk indexing #{records.size} at #{offset}"
-        bulk_indexer.index_records(records, offset)
-      end
-      logger.info 'finishing bulk index...'
-      flush
-      if options[:optimize]
-        logger.info 'optimizing...'
-        optimize 
-      end
-      @auto_flush = orig_flush
-    end
-
-  end
-
-  # add marshalling support to SortFields
-  class Search::SortField
-    def _dump(depth)
-      to_s
-    end
-
-    def self._load(string)
-      case string
-        when /<DOC(_ID)?>!/         : Ferret::Search::SortField::DOC_ID_REV
-        when /<DOC(_ID)?>/          : Ferret::Search::SortField::DOC_ID
-        when '<SCORE>!'             : Ferret::Search::SortField::SCORE_REV
-        when '<SCORE>'              : Ferret::Search::SortField::SCORE
-        when /^(\w+):<(\w+)>(!)?$/ : new($1.to_sym, :type => $2.to_sym, :reverse => !$3.nil?)
-        else raise "invalid value: #{string}"
-      end
-    end
-  end
-
-  # add marshalling support to Sort
-  class Search::Sort
-    def _dump(depth)
-      to_s
-    end
-
-    def self._load(string)
-      # we exclude the last <DOC> sorting as it is appended by new anyway
-      if string =~ /^Sort\[(.*?)(<DOC>(!)?)?\]$/
-        sort_fields = $1.split(',').map do |value| 
-        value.strip!
-          Ferret::Search::SortField._load value unless value.blank?
-        end
-        new sort_fields.compact
-      else
-        raise "invalid value: #{string}"
-      end
-    end
-  end
-
-end
@@ -1,118 +0,0 @@
-module ActsAsFerret
-  # Ferret search logic common to single-class indexes, shared indexes and
-  # multi indexes.
-  module FerretFindMethods
-
-    def find_records(q, options = {}, ar_options = {})
-      if options[:lazy]
-        logger.warn "find_options #{ar_options} are ignored because :lazy => true" unless ar_options.empty?
-        lazy_find q, options
-      else
-        ar_find q, options, ar_options
-      end
-    end
-
-    def lazy_find(q, options = {})
-      logger.debug "lazy_find: #{q}"
-      result = []
-      rank   = 0
-      total_hits = find_ids(q, options) do |model, id, score, data|
-        logger.debug "model: #{model}, id: #{id}, data: #{data}"
-        result << FerretResult.new(model, id, score, rank += 1, data)
-      end
-      [ total_hits, result ]
-    end
-
-    def ar_find(q, options = {}, ar_options = {})
-      total_hits, id_arrays = find_id_model_arrays q, options
-      result = ActsAsFerret::retrieve_records(id_arrays, ar_options)
-      
-      # count total_hits via sql when using conditions, multiple models, or when we're called
-      # from an ActiveRecord association.
-      if id_arrays.size > 1 or ar_options[:conditions]
-        # chances are the ferret result count is not our total_hits value, so
-        # we correct this here.
-        if options[:limit] != :all || options[:page] || options[:offset] || ar_options[:limit] || ar_options[:offset]
-          # our ferret result has been limited, so we need to re-run that
-          # search to get the full result set from ferret.
-          new_th, id_arrays = find_id_model_arrays( q, options.merge(:limit => :all, :offset => 0) )
-          # Now ask the database for the total size of the final result set.
-          total_hits = count_records( id_arrays, ar_options )
-        else
-          # what we got from the database is our full result set, so take
-          # it's size
-          total_hits = result.length
-        end
-      end
-      [ total_hits, result ]
-    end
-
-    def count_records(id_arrays, ar_options = {})
-      count_options = ar_options.dup
-      count_options.delete :limit
-      count_options.delete :offset
-      count = 0
-      id_arrays.each do |model, id_array|
-        next if id_array.empty?
-        model = model.constantize
-        # merge conditions
-        conditions = ActsAsFerret::conditions_for_model model, ar_options[:conditions]
-        count_options[:conditions] = ActsAsFerret::combine_conditions([ "#{model.table_name}.#{model.primary_key} in (?)", id_array.keys ], conditions)
-        count += model.count count_options
-      end
-      count
-    end
-
-    def find_id_model_arrays(q, options)
-      id_arrays = {}
-      rank = 0
-      total_hits = find_ids(q, options) do |model, id, score, data|
-        id_arrays[model] ||= {}
-        id_arrays[model][id] = [ rank += 1, score ]
-      end
-      [total_hits, id_arrays]
-    end
-
-    # Queries the Ferret index to retrieve model class, id, score and the
-    # values of any fields stored in the index for each hit.
-    # If a block is given, these are yielded and the number of total hits is
-    # returned. Otherwise [total_hits, result_array] is returned.
-    def find_ids(query, options = {})
-
-      result = []
-      stored_fields = determine_stored_fields options
-
-      q = process_query(query, options)
-      q = scope_query_to_models q, options[:models] #if shared?
-      logger.debug "query: #{query}\n-->#{q}"
-      s = searcher
-      total_hits = s.search_each(q, options) do |hit, score|
-        doc = s[hit]
-        model = doc[:class_name]
-        # fetch stored fields if lazy loading
-        data = extract_stored_fields(doc, stored_fields)
-        if block_given?
-          yield model, doc[:id], score, data
-        else
-          result << { :model => model, :id => doc[:id], :score => score, :data => data }
-        end
-      end
-      #logger.debug "id_score_model array: #{result.inspect}"
-      return block_given? ? total_hits : [total_hits, result]
-    end
-
-    def scope_query_to_models(query, models)
-      return query if models.nil? or models == :all
-      models = [ models ] if Class === models
-      q = Ferret::Search::BooleanQuery.new
-      q.add_query(query, :must)
-      model_query = Ferret::Search::BooleanQuery.new
-      models.each do |model|
-        model_query.add_query(Ferret::Search::TermQuery.new(:class_name, model.name), :should)
-      end
-      q.add_query(model_query, :must)
-      return q
-    end
-
-  end
-end
@@ -1,53 +0,0 @@
-module ActsAsFerret
-
-  # mixed into the FerretResult and AR classes calling acts_as_ferret
-  module ResultAttributes
-    # holds the score this record had when it was found via
-    # acts_as_ferret
-    attr_accessor :ferret_score
-
-    attr_accessor :ferret_rank
-  end
-
-  class FerretResult < ActsAsFerret::BlankSlate
-    include ResultAttributes
-    attr_accessor :id
-    reveal :methods
-
-    def initialize(model, id, score, rank, data = {})
-      @model = model.constantize
-      @id = id
-      @ferret_score = score
-      @ferret_rank  = rank
-      @data = data
-      @use_record = false
-    end
-
-    def inspect
-      "#<FerretResult wrapper for #{@model} with id #{@id}"
-    end
-
-    def method_missing(method, *args, &block)
-      if (@ar_record && @use_record) || !@data.has_key?(method)
-        to_record.send method, *args, &block
-      else
-        @data[method]
-      end
-    end
-
-    def respond_to?(name)
-      methods.include?(name.to_s) || @data.has_key?(name.to_sym) || to_record.respond_to?(name)
-    end
-
-    def to_record
-      unless @ar_record
-        @ar_record = @model.find(id)
-        @ar_record.ferret_rank  = ferret_rank
-        @ar_record.ferret_score = ferret_score
-        # don't try to fetch attributes from RDig based records
-        @use_record = !@ar_record.class.included_modules.include?(ActsAsFerret::RdigAdapter)
-      end
-      @ar_record
-    end
-  end
-end
@@ -1,238 +0,0 @@
-require 'drb'
-require 'thread'
-require 'yaml'
-require 'erb'
-
-################################################################################
-module ActsAsFerret
-  module Remote
-
-    ################################################################################
-    class Config
-
-      ################################################################################
-      DEFAULTS = {
-        'host'      => 'localhost',
-        'port'      => '9009',
-        'cf'        => "#{RAILS_ROOT}/config/ferret_server.yml",
-        'pid_file'  => "#{RAILS_ROOT}/log/ferret_server.pid",
-        'log_file'  => "#{RAILS_ROOT}/log/ferret_server.log",
-        'log_level' => 'debug',
-        'socket'    => nil,
-        'script'    => nil
-      }
-
-      ################################################################################
-      # load the configuration file and apply default settings
-      def initialize (file=DEFAULTS['cf'])
-        @everything = YAML.load(ERB.new(IO.read(file)).result)
-        raise "malformed ferret server config" unless @everything.is_a?(Hash)
-        @config = DEFAULTS.merge(@everything[RAILS_ENV] || {})
-        if @everything[RAILS_ENV]
-          @config['uri'] = socket.nil? ? "druby://#{host}:#{port}" : "drbunix:#{socket}"
-        end
-      end
-
-      ################################################################################
-      # treat the keys of the config data as methods
-      def method_missing (name, *args)
-        @config.has_key?(name.to_s) ? @config[name.to_s] : super
-      end
-
-    end
-
-    #################################################################################
-    # This class acts as a drb server listening for indexing and
-    # search requests from models declared to 'acts_as_ferret :remote => true'
-    #
-    # Usage: 
-    # - modify RAILS_ROOT/config/ferret_server.yml to suit your needs. 
-    # - environments for which no section in the config file exists will use 
-    #   the index locally (good for unit tests/development mode)
-    # - run script/ferret_server to start the server:
-    # script/ferret_server -e production start
-    # - to stop the server run
-    # script/ferret_server -e production stop
-    #
-    class Server
-
-      #################################################################################
-      # FIXME include detection of OS and include the correct file
-      require 'unix_daemon'
-      include(ActsAsFerret::Remote::UnixDaemon)
-
-
-      ################################################################################
-      cattr_accessor :running
-
-      ################################################################################
-      def initialize
-        ActiveRecord::Base.allow_concurrency = true
-        require 'ar_mysql_auto_reconnect_patch'
-        @cfg = ActsAsFerret::Remote::Config.new
-        ActiveRecord::Base.logger = @logger = Logger.new(@cfg.log_file)
-        ActiveRecord::Base.logger.level = Logger.const_get(@cfg.log_level.upcase) rescue Logger::DEBUG
-        if @cfg.script
-          path = File.join(RAILS_ROOT, @cfg.script) 
-          load path
-          @logger.info "loaded custom startup script from #{path}"
-        end
-      end
-
-      ################################################################################
-      # start the server as a daemon process
-      def start
-        raise "ferret_server not configured for #{RAILS_ENV}" unless (@cfg.uri rescue nil)
-        platform_daemon { run_drb_service }
-      end
-
-      ################################################################################
-      # run the server and block until it exits
-      def run
-        raise "ferret_server not configured for #{RAILS_ENV}" unless (@cfg.uri rescue nil)
-        run_drb_service
-      end
-
-      def run_drb_service
-        $stdout.puts("starting ferret server...")
-        self.class.running = true
-        DRb.start_service(@cfg.uri, self)
-        DRb.thread.join
-      rescue Exception => e
-        @logger.error(e.to_s)
-        raise
-      end
-
-      #################################################################################
-      # handles all incoming method calls, and sends them on to the correct local index
-      # instance.
-      #
-      # Calls are not queued, so this will block until the call returned.
-      #
-      def method_missing(name, *args)
-        @logger.debug "\#method_missing(#{name.inspect}, #{args.inspect})"
-
-
-        index_name = args.shift
-        index = if name.to_s =~ /^multi_(.+)/
-          name = $1
-          ActsAsFerret::multi_index(index_name)
-        else
-          ActsAsFerret::get_index(index_name)
-        end
-
-        if index.nil?
-          @logger.error "\#index with name #{index_name} not found in call to #{name} with args #{args.inspect}"
-          raise ActsAsFerret::IndexNotDefined.new(index_name)
-        end
-
-
-        # TODO find another way to implement the reconnection logic (maybe in
-        # local_index or class_methods)
-        #  reconnect_when_needed(clazz) do
-        
-        # using respond_to? here so we not have to catch NoMethodError
-        # which would silently catch those from deep inside the indexing
-        # code, too...
-
-        if index.respond_to?(name)
-          index.send name, *args
-        # TODO check where we need this:
-        #elsif clazz.respond_to?(name)
-        #      @logger.debug "no luck, trying to call class method instead"
-        #      clazz.send name, *args
-        else
-          raise NoMethodError.new("method #{name} not supported by DRb server")
-        end
-      rescue => e
-        @logger.error "ferret server error #{$!}\n#{$!.backtrace.join "\n"}"
-        raise e
-      end
-
-      def register_class(class_name)
-        @logger.debug "############ registerclass #{class_name}"
-        class_name.constantize
-        @logger.debug "index for class #{class_name}: #{ActsAsFerret::ferret_indexes[class_name.underscore.to_sym]}"
-
-      end
-
-      # make sure we have a versioned index in place, building one if necessary
-      def ensure_index_exists(index_name)
-        @logger.debug "DRb server: ensure_index_exists for index #{index_name}"
-        definition = ActsAsFerret::get_index(index_name).index_definition
-        dir = definition[:index_dir]
-        unless File.directory?(dir) && File.file?(File.join(dir, 'segments')) && dir =~ %r{/\d+(_\d+)?$}
-          rebuild_index(index_name)
-        end
-      end
-
-      # disconnects the db connection for the class specified by class_name
-      # used only in unit tests to check the automatic reconnection feature
-      def db_disconnect!(class_name)
-        with_class class_name do |clazz|
-          clazz.connection.disconnect!
-        end
-      end
-
-      # hides LocalIndex#rebuild_index to implement index versioning
-      def rebuild_index(index_name)
-        definition = ActsAsFerret::get_index(index_name).index_definition.dup
-        models = definition[:registered_models]
-        index = new_index_for(definition)
-        # TODO fix reconnection stuff
-        #  reconnect_when_needed(clazz) do
-        #    @logger.debug "DRb server: rebuild index for class(es) #{models.inspect} in #{index.options[:path]}"
-        index.index_models models
-        #  end
-        new_version = File.join definition[:index_base_dir], Time.now.utc.strftime('%Y%m%d%H%M%S')
-        # create a unique directory name (needed for unit tests where 
-        # multiple rebuilds per second may occur)
-        if File.exists?(new_version)
-          i = 0
-          i+=1 while File.exists?("#{new_version}_#{i}")
-          new_version << "_#{i}"
-        end
-          
-        File.rename index.options[:path], new_version
-        ActsAsFerret::change_index_dir index_name, new_version 
-      end
-
-
-      protected
-
-        def reconnect_when_needed(clazz)
-          retried = false
-          begin
-            yield
-          rescue ActiveRecord::StatementInvalid => e
-            if e.message =~ /MySQL server has gone away/
-              if retried
-                raise e
-              else
-                @logger.info "StatementInvalid caught, trying to reconnect..."
-                clazz.connection.reconnect!
-                retried = true
-                retry
-              end
-            else
-              @logger.error "StatementInvalid caught, but unsure what to do with it: #{e}"
-              raise e
-            end
-          end
-        end
-
-        def new_index_for(index_definition)
-          ferret_cfg = index_definition[:ferret].dup
-          ferret_cfg.update :auto_flush  => false, 
-                            :create      => true,
-                            :field_infos => ActsAsFerret::field_infos(index_definition),
-                            :path        => File.join(index_definition[:index_base_dir], 'rebuild')
-          returning Ferret::Index::Index.new(ferret_cfg) do |i|
-            i.batch_size = index_definition[:reindex_batch_size]
-            i.logger = @logger
-          end
-        end
-
-    end
-  end
-end
@@ -1,99 +0,0 @@
-module ActsAsFerret
-
-  class IndexLogger
-    def initialize(logger, name)
-      @logger = logger
-      @index_name = name
-    end
-    %w(debug info warn error).each do |m|
-      define_method(m) do |message|
-        @logger.send m, "[#{@index_name}] #{message}"
-      end
-      question = :"#{m}?"
-      define_method(question) do
-        @logger.send question
-      end
-    end
-  end
-
-  # base class for local and remote indexes
-  class AbstractIndex
-    include FerretFindMethods
-
-    attr_reader :logger, :index_name, :index_definition, :registered_models_config
-    def initialize(index_definition)
-      @index_definition = index_definition
-      @registered_models_config = {}
-      @index_name = index_definition[:name]
-      @logger = IndexLogger.new(ActsAsFerret::logger, @index_name)
-    end
-
-    # TODO allow for per-class field configuration (i.e. different via, boosts
-    # for the same field among different models)
-    def register_class(clazz, options = {})
-      logger.info "register class #{clazz} with index #{index_name}"
-
-      if force = options.delete(:force_re_registration)
-        index_definition[:registered_models].delete(clazz)
-      end
-
-      if index_definition[:registered_models].map(&:name).include?(clazz.name)
-        logger.info("refusing re-registration of class #{clazz}")
-      else
-        index_definition[:registered_models] << clazz
-        @registered_models_config[clazz] = options
-
-        # merge fields from this acts_as_ferret call with predefined fields
-        already_defined_fields = index_definition[:ferret_fields]
-        field_config = ActsAsFerret::build_field_config options[:fields]
-        field_config.update ActsAsFerret::build_field_config( options[:additional_fields] )
-        field_config.each do |field, config|
-          if already_defined_fields.has_key?(field)
-            logger.info "ignoring redefinition of ferret field #{field}" if shared? 
-          else
-            already_defined_fields[field] = config
-            logger.info "adding new field #{field} from class #{clazz.name} to index #{index_name}"
-          end
-        end
-
-        # update default field list to be used by the query parser, unless it 
-        # was explicitly given by user.
-        #
-        # It will include all content fields *not* marked as :untokenized.
-        # This fixes the otherwise failing CommentTest#test_stopwords. Basically
-        # this means that by default only tokenized fields (which all fields are
-        # by default) will be searched. If you want to search inside the contents 
-        # of an untokenized field, you'll have to explicitly specify it in your 
-        # query.
-        unless index_definition[:user_default_field]
-          # grab all tokenized fields
-          ferret_fields = index_definition[:ferret_fields]
-          index_definition[:ferret][:default_field] = ferret_fields.keys.select do |field|
-            ferret_fields[field][:index] != :untokenized
-          end
-          logger.info "default field list for index #{index_name}: #{index_definition[:ferret][:default_field].inspect}"
-        end
-      end
-
-      return index_definition
-    end
-
-    # true if this index is used by more than one model class
-    def shared?
-      index_definition[:registered_models].size > 1
-    end
-
-    # Switches the index to a new index directory.
-    # Used by the DRb server when switching to a new index version.
-    def change_index_dir(new_dir)
-      logger.debug "[#{index_name}] changing index dir to #{new_dir}"
-      index_definition[:index_dir] = index_definition[:ferret][:path] = new_dir
-      reopen!
-      logger.debug "[#{index_name}] index dir is now #{new_dir}"
-    end
-
-    protected
-
-  end
-
-end
@@ -1,165 +0,0 @@
-module ActsAsFerret #:nodoc:
-
-  module InstanceMethods
-    include ResultAttributes
-
-    # Returns an array of strings with the matches highlighted. The +query+ can
-    # either be a String or a Ferret::Search::Query object.
-    # 
-    # === Options
-    #
-    # field::            field to take the content from. This field has 
-    #                    to have it's content stored in the index 
-    #                    (:store => :yes in your call to aaf). If not
-    #                    given, all stored fields are searched, and the
-    #                    highlighted content found in all of them is returned.
-    #                    set :highlight => :no in the field options to
-    #                    avoid highlighting of contents from a :stored field.
-    # excerpt_length::   Default: 150. Length of excerpt to show. Highlighted
-    #                    terms will be in the centre of the excerpt.
-    # num_excerpts::     Default: 2. Number of excerpts to return.
-    # pre_tag::          Default: "<em>". Tag to place to the left of the
-    #                    match.  
-    # post_tag::         Default: "</em>". This tag should close the
-    #                    +:pre_tag+.
-    # ellipsis::         Default: "...". This is the string that is appended
-    #                    at the beginning and end of excerpts (unless the
-    #                    excerpt hits the start or end of the field. You'll
-    #                    probably want to change this to a Unicode elipsis
-    #                    character.
-    def highlight(query, options = {})
-      self.class.aaf_index.highlight(self.send(self.class.primary_key), self.class.name, query, options)
-    end
-    
-    # re-eneable ferret indexing for this instance after a call to #disable_ferret
-    def enable_ferret  
-      @ferret_disabled = nil 
-    end
-    alias ferret_enable enable_ferret  # compatibility
-    
-    # returns true if ferret indexing is enabled for this record.
-    #
-    # The optional is_bulk_index parameter will be true if the method is called
-    # by rebuild_index or bulk_index, and false otherwise.
-    #
-    # If is_bulk_index is true, the class level ferret_enabled state will be
-    # ignored by this method (per-instance ferret_enabled checks however will 
-    # take place, so if you override this method to forbid indexing of certain 
-    # records you're still safe).
-    def ferret_enabled?(is_bulk_index = false)
-      @ferret_disabled.nil? && (is_bulk_index || self.class.ferret_enabled?) && (aaf_configuration[:if].nil? || aaf_configuration[:if].call(self))
-    end
-
-    # Returns the analyzer to use when adding this record to the index.
-    #
-    # Override to return a specific analyzer for any record that is to be
-    # indexed, i.e. specify a different analyzer based on language. Returns nil
-    # by default so the global analyzer (specified with the acts_as_ferret
-    # call) is used.
-    def ferret_analyzer
-      nil
-    end
-
-    # Disable Ferret for this record for a specified amount of time. ::once will 
-    # disable Ferret for the next call to #save (this is the default), ::always 
-    # will do so for all subsequent calls. 
-    #
-    # Note that this will turn off only the create and update hooks, but not the 
-    # destroy hook. I think that's reasonable, if you think the opposite, please 
-    # tell me.
-    #
-    # To manually trigger reindexing of a record after you're finished modifying 
-    # it, you can call #ferret_update directly instead of #save (remember to
-    # enable ferret again before).
-    #
-    # When given a block, this will be executed without any ferret indexing of 
-    # this object taking place. The optional argument in this case can be used 
-    # to indicate if the object should be indexed after executing the block
-    # (::index_when_finished). Automatic Ferret indexing of this object will be 
-    # turned on after the block has been executed. If passed ::index_when_true, 
-    # the index will only be updated if the block evaluated not to false or nil.
-    #
-    def disable_ferret(option = :once)
-      if block_given?
-        @ferret_disabled = :always
-        result = yield
-        ferret_enable
-        ferret_update if option == :index_when_finished || (option == :index_when_true && result)
-        result
-      elsif [:once, :always].include?(option)
-        @ferret_disabled = option
-      else
-        raise ArgumentError.new("Invalid Argument #{option}")
-      end
-    end
-
-    # add to index
-    def ferret_create
-      if ferret_enabled?
-        logger.debug "ferret_create/update: #{self.class.name} : #{self.id}"
-        self.class.aaf_index << self
-      else
-        ferret_enable if @ferret_disabled == :once
-      end
-      true # signal success to AR
-    end
-    alias :ferret_update :ferret_create
-    
-
-    # remove from index
-    def ferret_destroy
-      logger.debug "ferret_destroy: #{self.class.name} : #{self.id}"
-      begin
-        self.class.aaf_index.remove self.id, self.class.name
-      rescue
-        logger.warn("Could not find indexed value for this object: #{$!}\n#{$!.backtrace}")
-      end
-      true # signal success to AR
-    end
-    
-    # turn this instance into a ferret document (which basically is a hash of
-    # fieldname => value pairs)
-    def to_doc
-      logger.debug "creating doc for class: #{self.class.name}, id: #{self.id}"
-      returning Ferret::Document.new do |doc|
-        # store the id and class name of each item
-        doc[:id] = self.id
-        doc[:class_name] = self.class.name
-      
-        # iterate through the fields and add them to the document
-        aaf_configuration[:defined_fields].each_pair do |field, config|
-          doc[field] = self.send("#{field}_to_ferret") unless config[:ignore]
-        end
-        if aaf_configuration[:boost]
-          if self.respond_to?(aaf_configuration[:boost])
-            boost = self.send aaf_configuration[:boost]
-            doc.boost = boost.to_i if boost
-          else
-            logger.error "boost option should point to an instance method: #{aaf_configuration[:boost]}"
-          end
-        end
-      end
-    end
-
-    def document_number
-      self.class.aaf_index.document_number(id, self.class.name)
-    end
-
-    def query_for_record
-      self.class.aaf_index.query_for_record(id, self.class.name)
-    end
-
-    def content_for_field_name(field, via = field, dynamic_boost = nil)
-      return nil if field.to_sym == :type
-      field_data = self.send(via) || self.instance_variable_get("@#{via}")
-      if (dynamic_boost && boost_value = self.send(dynamic_boost))
-        field_data = Ferret::Field.new(field_data)
-        field_data.boost = boost_value.to_i
-      end
-      field_data
-    end
-
-
-  end
-
-end
@@ -1,199 +0,0 @@
-module ActsAsFerret
-  class LocalIndex < AbstractIndex
-    include MoreLikeThis::IndexMethods
-
-    def initialize(index_name)
-      super
-      ensure_index_exists
-    end
-
-    def reopen!
-      logger.debug "reopening index at #{index_definition[:ferret][:path]}"
-      close
-      ferret_index
-    end
-
-    # The 'real' Ferret Index instance
-    def ferret_index
-      ensure_index_exists
-      returning @ferret_index ||= Ferret::Index::Index.new(index_definition[:ferret]) do
-        @ferret_index.batch_size = index_definition[:reindex_batch_size]
-        @ferret_index.logger = logger
-      end
-    end
-
-    # Checks for the presence of a segments file in the index directory
-    # Rebuilds the index if none exists.
-    def ensure_index_exists
-      #logger.debug "LocalIndex: ensure_index_exists at #{index_definition[:index_dir]}"
-      unless File.file? "#{index_definition[:index_dir]}/segments"
-        ActsAsFerret::ensure_directory(index_definition[:index_dir])
-        rebuild_index 
-      end
-    end
-
-    # Closes the underlying index instance
-    def close
-      @ferret_index.close if @ferret_index
-    rescue StandardError 
-      # is raised when index already closed
-    ensure
-      @ferret_index = nil
-    end
-
-    # rebuilds the index from all records of the model classes associated with this index
-    def rebuild_index
-      models = index_definition[:registered_models]
-      logger.debug "rebuild index with models: #{models.inspect}"
-      close
-      index = Ferret::Index::Index.new(index_definition[:ferret].dup.update(:auto_flush  => false, 
-                                                                            :field_infos => ActsAsFerret::field_infos(index_definition),
-                                                                            :create      => true))
-      index.batch_size = index_definition[:reindex_batch_size]
-      index.logger = logger
-      index.index_models models
-      reopen!
-    end
-
-    def bulk_index(class_name, ids, options)
-      ferret_index.bulk_index(class_name.constantize, ids, options)
-    end
-
-    # Parses the given query string into a Ferret Query object.
-    def process_query(query, options = {})
-      return query unless String === query
-      ferret_index.synchronize do
-        if options[:analyzer]
-          # use per-query analyzer if present
-          qp = Ferret::QueryParser.new ferret_index.instance_variable_get('@options').merge(options)
-          reader = ferret_index.reader
-          qp.fields =
-              reader.fields unless options[:all_fields] || options[:fields]
-          qp.tokenized_fields =
-              reader.tokenized_fields unless options[:tokenized_fields]
-          return qp.parse query
-        else
-          # work around ferret bug in #process_query (doesn't ensure the
-          # reader is open)
-          ferret_index.send(:ensure_reader_open)
-          return ferret_index.process_query(query)
-        end
-      end
-    end
-
-    # Total number of hits for the given query. 
-    def total_hits(query, options = {})
-      ferret_index.search(query, options).total_hits
-    end
-
-    def searcher
-      ferret_index
-    end
-
-
-    ######################################
-    # methods working on a single record
-    # called from instance_methods, here to simplify interfacing with the
-    # remote ferret server
-    # TODO having to pass id and class_name around like this isn't nice
-    ######################################
-
-    # add record to index
-    # record may be the full AR object, a Ferret document instance or a Hash
-    def add(record, analyzer = nil)
-      unless Hash === record || Ferret::Document === record
-        analyzer = record.ferret_analyzer
-        record = record.to_doc 
-      end
-      ferret_index.add_document(record, analyzer)
-    end
-    alias << add
-
-    # delete record from index
-    def remove(id, class_name)
-      ferret_index.query_delete query_for_record(id, class_name)
-    end
-
-    # highlight search terms for the record with the given id.
-    def highlight(id, class_name, query, options = {})
-      logger.debug("highlight: #{class_name} / #{id} query: #{query}")
-      options.reverse_merge! :num_excerpts => 2, :pre_tag => '<em>', :post_tag => '</em>'
-      highlights = []
-      ferret_index.synchronize do
-        doc_num = document_number(id, class_name)
-
-        if options[:field]
-          highlights << ferret_index.highlight(query, doc_num, options)
-        else
-          query = process_query(query) # process only once
-          index_definition[:ferret_fields].each_pair do |field, config|
-            next if config[:store] == :no || config[:highlight] == :no
-            options[:field] = field
-            highlights << ferret_index.highlight(query, doc_num, options)
-          end
-        end
-      end
-      return highlights.compact.flatten[0..options[:num_excerpts]-1]
-    end
-
-    # retrieves the ferret document number of the record with the given id.
-    def document_number(id, class_name)
-      hits = ferret_index.search(query_for_record(id, class_name))
-      return hits.hits.first.doc if hits.total_hits == 1
-      raise "cannot determine document number for class #{class_name} / primary key: #{id}\nresult was: #{hits.inspect}"
-    end
-
-    # build a ferret query matching only the record with the given id
-    # the class name only needs to be given in case of a shared index configuration
-    def query_for_record(id, class_name = nil)
-      if shared?
-        raise InvalidArgumentError.new("shared index needs class_name argument") if class_name.nil?
-        returning bq = Ferret::Search::BooleanQuery.new do
-          bq.add_query(Ferret::Search::TermQuery.new(:id,         id.to_s),    :must)
-          bq.add_query(Ferret::Search::TermQuery.new(:class_name, class_name), :must)
-        end
-      else
-        Ferret::Search::TermQuery.new(:id, id.to_s)
-      end
-    end
-
-
-
-    def determine_stored_fields(options = {})
-      stored_fields = options[:lazy]
-      if stored_fields && !(Array === stored_fields)
-        stored_fields = index_definition[:ferret_fields].select { |field, config| config[:store] == :yes }.map(&:first)
-      end
-      logger.debug "stored_fields: #{stored_fields.inspect}"
-      return stored_fields
-    end
-
-    # loads data for fields declared as :lazy from the Ferret document
-    def extract_stored_fields(doc, stored_fields) 
-      fields = index_definition[:ferret_fields] 
-      data = {} 
-      logger.debug "extracting stored fields #{stored_fields.inspect} from document #{doc[:class_name]} / #{doc[:id]}"
-      stored_fields.each do |field|
-        if field_cfg = fields[field]
-          data[field_cfg[:via]] = doc[field]
-        end
-      end if stored_fields 
-      logger.debug "done: #{data.inspect}"
-      return data 
-    end
-
-    protected
-
-    # returns a MultiIndex instance operating on a MultiReader
-    #def multi_index(model_classes)
-    #  model_classes.map!(&:constantize) if String === model_classes.first
-    #  model_classes.sort! { |a, b| a.name <=> b.name }
-    #  key = model_classes.inject("") { |s, clazz| s + clazz.name }
-    #  multi_config = index_definition[:ferret].dup
-    #  multi_config.delete :default_field  # we don't want the default field list of *this* class for multi_searching
-    #  ActsAsFerret::multi_indexes[key] ||= MultiIndex.new(model_classes, multi_config)
-    #end
- 
-  end
-
-end
@@ -1,217 +0,0 @@
-module ActsAsFerret #:nodoc:
-
-    module MoreLikeThis
-
-      module InstanceMethods
-
-        # returns other instances of this class, which have similar contents
-        # like this one. Basically works like this: find out n most interesting
-        # (i.e. characteristic) terms from this document, and then build a
-        # query from those which is run against the whole index. Which terms
-        # are interesting is decided on variour criteria which can be
-        # influenced by the given options. 
-        #
-        # The algorithm used here is a quite straight port of the MoreLikeThis class
-        # from Apache Lucene.
-        #
-        # options are:
-        # :field_names : Array of field names to use for similarity search (mandatory)
-        # :min_term_freq => 2,  # Ignore terms with less than this frequency in the source doc.
-        # :min_doc_freq => 5,   # Ignore words which do not occur in at least this many docs
-        # :min_word_length => nil, # Ignore words shorter than this length (longer words tend to 
-        #                            be more characteristic for the document they occur in).
-        # :max_word_length => nil, # Ignore words if greater than this len.
-        # :max_query_terms => 25,  # maximum number of terms in the query built
-        # :max_num_tokens => 5000, # maximum number of tokens to examine in a single field
-        # :boost => false,         # when true, a boost according to the relative score of 
-        #                            a term is applied to this Term's TermQuery.
-        # :similarity => 'DefaultAAFSimilarity'   # the similarity implementation to use (the default 
-        #                                           equals Ferret's internal similarity implementation)
-        # :analyzer => 'Ferret::Analysis::StandardAnalyzer' # class name of the analyzer to use
-        # :append_to_query => nil # proc taking a query object as argument, which will be called after generating the query. can be used to further manipulate the query used to find related documents, i.e. to constrain the search to a given class in single table inheritance scenarios
-        # ferret_options : Ferret options handed over to find_by_contents (i.e. for limits and sorting)
-        # ar_options : options handed over to find_by_contents for AR scoping
-        def more_like_this(options = {}, ferret_options = {}, ar_options = {})
-          options = {
-            :field_names => nil,  # Default field names
-            :min_term_freq => 2,  # Ignore terms with less than this frequency in the source doc.
-            :min_doc_freq => 5,   # Ignore words which do not occur in at least this many docs
-            :min_word_length => 0, # Ignore words if less than this len. Default is not to ignore any words.
-            :max_word_length => 0, # Ignore words if greater than this len. Default is not to ignore any words.
-            :max_query_terms => 25,  # maximum number of terms in the query built
-            :max_num_tokens => 5000, # maximum number of tokens to analyze when analyzing contents
-            :boost => false,      
-            :similarity => 'ActsAsFerret::MoreLikeThis::DefaultAAFSimilarity',  # class name of the similarity implementation to use
-            :analyzer => 'Ferret::Analysis::StandardAnalyzer', # class name of the analyzer to use
-            :append_to_query => nil,
-            :base_class => self.class # base class to use for querying, useful in STI scenarios where BaseClass.find_by_contents can be used to retrieve results from other classes, too
-          }.update(options)
-          #index.search_each('id:*') do |doc, score|
-          #  puts "#{doc} == #{index[doc][:description]}"
-          #end
-          clazz = options[:base_class]
-          options[:base_class] = clazz.name
-          query = clazz.aaf_index.build_more_like_this_query(self.id, self.class.name, options)
-          options[:append_to_query].call(query) if options[:append_to_query]
-          clazz.find_with_ferret(query, ferret_options, ar_options)
-        end
-
-      end
-
-      module IndexMethods
-
-        # TODO to allow morelikethis for unsaved records, we have to give the
-        # unsaved record's data to this method. check how this will work out
-        # via drb...
-        def build_more_like_this_query(id, class_name, options)
-          [:similarity, :analyzer].each { |sym| options[sym] = options[sym].constantize.new }
-          ferret_index.synchronize do # avoid that concurrent writes close our reader
-            ferret_index.send(:ensure_reader_open)
-            reader = ferret_index.send(:reader)
-            term_freq_map = retrieve_terms(id, class_name, reader, options)
-            priority_queue = create_queue(term_freq_map, reader, options)
-            create_query(id, class_name, priority_queue, options)
-          end
-        end
-
-        protected
-        
-        def create_query(id, class_name, priority_queue, options={})
-          query = Ferret::Search::BooleanQuery.new
-          qterms = 0
-          best_score = nil
-          while(cur = priority_queue.pop)
-            term_query = Ferret::Search::TermQuery.new(cur.field, cur.word)
-            
-            if options[:boost]
-              # boost term according to relative score
-              # TODO untested
-              best_score ||= cur.score
-              term_query.boost = cur.score / best_score
-            end
-            begin
-              query.add_query(term_query, :should) 
-            rescue Ferret::Search::BooleanQuery::TooManyClauses
-              break
-            end
-            qterms += 1
-            break if options[:max_query_terms] > 0 && qterms >= options[:max_query_terms]
-          end
-          # exclude the original record 
-          query.add_query(query_for_record(id, class_name), :must_not)
-          return query
-        end
-
-        
-
-        # creates a term/term_frequency map for terms from the fields
-        # given in options[:field_names]
-        def retrieve_terms(id, class_name, reader, options)
-          raise "more_like_this atm only works on saved records" if id.nil?
-          document_number = document_number(id, class_name) rescue nil
-          field_names = options[:field_names]
-          max_num_tokens = options[:max_num_tokens]
-          term_freq_map = Hash.new(0)
-          doc = nil
-          record = nil
-          field_names.each do |field|
-            #puts "field: #{field}"
-            term_freq_vector = reader.term_vector(document_number, field) if document_number
-            #if false
-            if term_freq_vector
-              # use stored term vector
-              # puts 'using stored term vector'
-              term_freq_vector.terms.each do |term|
-                term_freq_map[term.text] += term.positions.size unless noise_word?(term.text, options)
-              end
-            else
-              # puts 'no stored term vector'
-              # no term vector stored, but we have stored the contents in the index
-              # -> extract terms from there
-              content = nil
-              if document_number
-                doc = reader[document_number]
-                content = doc[field]
-              end
-              unless content
-                # no term vector, no stored content, so try content from this instance
-                record ||= options[:base_class].constantize.find(id)
-                content = record.content_for_field_name(field.to_s)
-              end
-              puts "have doc: #{doc[:id]} with #{field} == #{content}"
-              token_count = 0
-              
-              ts = options[:analyzer].token_stream(field, content)
-              while token = ts.next
-                break if (token_count+=1) > max_num_tokens
-                next if noise_word?(token.text, options)
-                term_freq_map[token.text] += 1
-              end
-            end
-          end
-          term_freq_map
-        end
-
-        # create an ordered(by score) list of word,fieldname,score 
-        # structures
-        def create_queue(term_freq_map, reader, options)
-          pq = Array.new(term_freq_map.size)
-          
-          similarity = options[:similarity]
-          num_docs = reader.num_docs
-          term_freq_map.each_pair do |word, tf|
-            # filter out words that don't occur enough times in the source
-            next if options[:min_term_freq] && tf < options[:min_term_freq]
-            
-            # go through all the fields and find the largest document frequency
-            top_field = options[:field_names].first
-            doc_freq = 0
-            options[:field_names].each do |field_name| 
-              freq = reader.doc_freq(field_name, word)
-              if freq > doc_freq 
-                top_field = field_name
-                doc_freq = freq
-              end
-            end
-            # filter out words that don't occur in enough docs
-            next if options[:min_doc_freq] && doc_freq < options[:min_doc_freq]
-            next if doc_freq == 0 # index update problem ?
-            
-            idf = similarity.idf(doc_freq, num_docs)
-            score = tf * idf
-            pq << FrequencyQueueItem.new(word, top_field, score)
-          end
-          pq.compact!
-          pq.sort! { |a,b| a.score<=>b.score }
-          return pq
-        end
-        
-        def noise_word?(text, options)
-          len = text.length
-          (
-            (options[:min_word_length] > 0 && len < options[:min_word_length]) ||
-            (options[:max_word_length] > 0 && len > options[:max_word_length]) ||
-            (options[:stop_words] && options.include?(text))
-          )
-        end
-
-      end
-
-      class DefaultAAFSimilarity
-        def idf(doc_freq, num_docs)
-          return 0.0 if num_docs == 0
-          return Math.log(num_docs.to_f/(doc_freq+1)) + 1.0
-        end
-      end
-
-
-      class FrequencyQueueItem
-        attr_reader :word, :field, :score
-        def initialize(word, field, score)
-          @word = word; @field = field; @score = score
-        end
-      end
-
-    end
-end
-
@@ -1,126 +0,0 @@
-module ActsAsFerret #:nodoc:
-
-  # Base class for remote and local multi-indexes
-  class MultiIndexBase
-    include FerretFindMethods
-    attr_accessor :logger
-
-    def initialize(indexes, options = {})
-      # ensure all models indexes exist
-      @indexes = indexes
-      indexes.each { |i| i.ensure_index_exists }
-      default_fields = indexes.inject([]) do |fields, idx| 
-        fields + [ idx.index_definition[:ferret][:default_field] ]
-      end.flatten.uniq
-      @options = {
-        :default_field => default_fields
-      }.update(options)
-      @logger = IndexLogger.new(ActsAsFerret::logger, "multi: #{indexes.map(&:index_name).join(',')}")
-    end
-
-    def ar_find(query, options = {}, ar_options = {})
-      limit = options.delete(:limit)
-      offset = options.delete(:offset) || 0
-      options[:limit] = :all
-      total_hits, result = super query, options, ar_options  
-      total_hits = result.size if ar_options[:conditions]
-      if limit && limit != :all
-        result = result[offset..limit+offset-1]
-      end
-      [total_hits, result]
-    end
-    
-    def determine_stored_fields(options)
-      return nil unless options.has_key?(:lazy)
-      stored_fields = []
-      @indexes.each do |index|
-        stored_fields += index.determine_stored_fields(options)
-      end
-      return stored_fields.uniq
-    end
-
-    def shared?
-      false
-    end
-      
-  end
-  
-  # This class can be used to search multiple physical indexes at once.
-  class MultiIndex < MultiIndexBase
-    
-    def extract_stored_fields(doc, stored_fields)
-      ActsAsFerret::get_index_for(doc[:class_name]).extract_stored_fields(doc, stored_fields) unless stored_fields.blank?
-    end
-
-    def total_hits(q, options = {})
-      search(q, options).total_hits
-    end
-    
-    def search(query, options={})
-      query = process_query(query, options)
-      logger.debug "parsed query: #{query.to_s}"
-      searcher.search(query, options)
-    end
-
-    def search_each(query, options = {}, &block)
-      query = process_query(query, options)
-      searcher.search_each(query, options, &block)
-    end
-
-    # checks if all our sub-searchers still are up to date
-    def latest?
-      #return false unless @reader
-      # segfaults with 0.10.4 --> TODO report as bug @reader.latest?
-      @reader and @reader.latest?
-      #@sub_readers.each do |r| 
-      #  return false unless r.latest? 
-      #end
-      #true
-    end
-
-    def searcher
-      ensure_searcher
-      @searcher
-    end
-    
-    def doc(i)
-      searcher[i]
-    end
-    alias :[] :doc
-    
-    def query_parser
-      @query_parser ||= Ferret::QueryParser.new(@options)
-    end
-    
-    def process_query(query, options = {})
-      query = query_parser.parse(query) if query.is_a?(String)
-      return query
-    end
-
-    def close
-      @searcher.close if @searcher
-      @reader.close if @reader
-    end
-
-    protected
-
-      def ensure_searcher
-        unless latest?
-          @sub_readers = @indexes.map { |idx| 
-            begin
-              reader = Ferret::Index::IndexReader.new(idx.index_definition[:index_dir])
-              logger.debug "sub-reader opened: #{reader}"
-              reader
-            rescue Exception
-              raise "error opening reader on index for class #{clazz.inspect}: #{$!}"
-            end
-          }
-          close
-          @reader = Ferret::Index::IndexReader.new(@sub_readers)
-          @searcher = Ferret::Search::Searcher.new(@reader)
-        end
-      end
-
-  end # of class MultiIndex
-
-end
@@ -1,141 +0,0 @@
-begin
-  require 'rdig'
-rescue LoadError
-end
-module ActsAsFerret
-
-  # The RdigAdapter is automatically included into your model if you specify
-  # the +:rdig+ options hash in your call to acts_as_ferret. It overrides
-  # several methods declared by aaf to retrieve documents with the help of
-  # RDig's http crawler when you call rebuild_index.
-  module RdigAdapter
-
-    if defined?(RDig)
-
-      def self.included(target)
-        target.extend ClassMethods
-        target.send :include, InstanceMethods
-      end
-
-      # Indexer class to replace RDig's original indexer
-      class Indexer
-        include MonitorMixin
-        def initialize(batch_size, model_class, &block)
-          @batch_size = batch_size
-          @model_class = model_class
-          @documents = []
-          @offset = 0
-          @block = block
-          super()
-        end
-
-        def add(doc)
-          synchronize do
-            @documents << @model_class.new(doc.uri.to_s, doc)
-            process_batch if @documents.size >= @batch_size
-          end
-        end
-        alias << add
-
-        def close
-          synchronize do
-            process_batch
-          end
-        end
-
-        protected
-        def process_batch
-          ActsAsFerret::logger.info "RdigAdapter::Indexer#process_batch: #{@documents.size} docs in queue, offset #{@offset}"
-          @block.call @documents, @offset
-          @offset += @documents.size
-          @documents = []
-        end
-      end
-      
-      module ClassMethods
-        # overriding aaf to return the documents fetched via RDig
-        def records_for_rebuild(batch_size = 1000, &block)
-          indexer = Indexer.new(batch_size, self, &block)
-          configure_rdig do
-            crawler = RDig::Crawler.new RDig.configuration, ActsAsFerret::logger
-            crawler.instance_variable_set '@indexer', indexer
-            ActsAsFerret::logger.debug "now crawling..."
-            crawler.crawl
-          end
-        rescue => e
-          ActsAsFerret::logger.error e
-          ActsAsFerret::logger.debug e.backtrace.join("\n")
-        ensure
-          indexer.close if indexer
-        end
-
-        # overriding aaf to skip reindexing records changed during the rebuild
-        # when rebuilding with the rake task
-        def records_modified_since(time)
-          []
-        end
-
-        # unfortunately need to modify global RDig.configuration because it's
-        # used everywhere in RDig
-        def configure_rdig
-          # back up original config
-          old_logger = RDig.logger
-          old_cfg = RDig.configuration.dup
-          RDig.logger = ActsAsFerret.logger
-          rdig_configuration[:crawler].each { |k,v| RDig.configuration.crawler.send :"#{k}=", v } if rdig_configuration[:crawler]
-          if ce_config = rdig_configuration[:content_extraction]
-            RDig.configuration.content_extraction = OpenStruct.new( :hpricot => OpenStruct.new( ce_config ) )
-          end
-          yield
-        ensure
-          # restore original config
-          RDig.configuration.crawler = old_cfg.crawler
-          RDig.configuration.content_extraction = old_cfg.content_extraction
-          RDig.logger = old_logger
-        end
-
-        # overriding aaf to enforce loading page title and content from the
-        # ferret index
-        def find_with_ferret(q, options = {}, find_options = {})
-          options[:lazy] = true
-          super
-        end
-
-        def find_for_id(id)
-          new id
-        end
-      end
-
-      module InstanceMethods
-        def initialize(uri, rdig_document = nil)
-          @id = uri
-          @rdig_document = rdig_document
-        end
-
-        # Title of the document.
-        # Use the +:title_tag_selector+ option to declare the hpricot expression
-        # that should be used for selecting the content for this field.
-        def title
-          @rdig_document.title
-        end
-
-        # Content of the document.
-        # Use the +:content_tag_selector+ option to declare the hpricot expression
-        # that should be used for selecting the content for this field.
-        def content
-          @rdig_document.body
-        end
-
-        # Url of this document.
-        def id
-          @id
-        end
-
-        def to_s
-          "Page at #{id}, title: #{title}"
-        end
-      end
-    end
-  end
-  
-end
@@ -1,23 +0,0 @@
-module ActsAsFerret
-  module RemoteFunctions
-
-    private
-
-    def yield_results(total_hits, results)
-      results.each do |result|
-        yield result[:model], result[:id], result[:score], result[:data]
-      end
-      total_hits
-    end
-
-
-    def handle_drb_error(return_value_in_case_of_error = false)
-      yield
-    rescue DRb::DRbConnError => e
-      logger.error "DRb connection error: #{e}"
-      logger.warn e.backtrace.join("\n")
-      raise e if ActsAsFerret::raise_drb_errors?
-      return_value_in_case_of_error
-    end
-  end
-end
@@ -1,54 +0,0 @@
-require 'drb'
-module ActsAsFerret
-
-  # This index implementation connects to a remote ferret server instance. It
-  # basically forwards all calls to the remote server.
-  class RemoteIndex < AbstractIndex
-    include RemoteFunctions
-
-    def initialize(config)
-      super
-      @server = DRbObject.new(nil, ActsAsFerret::remote)
-    end
-
-    # Cause model classes to be loaded (and indexes get declared) on the DRb
-    # side of things.
-    def register_class(clazz, options)
-      handle_drb_error { @server.register_class clazz.name }
-    end
-
-    def method_missing(method_name, *args)
-      args.unshift index_name
-      handle_drb_error { @server.send(method_name, *args) }
-    end
-
-    # Proxy any methods that require special return values in case of errors
-    { 
-      :highlight => [] 
-    }.each do |method_name, default_result|
-      define_method method_name do |*args|
-        args.unshift index_name
-        handle_drb_error(default_result) { @server.send method_name, *args }
-      end
-    end
-
-    def find_ids(q, options = {}, &proc)
-      total_hits, results = handle_drb_error([0, []]) { @server.find_ids(index_name, q, options) }
-      block_given? ? yield_results(total_hits, results, &proc) : [ total_hits, results ]
-    end
-
-    # add record to index
-    def add(record)
-      handle_drb_error { @server.add index_name, record.to_doc }
-    end
-    alias << add
-
-    private
-
-    #def model_class_name
-    #  index_definition[:class_name]
-    #end
-
-  end
-
-end
@@ -1,20 +0,0 @@
-module ActsAsFerret
-  class RemoteMultiIndex < MultiIndexBase
-    include RemoteFunctions
-
-    def initialize(indexes, options = {})
-      @index_names = indexes.map(&:index_name)
-      @server = DRbObject.new(nil, ActsAsFerret::remote)
-      super
-    end
-
-    def find_ids(query, options, &proc)
-      total_hits, results = handle_drb_error([0, []]) { @server.multi_find_ids(@index_names, query, options) }
-      block_given? ? yield_results(total_hits, results, &proc) : [ total_hits, results ]
-    end
-
-    def method_missing(name, *args)
-      handle_drb_error { @server.send(:"multi_#{name}", @index_names, *args) }
-    end
-  end
-end
@@ -1,50 +0,0 @@
-module ActsAsFerret
-
-  # decorator that adds a total_hits accessor and will_paginate compatible 
-  # paging support to search result arrays
-  class SearchResults < ActsAsFerret::BlankSlate
-    reveal :methods
-    attr_reader :current_page, :per_page, :total_hits, :total_pages
-    alias total_entries total_hits  # will_paginate compatibility
-    alias page_count total_pages    # will_paginate backwards compatibility
-
-    def initialize(results, total_hits, current_page = 1, per_page = nil)
-      @results = results
-      @total_hits = total_hits
-      @current_page = current_page
-      @per_page = (per_page || total_hits)
-      @total_pages   = @per_page > 0 ? (@total_hits / @per_page.to_f).ceil : 0
-    end
-
-    def method_missing(symbol, *args, &block)
-      @results.send(symbol, *args, &block)
-    end
-
-    def respond_to?(name)
-      methods.include?(name.to_s) || @results.respond_to?(name)
-    end
-
-
-    # code from here on was directly taken from will_paginate's collection.rb
-
-    # 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 < total_pages ? (current_page + 1) : nil
-    end
-  end
-
-end
@@ -1,58 +0,0 @@
-################################################################################
-require 'optparse'
-
-################################################################################
-$ferret_server_options = {
-  'environment' => nil,
-  'debug'       => nil,
-  'root'        => nil
-}
-
-################################################################################
-OptionParser.new do |optparser|
-  optparser.banner = "Usage: #{File.basename($0)} [options] {start|stop|run}"
-
-  optparser.on('-h', '--help', "This message") do
-    puts optparser
-    exit
-  end
-  
-  optparser.on('-R', '--root=PATH', 'Set RAILS_ROOT to the given string') do |r|
-    $ferret_server_options['root'] = r
-  end
-
-  optparser.on('-e', '--environment=NAME', 'Set RAILS_ENV to the given string') do |e|
-    $ferret_server_options['environment'] = e
-  end
-
-  optparser.on('--debug', 'Include full stack traces on exceptions') do
-    $ferret_server_options['debug'] = true
-  end
-
-  $ferret_server_action = optparser.permute!(ARGV)
-  (puts optparser; exit(1)) unless $ferret_server_action.size == 1
-
-  $ferret_server_action = $ferret_server_action.first
-  (puts optparser; exit(1)) unless %w(start stop run).include?($ferret_server_action)
-end
-
-################################################################################
-begin
-  ENV['FERRET_USE_LOCAL_INDEX'] = 'true'
-  ENV['RAILS_ENV'] = $ferret_server_options['environment']
-  
-  # determine RAILS_ROOT unless already set
-  RAILS_ROOT = $ferret_server_options['root'] || File.join(File.dirname(__FILE__), *(['..']*4)) unless defined? RAILS_ROOT
-  # check if environment.rb is present
-  rails_env_file = File.join(RAILS_ROOT, 'config', 'environment')
-  raise "Unable to find Rails environment.rb at \n#{rails_env_file}.rb\nPlease use the --root option of ferret_server to point it to your RAILS_ROOT." unless File.exists?(rails_env_file+'.rb')
-  # load it
-  require rails_env_file
-
-  require 'acts_as_ferret'
-  ActsAsFerret::Remote::Server.new.send($ferret_server_action)
-rescue Exception => e
-  $stderr.puts(e.message)
-  $stderr.puts(e.backtrace.join("\n")) if $ferret_server_options['debug']
-  exit(1)
-end
@@ -1,64 +0,0 @@
-################################################################################
-module ActsAsFerret
-  module Remote
-
-    ################################################################################
-    # methods for becoming a daemon on Unix-like operating systems
-    module UnixDaemon
-
-      ################################################################################
-      def platform_daemon (&block)
-        safefork do
-          write_pid_file
-          trap("TERM") { exit(0) }
-          sess_id = Process.setsid
-          STDIN.reopen("/dev/null")
-          STDOUT.reopen("#{RAILS_ROOT}/log/ferret_server.out", "a")
-          STDERR.reopen(STDOUT)
-          block.call
-        end
-      end
-
-      ################################################################################
-      # stop the daemon, nicely at first, and then forcefully if necessary
-      def stop
-        pid = read_pid_file
-        raise "ferret_server doesn't appear to be running" unless pid
-        $stdout.puts("stopping ferret server...")
-        Process.kill("TERM", pid)
-        30.times { Process.kill(0, pid); sleep(0.5) }
-        $stdout.puts("using kill -9 #{pid}")
-        Process.kill(9, pid)
-      rescue Errno::ESRCH => e
-        $stdout.puts("process #{pid} has stopped")
-      ensure
-        File.unlink(@cfg.pid_file) if File.exist?(@cfg.pid_file)
-      end
-
-      ################################################################################
-      def safefork (&block)
-        @fork_tries ||= 0
-        fork(&block)
-      rescue Errno::EWOULDBLOCK
-        raise if @fork_tries >= 20
-        @fork_tries += 1
-        sleep 5
-        retry
-      end
-
-      #################################################################################
-      # create the PID file and install an at_exit handler
-      def write_pid_file
-        raise "ferret_server may already be running, a pid file exists: #{@cfg.pid_file}" if read_pid_file
-        open(@cfg.pid_file, "w") {|f| f << Process.pid << "\n"}
-        at_exit { File.unlink(@cfg.pid_file) if read_pid_file == Process.pid }
-      end
-
-      #################################################################################
-      def read_pid_file
-        File.read(@cfg.pid_file).to_i if File.exist?(@cfg.pid_file)
-      end
-
-    end
-  end
-end
@@ -1,49 +0,0 @@
-module ActsAsFerret
-
-  # Include this module to use acts_as_ferret with model classes 
-  # not based on ActiveRecord. 
-  #
-  # Implement the find_for_id(id) class method in your model class in
-  # order to make search work.
-  module WithoutAR
-    def self.included(target)
-      target.extend ClassMethods
-      target.extend ActsAsFerret::ActMethods
-      target.send :include, InstanceMethods
-    end
-
-    module ClassMethods
-      def logger
-        RAILS_DEFAULT_LOGGER
-      end
-      def table_name
-        self.name.underscore
-      end
-      def primary_key
-        'id'
-      end
-      def find(what, args = {})
-        case what
-        when :all
-          ids = args[:conditions][1]
-          ids.map { |id| find id }
-        else
-          find_for_id what
-        end
-      end
-      def find_for_id(id)
-        raise NotImplementedError.new("implement find_for_id in class #{self.name}")
-      end
-      def count
-        0
-      end
-    end
-
-    module InstanceMethods
-      def logger
-        self.class.logger
-      end
-    end
-  end
-        
-end
@@ -1,134 +0,0 @@
-# rakefile for acts_as_ferret. 
-# use to create a gem or generate rdoc api documentation.
-#
-# RELEASE creation:
-# rake release REL=x.y.z 
-
-require 'rake'
-require 'rake/rdoctask'
-require 'rake/packagetask'
-require 'rake/gempackagetask'
-require 'rake/testtask'
-require 'rake/contrib/rubyforgepublisher'
-
-def announce(msg='')
-  STDERR.puts msg
-end
-
-
-PKG_NAME      = 'acts_as_ferret'
-PKG_VERSION   = ENV['REL']
-PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
-RUBYFORGE_PROJECT = 'actsasferret'
-RUBYFORGE_USER    = 'jkraemer'
-
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'Test the acts_as_ferret plugin.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
-
-desc 'Generate documentation for the acts_as_ferret plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'html'
-  rdoc.title    = "acts_as_ferret - Ferret based full text search for any ActiveRecord model"
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.options << '--main' << 'README'
-  rdoc.rdoc_files.include('README', 'LICENSE')
-  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-desc "Publish the API documentation"
-task :pdoc => [:rdoc] do
-  Rake::RubyForgePublisher.new(RUBYFORGE_PROJECT, RUBYFORGE_USER).upload
-end
-
-if PKG_VERSION
-  spec = Gem::Specification.new do |s|
-    s.name            = PKG_NAME
-    s.version         = PKG_VERSION
-    s.platform        = Gem::Platform::RUBY
-    s.summary         = "acts_as_ferret - Ferret based full text search for any ActiveRecord model"
-    s.files  = Dir.glob('**/*', File::FNM_DOTMATCH).reject do |f| 
-      [ /\.$/, /sqlite$/, /\.log$/, /^pkg/, /\.svn/, /\.\w+\.sw.$/,
-        /^html/, /\~$/, /\/\._/, /\/#/ ].any? {|regex| f =~ regex }
-    end
-    #s.files           = FileList["{lib,test}/**/*"].to_a + %w(README MIT-LICENSE CHANGELOG)
-  # s.files.delete  ...    
-    s.require_path    = 'lib'
-    s.bindir          = "bin"
-    s.executables     = ["aaf_install"]
-    s.default_executable = "aaf_install"
-    s.autorequire     = 'acts_as_ferret'
-    s.has_rdoc        = true
-  # s.test_files      = Dir['test/**/*_test.rb']
-    s.author          = "Jens Kraemer"
-    s.email           = "jk@jkraemer.net"
-    s.homepage        = "http://projects.jkraemer.net/acts_as_ferret"
-  end
-
-  package_task = Rake::GemPackageTask.new(spec) do |pkg|
-    pkg.need_tar = true
-  end
-
-  # Validate that everything is ready to go for a release.
-  task :prerelease do
-    announce 
-    announce "**************************************************************"
-    announce "* Making RubyGem Release #{PKG_VERSION}"
-    announce "**************************************************************"
-    announce  
-    # Are all source files checked in?
-    if ENV['RELTEST']
-      announce "Release Task Testing, skipping checked-in file test"
-    else
-      announce "Pulling in svn..."
-      `svk pull .`
-      announce "Checking for unchecked-in files..."
-      data = `svk st`
-      unless data =~ /^$/
-        fail "SVK status is not clean ... do you have unchecked-in files?"
-      end
-      announce "No outstanding checkins found ... OK"
-#      announce "Pushing to svn..."
-#      `svk push .`
-    end
-  end
-  
-  
-  desc "tag the new release"
-  task :tag => [ :prerelease ] do
-    reltag = "REL_#{PKG_VERSION.gsub(/\./, '_')}"
-    reltag << ENV['REUSE'].gsub(/\./, '_') if ENV['REUSE']
-    announce "Tagging with [#{PKG_VERSION}]"
-    if ENV['RELTEST']
-      announce "Release Task Testing, skipping tagging"
-    else
-      `svn copy -m 'tagging version #{PKG_VERSION}' svn://projects.jkraemer.net/acts_as_ferret/trunk/plugin svn://projects.jkraemer.net/acts_as_ferret/tags/#{PKG_VERSION}`
-      `svn del -m 'remove old stable' svn://projects.jkraemer.net/acts_as_ferret/tags/stable`
-      `svn copy -m 'tagging version #{PKG_VERSION} as stable' svn://projects.jkraemer.net/acts_as_ferret/tags/#{PKG_VERSION} svn://projects.jkraemer.net/acts_as_ferret/tags/stable`
-    end
-  end
-  
-  # Upload release to rubyforge
-  desc "Upload release to rubyforge"
-  task :prel => [ :tag, :prerelease, :package ] do
-    `rubyforge login`
-    release_command = "rubyforge add_release #{RUBYFORGE_PROJECT} #{PKG_NAME} '#{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.gem"
-    puts release_command
-    system(release_command)
-    `rubyforge config #{RUBYFORGE_PROJECT}`
-    release_command = "rubyforge add_file #{RUBYFORGE_PROJECT} #{PKG_NAME} '#{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.tgz"
-    puts release_command
-    system(release_command)
-  end
-  
-  desc 'Publish the gem and API docs'
-  task :release => [:pdoc, :prel ]
-  
-end
@@ -1,97 +0,0 @@
-# Ferret DRb server Capistrano tasks
-# 
-# Usage:
-# in your Capfile, add acts_as_ferret's recipes directory to your load path and
-# load the ferret tasks:
-#
-# load_paths << 'vendor/plugins/acts_as_ferret/recipes'
-# load 'aaf_recipes'
-#
-# This will hook aaf's DRb start/stop tasks into the standard
-# deploy:{start|restart|stop} tasks so the server will be restarted along with
-# the rest of your application.
-# Also an index directory in the shared folder will be created and symlinked
-# into current/ when you deploy.
-#
-# In order to use the ferret:index:rebuild task, declare the indexes you intend to
-# rebuild remotely in config/deploy.rb:
-#
-# set :ferret_indexes, %w( model another_model shared )
-#
-# HINT: To be very sure that your DRb server and application are always using
-# the same model and schema versions, and you never lose any index updates because
-# of the DRb server being restarted in that moment, use the following sequence
-# to update your application:
-#
-# cap deploy:stop deploy:update deploy:migrate deploy:start
-#
-# That will stop the DRb server after stopping your application, and bring it
-# up before starting the application again. Plus they'll never use different
-# versions of model classes (which might happen otherwise)
-# Downside: Your downtime is a bit longer than with the usual deploy, so be sure to
-# put up some maintenance page for the meantime. Obviously this won't work if
-# your migrations need acts_as_ferret (i.e. if you update model instances which
-# would lead to index updates). In this case bring up the DRb server before
-# running your migrations:
-#
-# cap deploy:stop deploy:update ferret:start deploy:migrate ferret:stop deploy:start
-#
-# Chances are that you're still not safe if your migrations not only modify the index, 
-# but also change the structure of your models. So just don't do both things in
-# one go - I can't think of an easy way to handle this case automatically.
-# Suggestions and patches are of course very welcome :-)
-
-namespace :ferret do
-
-  desc "Stop the Ferret DRb server"
-  task :stop, :roles => :app do
-    rails_env = fetch(:rails_env, 'production')
-    run "cd #{current_path}; script/ferret_server -e #{rails_env} stop || true"
-  end
-
-  desc "Start the Ferret DRb server"
-  task :start, :roles => :app do
-    rails_env = fetch(:rails_env, 'production')
-    run "cd #{current_path}; script/ferret_server -e #{rails_env} start"
-  end
-
-  desc "Restart the Ferret DRb server"
-  task :restart, :roles => :app do
-    top.ferret.stop
-    sleep 1
-    top.ferret.start
-  end
-
-  namespace :index do
-
-    desc "Rebuild the Ferret index. See aaf_recipes.rb for instructions."
-    task :rebuild => :environment, :roles => :app do
-      rake = fetch(:rake, 'rake')
-      rails_env = fetch(:rails_env, 'production')
-      indexes = fetch(:ferret_indexes, nil)
-      if indexes and indexes.any?
-        run "cd #{current_path}; RAILS_ENV=#{rails_env} INDEXES='#{indexes.join(' ')}' #{rake} ferret:rebuild"
-      end
-    end
-
-    desc "purges all indexes for the current environment"
-    task :purge, :roles => :app do
-      run "rm -fr #{shared_path}/index/#{rails_env}"
-    end
-
-    desc "symlinks index folder"
-    task :symlink, :roles => :app do
-      run "mkdir -p  #{shared_path}/index && rm -rf #{release_path}/index && ln -nfs #{shared_path}/index #{release_path}/index"
-    end
-
-  end
-
-end
-
-after  "deploy:stop",    "ferret:stop"
-before "deploy:start",   "ferret:start"
-
-before "deploy:restart", "ferret:stop"
-after  "deploy:restart", "ferret:start"
-after "deploy:symlink", "ferret:index:symlink"
-
@@ -1,94 +0,0 @@
-# Ferret Win32 Service Daemon, called by Win 32 service, 
-# created by Herryanto Siatono <herryanto@pluitsolutions.com>
-#
-# see doc/README.win32 for usage instructions
-#
-require 'optparse'
-require 'win32/service'
-include Win32
-
-# Read options
-options = {}
-ARGV.options  do |opts|
-  opts.banner = 'Usage: ferret_daemon [options]'
-  opts.on("-l", "--log FILE", "Daemon log file") {|file| options[:log] = file }  
-  opts.on("-c","--console","Run Ferret server on console.") {options[:console] = true}
-  opts.on_tail("-h","--help", "Show this help message") {puts opts; exit}
-  opts.on("-e", "--environment ENV ", "Rails environment") {|env|
-    options[:environment] = env
-    ENV['RAILS_ENV'] = env
-  }
-  opts.parse!
-end
-
-require File.dirname(__FILE__) + '/../config/environment'
-
-# Ferret Win32 Service Daemon, called by Win 32 service, 
-# to run on the console, use -c or --console option.
-module Ferret
-  class FerretDaemon < Daemon
-    # Standard logger to redirect STDOUT and STDERR to a log file
-    class FerretStandardLogger
-      def initialize(logger)
-        @logger = logger
-      end
-      
-      def write(s)
-        @logger.info s
-      end
-    end
-    
-    def initialize(options={})
-      @options = options
-      
-      # initialize logger
-      if options[:log]      
-        @logger = Logger.new @options[:log]
-      else 
-        @logger = Logger.new RAILS_ROOT + "/log/ferret_service_#{RAILS_ENV}.log"
-      end
-      
-      # redirect stout and stderr to Ferret logger if running as windows service
-      $stdout = $stderr = FerretStandardLogger.new(@logger) unless @options[:console]
-      
-      log "Initializing FerretDaemon..."
-      if @options[:console]
-      	self.service_init
-      	self.service_main
-      end
-    end
-    
-    def service_main
-      log "Service main enterred..."
-      
-      while running?
-        log "Listening..."
-        sleep
-      end
-      
-      log "Service main exit..."
-    end
-    
-    def service_init
-      log "Starting Ferret DRb server..."
-      ActsAsFerret::Remote::Server.start
-      log "FerretDaemon started."    
-    end
-    
-    def service_stop
-      log "Stopping service..."
-      DRb.stop_service
-      log "FerretDaemon stopped."
-    end
-    
-    def log(msg)
-      @logger.info msg 
-      puts msg if @options[:console]
-    end
-  end
-end
-
-if __FILE__ == $0
-  d = Ferret::FerretDaemon.new(options)
-  d.mainloop
-end
@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-
-begin
-  require File.join(File.dirname(__FILE__), '../vendor/plugins/acts_as_ferret/lib/server_manager')
-rescue LoadError
-  # try the gem
-  require 'rubygems'
-  gem 'acts_as_ferret'
-  require 'server_manager'
-end
@@ -1,178 +0,0 @@
-# Ferret Win32 Service Daemon install script 
-# created by Herryanto Siatono <herryanto@pluitsolutions.com>
-#
-# see doc/README.win32 for usage instructions
-#
-require 'optparse'
-require 'win32/service'
-include Win32
-
-module Ferret
-  # Parse and validate service command and options
-  class FerretServiceCommand
-    COMMANDS = ['install', 'remove', 'start', 'stop', 'help']
-    BANNER = "Usage: ruby script/ferret_service <command> [options]"
-    
-    attr_reader :options, :command
-    
-    def initialize
-      @options = {}
-    end
-    
-    def valid_command?      
-      COMMANDS.include?@command
-    end
-    
-    def valid_options?
-      @options[:name] and !@options[:name].empty?
-    end
-    
-    def print_command_list
-      puts BANNER 
-      puts "\nAvailable commands:\n"
-      puts COMMANDS.map {|cmd| " - #{cmd}\n"}
-      puts "\nUse option -h for each command to help."
-      exit
-    end
-    
-    def validate_options
-      errors = []
-      errors << "Service name is required." unless @options[:name]
-      
-      if (errors.size > 0)
-        errors << "Error found. Use: 'ruby script/ferret_service #{@command} -h' for to get help."
-        puts errors.join("\n")
-        exit
-      end
-    end
-    
-    def run(args)
-      @command = args.shift      
-      @command = @command.dup.downcase if @command
-      
-      # validate command and options      
-      print_command_list unless valid_command? or @command == 'help'
-      
-      opts_parser = create_options_parser
-      begin
-        opts_parser.parse!(args)
-      rescue OptionParser::ParseError => e
-        puts e
-        puts opts_parser
-      end
-      
-      # validate required options
-      validate_options
-    end
-    
-    def create_options_parser
-      opts_parser = OptionParser.new
-      opts_parser.banner = BANNER
-      opts_parser.on("-n", "--name=NAME", "Service name") {|name| @options[:name] = name }
-      opts_parser.on_tail("-t", "--trace",  "Display stack trace when exception thrown") { @options[:trace] = true }
-      opts_parser.on_tail("-h", "--help",   "Show this help message") { puts opts_parser; exit }
-      
-      if ['install'].include?@command
-        opts_parser.on("-d", "--display=NAME", "Service display name") {|name| @options[:display] = name }
-        
-        opts_parser.on("-l", "--log FILE", "Service log file") {|file| @options[:log] = file }  
-        opts_parser.on("-e",     "--environment ENV ",    "Rails environment") { |env|
-          @options[:environment] = env
-          ENV['RAILS_ENV'] = env
-        }    
-      end
-      opts_parser
-    end
-  end
-  
-  # Install, Remove, Start and Stop Ferret DRb server Win32 service
-  class FerretService
-    FERRET_DAEMON = 'ferret_daemon'
-    
-    def initialize
-    end
-    
-    def install
-      svc = Service.new
-      
-      begin
-        if Service.exists?(@options[:name])
-          puts "Service name '#{@options[:name]}' already exists."
-          return
-        end 
-        
-        svc.create_service do |s|
-          s.service_name = @options[:name]
-          s.display_name = @options[:display]
-          s.binary_path_name = binary_path_name
-          s.dependencies = []
-        end
-        
-        svc.close
-        puts "'#{@options[:name]}' service installed."
-      rescue => e
-        handle_error(e)
-      end
-    end
-    
-    def remove
-      begin
-        Service.stop(@options[:name])
-      rescue
-      end
-      
-      begin
-        Service.delete(@options[:name])    
-        puts "'#{@options[:name]}' service removed."
-      rescue => e      
-        handle_error(e)
-      end
-    end
-    
-    def start
-      begin
-        Service.start(@options[:name])
-        puts "'#{@options[:name]}' successfully started."
-      rescue => e
-        handle_error(e)
-      end 
-    end
-    
-    def stop
-      begin
-        Service.stop(@options[:name])
-        puts "'#{@options[:name]}' successfully stopped.\n"
-      rescue => e
-        handle_error(e)
-      end 
-    end
-    
-    def run(args)
-      svc_cmd = FerretServiceCommand.new
-      svc_cmd.run(args)
-      @options = svc_cmd.options
-      self.send(svc_cmd.command.to_sym)
-    end
-    
-    protected  
-    def handle_error(e)
-      if @options[:trace]
-        raise e
-      else
-        puts e
-      end
-    end
-    
-    def binary_path_name
-      path = ""
-      path << "#{ENV['RUBY_HOME']}/bin/" if ENV['RUBY_HOME']
-      path << "ruby.exe "
-      path << File.expand_path("script/" + FERRET_DAEMON)
-      path << " -e #{@options[:environment]} " if @options[:environment]
-      path << " -l #{@options[:log]} " if @options[:log]
-      path
-    end
-  end
-end
-
-Ferret::FerretService.new.run(ARGV)
@@ -1,24 +0,0 @@
-namespace :ferret do
-
-  # Rebuild index task. Declare the indexes to be rebuilt with the INDEXES
-  # environment variable:
-  #
-  # INDEXES="my_model shared" rake ferret:rebuild
-  desc "Rebuild a Ferret index. Specify what model to rebuild with the MODEL environment variable."
-  task :rebuild do
-    require File.join(RAILS_ROOT, 'config', 'environment')
-
-    indexes = ENV['INDEXES'].split
-    indexes.each do |index_name|
-      start = 1.minute.ago
-      ActsAsFerret::rebuild_index index_name
-      idx = ActsAsFerret::get_index index_name
-      # update records that have changed since the rebuild started
-      idx.index_definition[:registered_models].each do |m|
-        m.records_modified_since(start).each do |object|
-          object.ferret_update
-        end
-      end
-    end
-  end
-end
@@ -0,0 +1,17 @@
+*.log
+*.log
+*_pid
+coverage/*
+coverage.data
+solr/solr/data/*
+.svn
+test/db/*.db
+test/log/*.log
+pkg/*
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+acts_as_solr_reloaded-*.gem
+tags
@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright © 2010
+
+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.
@@ -0,0 +1,64 @@
+Description
+======
+This plugin adds full text search capabilities and many other nifty features from Apache's [Solr](http://lucene.apache.org/solr/) to any Rails model.
+It was based on the first draft by Erik Hatcher.
+
+This plugin is intended for use in old versions of Rails. For newer versions, I strongly advice using Sunspot!
+Nevertheless, this plugin is used for Noosfero project in production. Any problem please open an issue.
+
+Installation
+======
+
+Install as a plugin
+
+    script/plugin install git://github.com/brauliobo/acts_as_solr_reloaded.git
+
+Download Solr 3.1
+
+    rake solr:download
+
+Requirements
+------
+* Java Runtime Environment(JRE) 1.6 aka 6.0 or newer [http://www.java.com/en/download/index.jsp](http://www.java.com/en/download/index.jsp) (use default-jre for Debian like distribution)
+* (Recommended) If you have libxml-ruby installed, make sure it's at least version 0.7
+
+Configuration
+======
+See config/solr.yml file.
+
+Basic Usage
+======
+<pre><code>
+# Just include the line below to any of your ActiveRecord models:
+  acts_as_solr
+
+# Or if you want, you can specify only the fields that should be indexed:
+  acts_as_solr :fields => [:name, :author]
+
+# Then to find instances of your model, just do:
+  Model.search(query) #query is a string representing your query
+
+# Please see ActsAsSolr::ActsMethods for a complete info
+
+</code></pre>
+
+
+`acts_as_solr` in your tests
+======
+To test code that uses `acts_as_solr` you must start a Solr server for the test environment. You can do that with `rake solr:start RAILS_ENV=test`
+
+However, if you would like to mock out Solr calls so that a Solr server is not needed (and your tests will run much faster), just add this to your `test_helper.rb` or similar:
+
+<pre><code>
+class ActsAsSolr::Post
+  def self.execute(request)
+    true
+  end
+end
+</pre></code>
+
+([via](http://www.subelsky.com/2007/10/actsassolr-capistranhttpwwwbloggercomim.html#c1646308013209805416))
+
+Release Information
+======
+Released under the MIT license.
@@ -0,0 +1,96 @@
+= DESCRIPTION
+
+This plugin adds full text search capabilities and many other nifty features from Apache's Solr[http://lucene.apache.org/solr/] to any Rails model, like:
+
+* faceting
+* dynamic attributes
+* integration with acts_as_taggable_on
+* integration with will_paginate
+* highlighting
+* geolocation
+* relevance
+* suggest
+
+Watch this screencast for a short demo of the latests features:
+
+http://www.vimeo.com/8728276
+
+== INSTALLATION
+
+    script/plugin install git://github.com/brauliobo/acts_as_solr_reloaded.git
+    rake solr:download
+
+== REQUIREMENTS
+
+* Java Runtime Environment(JRE) 1.5 aka 5.0 [http://www.java.com/en/download/index.jsp](http://www.java.com/en/download/index.jsp) (use default-jre for Debian like distribution)
+* (Recommended) If you have libxml-ruby installed, make sure it's at least version 0.7
+
+== CONFIGURATION
+
+See config/solr.yml file.
+
+== USAGE
+
+Just include the line below to any of your ActiveRecord models:
+  acts_as_solr
+
+Or if you want, you can specify only the fields that should be indexed:
+  acts_as_solr :fields => [:name, :author]
+
+Then to find instances of your model, just do:
+  Model.search(query) #query is a string representing your query
+  
+Case you want to use dynamic attributes or geolocalization, you can use this generators that setup the database:
+
+  script/generate dynamic_attributes_migration
+  script/generate local_migration
+  
+and then configure your model like this:
+
+  acts_as_solr :dynamic_attributes => true,
+               :spatial => true
+               
+If you want to integrate the model with acts_as_taggable_on, just add the option :taggable => true :
+
+  acts_as_solr :taggable => true
+
+Please see ActsAsSolr::ActsMethods for a complete info
+
+== PAGINATION
+
+In your controller:
+
+  @search = Product.search "beer", :page => 2, :per_page => 20
+
+And in your view:
+
+  will_paginate @search
+
+== TESTING
+
+To test code that uses acts_as_solr_reloaded you must start a Solr server for the test environment and also start MongoDB.
+
+== LICENSE
+
+(The MIT License)
+
+Copyright © 2010
+
+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.
@@ -0,0 +1,71 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+Dir["#{File.dirname(__FILE__)}/lib/tasks/*.rake"].sort.each { |ext| load ext }
+
+desc "Default Task"
+task :default => [:test]
+
+desc "Runs the unit tests"
+task :test => "test:unit"
+
+namespace :test do
+  task :setup do
+    RAILS_ROOT = File.expand_path("#{File.dirname(__FILE__)}/test") unless defined? RAILS_ROOT
+    ENV['RAILS_ENV'] = "test"
+    ENV["ACTS_AS_SOLR_TEST"] = "true"
+    require File.expand_path("#{File.dirname(__FILE__)}/config/solr_environment")
+    puts "Using " + DB
+    %x(mysql -u#{MYSQL_USER} < #{File.dirname(__FILE__) + "/test/fixtures/db_definitions/mysql.sql"}) if DB == 'mysql'
+
+    Rake::Task["test:migrate"].invoke
+  end
+
+  desc 'Measures test coverage using rcov'
+  task :rcov => :setup do
+    rm_f "coverage"
+    rm_f "coverage.data"
+    rcov = "rcov --rails --aggregate coverage.data --text-summary -Ilib"
+
+    system("#{rcov} --html #{Dir.glob('test/**/*_shoulda.rb').join(' ')}")
+    system("open coverage/index.html") if PLATFORM['darwin']
+  end
+
+  desc 'Runs the functional tests, testing integration with Solr'
+  Rake::TestTask.new('functional' => :setup) do |t|
+    t.pattern = "test/functional/*_test.rb"
+    t.verbose = true
+  end
+
+  desc "Unit tests"
+  Rake::TestTask.new(:unit) do |t|
+    t.libs << 'test/unit'
+    t.pattern = "test/unit/*_shoulda.rb"
+    t.verbose = true
+  end
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_dir = "rdoc"
+  rd.rdoc_files.exclude("lib/solr/**/*.rb", "lib/solr.rb")
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "acts_as_solr_reloaded"
+    s.summary = "This gem adds full text search capabilities and many other nifty features from Apache Solr to any Rails model."
+    s.email = "dc.rec1@gmail.com"
+    s.homepage = "http://github.com/dcrec1/acts_as_solr_reloaded"
+    s.description = "This gem adds full text search capabilities and many other nifty features from Apache Solr to any Rails model."
+    s.authors = ["Diego Carrion"]
+    s.files =  FileList["[A-Z]*", "{bin,generators,config,lib,solr}/**/*"] +
+      FileList["test/**/*"].reject {|f| f.include?("test/log")}.reject {|f| f.include?("test/tmp")}
+  end
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install jeweler"
+end
@@ -0,0 +1,25 @@
+acts_as_solr comes with a quick and fast unit test suite, and with a longer-running
+functional test suite, the latter testing the actual integration with Solr.
+
+The unit test suite is written using Shoulda, so make sure you have a recent version
+installed.
+
+Running `rake test` or just `rake` will run both test suites. Use `rake test:unit` to
+just run the unit test suite.
+ 
+== How to run functional tests for this plugin:
+To run the acts_as_solr's plugin tests run the following steps:
+
+- create a MySQL database called "actsassolr_test" (if you want to use MySQL)
+
+- create a new Rails project, if needed (the plugin can only be tested from within a Rails project); move/checkout acts_as_solr into its vendor/plugins/, as usual
+
+- copy vendor/plugins/acts_as_solr/config/solr.yml to config/ (the Rails config folder)
+
+- rake solr:start RAILS_ENV=test
+
+- rake test:functional (Accepts the following arguments: DB=sqlite|mysql and MYSQL_USER=user)
+
+== Troubleshooting:
+If for some reason the tests don't run and you get MySQL errors, make sure you edit the MYSQL_USER entry under
+config/environment.rb. It's recommended to create or use a MySQL user with no password.
@@ -0,0 +1 @@
+1.6.0
 \ No newline at end of file
@@ -0,0 +1,205 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{acts_as_solr_reloaded}
+  s.version = "1.6.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Diego Carrion"]
+  s.date = %q{2011-03-20}
+  s.description = %q{This gem adds full text search capabilities and many other nifty features from Apache Solr to any Rails model.}
+  s.email = %q{dc.rec1@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.markdown",
+    "README.rdoc"
+  ]
+  s.files = [
+    "LICENSE",
+    "README.markdown",
+    "README.rdoc",
+    "Rakefile",
+    "TESTING_THE_PLUGIN",
+    "VERSION",
+    "config/solr.yml",
+    "config/solr_environment.rb",
+    "generators/dynamic_attributes_migration/dynamic_attributes_migration_generator.rb",
+    "generators/dynamic_attributes_migration/templates/migration.rb",
+    "generators/local_migration/local_migration_generator.rb",
+    "generators/local_migration/templates/migration.rb",
+    "lib/acts_as_solr.rb",
+    "lib/acts_as_solr/acts_methods.rb",
+    "lib/acts_as_solr/class_methods.rb",
+    "lib/acts_as_solr/common_methods.rb",
+    "lib/acts_as_solr/deprecation.rb",
+    "lib/acts_as_solr/dynamic_attribute.rb",
+    "lib/acts_as_solr/instance_methods.rb",
+    "lib/acts_as_solr/lazy_document.rb",
+    "lib/acts_as_solr/local.rb",
+    "lib/acts_as_solr/mongo_mapper.rb",
+    "lib/acts_as_solr/parser_methods.rb",
+    "lib/acts_as_solr/search_results.rb",
+    "lib/acts_as_solr/solr_fixtures.rb",
+    "lib/acts_as_solr/tasks.rb",
+    "lib/acts_as_solr_reloaded.rb",
+    "lib/solr.rb",
+    "lib/solr/connection.rb",
+    "lib/solr/document.rb",
+    "lib/solr/exception.rb",
+    "lib/solr/field.rb",
+    "lib/solr/importer.rb",
+    "lib/solr/importer/array_mapper.rb",
+    "lib/solr/importer/delimited_file_source.rb",
+    "lib/solr/importer/hpricot_mapper.rb",
+    "lib/solr/importer/mapper.rb",
+    "lib/solr/importer/solr_source.rb",
+    "lib/solr/importer/xpath_mapper.rb",
+    "lib/solr/indexer.rb",
+    "lib/solr/request.rb",
+    "lib/solr/request/add_document.rb",
+    "lib/solr/request/base.rb",
+    "lib/solr/request/commit.rb",
+    "lib/solr/request/delete.rb",
+    "lib/solr/request/dismax.rb",
+    "lib/solr/request/index_info.rb",
+    "lib/solr/request/modify_document.rb",
+    "lib/solr/request/optimize.rb",
+    "lib/solr/request/ping.rb",
+    "lib/solr/request/select.rb",
+    "lib/solr/request/spellcheck.rb",
+    "lib/solr/request/standard.rb",
+    "lib/solr/request/update.rb",
+    "lib/solr/response.rb",
+    "lib/solr/response/add_document.rb",
+    "lib/solr/response/base.rb",
+    "lib/solr/response/commit.rb",
+    "lib/solr/response/delete.rb",
+    "lib/solr/response/dismax.rb",
+    "lib/solr/response/index_info.rb",
+    "lib/solr/response/modify_document.rb",
+    "lib/solr/response/optimize.rb",
+    "lib/solr/response/ping.rb",
+    "lib/solr/response/ruby.rb",
+    "lib/solr/response/select.rb",
+    "lib/solr/response/spellcheck.rb",
+    "lib/solr/response/standard.rb",
+    "lib/solr/response/xml.rb",
+    "lib/solr/solrtasks.rb",
+    "lib/solr/util.rb",
+    "lib/solr/xml.rb",
+    "lib/tasks/database.rake",
+    "lib/tasks/solr.rake",
+    "lib/tasks/test.rake",
+    "test/config/solr.yml",
+    "test/db/connections/mysql/connection.rb",
+    "test/db/connections/sqlite/connection.rb",
+    "test/db/migrate/001_create_books.rb",
+    "test/db/migrate/002_create_movies.rb",
+    "test/db/migrate/003_create_categories.rb",
+    "test/db/migrate/004_create_electronics.rb",
+    "test/db/migrate/005_create_authors.rb",
+    "test/db/migrate/006_create_postings.rb",
+    "test/db/migrate/007_create_posts.rb",
+    "test/db/migrate/008_create_gadgets.rb",
+    "test/db/migrate/009_create_dynamic_attributes.rb",
+    "test/db/migrate/010_create_advertises.rb",
+    "test/db/migrate/011_create_locals.rb",
+    "test/db/test.db",
+    "test/fixtures/advertises.yml",
+    "test/fixtures/authors.yml",
+    "test/fixtures/books.yml",
+    "test/fixtures/categories.yml",
+    "test/fixtures/db_definitions/mysql.sql",
+    "test/fixtures/dynamic_attributes.yml",
+    "test/fixtures/electronics.yml",
+    "test/fixtures/locals.yml",
+    "test/fixtures/movies.yml",
+    "test/fixtures/postings.yml",
+    "test/functional/acts_as_solr_test.rb",
+    "test/functional/association_indexing_test.rb",
+    "test/functional/faceted_search_test.rb",
+    "test/functional/multi_solr_search_test.rb",
+    "test/models/advertise.rb",
+    "test/models/author.rb",
+    "test/models/book.rb",
+    "test/models/category.rb",
+    "test/models/document.rb",
+    "test/models/dynamic_attribute.rb",
+    "test/models/electronic.rb",
+    "test/models/gadget.rb",
+    "test/models/local.rb",
+    "test/models/movie.rb",
+    "test/models/novel.rb",
+    "test/models/post.rb",
+    "test/models/posting.rb",
+    "test/test_helper.rb",
+    "test/unit/acts_methods_shoulda.rb",
+    "test/unit/class_methods_shoulda.rb",
+    "test/unit/common_methods_shoulda.rb",
+    "test/unit/instance_methods_shoulda.rb",
+    "test/unit/lazy_document_shoulda.rb",
+    "test/unit/parser_instance.rb",
+    "test/unit/parser_methods_shoulda.rb",
+    "test/unit/solr_instance.rb",
+    "test/unit/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/dcrec1/acts_as_solr_reloaded}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.0}
+  s.summary = %q{This gem adds full text search capabilities and many other nifty features from Apache Solr to any Rails model.}
+  s.test_files = [
+    "test/db/connections/mysql/connection.rb",
+    "test/db/connections/sqlite/connection.rb",
+    "test/db/migrate/001_create_books.rb",
+    "test/db/migrate/002_create_movies.rb",
+    "test/db/migrate/003_create_categories.rb",
+    "test/db/migrate/004_create_electronics.rb",
+    "test/db/migrate/005_create_authors.rb",
+    "test/db/migrate/006_create_postings.rb",
+    "test/db/migrate/007_create_posts.rb",
+    "test/db/migrate/008_create_gadgets.rb",
+    "test/db/migrate/009_create_dynamic_attributes.rb",
+    "test/db/migrate/010_create_advertises.rb",
+    "test/db/migrate/011_create_locals.rb",
+    "test/functional/acts_as_solr_test.rb",
+    "test/functional/association_indexing_test.rb",
+    "test/functional/faceted_search_test.rb",
+    "test/functional/multi_solr_search_test.rb",
+    "test/models/advertise.rb",
+    "test/models/author.rb",
+    "test/models/book.rb",
+    "test/models/category.rb",
+    "test/models/document.rb",
+    "test/models/dynamic_attribute.rb",
+    "test/models/electronic.rb",
+    "test/models/gadget.rb",
+    "test/models/local.rb",
+    "test/models/movie.rb",
+    "test/models/novel.rb",
+    "test/models/post.rb",
+    "test/models/posting.rb",
+    "test/test_helper.rb",
+    "test/unit/acts_methods_shoulda.rb",
+    "test/unit/class_methods_shoulda.rb",
+    "test/unit/common_methods_shoulda.rb",
+    "test/unit/instance_methods_shoulda.rb",
+    "test/unit/lazy_document_shoulda.rb",
+    "test/unit/parser_instance.rb",
+    "test/unit/parser_methods_shoulda.rb",
+    "test/unit/solr_instance.rb",
+    "test/unit/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+
@@ -0,0 +1,14 @@
+# Config file for the acts_as_solr_reloaded plugin.
+#
+# If you change the host or port number here, make sure you update 
+# them in your Solr config file
+
+development:
+  url: http://127.0.0.1:8982/solr
+  
+test:
+  url: http://127.0.0.1:8981/solr
+  
+production:
+  url: http://127.0.0.1:8983/solr
+  jvm_options: -server -d64 -Xmx1024M -Xms64M
 \ No newline at end of file
@@ -0,0 +1,43 @@
+ENV['RAILS_ENV']  = (ENV['RAILS_ENV'] || 'development').dup
+require "uri"
+require "fileutils"
+require "yaml"
+dir = File.dirname(__FILE__)
+SOLR_PATH = File.expand_path("#{dir}/../solr") unless defined? SOLR_PATH
+
+# RAILS_ROOT isn't defined yet, so figure it out.
+unless defined? RAILS_ROOT
+  RAILS_ROOT = File.expand_path("#{File.dirname(__FILE__)}/../test")
+end
+unless defined? SOLR_LOGS_PATH
+  SOLR_LOGS_PATH = ENV["SOLR_LOGS_PATH"] || "#{RAILS_ROOT}/log"
+end
+unless defined? SOLR_PIDS_PATH
+  SOLR_PIDS_PATH = ENV["SOLR_PIDS_PATH"] || "#{RAILS_ROOT}/tmp/pids"
+end
+unless defined? SOLR_DATA_PATH
+  SOLR_DATA_PATH = ENV["SOLR_DATA_PATH"] || "#{RAILS_ROOT}/solr/#{ENV['RAILS_ENV']}"
+end
+unless defined? SOLR_CONFIG_PATH
+  SOLR_CONFIG_PATH = ENV["SOLR_CONFIG_PATH"] || "#{SOLR_PATH}/solr"
+end
+unless defined? SOLR_PID_FILE
+  SOLR_PID_FILE="#{SOLR_PIDS_PATH}/solr.#{ENV['RAILS_ENV']}.pid"
+end
+
+unless defined? SOLR_PORT
+  config = YAML::load_file(RAILS_ROOT+'/config/solr.yml')
+  raise("No solr environment defined for RAILS_ENV the #{ENV['RAILS_ENV'].inspect}") unless config[ENV['RAILS_ENV']]
+
+  SOLR_HOST = ENV['HOST'] || URI.parse(config[ENV['RAILS_ENV']]['url']).host
+  SOLR_PORT = ENV['PORT'] || URI.parse(config[ENV['RAILS_ENV']]['url']).port
+end
+
+SOLR_JVM_OPTIONS = config[ENV['RAILS_ENV']]['jvm_options'] unless defined? SOLR_JVM_OPTIONS
+
+if ENV["ACTS_AS_SOLR_TEST"]
+  require "activerecord"
+  DB = (ENV['DB'] ? ENV['DB'] : 'sqlite') unless defined?(DB)
+  MYSQL_USER = (ENV['MYSQL_USER'].nil? ? 'root' : ENV['MYSQL_USER']) unless defined? MYSQL_USER
+  require File.join(File.dirname(File.expand_path(__FILE__)), '..', 'test', 'db', 'connections', DB, 'connection.rb')
+end
@@ -0,0 +1,7 @@
+class DynamicAttributesMigrationGenerator < Rails::Generator::Base 
+  def manifest 
+    record do |m| 
+      m.migration_template 'migration.rb', 'db/migrate', :migration_file_name => "dynamic_attributes_migration"
+    end
+  end
+end
 \ No newline at end of file
@@ -0,0 +1,17 @@
+class DynamicAttributesMigration < ActiveRecord::Migration
+  def self.up
+    create_table :dynamic_attributes do |t|
+      t.integer :dynamicable_id
+      t.string  :dynamicable_type
+      t.string :name
+      t.text :value
+      t.timestamps
+    end
+    add_index :dynamic_attributes, [:dynamicable_id, :dynamicable_type, :name], :unique => true,  :name => 'da_pk'
+  end
+
+  def self.down
+    remove_index 'da_pk'
+    drop_table :dynamic_attributes
+  end
+end
@@ -0,0 +1,7 @@
+class LocalMigrationGenerator < Rails::Generator::Base 
+  def manifest 
+    record do |m| 
+      m.migration_template 'migration.rb', 'db/migrate', :migration_file_name => "local_migration"
+    end
+  end
+end
 \ No newline at end of file
@@ -0,0 +1,16 @@
+class LocalMigration < ActiveRecord::Migration
+  def self.up
+    create_table :locals do |t|
+      t.integer :localizable_id
+      t.string  :localizable_type
+      t.string :latitude
+      t.string :longitude
+
+      t.timestamps
+    end
+  end
+  
+  def self.down
+    drop_table :locals
+  end
+end
 \ No newline at end of file
@@ -0,0 +1 @@
+require 'acts_as_solr'
 \ No newline at end of file
@@ -0,0 +1,5 @@
+require 'fileutils'
+
+src = File.join(File.dirname(__FILE__), 'config', 'solr.yml')
+target = File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'solr.yml')
+FileUtils.cp src, target
 \ No newline at end of file
@@ -0,0 +1,47 @@
+require 'active_record'
+require 'rexml/document'
+require 'net/http'
+require 'yaml'
+require 'time'
+require 'erb'
+require 'rexml/xpath'
+
+require File.dirname(__FILE__) + '/solr'
+require File.dirname(__FILE__) + '/acts_as_solr/acts_methods'
+require File.dirname(__FILE__) + '/acts_as_solr/common_methods'
+require File.dirname(__FILE__) + '/acts_as_solr/parser_methods'
+require File.dirname(__FILE__) + '/acts_as_solr/class_methods'
+require File.dirname(__FILE__) + '/acts_as_solr/dynamic_attribute'
+require File.dirname(__FILE__) + '/acts_as_solr/local'
+require File.dirname(__FILE__) + '/acts_as_solr/instance_methods'
+require File.dirname(__FILE__) + '/acts_as_solr/common_methods'
+require File.dirname(__FILE__) + '/acts_as_solr/deprecation'
+require File.dirname(__FILE__) + '/acts_as_solr/search_results'
+require File.dirname(__FILE__) + '/acts_as_solr/lazy_document'
+require File.dirname(__FILE__) + '/acts_as_solr/mongo_mapper'
+
+module ActsAsSolr
+  class Post
+    class << self
+      def config
+        @config ||= YAML::load_file("#{Rails.root}/config/solr.yml")[Rails.env]
+      end
+
+      def credentials
+        @credentials ||= {:username => config['username'], :password => config['password']}
+      end
+
+      def url(core)
+        core.nil? ? config['url'] : "#{config['url']}/#{core}"
+      end
+    
+      def execute(request, core = nil)
+        connection = Solr::Connection.new(url(core), credentials)
+        connection.send request
+      end
+    end
+  end
+end
+
+# reopen ActiveRecord and include the acts_as_solr method
+ActiveRecord::Base.extend ActsAsSolr::ActsMethods
@@ -0,0 +1,373 @@
+module ActsAsSolr #:nodoc:
+
+  module ActsMethods
+
+    # declares a class as solr-searchable
+    #
+    # ==== options:
+    # fields:: This option can be used to specify only the fields you'd
+    #          like to index. If not given, all the attributes from the
+    #          class will be indexed. You can also use this option to
+    #          include methods that should be indexed as fields
+    #
+    #           class Movie < ActiveRecord::Base
+    #             acts_as_solr :fields => [:name, :description, :current_time]
+    #             def current_time
+    #               Time.now.to_s
+    #             end
+    #           end
+    #
+    #          Each field passed can also be a hash with the value being a field type
+    #
+    #           class Electronic < ActiveRecord::Base
+    #             acts_as_solr :fields => [{:price => :range_float}]
+    #             def current_time
+    #               Time.now
+    #             end
+    #           end
+    #
+    #          The field types accepted are:
+    #
+    #          :float:: Index the field value as a float (ie.: 12.87)
+    #          :integer:: Index the field value as an integer (ie.: 31)
+    #          :boolean:: Index the field value as a boolean (ie.: true/false)
+    #          :date:: Index the field value as a date (ie.: Wed Nov 15 23:13:03 PST 2006)
+    #          :string:: Index the field value as a text string, not applying the same indexing
+    #                    filters as a regular text field
+    #          :range_integer:: Index the field value for integer range queries (ie.:[5 TO 20])
+    #          :range_float:: Index the field value for float range queries (ie.:[14.56 TO 19.99])
+    #
+    #          Setting the field type preserves its original type when indexed
+    #
+    #          The field may also be passed with a hash value containing options
+    #
+    #          class Author < ActiveRecord::Base
+    #            acts_as_solr :fields => [{:full_name => {:type => :text, :as => :name}}]
+    #            def full_name
+    #              self.first_name + ' ' + self.last_name
+    #            end
+    #          end
+    #
+    #          The options accepted are:
+    #
+    #          :type:: Index the field using the specified type
+    #          :as:: Index the field using the specified field name
+    #
+    # additional_fields:: This option takes fields to be include in the index
+    #                     in addition to those derived from the database. You
+    #                     can also use this option to include custom fields
+    #                     derived from methods you define. This option will be
+    #                     ignored if the :fields option is given. It also accepts
+    #                     the same field types as the option above
+    #
+    #                      class Movie < ActiveRecord::Base
+    #                       acts_as_solr :additional_fields => [:current_time]
+    #                       def current_time
+    #                         Time.now.to_s
+    #                       end
+    #                      end
+    #
+    # exclude_fields:: This option taks an array of fields that should be ignored from indexing:
+    #
+    #                    class User < ActiveRecord::Base
+    #                      acts_as_solr :exclude_fields => [:password, :login, :credit_card_number]
+    #                    end
+    #
+    # include:: This option can be used for association indexing, which
+    #           means you can include any :has_one, :has_many, :belongs_to
+    #           and :has_and_belongs_to_many association to be indexed:
+    #
+    #            class Category < ActiveRecord::Base
+    #              has_many :books
+    #              acts_as_solr :include => [:books]
+    #            end
+    #
+    #           Each association may also be specified as a hash with an option hash as a value
+    #
+    #           class Book < ActiveRecord::Base
+    #             belongs_to :author
+    #             has_many :distribution_companies
+    #             has_many :copyright_dates
+    #             has_many :media_types
+    #             acts_as_solr(
+    #               :fields => [:name, :description],
+    #               :include => [
+    #                 {:author => {:using => :fullname, :as => :name}},
+    #                 {:media_types => {:using => lambda{|media| type_lookup(media.id)}}}
+    #                 {:distribution_companies => {:as => :distributor, :multivalued => true}},
+    #                 {:copyright_dates => {:as => :copyright, :type => :date}}
+    #               ]
+    #             ]
+    #
+    #           The options accepted are:
+    #
+    #           :type:: Index the associated objects using the specified type
+    #           :as:: Index the associated objects using the specified field name
+    #           :using:: Index the associated objects using the value returned by the specified method or proc.  If a method
+    #                    symbol is supplied, it will be sent to each object to look up the value to index; if a proc is
+    #                    supplied, it will be called once for each object with the object as the only argument
+    #           :multivalued:: Index the associated objects using one field for each object rather than joining them
+    #                          all into a single field
+    #
+    # facets:: This option can be used to specify the fields you'd like to
+    #          index as facet fields
+    #
+    #           class Electronic < ActiveRecord::Base
+    #             acts_as_solr :facets => [:category, :manufacturer]
+    #           end
+    #
+    # boost:: You can pass a boost (float) value that will be used to boost the document and/or a field. To specify a more
+    #         boost for the document, you can either pass a block or a symbol. The block will be called with the record
+    #         as an argument, a symbol will result in the according method being called:
+    #
+    #           class Electronic < ActiveRecord::Base
+    #             acts_as_solr :fields => [{:price => {:boost => 5.0}}], :boost => 10.0
+    #           end
+    #
+    #           class Electronic < ActiveRecord::Base
+    #             acts_as_solr :fields => [{:price => {:boost => 5.0}}], :boost => proc {|record| record.id + 120*37}
+    #           end
+    #
+    #           class Electronic < ActiveRecord::Base
+    #             acts_as_solr :fields => [{:price => {:boost => :price_rating}}], :boost => 10.0
+    #           end
+    #
+    # if:: Only indexes the record if the condition evaluated is true. The argument has to be
+    #      either a symbol, string (to be eval'ed), proc/method, or class implementing a static
+    #      validation method. It behaves the same way as ActiveRecord's :if option.
+    #
+    #        class Electronic < ActiveRecord::Base
+    #          acts_as_solr :if => proc{|record| record.is_active?}
+    #        end
+    #
+    # offline:: Assumes that your using an outside mechanism to explicitly trigger indexing records, e.g. you only
+    #           want to update your index through some asynchronous mechanism. Will accept either a boolean or a block
+    #           that will be evaluated before actually contacting the index for saving or destroying a document. Defaults
+    #           to false. It doesn't refer to the mechanism of an offline index in general, but just to get a centralized point
+    #           where you can control indexing. Note: This is only enabled for saving records. acts_as_solr doesn't always like
+    #           it, if you have a different number of results coming from the database and the index. This might be rectified in
+    #           another patch to support lazy loading.
+    #
+    #             class Electronic < ActiveRecord::Base
+    #               acts_as_solr :offline => proc {|record| record.automatic_indexing_disabled?}
+    #             end
+    #
+    # auto_commit:: The commit command will be sent to Solr only if its value is set to true:
+    #
+    #                 class Author < ActiveRecord::Base
+    #                   acts_as_solr :auto_commit => false
+    #                 end
+    #
+    # dynamic_attributes: Default false. When true, requires a has_many relationship to a DynamicAttribute
+    #                     (:name, :value) model. Then, all dynamic attributes will be mapped as normal attributes
+    #                    in Solr, so you can filter like this: Model.find_by_solr "#{dynamic_attribute.name}:Lorem"
+    # taggable: Default false. When true, indexes tags with field name tag. Tags are taken from taggings.tag
+    # spatial: Default false. When true, indexes model.local.latitude and model.local.longitude as coordinates.
+    def acts_as_solr(options={}, solr_options={}, &deferred_solr_configuration)
+
+      extend ClassMethods
+      include InstanceMethods
+      include CommonMethods
+      include ParserMethods
+
+      define_solr_configuration_methods
+
+      acts_as_taggable_on :tags if options[:taggable]
+      has_many :dynamic_attributes, :as => "dynamicable" if options[:dynamic_attributes]
+      has_one :local, :as => "localizable" if options[:spatial]
+
+      after_save    :solr_save
+      after_destroy :solr_destroy
+
+      if deferred_solr_configuration
+        self.deferred_solr_configuration = deferred_solr_configuration
+      else
+        process_acts_as_solr(options, solr_options)
+      end
+    end
+
+    def process_acts_as_solr(options, solr_options)
+      process_solr_options(options, solr_options)
+    end
+
+    def define_solr_configuration_methods
+      # I'd like to use cattr_accessor, but it does not support lazy loaders and delegation to the class in the instance methods.
+      # TODO: Reconcile with cattr_accessor, or a more appropriate method.
+      class_eval(<<-EOS, __FILE__, __LINE__)
+      @@configuration = nil unless defined?(@@configuration)
+      @@solr_configuration = nil unless defined?(@@solr_configuration)
+      @@deferred_solr_configuration = nil unless defined?(@@deferred_solr_configuration)
+
+      def self.configuration
+        return @@configuration if @@configuration
+        process_deferred_solr_configuration
+        @@configuration
+      end
+      def configuration
+        self.class.configuration
+      end
+      def self.configuration=(value)
+        @@configuration = value
+      end
+      def configuration=(value)
+        self.class.configuration = value
+      end
+
+      def self.solr_configuration
+        return @@solr_configuration if @@solr_configuration
+        process_deferred_solr_configuration
+        @@solr_configuration
+      end
+      def solr_configuration
+        self.class.solr_configuration
+      end
+      def self.solr_configuration=(value)
+        @@solr_configuration = value
+      end
+      def solr_configuration=(value)
+        self.class.solr_configuration = value
+      end
+
+      def self.deferred_solr_configuration
+        return @@deferred_solr_configuration if @@deferred_solr_configuration
+        @@deferred_solr_configuration
+      end
+      def deferred_solr_configuration
+        self.class.deferred_solr_configuration
+      end
+      def self.deferred_solr_configuration=(value)
+        @@deferred_solr_configuration = value
+      end
+      def deferred_solr_configuration=(value)
+        self.class.deferred_solr_configuration = value
+      end
+      EOS
+    end
+
+    def process_deferred_solr_configuration
+      return unless deferred_solr_configuration
+      options, solr_options = deferred_solr_configuration.call
+      self.deferred_solr_configuration = nil
+      self.process_solr_options(options, solr_options)
+    end
+
+    def process_solr_options(options={}, solr_options={})
+      self.configuration = {
+        :fields => nil,
+        :additional_fields => nil,
+        :dynamic_attributes => false,
+        :exclude_fields => [],
+        :auto_commit => true,
+        :include => nil,
+        :facets => nil,
+        :boost => nil,
+        :if => "true",
+        :offline => false,
+        :spatial => false
+      }
+      self.solr_configuration = {
+        :type_field => "type_s",
+        :primary_key_field => "pk_s",
+        :default_boost => 1.0
+      }
+
+      configuration.update(options) if options.is_a?(Hash)
+      solr_configuration.update(solr_options) if solr_options.is_a?(Hash)
+      Deprecation.validate_index(configuration)
+
+      configuration[:solr_fields] = {}
+      configuration[:solr_includes] = {}
+
+      if configuration[:fields].respond_to?(:each)
+        process_fields(configuration[:fields])
+      else
+        process_fields(self.new.attributes.keys.map { |k| k.to_sym })
+        process_fields(configuration[:additional_fields])
+      end
+
+      if configuration[:include].respond_to?(:each)
+        process_includes(configuration[:include])
+      end
+    end
+
+    private
+
+    def get_field_value(field)
+      field_name, options = determine_field_name_and_options(field)
+      configuration[:solr_fields][field_name] = options
+
+      define_method("#{field_name}_for_solr".to_sym) do
+        begin
+          value = self[field_name] || self.instance_variable_get("@#{field_name.to_s}".to_sym) || self.send(field_name.to_sym)
+          case options[:type]
+            # format dates properly; return nil for nil dates
+            when :date
+              value ? (value.respond_to?(:utc) ? value.utc : value).strftime("%Y-%m-%dT%H:%M:%SZ") : nil
+            else value
+          end
+        rescue
+          puts $!
+          logger.debug "There was a problem getting the value for the field '#{field_name}': #{$!}"
+          value = ''
+        end
+      end
+    end
+
+    def process_fields(raw_field)
+      if raw_field.respond_to?(:each)
+        raw_field.each do |field|
+          next if configuration[:exclude_fields].include?(field)
+          get_field_value(field)
+        end
+      end
+    end
+
+    def process_includes(includes)
+      if includes.respond_to?(:each)
+        includes.each do |assoc|
+          field_name, options = determine_field_name_and_options(assoc)
+          configuration[:solr_includes][field_name] = options
+        end
+      end
+    end
+
+    def determine_field_name_and_options(field)
+      if field.is_a?(Hash)
+        name = field.keys.first
+        options = field.values.first
+        if options.is_a?(Hash)
+          [name, {:type => type_for_field(field)}.merge(options)]
+        else
+          [name, {:type => options}]
+        end
+      else
+        [field, {:type => type_for_field(field)}]
+      end
+    end
+
+    def type_for_field(field)
+      if configuration[:facets] && configuration[:facets].include?(field)
+        :facet
+      elsif column = columns_hash[field.to_s]
+        column_type = format_column_type(column.type)
+        
+        case column_type
+          when :string then :text
+          when :datetime then :date
+          when :time then :date
+          else column_type
+        end
+      else
+        :text
+      end
+    end
+    
+    def format_column_type(type)
+      if type.class.eql? Symbol
+        type
+      else
+        type.to_s.eql?("ObjectId") ? :string : type.to_s.downcase.to_sym
+      end
+    end
+  end
+end
 \ No newline at end of file
@@ -0,0 +1,242 @@
+module ActsAsSolr #:nodoc:
+
+  module ClassMethods
+    include CommonMethods
+    include ParserMethods
+    
+    # Finds instances of a model. Terms are ANDed by default, can be overwritten 
+    # by using OR between terms
+    # 
+    # Here's a sample (untested) code for your controller:
+    # 
+    #  def search
+    #    results = Book.find_by_solr params[:query]
+    #  end
+    # 
+    # You can also search for specific fields by searching for 'field:value'
+    # 
+    # ====options:
+    # offset:: - The first document to be retrieved (offset)
+    # page:: - The page to be retrieved
+    # limit:: - The number of rows per page
+    # per_page:: - Alias for limit
+    # order:: - Orders (sort by) the result set using a given criteria:
+    #
+    #             Book.find_by_solr 'ruby', :order => 'description asc'
+    # 
+    # field_types:: This option is deprecated and will be obsolete by version 1.0.
+    #               There's no need to specify the :field_types anymore when doing a 
+    #               search in a model that specifies a field type for a field. The field 
+    #               types are automatically traced back when they're included.
+    # 
+    #                 class Electronic < ActiveRecord::Base
+    #                   acts_as_solr :fields => [{:price => :range_float}]
+    #                 end
+    # 
+    # facets:: This option argument accepts the following arguments:
+    #          fields:: The fields to be included in the faceted search (Solr's facet.field)
+    #          query:: The queries to be included in the faceted search (Solr's facet.query)
+    #          zeros:: Display facets with count of zero. (true|false)
+    #          sort:: Sorts the faceted resuls by highest to lowest count. (true|false)
+    #          browse:: This is where the 'drill-down' of the facets work. Accepts an array of
+    #                   fields in the format "facet_field:term"
+    #          mincount:: Replacement for zeros (it has been deprecated in Solr). Specifies the
+    #                     minimum count necessary for a facet field to be returned. (Solr's
+    #                     facet.mincount) Overrides :zeros if it is specified. Default is 0.
+    #
+    #          dates:: Run date faceted queries using the following arguments:
+    #            fields:: The fields to be included in the faceted date search (Solr's facet.date).
+    #                     It may be either a String/Symbol or Hash. If it's a hash the options are the
+    #                     same as date_facets minus the fields option (i.e., :start:, :end, :gap, :other,
+    #                     :between). These options if provided will override the base options.
+    #                     (Solr's f.<field_name>.date.<key>=<value>).
+    #            start:: The lower bound for the first date range for all Date Faceting. Required if
+    #                    :fields is present
+    #            end:: The upper bound for the last date range for all Date Faceting. Required if
+    #                  :fields is prsent
+    #            gap:: The size of each date range expressed as an interval to be added to the lower
+    #                  bound using the DateMathParser syntax.  Required if :fields is prsent
+    #            hardend:: A Boolean parameter instructing Solr what do do in the event that
+    #                      facet.date.gap does not divide evenly between facet.date.start and facet.date.end.
+    #            other:: This param indicates that in addition to the counts for each date range
+    #                    constraint between facet.date.start and facet.date.end, other counds should be
+    #                    calculated. May specify more then one in an Array. The possible options are:
+    #              before:: - all records with lower bound less than start
+    #              after:: - all records with upper bound greater than end
+    #              between:: - all records with field values between start and end
+    #              none:: - compute no other bounds (useful in per field assignment)
+    #              all:: - shortcut for before, after, and between
+    #            filter:: Similar to :query option provided by :facets, in that accepts an array of
+    #                     of date queries to limit results. Can not be used as a part of a :field hash.
+    #                     This is the only option that can be used if :fields is not present.
+    # 
+    # Example:
+    # 
+    #   Electronic.find_by_solr "memory", :facets => {:zeros => false, :sort => true,
+    #                                                 :query => ["price:[* TO 200]",
+    #                                                            "price:[200 TO 500]",
+    #                                                            "price:[500 TO *]"],
+    #                                                 :fields => [:category, :manufacturer],
+    #                                                 :browse => ["category:Memory","manufacturer:Someone"]}
+    # 
+    #
+    # Examples of date faceting:
+    #
+    #  basic:
+    #    Electronic.find_by_solr "memory", :facets => {:dates => {:fields => [:updated_at, :created_at],
+    #      :start => 'NOW-10YEARS/DAY', :end => 'NOW/DAY', :gap => '+2YEARS', :other => :before}}
+    #
+    #  advanced:
+    #    Electronic.find_by_solr "memory", :facets => {:dates => {:fields => [:updated_at,
+    #    {:created_at => {:start => 'NOW-20YEARS/DAY', :end => 'NOW-10YEARS/DAY', :other => [:before, :after]}
+    #    }], :start => 'NOW-10YEARS/DAY', :end => 'NOW/DAY', :other => :before, :filter =>
+    #    ["created_at:[NOW-10YEARS/DAY TO NOW/DAY]", "updated_at:[NOW-1YEAR/DAY TO NOW/DAY]"]}}
+    #
+    #  filter only:
+    #    Electronic.find_by_solr "memory", :facets => {:dates => {:filter => "updated_at:[NOW-1YEAR/DAY TO NOW/DAY]"}}
+    #
+    #
+    #
+    # scores:: If set to true this will return the score as a 'solr_score' attribute
+    #          for each one of the instances found. Does not currently work with find_id_by_solr
+    # 
+    #            books = Book.find_by_solr 'ruby OR splinter', :scores => true
+    #            books.records.first.solr_score
+    #            => 1.21321397
+    #            books.records.last.solr_score
+    #            => 0.12321548
+    # 
+    # lazy:: If set to true the search will return objects that will touch the database when you ask for one
+    #        of their attributes for the first time. Useful when you're using fragment caching based solely on
+    #        types and ids.
+    #
+    # relevance:: Sets fields relevance
+    #
+    #            Book.find_by_solr "zidane", :relevance => {:title => 5, :author => 2}
+    #
+    def find_by_solr(query, options={})
+      data = parse_query(query, options)
+      return parse_results(data, options)
+    end
+    alias :search :find_by_solr
+    
+    # Finds instances of a model and returns an array with the ids:
+    #  Book.find_id_by_solr "rails" => [1,4,7]
+    # The options accepted are the same as find_by_solr
+    # 
+    def find_id_by_solr(query, options={})
+      data = parse_query(query, options)
+      return parse_results(data, {:format => :ids})
+    end
+    
+    # This method can be used to execute a search across multiple models:
+    #   Book.multi_solr_search "Napoleon OR Tom", :models => [Movie]
+    # 
+    # ====options:
+    # Accepts the same options as find_by_solr plus:
+    # models:: The additional models you'd like to include in the search
+    # results_format:: Specify the format of the results found
+    #                  :objects :: Will return an array with the results being objects (default). Example:
+    #                               Book.multi_solr_search "Napoleon OR Tom", :models => [Movie], :results_format => :objects
+    #                  :ids :: Will return an array with the ids of each entry found. Example:
+    #                           Book.multi_solr_search "Napoleon OR Tom", :models => [Movie], :results_format => :ids
+    #                           => [{"id" => "Movie:1"},{"id" => Book:1}]
+    #                          Where the value of each array is as Model:instance_id
+    # scores:: If set to true this will return the score as a 'solr_score' attribute
+    #          for each one of the instances found. Does not currently work with find_id_by_solr
+    # 
+    #            books = Book.multi_solr_search 'ruby OR splinter', :scores => true
+    #            books.records.first.solr_score
+    #            => 1.21321397
+    #            books.records.last.solr_score
+    #            => 0.12321548
+    # 
+    def multi_solr_search(query, options = {})
+      models = multi_model_suffix(options)
+      options.update(:results_format => :objects) unless options[:results_format]
+      data = parse_query(query, options, models)
+      
+      if data.nil? or data.total_hits == 0
+        return SearchResults.new(:docs => [], :total => 0)
+      end
+
+      result = find_multi_search_objects(data, options)
+      if options[:scores] and options[:results_format] == :objects
+        add_scores(result, data) 
+      end
+      SearchResults.new :docs => result, :total => data.total_hits
+    end
+
+    def find_multi_search_objects(data, options)
+      result = []
+      if options[:results_format] == :objects
+        data.hits.each do |doc| 
+          k = doc.fetch('id').first.to_s.split(':')
+          result << k[0].constantize.find_by_id(k[1])
+        end
+      elsif options[:results_format] == :ids
+        data.hits.each{|doc| result << {"id" => doc["id"].to_s}}
+      end
+      result
+    end
+    
+    def multi_model_suffix(options)
+      models = "AND (#{solr_configuration[:type_field]}:#{self.name}"
+      models << " OR " + options[:models].collect {|m| "#{solr_configuration[:type_field]}:" + m.to_s}.join(" OR ") if options[:models].is_a?(Array)
+      models << ")"
+    end
+    
+    # returns the total number of documents found in the query specified:
+    #  Book.count_by_solr 'rails' => 3
+    # 
+    def count_by_solr(query, options = {})        
+      data = parse_query(query, options)
+      data.total_hits
+    end
+            
+    # It's used to rebuild the Solr index for a specific model. 
+    #  Book.rebuild_solr_index
+    # 
+    # If batch_size is greater than 0, adds will be done in batches.
+    # NOTE: If using sqlserver, be sure to use a finder with an explicit order.
+    # Non-edge versions of rails do not handle pagination correctly for sqlserver
+    # without an order clause.
+    # 
+    # If a finder block is given, it will be called to retrieve the items to index.
+    # This can be very useful for things such as updating based on conditions or
+    # using eager loading for indexed associations.
+    def rebuild_solr_index(batch_size=100, &finder)
+      finder ||= lambda { |ar, options| ar.find(:all, options.merge({:order => self.primary_key})) }
+      start_time = Time.now
+
+      if batch_size > 0
+        items_processed = 0
+        limit = batch_size
+        offset = 0
+        begin
+          iteration_start = Time.now
+          items = finder.call(self, {:limit => limit, :offset => offset})
+          add_batch = items.collect { |content| content.to_solr_doc }
+    
+          if items.size > 0
+            solr_add add_batch
+            solr_commit
+          end
+    
+          items_processed += items.size
+          last_id = items.last.id if items.last
+          time_so_far = Time.now - start_time
+          iteration_time = Time.now - iteration_start         
+          logger.info "#{Process.pid}: #{items_processed} items for #{self.name} have been batch added to index in #{'%.3f' % time_so_far}s at #{'%.3f' % (items_processed / time_so_far)} items/sec (#{'%.3f' % (items.size / iteration_time)} items/sec for the last batch). Last id: #{last_id}"
+          offset += items.size
+        end while items.nil? || items.size > 0
+      else
+        items = finder.call(self, {})
+        items.each { |content| content.solr_save }
+        items_processed = items.size
+      end
+      solr_optimize
+      logger.info items_processed > 0 ? "Index for #{self.name} has been rebuilt" : "Nothing to index for #{self.name}"
+    end
+  end
+end
@@ -0,0 +1,87 @@
+module ActsAsSolr #:nodoc:
+  
+  module CommonMethods
+    
+    # Converts field types into Solr types
+    def get_solr_field_type(field_type)
+      if field_type.is_a?(Symbol)
+        case field_type
+          when :float
+            return "f"
+          when :integer
+            return "i"
+          when :boolean
+            return "b"
+          when :string
+            return "s"
+          when :date
+            return "d"
+          when :range_float
+            return "rf"
+          when :range_integer
+            return "ri"
+          when :facet
+            return "facet"
+          when :text
+            return "t"
+        else
+          raise "Unknown field_type symbol: #{field_type}"
+        end
+      elsif field_type.is_a?(String)
+        return field_type
+      else
+        raise "Unknown field_type class: #{field_type.class}: #{field_type}"
+      end
+    end
+    
+    # Sets a default value when value being set is nil.
+    def set_value_if_nil(field_type)
+      case field_type
+        when "b", :boolean
+          return "false"
+        when "s", "t", "d", :date, :string, :text
+          return ""
+        when "f", "rf", :float, :range_float
+          return 0.00
+        when "i", "ri", :integer, :range_integer
+          return 0
+      else
+        return ""
+      end
+    end
+    
+    # Sends an add command to Solr
+    def solr_add(add_xml)
+      ActsAsSolr::Post.execute(Solr::Request::AddDocument.new(add_xml))
+    end
+    
+    # Sends the delete command to Solr
+    def solr_delete(solr_ids)
+      ActsAsSolr::Post.execute(Solr::Request::Delete.new(:id => solr_ids))
+    end
+    
+    # Sends the commit command to Solr
+    def solr_commit
+      ActsAsSolr::Post.execute(Solr::Request::Commit.new)
+    end
+    
+    # Optimizes the Solr index. Solr says:
+    # 
+    # Optimizations can take nearly ten minutes to run. 
+    # We are presuming optimizations should be run once following large 
+    # batch-like updates to the collection and/or once a day.
+    # 
+    # One of the solutions for this would be to create a cron job that 
+    # runs every day at midnight and optmizes the index:
+    #   0 0 * * * /your_rails_dir/script/runner -e production "Model.solr_optimize"
+    # 
+    def solr_optimize
+      ActsAsSolr::Post.execute(Solr::Request::Optimize.new)
+    end
+    
+    # Returns the id for the given instance
+    def record_id(object)
+      eval "object.#{object.class.primary_key}"
+    end
+  end
+end
 \ No newline at end of file
@@ -0,0 +1,61 @@
+module ActsAsSolr #:nodoc:
+  
+  class Post
+    def initialize(body, mode = :search)
+      @body = body
+      @mode = mode
+      puts "The method ActsAsSolr::Post.new(body, mode).execute_post is depracated. " +
+           "Use ActsAsSolr::Post.execute(body, mode) instead!"
+    end
+    
+    def execute_post
+      ActsAsSolr::Post.execute(@body, @mode)
+    end    
+  end
+  
+  module ClassMethods
+    def find_with_facet(query, options={})
+      Deprecation.plog "The method find_with_facet is deprecated. Use find_by_solr instead, passing the " +
+                       "arguments the same way you used to do with find_with_facet."
+      find_by_solr(query, options)
+    end
+  end
+  
+  class Deprecation
+    # Validates the options passed during query
+    def self.validate_query options={}
+      if options[:field_types]
+        plog "The option :field_types for searching is deprecated. " +
+             "The field types are automatically traced back when you specify a field type in your model."
+      end
+      if options[:sort_by]
+        plog "The option :sort_by is deprecated, use :order instead!"
+        options[:order] ||= options[:sort_by]
+      end
+      if options[:start]
+        plog "The option :start is deprecated, use :offset instead!"
+        options[:offset] ||= options[:start]
+      end
+      if options[:rows]
+        plog "The option :rows is deprecated, use :limit instead!"
+        options[:limit] ||= options[:rows]
+      end
+    end
+    
+    # Validates the options passed during indexing
+    def self.validate_index options={}
+      if options[:background]
+        plog "The :background option is being deprecated. There are better and more efficient " +
+             "ways to handle delayed saving of your records."
+      end
+    end
+    
+    # This will print the text to stdout and log the text
+    # if rails logger is available
+    def self.plog text
+      puts text
+      RAILS_DEFAULT_LOGGER.warn text if defined? RAILS_DEFAULT_LOGGER
+    end
+  end
+  
+end
@@ -0,0 +1,3 @@
+class DynamicAttribute < ActiveRecord::Base
+  belongs_to :dynamicable, :polymorphic => true
+end
...	...	@@ -38,6 +38,9 @@ commands and make sure you understand what you are doing):
38	38	cp config/database.yml.sqlite3 config/database.yml
39	39	# create tmp directory if it doesn't exist
40	40	mkdir tmp
	41	+ # download and start Solr
	42	+ rake solr:download
	43	+ rake solr:start
41	44	# create the development database
42	45	rake db:schema:load
43	46	# run pending migrations
...	...
...	...	@@ -13,7 +13,7 @@ You need to install some packages Noosfero depends on. On Debian GNU/Linux or
13	13	Debian-based systems, all of these packages are available through the Debian
14	14	archive. You can install them with the following command:
15	15
16		- # apt-get install ruby rake po4a libgettext-ruby-util libgettext-ruby-data libgettext-ruby1.8 libsqlite3-ruby rcov librmagick-ruby libredcloth-ruby libwill-paginate-ruby iso-codes libfeedparser-ruby libferret-ruby libdaemons-ruby mongrel mongrel-cluster tango-icon-theme libhpricot-ruby
	16	+ # apt-get install ruby rake po4a libgettext-ruby-util libgettext-ruby-data libgettext-ruby1.8 libsqlite3-ruby rcov librmagick-ruby libredcloth-ruby libwill-paginate-ruby iso-codes libfeedparser-ruby openjdk-6-jre libdaemons-ruby mongrel mongrel-cluster tango-icon-theme libhpricot-ruby
17	17
18	18	On other systems, they may or may not be available through your regular package
19	19	management system. Below are the links to their homepages.
...	...	@@ -24,7 +24,7 @@ management system. Below are the links to their homepages.
24	24	* Ruby-GetText: http://www.yotabanana.com/hiki/ruby-gettext.html?ruby-gettext (at least version 1.9.0)
25	25	* Ruby-sqlite3: http://rubyforge.org/projects/sqlite-ruby
26	26	* rcov: http://eigenclass.org/hiki/rcov
27		-* Ferret: http://ferret.davebalmain.com/trac
	27	+* Solr: http://lucene.apache.org/solr
28	28	* RMagick: http://rmagick.rubyforge.org/
29	29	* RedCloth: http://redcloth.org/
30	30	* will_paginate: http://github.com/mislav/will_paginate/wikis
...	...	@@ -115,8 +115,11 @@ $ tar -zxvf noosfero-0.27.1.tar.gz
115	115	$ ln -s noosfero-0.27.1 current
116	116	$ cd current
117	117
118		-Copy config/ferret_server.yml.dist to config/ferret_server.yml. You will
	118	+Copy config/solr.yml.dist to config/solr.yml. You will
119	119	probably not need to customize this configuration, but have a look at it.
	120	+Then you'll need to download Solr into noosfero:
	121	+
	122	+$ rake solr:download
120	123
121	124	Create the mongrel configuration file:
122	125
...	...	@@ -237,6 +240,10 @@ Create the database structure:
237	240
238	241	$ RAILS_ENV=production rake db:schema:load
239	242
	243	+Run Solr:
	244	+
	245	+$ rake solr:start
	246	+
240	247	Now we have to create some initial data. To create your default environment
241	248	(the first one), run the command below:
242	249
...	...
...	...	@@ -7,4 +7,6 @@ require 'rake'
7	7	require 'rake/testtask'
8	8	require 'rake/rdoctask'
9	9
	10	+ACTS_AS_SEARCHABLE_ENABLED = false if Rake.application.top_level_tasks.detect{\|t\| t == 'db:data:minimal'}
	11	+
10	12	require 'tasks/rails'
...	...
...	...	@@ -126,11 +126,11 @@ class ProfileMembersController < MyProfileController
126	126	if !params[:query] \|\| params[:query].length <= 2
127	127	@users_found = []
128	128	elsif params[:scope] == 'all_users'
129		- @users_found = Person.find_by_contents(params[:query] + '*').select {\|user\| !profile.members.include?(user)}
	129	+ @users_found = Person.find_by_contents(params[:query] + '*')[:results].select {\|user\| !profile.members.include?(user)}
130	130	@button_alt = _('Add member')
131	131	@add_action = {:action => 'add_member'}
132	132	elsif params[:scope] == 'new_admins'
133		- @users_found = Person.find_by_contents(params[:query] + '*').select {\|user\| profile.members.include?(user) && !profile.admins.include?(user)}
	133	+ @users_found = Person.find_by_contents(params[:query] + '*')[:results].select {\|user\| profile.members.include?(user) && !profile.admins.include?(user)}
134	134	@button_alt = _('Add member')
135	135	@add_action = {:action => 'add_admin'}
136	136	end
...	...
...	...	@@ -19,7 +19,7 @@ class BrowseController < PublicController
19	19	@results = @environment.people.visible.send(@filter)
20	20
21	21	if !params[:query].blank?
22		- @results = @results.find_by_contents(params[:query])
	22	+ @results = @results.find_by_contents(params[:query])[:results]
23	23	end
24	24	@results = @results.compact.paginate(:per_page => per_page, :page => params[:page])
25	25	end
...	...	@@ -31,7 +31,7 @@ class BrowseController < PublicController
31	31	@results = @environment.communities.visible.send(@filter)
32	32
33	33	if !params[:query].blank?
34		- @results = @results.find_by_contents(params[:query])
	34	+ @results = @results.find_by_contents(params[:query])[:results]
35	35	end
36	36	@results = @results.compact.paginate(:per_page => per_page, :page => params[:page])
37	37	end
...	...
...	...	@@ -8,11 +8,10 @@ class ProfileSearchController < PublicController
8	8	def index
9	9	@q = params[:q]
10	10	unless @q.blank?
11		- @filtered_query = remove_stop_words(@q)
12	11	if params[:where] == 'environment'
13	12	redirect_to :controller => 'search', :query => @q
14	13	else
15		- @results = profile.articles.published.find_by_contents(@filtered_query).paginate(:per_page => 10, :page => params[:page])
	14	+ @results = profile.articles.published.find_by_contents(@q)[:results].paginate(:per_page => 10, :page => params[:page])
16	15	end
17	16	end
18	17	end
...	...
...	...	@@ -89,7 +89,8 @@ class SearchController < PublicController
89	89	# REFACTOR DUPLICATED CODE inner loop doing the same thing that outter loop
90	90
91	91	if !@query.blank? \|\| @region && !params[:radius].blank?
92		- @result_ids = @noosfero_finder.find(asset, @filtered_query, calculate_find_options(asset, nil, params[:page], @product_category, @region, params[:radius], params[:year], params[:month]).merge({:limit => :all}))
	92	+ ret = @noosfero_finder.find(asset, @query, calculate_find_options(asset, nil, params[:page], @product_category, @region, params[:radius], params[:year], params[:month]).merge({:limit => :all}))
	93	+ @result_ids = ret.is_a?(Hash) ? ret[:results] : ret
93	94	end
94	95
95	96	end
...	...	@@ -149,7 +150,6 @@ class SearchController < PublicController
149	150
150	151	def index
151	152	@query = params[:query] \|\| ''
152		- @filtered_query = remove_stop_words(@query)
153	153	@product_category = ProductCategory.find(params[:product_category]) if params[:product_category]
154	154
155	155	@region = City.find_by_id(params[:city]) if !params[:city].blank? && params[:city] =~ /^\d+$/
...	...	@@ -158,12 +158,16 @@ class SearchController < PublicController
158	158	number_of_result_assets = @searching.values.select{\|v\| v}.size
159	159
160	160	@results = {}
	161	+ @facets = {}
161	162	@order = []
162	163	@names = {}
163	164
164	165	where_to_search.select { \|key,description\| @searching[key] }.each do \|key, description\|
165	166	@order << key
166		- @results[key] = @noosfero_finder.find(key, @filtered_query, calculate_find_options(key, limit, params[:page], @product_category, @region, params[:radius], params[:year], params[:month]))
	167	+ find_options = calculate_find_options(key, limit, params[:page], @product_category, @region, params[:radius], params[:year], params[:month]);
	168	+ ret = @noosfero_finder.find(key, @query, find_options)
	169	+ @results[key] = ret.is_a?(Hash) ? ret[:results] : ret
	170	+ @facets[key] = ret.is_a?(Hash) ? ret[:facets] : {}
167	171	@names[key] = getterm(description)
168	172	end
169	173
...	...
...	...	@@ -3,21 +3,12 @@ module SearchHelper
3	3	# FIXME remove it after search_controler refactored
4	4	include EventsHelper
5	5
6		- STOP_WORDS = {
7		- 'pt_BR' => Ferret::Analysis::FULL_PORTUGUESE_STOP_WORDS,
8		- 'en' => Ferret::Analysis::FULL_ENGLISH_STOP_WORDS,
9		- }
10		-
11	6	def relevance_for(hit)
12	7	n = (hit.ferret_score if hit.respond_to?(:ferret_score))
13	8	n \|\|= 1.0
14	9	(n * 100.0).round
15	10	end
16	11
17		- def remove_stop_words(query)
18		- (query.downcase.scan(/"[^"]"?\|'[^']'?\|[^'"\s]+/) - (STOP_WORDS[locale] \|\| [])).join(' ')
19		- end
20		-
21	12	def display_results(use_map = true)
22	13
23	14	unless use_map && GoogleMaps.enabled?(environment.default_hostname)
...	...
...	...	@@ -388,7 +388,7 @@ class Article < ActiveRecord::Base
388	388	end
389	389
390	390	def comments_updated
391		- ferret_update
	391	+ solr_save
392	392	end
393	393
394	394	def accept_category?(cat)
...	...
...	...	@@ -28,10 +28,12 @@ class CategoryFinder
28	28	end
29	29
30	30	if query.blank?
	31	+ options.delete(:facets)
31	32	asset_class(asset).send(finder_method, :all, options_for_find(asset_class(asset), {:order => "#{asset_table(asset)}.name"}.merge(options), date_range))
32	33	else
33		- ferret_options = {:page => options.delete(:page), :per_page => options.delete(:per_page)}
34		- asset_class(asset).find_by_contents(query, ferret_options, options_for_find(asset_class(asset), options, date_range))
	34	+ pg_options = {:page => options.delete(:page), :per_page => options.delete(:per_page)}
	35	+ solr_options = {:facets => options.delete(:facets)}
	36	+ asset_class(asset).find_by_contents(query, pg_options, solr_options, options_for_find(asset_class(asset), options, date_range))[:results]
35	37	end
36	38	end
37	39
...	...