ActionItem129: added acts_as_ferret back with piston and new version

git-svn-id: https://svn.colivre.coop.br/svn/noosfero/trunk@1832 3f533792-8f58-4932-b0fe-aaf55b0a4547

ActionItem129: added acts_as_ferret back with piston and new version
git-svn-id: https://svn.colivre.coop.br/svn/noosfero/trunk@1832 3f533792-8f58-4932-b0fe-aaf55b0a4547
MoisesMachado
1 parent ad8ab8df
Showing 38 changed files with 3681 additions and 2 deletions Show diff stats
lib/acts_as_searchable.rb
vendor/plugins/acts_as_ferret/LICENSE
vendor/plugins/acts_as_ferret/README
vendor/plugins/acts_as_ferret/bin/aaf_install
vendor/plugins/acts_as_ferret/config/ferret_server.yml
vendor/plugins/acts_as_ferret/doc/README.win32
vendor/plugins/acts_as_ferret/doc/monit-example
vendor/plugins/acts_as_ferret/init.rb
vendor/plugins/acts_as_ferret/install.rb
vendor/plugins/acts_as_ferret/lib/act_methods.rb
vendor/plugins/acts_as_ferret/lib/acts_as_ferret.rb
vendor/plugins/acts_as_ferret/lib/ar_mysql_auto_reconnect_patch.rb
vendor/plugins/acts_as_ferret/lib/blank_slate.rb
vendor/plugins/acts_as_ferret/lib/bulk_indexer.rb
vendor/plugins/acts_as_ferret/lib/class_methods.rb
vendor/plugins/acts_as_ferret/lib/ferret_extensions.rb
vendor/plugins/acts_as_ferret/lib/ferret_find_methods.rb
vendor/plugins/acts_as_ferret/lib/ferret_result.rb
vendor/plugins/acts_as_ferret/lib/ferret_server.rb
vendor/plugins/acts_as_ferret/lib/index.rb
 class << ActiveRecord::Base
  
-  def acts_as_searchable(options = {}, ferret_options = {})
-    acts_as_ferret({ :remote => true }.merge(options), ferret_options)
+  def acts_as_searchable(options = {})
+    acts_as_ferret({ :remote => true }.merge(options))
+    def find_by_contents(*args)
+      find_with_ferret(*args)
+    end
   end
  
 end
@@ -0,0 +1,20 @@
+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.
@@ -0,0 +1,53 @@
+= 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)
+
@@ -0,0 +1,23 @@
+# 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'))
+
@@ -0,0 +1,24 @@
+# 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
@@ -0,0 +1,23 @@
+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.
+
+
@@ -0,0 +1,22 @@
+# 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
@@ -0,0 +1,24 @@
+# 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 }
@@ -0,0 +1,18 @@
+# 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'))
+
@@ -0,0 +1,155 @@
+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
@@ -0,0 +1,567 @@
+# 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               => [: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
+
@@ -0,0 +1,41 @@
+# 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
+
@@ -0,0 +1,53 @@
+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
+
@@ -0,0 +1,35 @@
+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
@@ -0,0 +1,293 @@
+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 = {})
+      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
+
@@ -0,0 +1,115 @@
+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
@@ -0,0 +1,118 @@
+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
@@ -0,0 +1,53 @@
+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
@@ -0,0 +1,238 @@
+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
@@ -0,0 +1,99 @@
+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
@@ -0,0 +1,164 @@
+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)
+      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
@@ -0,0 +1,199 @@
+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
@@ -0,0 +1,217 @@
+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
+
@@ -0,0 +1,126 @@
+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
@@ -0,0 +1,141 @@
+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
@@ -0,0 +1,23 @@
+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
@@ -0,0 +1,54 @@
+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
@@ -0,0 +1,20 @@
+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
@@ -0,0 +1,50 @@
+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
@@ -0,0 +1,58 @@
+################################################################################
+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
@@ -0,0 +1,64 @@
+################################################################################
+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
@@ -0,0 +1,49 @@
+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
@@ -0,0 +1,134 @@
+# 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
@@ -0,0 +1,97 @@
+# 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"
+
@@ -0,0 +1,94 @@
+# 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
@@ -0,0 +1,10 @@
+#!/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
@@ -0,0 +1,178 @@
+# 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)
@@ -0,0 +1,24 @@
+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
1	1	class << ActiveRecord::Base
2	2
3		- def acts_as_searchable(options = {}, ferret_options = {})
4		- acts_as_ferret({ :remote => true }.merge(options), ferret_options)
	3	+ def acts_as_searchable(options = {})
	4	+ acts_as_ferret({ :remote => true }.merge(options))
	5	+ def find_by_contents(*args)
	6	+ find_with_ferret(*args)
	7	+ end
