honkster-acts_as_solr 0.1.0

data/lib/acts_as_solr/search_results.rb

@@ -0,0 +1,68 @@
+module ActsAsSolr #:nodoc:
+  
+  # TODO: Possibly looking into hooking it up with Solr::Response::Standard
+  # 
+  # Class that returns the search results with four methods.
+  # 
+  #   books = Book.find_by_solr 'ruby'
+  # 
+  # the above will return a SearchResults class with 4 methods:
+  # 
+  # docs|results|records: will return an array of records found
+  # 
+  #   books.records.empty?
+  #   => false
+  # 
+  # total|num_found|total_hits: will return the total number of records found
+  # 
+  #   books.total
+  #   => 2
+  # 
+  # facets: will return the facets when doing a faceted search
+  # 
+  # max_score|highest_score: returns the highest score found
+  # 
+  #   books.max_score
+  #   => 1.3213213
+  # 
+  # 
+  class SearchResults
+    def initialize(solr_data={})
+      @solr_data = solr_data
+    end
+    
+    # Returns an array with the instances. This method
+    # is also aliased as docs and records
+    def results
+      @solr_data[:docs]
+    end
+    
+    # Returns the total records found. This method is
+    # also aliased as num_found and total_hits
+    def total
+      @solr_data[:total]
+    end
+    
+    # Returns the facets when doing a faceted search
+    def facets
+      @solr_data[:facets]
+    end
+    
+    # Returns the highest score found. This method is
+    # also aliased as highest_score
+    def max_score
+      @solr_data[:max_score]
+    end
+    
+    def query_time
+      @solr_data[:query_time]
+    end
+    
+    alias docs results
+    alias records results
+    alias num_found total
+    alias total_hits total
+    alias highest_score max_score
+  end
+  
+end

data/lib/acts_as_solr/solr_fixtures.rb

@@ -0,0 +1,13 @@
+module ActsAsSolr
+
+  class SolrFixtures
+    def self.load(table_names)
+      [table_names].flatten.map { |n| n.to_s }.each do |table_name|
+        klass = instance_eval(File.split(table_name.to_s).last.to_s.gsub('_',' ').split(" ").collect{|w| w.capitalize}.to_s.singularize)
+        klass.rebuild_solr_index if klass.respond_to?(:rebuild_solr_index)
+      end
+      ActsAsSolr::Post.execute(Solr::Request::Commit.new)
+    end
+  end
+  
+end

data/lib/acts_as_solr/tasks/database.rake

@@ -0,0 +1,16 @@
+namespace :db do
+  namespace :fixtures do
+    desc "Load fixtures into the current environment's database. Load specific fixtures using FIXTURES=x,y"
+    task :load => :environment do
+      begin
+        ActsAsSolr::Post.execute(Solr::Request::Delete.new(:query => "*:*"))
+        ActsAsSolr::Post.execute(Solr::Request::Commit.new)
+        (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir.glob(File.join(RAILS_ROOT, 'test', 'fixtures', '*.{yml,csv}'))).each do |fixture_file|    
+          ActsAsSolr::SolrFixtures.load(File.basename(fixture_file, '.*'))
+        end 
+        puts "The fixtures loaded have been added to Solr"       
+      rescue
+      end
+    end
+  end
+end

data/lib/acts_as_solr/tasks/solr.rake

