acts_as_ferret 0.4.8.2 → 0.5

data/README

@@ -19,13 +19,9 @@ http://github.com/jkraemer/acts_as_ferret/tree/master .
 
 === Set up your Rails > 2.1 project to use the acts_as_ferret gem.
 
-Add this to your project's config/environment.rb (inside the Rails::Initializer.run block):
+Add this to your project's config/environment.rb:
 
-<tt>
-  config.gem 'acts_as_ferret', :version => '~> 0.4.8'
-  config.after_initialize { ActsAsFerret::load_config }
-  config.to_prepare       { ActsAsFerret::load_config }  
-</tt>
+<tt>config.gem 'acts_as_ferret', :version => '~> 0.4.8'</tt>
 
 With the gem installed, change into your RAILS_ROOT and run the supplied aaf_install script.
 This will copy rake tasks, capistrano recipes and the ferret server config and startup script

data/bin/aaf_install

@@ -1,18 +1,23 @@
 #!/usr/bin/env ruby
+#
 # acts_as_ferret gem install script
-# Use inside the root of your Rails project
+#
+# Call this from Rails.root to install start/stop script, sample config and
+# Capistrano recipes into your rails project.
+
 require 'fileutils'
 
 @basedir = File.join(File.dirname(__FILE__), '..')
 
-def install(src, target_dir, executable=false)
+def install(src, target_dir, executable=false, overwrite=false)
   puts "Installing: #{src}"
   src = File.join(@basedir, src)
   fname = File.basename(src)
   target = File.join(target_dir, fname)
-  if File.exists?(target)
+  if !overwrite && File.exists?(target)
     puts "#{target} already exists, skipping"
   else
+    FileUtils.rm_f target
     FileUtils.mkdir_p target_dir
     FileUtils.cp src, target
     FileUtils.chmod 0755, target if executable
@@ -20,10 +25,9 @@ def install(src, target_dir, executable=false)
 end
 
 
-install 'script/ferret_server', 'script', true
+install 'script/ferret_server', 'script', true, true
 install 'config/ferret_server.yml', 'config'
-install 'tasks/ferret.rake', 'lib/tasks'
-install 'recipes/aaf_recipes.rb', 'lib/recipes'
+install 'recipes/aaf_recipes.rb', 'lib/recipes', false, true
 
 puts IO.read(File.join(@basedir, 'README'))
 

data/config/ferret_server.yml

@@ -2,8 +2,8 @@
 # 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
+# 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

data/doc/demo/app/models/stats.rb

@@ -9,7 +9,7 @@ class Stats < ActiveRecord::Base
       where kind=? group by time;
   END
     result = connection.execute sanitize_sql([sql, start_date, start_date, kind.to_s])
-    [].tap do |res|
+    returning [] do |res|
       while row = result.fetch_row
         data = row.last.split(',').map{|t|t.to_i}
         median = data.size.odd? ? data[data.size/2] : ((data[data.size/2-1]+data[data.size/2]) / 2.0)

data/lib/acts_as_ferret.rb

@@ -20,33 +20,34 @@
 
 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 'acts_as_ferret/ferret_find_methods'
+require 'acts_as_ferret/remote_functions'
+require 'acts_as_ferret/blank_slate'
+require 'acts_as_ferret/bulk_indexer'
+require 'acts_as_ferret/ferret_extensions'
+require 'acts_as_ferret/act_methods'
+require 'acts_as_ferret/search_results'
+require 'acts_as_ferret/class_methods'
+require 'acts_as_ferret/ferret_result'
+require 'acts_as_ferret/instance_methods'
+require 'acts_as_ferret/without_ar'
 
-require 'multi_index'
-require 'remote_multi_index'
-require 'more_like_this'
+require 'acts_as_ferret/multi_index'
+require 'acts_as_ferret/remote_multi_index'
+require 'acts_as_ferret/more_like_this'
 
-require 'index'
-require 'local_index'
-require 'remote_index'
+require 'acts_as_ferret/index'
+require 'acts_as_ferret/local_index'
+require 'acts_as_ferret/remote_index'
 
-require 'ferret_server'
+require 'acts_as_ferret/server/server'
 
-require 'rdig_adapter'
+require 'acts_as_ferret/rdig_adapter'
 
 # The Rails ActiveRecord Ferret Mixin.
 #
@@ -82,12 +83,14 @@ require 'rdig_adapter'
 #                    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
+#          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
 
+  require 'acts_as_ferret/railtie' if defined?(Rails)
+
   class ActsAsFerretError < StandardError; end
   class IndexNotDefined < ActsAsFerretError; end
   class IndexAlreadyDefined < ActsAsFerretError; end