5	8	end
6	9
7	10	end
...	...
...	...	@@ -0,0 +1,20 @@
	1	+Copyright (c) 2006 Kasper Weibel, Jens Kraemer
	2	+
	3	+Permission is hereby granted, free of charge, to any person obtaining
	4	+a copy of this software and associated documentation files (the
	5	+"Software"), to deal in the Software without restriction, including
	6	+without limitation the rights to use, copy, modify, merge, publish,
	7	+distribute, sublicense, and/or sell copies of the Software, and to
	8	+permit persons to whom the Software is furnished to do so, subject to
	9	+the following conditions:
	10	+
	11	+The above copyright notice and this permission notice shall be
	12	+included in all copies or substantial portions of the Software.
	13	+
	14	+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	15	+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	16	+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	17	+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
	18	+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
	19	+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
	20	+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
...	...
...	...	@@ -0,0 +1,53 @@
	1	+= acts_as_ferret
	2	+
	3	+This ActiveRecord mixin adds full text search capabilities to any Rails model.
	4	+
	5	+It is heavily based on the original acts_as_ferret plugin done by
	6	+Kasper Weibel and a modified version done by Thomas Lockney, which
	7	+both can be found on http://ferret.davebalmain.com/trac/wiki/FerretOnRails
	8	+
	9	+== Installation
	10	+
	11	+=== Installation inside your Rails project via script/plugin
	12	+
	13	+script/plugin install svn://projects.jkraemer.net/acts_as_ferret/trunk/plugin/acts_as_ferret
	14	+
	15	+Aaf is is also available via git from Rubyforge:
	16	+git clone git://rubyforge.org/actsasferret.git
	17	+
	18	+=== System-wide installation with Rubygems
	19	+
	20	+<tt>sudo gem install acts_as_ferret</tt>
	21	+
	22	+To use acts_as_ferret in your project, add the following line to your
	23	+project's config/environment.rb:
	24	+
	25	+<tt>require 'acts_as_ferret'</tt>
	26	+
	27	+Call the aaf_install script inside your project directory to install the sample
	28	+config file and the drb server start/stop script.
	29	+
	30	+
	31	+== Usage
	32	+
	33	+include the following in your model class (specifiying the fields you want to get indexed):
	34	+
	35	+<tt>acts_as_ferret :fields => [ :title, :description ]</tt>
	36	+
	37	+now you can use ModelClass.find_by_contents(query) to find instances of your model
	38	+whose indexed fields match a given query. All query terms are required by default,
	39	+but explicit OR queries are possible. This differs from the ferret default, but
	40	+imho is the more often needed/expected behaviour (more query terms result in
	41	+less results).
	42	+
	43	+Please see ActsAsFerret::ActMethods#acts_as_ferret for more information.
	44	+
	45	+== License
	46	+
	47	+Released under the MIT license.
	48	+
	49	+== Authors
	50	+
	51	+* Kasper Weibel Nielsen-Refs (original author)
	52	+* Jens Kraemer <jk@jkraemer.net> (current maintainer)
	53	+