@@ -0,0 +1,132 @@
+namespace :solr do
+
+  desc 'Starts Solr. Options accepted: RAILS_ENV=your_env, PORT=XX. Defaults to development if none.'
+  task :start do
+    require File.expand_path("#{File.dirname(__FILE__)}/../../config/solr_environment")
+    begin
+      n = Net::HTTP.new('127.0.0.1', SOLR_PORT)
+      n.request_head('/').value 
+
+    rescue Net::HTTPServerException #responding
+      puts "Port #{SOLR_PORT} in use" and return
+
+    rescue Errno::ECONNREFUSED #not responding
+      Dir.chdir(SOLR_PATH) do
+        pid = fork do
+          #STDERR.close
+          exec "java #{SOLR_JVM_OPTIONS} -Dsolr.data.dir=#{SOLR_DATA_PATH} -Djetty.logs=#{SOLR_LOGS_PATH} -Djetty.port=#{SOLR_PORT} -jar start.jar"
+        end
+        sleep(5)
+        File.open("#{SOLR_PIDS_PATH}/#{ENV['RAILS_ENV']}_pid", "w"){ |f| f << pid}
+        puts "#{ENV['RAILS_ENV']} Solr started successfully on #{SOLR_PORT}, pid: #{pid}."
+      end
+    end
+  end
+  
+  desc 'Stops Solr. Specify the environment by using: RAILS_ENV=your_env. Defaults to development if none.'
+  task :stop do
+    require File.expand_path("#{File.dirname(__FILE__)}/../../config/solr_environment")
+    fork do
+      file_path = "#{SOLR_PIDS_PATH}/#{ENV['RAILS_ENV']}_pid"
+      if File.exists?(file_path)
+        File.open(file_path, "r") do |f| 
+          pid = f.readline
+          Process.kill('TERM', pid.to_i)
+        end
+        File.unlink(file_path)
+        Rake::Task["solr:destroy_index"].invoke if ENV['RAILS_ENV'] == 'test'
+        puts "Solr shutdown successfully."
+      else
+        puts "PID file not found at #{file_path}. Either Solr is not running or no PID file was written."
+      end
+    end
+  end
+  
+  desc 'Remove Solr index'
+  task :destroy_index do
+    require File.expand_path("#{File.dirname(__FILE__)}/../../config/solr_environment")
+    raise "In production mode.  I'm not going to delete the index, sorry." if ENV['RAILS_ENV'] == "production"
+    if File.exists?("#{SOLR_DATA_PATH}")
+      Dir["#{SOLR_DATA_PATH}/index/*"].each{|f| File.unlink(f)}
+      Dir.rmdir("#{SOLR_DATA_PATH}/index")
+      puts "Index files removed under " + ENV['RAILS_ENV'] + " environment"
+    end
+  end
+  
+  # this task is by Henrik Nyh
+  # http://henrik.nyh.se/2007/06/rake-task-to-reindex-models-for-acts_as_solr
+  desc %{Reindexes data for all acts_as_solr models. Clears index first to get rid of orphaned records and optimizes index afterwards. RAILS_ENV=your_env to set environment. ONLY=book,person,magazine to only reindex those models; EXCEPT=book,magazine to exclude those models. START_SERVER=true to solr:start before and solr:stop after. BATCH=123 to post/commit in batches of that size: default is 300. CLEAR=false to not clear the index first; OPTIMIZE=false to not optimize the index afterwards.}
+  task :reindex => :environment do
+    require File.expand_path("#{File.dirname(__FILE__)}/../../config/solr_environment")
+
+    includes = env_array_to_constants('ONLY')
+    if includes.empty?
+      includes = Dir.glob("#{RAILS_ROOT}/app/models/*.rb").map { |path| File.basename(path, ".rb").camelize.constantize }
+    end
+    excludes = env_array_to_constants('EXCEPT')
+    includes -= excludes
+    
+    optimize            = env_to_bool('OPTIMIZE',     true)
+    start_server        = env_to_bool('START_SERVER', false)
+    clear_first         = env_to_bool('CLEAR',       true)
+    batch_size          = ENV['BATCH'].to_i.nonzero? || 300
+    debug_output        = env_to_bool("DEBUG", false)
+
+    RAILS_DEFAULT_LOGGER.level = ActiveSupport::BufferedLogger::INFO unless debug_output
+
+    if start_server
+      puts "Starting Solr server..."
+      Rake::Task["solr:start"].invoke 
+    end
+    
+    # Disable solr_optimize
+    module ActsAsSolr::CommonMethods
+      def blank() end
+      alias_method :deferred_solr_optimize, :solr_optimize
+      alias_method :solr_optimize, :blank
+    end
+    
+    models = includes.select { |m| m.respond_to?(:rebuild_solr_index) }    
+    models.each do |model|
+  
+      if clear_first
+        puts "Clearing index for #{model}..."
+        ActsAsSolr::Post.execute(Solr::Request::Delete.new(:query => "#{model.solr_configuration[:type_field]}:#{model}")) 
+        ActsAsSolr::Post.execute(Solr::Request::Commit.new)
+      end
+      
+      puts "Rebuilding index for #{model}..."
+      model.rebuild_solr_index(batch_size)
+
+    end 
+
+    if models.empty?
+      puts "There were no models to reindex."
+    elsif optimize
+      puts "Optimizing..."
+      models.last.deferred_solr_optimize
+    end
+
+    if start_server
+      puts "Shutting down Solr server..."
+      Rake::Task["solr:stop"].invoke 
+    end
+    
+  end
+  
+  def env_array_to_constants(env)
+    env = ENV[env] || ''
+    env.split(/\s*,\s*/).map { |m| m.singularize.camelize.constantize }.uniq
+  end
+  
+  def env_to_bool(env, default)
+    env = ENV[env] || ''
+    case env
+      when /^true$/i then true
+      when /^false$/i then false
+      else default
+    end
+  end
+
+end
+

