acts_as_ferret 0.4.3 → 0.4.4

data/lib/remote_index.rb

@@ -4,46 +4,50 @@ 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)
-      @config = config
-      @ferret_config = config[:ferret]
-      @server = DRbObject.new(nil, config[:remote])
+      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 model_class_name
-      @server.send(method_name, *args)
+      args.unshift index_name
+      handle_drb_error { @server.send(method_name, *args) }
     end
 
-    def find_id_by_contents(q, options = {}, &proc)
-      total_hits, results = @server.find_id_by_contents(model_class_name, q, options)
-      block_given? ? yield_results(total_hits, results, &proc) : [ total_hits, results ]
+    # 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 id_multi_search(query, models, options, &proc)
-      total_hits, results = @server.id_multi_search(model_class_name, query, models, options)
+    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)
-      @server.add record.class.name, record.to_doc
+      handle_drb_error { @server.add index_name, record.to_doc }
     end
     alias << add
 
     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 model_class_name
-      @config[:class_name]
-    end
+    #def model_class_name
+    #  index_definition[:class_name]
+    #end
 
   end
 

data/lib/remote_multi_index.rb

@@ -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

data/lib/search_results.rb

@@ -2,8 +2,11 @@ module ActsAsFerret
 
   # decorator that adds a total_hits accessor and will_paginate compatible 
   # paging support to search result arrays
-  class SearchResults
-    attr_reader :current_page, :per_page, :total_hits
+  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
@@ -18,18 +21,12 @@ module ActsAsFerret
     end
 
     def respond_to?(name)
-      self.methods.include?(name) || @results.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
 
-    #
-    # The total number of pages.
-    def page_count
-      @total_pages
-    end
-
     # Current offset of the paginated collection. If we're on the first page,
     # it is always 0. If we're on the 2nd page and there are 30 entries per page,
     # the offset is 30. This property is useful if you want to render ordinals
@@ -46,7 +43,7 @@ module ActsAsFerret
 
     # current_page + 1 or nil if there is no next page
     def next_page
-      current_page < page_count ? (current_page + 1) : nil
+      current_page < total_pages ? (current_page + 1) : nil
     end
   end
 

data/lib/server_manager.rb

@@ -5,16 +5,21 @@ require 'optparse'
 $ferret_server_options = {
   'environment' => nil,
   'debug'       => nil,
+  'root'        => nil
 }
 
 ################################################################################
 OptionParser.new do |optparser|
-  optparser.banner = "Usage: #{File.basename($0)} [options] {start|stop}"
+  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
@@ -28,15 +33,22 @@ OptionParser.new do |optparser|
   (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).include?($ferret_server_action)
+  (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']
-  #require(File.join(File.dirname(__FILE__), '../../../../config/environment'))
-  require(File.join(File.dirname(ENV['_']), '../config/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

data/lib/unix_daemon.rb

@@ -49,6 +49,7 @@ module ActsAsFerret
       #################################################################################
       # create the PID file and install an at_exit handler
       def write_pid_file
+        ensure_stopped
         open(@cfg.pid_file, "w") {|f| f << Process.pid << "\n"}
         at_exit { File.unlink(@cfg.pid_file) if read_pid_file == Process.pid }
       end
@@ -58,6 +59,28 @@ module ActsAsFerret
         File.read(@cfg.pid_file).to_i if File.exist?(@cfg.pid_file)
       end
 
+      #################################################################################
+      def ensure_stopped
+        if pid = read_pid_file
+          if process_exists(pid)
+            raise "ferret_server may already be running, a pid file exists: #{@cfg.pid_file} and a ferret_server process exists with matching pid #{pid}"
+          else
+            $stdout.puts("removing stale pid file...")
+            File.unlink(@cfg.pid_file) if File.exist?(@cfg.pid_file)
+          end
+        end
+      end
+
+      #################################################################################
+      # Check for existence of ferret_server process with PID from pid file
+      # checked on ubuntu and OSX only
+      def process_exists(pid)
+        ps = IO.popen("ps -fp #{pid}", "r")
+        process = ps.to_a[1]
+        ps.close
+        process =~ /ferret_server/
+      end
+
     end
   end
 end

data/lib/without_ar.rb

@@ -0,0 +1,52 @@
+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
+      def new_record?
+        false
+      end
+    end
+  end
+        
+end

data/rakefile

@@ -4,6 +4,8 @@
 # RELEASE creation:
 # rake release REL=x.y.z 
 
+require 'pathname'
+require 'yaml'
 require 'rake'
 require 'rake/rdoctask'
 require 'rake/packagetask'
@@ -55,7 +57,7 @@ if 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.$/,
+      [ /\.$/, /sqlite$/, /\.log$/, /^pkg/, /\.svn/, /\.git/, /\.\w+\.sw.$/,
         /^html/, /\~$/, /\/\._/, /\/#/ ].any? {|regex| f =~ regex }
     end
     #s.files           = FileList["{lib,test}/**/*"].to_a + %w(README MIT-LICENSE CHANGELOG)
@@ -71,6 +73,11 @@ if PKG_VERSION
     s.email           = "jk@jkraemer.net"
     s.homepage        = "http://projects.jkraemer.net/acts_as_ferret"
   end
+  
+  desc "Update the gemspec for GitHub's gem server"
+  task :gemspec do
+    Pathname("#{spec.name}.gemspec").open('w') {|f| f << YAML.dump(spec) }
+  end
 
   package_task = Rake::GemPackageTask.new(spec) do |pkg|
     pkg.need_tar = true
@@ -83,21 +90,21 @@ if PKG_VERSION
     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
+#     # 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
   
   

data/recipes/aaf_recipes.rb

@@ -0,0 +1,114 @@
+# 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, :roles => :app do
+      rake = fetch(:rake, 'rake')
+      rails_env = fetch(:rails_env, 'production')
+      indexes = fetch(:ferret_indexes, [])
+      if 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
+
+    desc "Clean up old index versions"
+    task :cleanup, :roles => :app do
+    	indexes = fetch(:ferret_indexes, [])
+    	indexes.each do |index|
+    	  ferret_index_path = "#{shared_path}/index/#{rails_env}/#{index}"
+    	  releases = capture("ls -x #{ferret_index_path}").split.sort
+    	  count = 2
+    	  if count >= releases.length
+    	    logger.important "no old indexes to clean up"
+    	  else
+    	    logger.info "keeping #{count} of #{releases.length} indexes"
+    	    directories = (releases - releases.last(count)).map { |release|
+    	      File.join(ferret_index_path, release) }.join(" ")
+    	    sudo "rm -rf #{directories}"
+    	  end
+    	end
+    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"
+