...	...
...	...	@@ -0,0 +1,23 @@
	1	+# acts_as_ferret gem install script
	2	+# Use inside the root of your Rails project
	3	+require 'fileutils'
	4	+
	5	+@basedir = File.join(File.dirname(__FILE__), '..')
	6	+
	7	+def install(dir, file, executable=false)
	8	+ puts "Installing: #{file}"
	9	+ target = File.join('.', dir, file)
	10	+ if File.exists?(target)
	11	+ puts "#{target} already exists, skipping"
	12	+ else
	13	+ FileUtils.cp File.join(@basedir, dir, file), target
	14	+ FileUtils.chmod 0755, target if executable
	15	+ end
	16	+end
	17	+
	18	+
	19	+install 'script', 'ferret_server', true
	20	+install 'config', 'ferret_server.yml'
	21	+
	22	+puts IO.read(File.join(@basedir, 'README'))
	23	+
...	...
...	...	@@ -0,0 +1,24 @@
	1	+# configuration for the acts_as_ferret DRb server
	2	+# host: where to reach the DRb server (used by application processes to contact the server)
	3	+# port: which port the server should listen on
	4	+# socket: where the DRb server should create the socket (absolute path), this setting overrides host:port configuration
	5	+# pid_file: location of the server's pid file (relative to RAILS_ROOT)
	6	+# log_file: log file (default: RAILS_ROOT/log/ferret_server.log
	7	+# log_level: log level for the server's logger
	8	+production:
	9	+ host: localhost
	10	+ port: 9010
	11	+ pid_file: log/ferret.pid
	12	+ log_file: log/ferret_server.log
	13	+ log_level: warn
	14	+
	15	+# aaf won't try to use the DRb server in environments that are not
	16	+# configured here.
	17	+#development:
	18	+# host: localhost
	19	+# port: 9010
	20	+# pid_file: log/ferret.pid
	21	+#test:
	22	+# host: localhost
	23	+# port: 9009
	24	+# pid_file: log/ferret.pid
...	...
...	...	@@ -0,0 +1,23 @@
	1	+Credits
	2	+=======
	3	+
	4	+The Win32 service support scripts have been written by
	5	+Herryanto Siatono <herryanto@pluitsolutions.com>.
	6	+
	7	+See his accompanying blog posting at
	8	+http://www.pluitsolutions.com/2007/07/30/acts-as-ferret-drbserver-win32-service/
	9	+
	10	+
	11	+Usage
	12	+=====
	13	+
	14	+There are two scripts:
	15	+
	16	+script/ferret_service is used to install/remove/start/stop the win32 service.
	17	+
	18	+script/ferret_daemon is to be called by Win32 service to start/stop the
	19	+DRbServer.
	20	+
	21	+Run 'ruby script/ferret_service -h' for more info.
	22	+
	23	+
...	...
...	...	@@ -0,0 +1,22 @@
	1	+# monit configuration snippet to watch the Ferret DRb server shipped with
	2	+# acts_as_ferret
	3	+check process ferret with pidfile /path/to/ferret.pid
	4	+
	5	+ # username is the user the drb server should be running as (It's good practice
	6	+ # to run such services as a non-privileged user)
	7	+ start program = "/bin/su -c 'cd /path/to/your/app/current/ && script/ferret_server -e production start' username"
	8	+ stop program = "/bin/su -c 'cd /path/to/your/app/current/ && script/ferret_server -e production stop' username"
	9	+
	10	+ # cpu usage boundaries
	11	+ if cpu > 60% for 2 cycles then alert
	12	+ if cpu > 90% for 5 cycles then restart
	13	+
	14	+ # memory usage varies with index size and usage scenarios, so check how
	15	+ # much memory your DRb server uses up usually and add some spare to that
	16	+ # before enabling this rule:
	17	+ # if totalmem > 50.0 MB for 5 cycles then restart
	18	+
	19	+ # adjust port numbers according to your setup:
	20	+ if failed port 9010 then alert
	21	+ if failed port 9010 for 2 cycles then restart
	22	+ group ferret