data/lib/acts_as_solr/tasks/test.rake

@@ -0,0 +1,5 @@
+namespace :test do
+  task :migrate do
+    ActiveRecord::Migrator.migrate("test/db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+  end
+end

data/lib/acts_as_solr/tasks.rb

@@ -0,0 +1,10 @@
+dir = File.dirname(__FILE__)
+require 'rubygems'
+require 'rake'
+require 'net/http'
+require 'active_record'
+require File.expand_path("#{dir}/solr_fixtures")
+
+load File.expand_path("#{dir}/tasks/database.rake")
+load File.expand_path("#{dir}/tasks/solr.rake")
+load File.expand_path("#{dir}/tasks/test.rake")

data/lib/acts_as_solr.rb

@@ -0,0 +1,64 @@
+# Copyright (c) 2006 Erik Hatcher, Thiago Jackiw
+#
+# 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_record'
+require 'rexml/document'
+require 'net/http'
+require 'yaml'
+require 'time'
+require 'erb'
+require 'rexml/xpath'
+
+require File.dirname(__FILE__) + '/solr'
+require File.dirname(__FILE__) + '/acts_as_solr/acts_methods'
+require File.dirname(__FILE__) + '/acts_as_solr/common_methods'
+require File.dirname(__FILE__) + '/acts_as_solr/parser_methods'
+require File.dirname(__FILE__) + '/acts_as_solr/class_methods'
+require File.dirname(__FILE__) + '/acts_as_solr/instance_methods'
+require File.dirname(__FILE__) + '/acts_as_solr/common_methods'
+require File.dirname(__FILE__) + '/acts_as_solr/deprecation'
+require File.dirname(__FILE__) + '/acts_as_solr/search_results'
+require File.dirname(__FILE__) + '/acts_as_solr/lazy_document'
+module ActsAsSolr
+  
+  class Post    
+    def self.execute(request)
+      begin
+        if File.exists?(RAILS_ROOT+'/config/solr.yml')
+          config = YAML::load_file(RAILS_ROOT+'/config/solr.yml')
+          url = config[RAILS_ENV]['url']
+          # for backwards compatibility
+          url ||= "http://#{config[RAILS_ENV]['host']}:#{config[RAILS_ENV]['port']}/#{config[RAILS_ENV]['servlet_path']}"
+        else
+          url = 'http://localhost:8982/solr'
+        end
+        connection = Solr::Connection.new(url)
+        return connection.send(request)
+      rescue 
+        raise "Couldn't connect to the Solr server at #{url}. #{$!}"
+        false
+      end
+    end
+  end
+  
+end
+
+# reopen ActiveRecord and include the acts_as_solr method
+ActiveRecord::Base.extend ActsAsSolr::ActsMethods

data/lib/solr/connection.rb

@@ -0,0 +1,177 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# TODO: add a convenience method to POST a Solr .xml file, like Solr's example post.sh
+
+class Solr::Connection
+  attr_reader :url, :autocommit, :connection
+
+  # create a connection to a solr instance using the url for the solr
+  # application context:
+  #
+  #   conn = Solr::Connection.new("http://example.com:8080/solr")
+  #
+  # if you would prefer to have all adds/updates autocommitted, 
+  # use :autocommit => :on
+  #
+  #   conn = Solr::Connection.new('http://example.com:8080/solr', 
+  #     :autocommit => :on)
+
+  def initialize(url="http://localhost:8983/solr", opts={})
+    @url = URI.parse(url)
+    unless @url.kind_of? URI::HTTP
+      raise "invalid http url: #{url}"
+    end
+  
+    # TODO: Autocommit seems nice at one level, but it currently is confusing because
+    # only calls to Connection#add/#update/#delete, though a Connection#send(AddDocument.new(...))
+    # does not autocommit.  Maybe #send should check for the request types that require a commit and
+    # commit in #send instead of the individual methods?
+    @autocommit = opts[:autocommit] == :on
+  
+    # Not actually opening the connection yet, just setting up the persistent connection.
+    @connection = Net::HTTP.new(@url.host, @url.port)
+    
+    @connection.read_timeout = opts[:timeout] if opts[:timeout]
+  end
+
+  # add a document to the index. you can pass in either a hash
+  #
+  #   conn.add(:id => 123, :title => 'Tlon, Uqbar, Orbis Tertius')
+  #
+  # or a Solr::Document
+  #
+  #   conn.add(Solr::Document.new(:id => 123, :title = 'On Writing')
+  #
+  # true/false will be returned to designate success/failure
+
+  def add(doc)
+    request = Solr::Request::AddDocument.new(doc)
+    response = send(request)
+    commit if @autocommit
+    return response.ok?
+  end
+
+  # update a document in the index (really just an alias to add)
+
+  def update(doc)
+    return add(doc)
+  end
+
+  # performs a standard query and returns a Solr::Response::Standard
+  #
+  #   response = conn.query('borges')
+  # 
+  # alternative you can pass in a block and iterate over hits
+  #
+  #   conn.query('borges') do |hit|
+  #     puts hit
+  #   end
+  #
+  # options include:
+  # 
+  #   :sort, :default_field, :rows, :filter_queries, :debug_query,
+  #   :explain_other, :facets, :highlighting, :mlt,
+  #   :operator         => :or / :and
+  #   :start            => defaults to 0
+  #   :field_list       => array, defaults to ["*", "score"]
+
+  def query(query, options={}, &action)
+    # TODO: Shouldn't this return an exception if the Solr status is not ok?  (rather than true/false).
+    create_and_send_query(Solr::Request::Standard, options.update(:query => query), &action)
+  end
+  
+  # performs a dismax search and returns a Solr::Response::Standard
+  #
+  #   response = conn.search('borges')
+  # 
+  # options are same as query, but also include:
+  # 
+  #   :tie_breaker, :query_fields, :minimum_match, :phrase_fields,
+  #   :phrase_slop, :boost_query, :boost_functions
+
+  def search(query, options={}, &action)
+    create_and_send_query(Solr::Request::Dismax, options.update(:query => query), &action)
+  end
+
+  # sends a commit message to the server
+  def commit(options={})
+    response = send(Solr::Request::Commit.new(options))
+    return response.ok?
+  end
+
+  # sends an optimize message to the server
+  def optimize
+    response = send(Solr::Request::Optimize.new)
+    return response.ok?
+  end
+  
+  # pings the connection and returns true/false if it is alive or not
+  def ping
+    begin
+      response = send(Solr::Request::Ping.new)
+      return response.ok?
+    rescue
+      return false
+    end
+  end
+
+  # delete a document from the index using the document id
+  def delete(document_id)
+    response = send(Solr::Request::Delete.new(:id => document_id))
+    commit if @autocommit
+    response.ok?
+  end
+
+  # delete using a query
+  def delete_by_query(query)
+    response = send(Solr::Request::Delete.new(:query => query))
+    commit if @autocommit
+    response.ok?
+  end
+  
+  def info
+    send(Solr::Request::IndexInfo.new)
+  end
+  
+  # send a given Solr::Request and return a RubyResponse or XmlResponse
+  # depending on the type of request
+  def send(request)
+    data = post(request)
+    Solr::Response::Base.make_response(request, data)
+  end
+
+  # send the http post request to solr; for convenience there are shortcuts
+  # to some requests: add(), query(), commit(), delete() or send()
+  def post(request)
+    response = @connection.post(@url.path + "/" + request.handler,
+                                request.to_s,
+                                { "Content-Type" => request.content_type })
+  
+    case response
+    when Net::HTTPSuccess then response.body
+    else
+      response.error!
+    end
+  
+  end
+  
+private
+  
+  def create_and_send_query(klass, options = {}, &action)
+    request = klass.new(options)
+    response = send(request)
+    return response unless action
+    response.each {|hit| action.call(hit)}
+  end
+  
+end