@@ -107,7 +110,7 @@ module ActsAsFerret
   @@index_using_classes = {}
   def self.index_using_classes; @@index_using_classes end
 
-  @@logger = Logger.new "#{RAILS_ROOT}/log/acts_as_ferret.log"
+  @@logger = Logger.new "#{Rails.root || '.'}/log/acts_as_ferret.log"
   @@logger.level = ActiveRecord::Base.logger.level rescue Logger::DEBUG
   mattr_accessor :logger
 
@@ -129,10 +132,10 @@ module ActsAsFerret
   mattr_accessor :remote
   def self.remote?
     if @@remote.nil?
-      if ENV["FERRET_USE_LOCAL_INDEX"] || ActsAsFerret::Remote::Server.running
+      if ENV["FERRET_USE_LOCAL_INDEX"] || ActsAsFerret::Server::Server.running
         @@remote = false
       else
-        @@remote = ActsAsFerret::Remote::Config.new.uri rescue false
+        @@remote = ActsAsFerret::Server::Config.new.uri rescue false
       end
       if @@remote
         logger.info "Will use remote index server which should be available at #{@@remote}"
@@ -255,7 +258,7 @@ module ActsAsFerret
 
   def self.load_config
     # using require_dependency to make the reloading in dev mode work.
-    require_dependency "#{RAILS_ROOT}/config/aaf.rb"
+    require_dependency "#{Rails.root}/config/aaf.rb"
     ActsAsFerret::logger.info "loaded configuration file aaf.rb"
   rescue LoadError
   ensure
@@ -456,8 +459,6 @@ module ActsAsFerret
     # get objects for each model
     id_arrays.each do |model, id_array|
       next if id_array.empty?
-      # logger.debug "id array from index: #{id_array.inspect}"
-      
       model_class = model.constantize
 
       # merge conditions
@@ -486,21 +487,20 @@ module ActsAsFerret
     
     # order results as they were found by ferret, unless an AR :order
     # option was given
-    # logger.debug "unsorted result: #{result.map{|a| "#{a.id} / #{a.title} / #{a.ferret_rank}"}.inspect}"
     result.sort! { |a, b| a.ferret_rank <=> b.ferret_rank } unless find_options[:order]
-    # logger.debug "sorted result: #{result.map{|a| "#{a.id} / #{a.ferret_rank}"}.inspect}"
     return result
   end
   
   # combine our conditions with those given by user, if any
   def self.combine_conditions(conditions, additional_conditions = [])
-    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)
+    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
-    return conditions
   end
 
   def self.build_field_config(fields)
@@ -521,10 +521,10 @@ module ActsAsFerret
 
   
   # make sure the default index base dir exists. by default, all indexes are created
-  # under RAILS_ROOT/index/RAILS_ENV
+  # under Rails.root/index/Rails.env
   def self.init_index_basedir
-    index_base = "#{RAILS_ROOT}/index"
-    @@index_dir = "#{index_base}/#{RAILS_ENV}"
+    index_base = "#{Rails.root || '.'}/index"
+    @@index_dir = "#{index_base}/#{Rails.env}"
   end
   
   mattr_accessor :index_dir
@@ -591,3 +591,5 @@ end
 # include acts_as_ferret method into ActiveRecord::Base
 ActiveRecord::Base.extend ActsAsFerret::ActMethods
 
+
+

data/lib/{act_methods.rb → acts_as_ferret/act_methods.rb}

@@ -26,7 +26,7 @@ module ActsAsFerret #:nodoc:
     #      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 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

data/lib/{ferret_extensions.rb → acts_as_ferret/ferret_extensions.rb}

@@ -94,20 +94,6 @@ module Ferret
         flush()
       end      
     end
-
-    # search for the first document with +arg+ in the +id+ field and return it's internal document number. 
-    # The +id+ field is either :id or whatever you set
-    # :id_field parameter to when you create the Index object.
-    def doc_number(id)
-      @dir.synchronize do
-        ensure_reader_open()
-        term_doc_enum = @reader.term_docs_for(@id_field, id.to_s)
-        return term_doc_enum.next? ? term_doc_enum.doc : nil
-      end
-    end
-    
-    private
-    
     
     # If +docs+ is a Hash or an Array then a batch delete will be performed.
     # If +docs+ is an Array then it will be considered an array of +id+'s. If
@@ -148,7 +134,17 @@ module Ferret
       end
       return self
     end
-    
+
+    # search for the first document with +arg+ in the +id+ field and return it's internal document number. 
+    # The +id+ field is either :id or whatever you set
+    # :id_field parameter to when you create the Index object.
+    def doc_number(id)
+      @dir.synchronize do
+        ensure_reader_open()
+        term_doc_enum = @reader.term_docs_for(@id_field, id.to_s)
+        return term_doc_enum.next? ? term_doc_enum.doc : nil
+      end
+    end
   end
 
   # add marshalling support to SortFields