...	...
...	...	@@ -0,0 +1,24 @@
	1	+# Copyright (c) 2006 Kasper Weibel Nielsen-Refs, Thomas Lockney, Jens Krämer
	2	+#
	3	+# Permission is hereby granted, free of charge, to any person obtaining a copy
	4	+# of this software and associated documentation files (the "Software"), to deal
	5	+# in the Software without restriction, including without limitation the rights
	6	+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	7	+# copies of the Software, and to permit persons to whom the Software is
	8	+# furnished to do so, subject to the following conditions:
	9	+#
	10	+# The above copyright notice and this permission notice shall be included in all
	11	+# copies or substantial portions of the Software.
	12	+#
	13	+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	14	+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	15	+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	16	+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	17	+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	18	+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	19	+# SOFTWARE.
	20	+
	21	+require 'acts_as_ferret'
	22	+
	23	+config.after_initialize { ActsAsFerret::load_config }
	24	+config.to_prepare { ActsAsFerret::load_config }
...	...
...	...	@@ -0,0 +1,18 @@
	1	+# acts_as_ferret install script
	2	+require 'fileutils'
	3	+
	4	+def install(file)
	5	+ puts "Installing: #{file}"
	6	+ target = File.join(File.dirname(__FILE__), '..', '..', '..', file)
	7	+ if File.exists?(target)
	8	+ puts "target #{target} already exists, skipping"
	9	+ else
	10	+ FileUtils.cp File.join(File.dirname(__FILE__), file), target
	11	+ end
	12	+end
	13	+
	14	+install File.join( 'script', 'ferret_server' )
	15	+install File.join( 'config', 'ferret_server.yml' )
	16	+
	17	+puts IO.read(File.join(File.dirname(__FILE__), 'README'))
	18	+
...	...
...	...	@@ -0,0 +1,155 @@
	1	+module ActsAsFerret #:nodoc:
	2	+
	3	+ # This module defines the acts_as_ferret method and is included into
	4	+ # ActiveRecord::Base
	5	+ module ActMethods
	6	+
	7	+
	8	+ def reloadable?; false end
	9	+
	10	+ # declares a class as ferret-searchable.
	11	+ #
	12	+ # ====options:
	13	+ # fields:: names all fields to include in the index. If not given,
	14	+ # all attributes of the class will be indexed. You may also give
	15	+ # symbols pointing to instance methods of your model here, i.e.
	16	+ # to retrieve and index data from a related model.
	17	+ #
	18	+ # additional_fields:: names fields to include in the index, in addition
	19	+ # to those derived from the db scheme. use if you want
	20	+ # to add custom fields derived from methods to the db
	21	+ # fields (which will be picked by aaf). This option will
	22	+ # be ignored when the fields option is given, in that
	23	+ # case additional fields get specified there.
	24	+ #
	25	+ # if:: Can be set to a block that will be called with the record in question
	26	+ # to determine if it should be indexed or not.
	27	+ #
	28	+ # index_dir:: declares the directory where to put the index for this class.
	29	+ # The default is RAILS_ROOT/index/RAILS_ENV/CLASSNAME.
	30	+ # The index directory will be created if it doesn't exist.
	31	+ #
	32	+ # reindex_batch_size:: reindexing is done in batches of this size, default is 1000
	33	+ # mysql_fast_batches:: set this to false to disable the faster mysql batching
	34	+ # algorithm if this model uses a non-integer primary key named
	35	+ # 'id' on MySQL.
	36	+ #
	37	+ # ferret:: Hash of Options that directly influence the way the Ferret engine works. You
	38	+ # can use most of the options the Ferret::I class accepts here, too. Among the
	39	+ # more useful are:
	40	+ #
	41	+ # or_default:: whether query terms are required by
	42	+ # default (the default, false), or not (true)
	43	+ #
	44	+ # analyzer:: the analyzer to use for query parsing (default: nil,
	45	+ # which means the ferret StandardAnalyzer gets used)
	46	+ #
	47	+ # default_field:: use to set one or more fields that are searched for query terms
	48	+ # that don't have an explicit field list. This list should not
	49	+ # contain any untokenized fields. If it does, you're asking
	50	+ # for trouble (i.e. not getting results for queries having
	51	+ # stop words in them). Aaf by default initializes the default field
	52	+ # list to contain all tokenized fields. If you use :single_index => true,
	53	+ # you really should set this option specifying your default field
	54	+ # list (which should be equal in all your classes sharing the index).
	55	+ # Otherwise you might get incorrect search results and you won't get
	56	+ # any lazy loading of stored field data.
	57	+ #
	58	+ # For downwards compatibility reasons you can also specify the Ferret options in the
	59	+ # last Hash argument.
	60	+ def acts_as_ferret(options={})
	61	+
	62	+ extend ClassMethods
	63	+
	64	+ include InstanceMethods
	65	+ include MoreLikeThis::InstanceMethods
	66	+
	67	+ if options[:rdig]
	68	+ cattr_accessor :rdig_configuration
	69	+ self.rdig_configuration = options[:rdig]
	70	+ require 'rdig_adapter'
	71	+ include ActsAsFerret::RdigAdapter
	72	+ end
	73	+
	74	+ unless included_modules.include?(ActsAsFerret::WithoutAR)
	75	+ # set up AR hooks
	76	+ after_create :ferret_create
	77	+ after_update :ferret_update
	78	+ after_destroy :ferret_destroy
	79	+ end
	80	+
	81	+ cattr_accessor :aaf_configuration
	82	+
	83	+ # apply default config for rdig based models
	84	+ if options[:rdig]
	85	+ options[:fields] \|\|= { :title => { :boost => 3, :store => :yes },
	86	+ :content => { :store => :yes } }
	87	+ end
	88	+
	89	+ # name of this index
	90	+ index_name = options.delete(:index) \|\| self.name.underscore
	91	+
	92	+ index = ActsAsFerret::register_class_with_index(self, index_name, options)
	93	+ self.aaf_configuration = index.index_definition.dup
	94	+ logger.debug "configured index for class #{self.name}:\n#{aaf_configuration.inspect}"
	95	+
	96	+ # update our copy of the global index config with options local to this class
	97	+ aaf_configuration[:class_name] \|\|= self.name
	98	+ aaf_configuration[:if] \|\|= options[:if]
	99	+
	100	+ # add methods for retrieving field values
	101	+ add_fields options[:fields]
	102	+ add_fields options[:additional_fields]
	103	+ add_fields aaf_configuration[:fields]
	104	+ add_fields aaf_configuration[:additional_fields]
	105	+
	106	+ # not good at class level, index might get initialized too early
	107	+ #if options[:remote]
	108	+ # aaf_index.ensure_index_exists
	109	+ #end
	110	+ end
	111	+
	112	+
	113	+ protected
	114	+
	115	+
	116	+ # helper to defines a method which adds the given field to a ferret
	117	+ # document instance
	118	+ def define_to_field_method(field, options = {})
	119	+ method_name = "#{field}_to_ferret"
	120	+ return if instance_methods.include?(method_name) # already defined
	121	+ aaf_configuration[:defined_fields] \|\|= {}
	122	+ aaf_configuration[:defined_fields][field] = options
	123	+ dynamic_boost = options[:boost] if options[:boost].is_a?(Symbol)
	124	+ via = options[:via] \|\| field
	125	+ define_method(method_name.to_sym) do
	126	+ val = begin
	127	+ content_for_field_name(field, via, dynamic_boost)
	128	+ rescue
	129	+ logger.warn("Error retrieving value for field #{field}: #{$!}")
	130	+ ''
	131	+ end
	132	+ logger.debug("Adding field #{field} with value '#{val}' to index")
	133	+ val
	134	+ end
	135	+ end
	136	+
	137	+ def add_fields(field_config)
	138	+ # TODO
	139	+ #field_config.each do \|*args\|
	140	+ # define_to_field_method *args
	141	+ #end
	142	+ if field_config.is_a? Hash
	143	+ field_config.each_pair do \|field, options\|
	144	+ define_to_field_method field, options
	145	+ end
	146	+ elsif field_config.respond_to?(:each)
	147	+ field_config.each do \|field\|
	148	+ define_to_field_method field
	149	+ end
	150	+ end
	151	+ end
	152	+
	153	+ end
	154	+
	155	+end
...	...