@@ -179,7 +175,7 @@ module Ferret
       # 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!
+        value.strip!
           Ferret::Search::SortField._load value unless value.blank?
         end
         new sort_fields.compact

data/lib/{instance_methods.rb → acts_as_ferret/instance_methods.rb}

@@ -125,7 +125,7 @@ module ActsAsFerret #:nodoc:
     # fieldname => value pairs)
     def to_doc
       logger.debug "creating doc for class: #{self.ferret_key}"
-      Ferret::Document.new.tap do |doc|
+      returning Ferret::Document.new do |doc|
         # store the id and class name of each item, and the unique key used for identifying the record
         # even in multi-class indexes.
         doc[:key] = self.ferret_key

data/lib/{local_index.rb → acts_as_ferret/local_index.rb}

@@ -16,9 +16,9 @@ module ActsAsFerret
     # The 'real' Ferret Index instance
     def ferret_index
       ensure_index_exists
-      (@ferret_index ||= Ferret::Index::Index.new(index_definition[:ferret])).tap do |idx|
-        idx.batch_size = index_definition[:reindex_batch_size]
-        idx.logger = logger
+      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
 
@@ -73,6 +73,9 @@ module ActsAsFerret
               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
@@ -148,7 +151,7 @@ module ActsAsFerret
       return Ferret::Search::TermQuery.new(:key, key.to_s)
       # if shared?
       #   raise InvalidArgumentError.new("shared index needs class_name argument") if class_name.nil?
-      #   Ferret::Search::BooleanQuery.new.tap do |bq|
+      #   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

data/lib/acts_as_ferret/railtie.rb

@@ -0,0 +1,16 @@
+require 'acts_as_ferret'
+require 'rails'
+
+module ActsAsFerret
+  
+  class Railtie < Rails::Railtie
+        
+    rake_tasks do
+      load File.join(File.dirname(__FILE__), '../../tasks/ferret.rake')
+    end
+      
+    config.to_prepare { ActsAsFerret::load_config }
+    
+  end
+  
+end

data/lib/{rdig_adapter.rb → acts_as_ferret/rdig_adapter.rb}

@@ -1,7 +1,6 @@
 begin
   require 'rdig'
 rescue LoadError
-  puts "RDig gem not found, searching and indexing static pages won't work."
 end
 require 'digest/md5'
 

data/lib/acts_as_ferret/server/config.rb

@@ -0,0 +1,50 @@
+require 'yaml'
+require 'erb'
+
+module ActsAsFerret
+  module Server
+    
+    class Config
+
+      ################################################################################
+      DEFAULTS = {
+        'host'      => 'localhost',
+        'port'      => '9009',
+        'cf'        => "config/ferret_server.yml",
+        'pid_file'  => "log/ferret_server.pid",
+        'log_file'  => "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(abs_config_file_path(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
+      
+      def abs_config_file_path(path)
+        if path =~ /^\//
+          path
+        else
+          Rails.root.join(path).to_s
+        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
+    
+    
+  end
+end

data/lib/{ferret_server.rb → acts_as_ferret/server/server.rb}

@@ -1,52 +1,18 @@
 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
+require 'acts_as_ferret/server/unix_daemon'
+require 'acts_as_ferret/server/config'
 
-      ################################################################################
-      # 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
+module ActsAsFerret
+  module Server
 
-    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. 
+    # - 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:
@@ -55,41 +21,31 @@ module ActsAsFerret
     # 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)
+      include UnixDaemon
 
 
-      ################################################################################
       cattr_accessor :running
 
-      ################################################################################
       def initialize
-        ActiveRecord::Base.allow_concurrency = true
-        require 'ar_mysql_auto_reconnect_patch'
-        @cfg = ActsAsFerret::Remote::Config.new
+        @cfg = 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) 
+          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)
+        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)
+        raise "ferret_server not configured for #{Rails.env}" unless (@cfg.uri rescue nil)
         run_drb_service
       end
 
@@ -103,7 +59,6 @@ module ActsAsFerret
         raise
       end
 
-      #################################################################################
       # handles all incoming method calls, and sends them on to the correct local index
       # instance.
       #
@@ -227,7 +182,7 @@ module ActsAsFerret
                             :create      => true,
                             :field_infos => ActsAsFerret::field_infos(index_definition),
                             :path        => File.join(index_definition[:index_base_dir], 'rebuild')
-          Ferret::Index::Index.new(ferret_cfg).tap do |i|
+          returning Ferret::Index::Index.new(ferret_cfg) do |i|
             i.batch_size = index_definition[:reindex_batch_size]
             i.logger = @logger
           end