onemorecloud-websolr-rails 1.1.1

data/lib/lazy_document.rb

@@ -0,0 +1,18 @@
+module ActsAsSolr
+  class LazyDocument
+    attr_reader :id, :clazz
+    
+    def initialize(id, clazz)
+      @id = id
+      @clazz = clazz
+    end
+  
+    def method_missing(name, *args)
+      unless @__instance
+        @__instance = @clazz.find(@id)
+      end
+      
+      @__instance.send(name, *args)
+    end
+  end
+end

data/lib/parser_methods.rb

@@ -0,0 +1,201 @@
+module ActsAsSolr #:nodoc:
+  module ParserMethods
+    protected    
+    
+    # Method used by mostly all the ClassMethods when doing a search
+    def parse_query(query=nil, options={}, models=nil)
+      valid_options = [:offset, :limit, :facets, :models, :results_format, :order, :scores, :operator, :include, :lazy]
+      query_options = {}
+
+      return nil if (query.nil? || query.strip == '')
+
+      raise "Invalid parameters: #{(options.keys - valid_options).join(',')}" unless (options.keys - valid_options).empty?
+      begin
+        Deprecation.validate_query(options)
+        query_options[:start] = options[:offset]
+        query_options[:rows] = options[:limit]
+        query_options[:operator] = options[:operator]
+        
+        # first steps on the facet parameter processing
+        if options[:facets]
+          query_options[:facets] = {}
+          query_options[:facets][:limit] = -1  # TODO: make this configurable
+          query_options[:facets][:sort] = :count if options[:facets][:sort]
+          query_options[:facets][:mincount] = 0
+          query_options[:facets][:mincount] = 1 if options[:facets][:zeros] == false
+          # override the :zeros (it's deprecated anyway) if :mincount exists
+          query_options[:facets][:mincount] = options[:facets][:mincount] if options[:facets][:mincount]
+          query_options[:facets][:fields] = options[:facets][:fields].collect{|k| "#{k}_facet"} if options[:facets][:fields]
+          query_options[:filter_queries] = replace_types([*options[:facets][:browse]].collect{|k| "#{k.sub!(/ *: */,"_facet:")}"}) if options[:facets][:browse]
+          query_options[:facets][:queries] = replace_types(options[:facets][:query].collect{|k| "#{k.sub!(/ *: */,"_t:")}"}) if options[:facets][:query]
+          
+          
+          if options[:facets][:dates]
+            query_options[:date_facets] = {}
+            # if options[:facets][:dates][:fields] exists then :start, :end, and :gap must be there
+            if options[:facets][:dates][:fields]
+              [:start, :end, :gap].each { |k| raise "#{k} must be present in faceted date query" unless options[:facets][:dates].include?(k) }
+              query_options[:date_facets][:fields] = []
+              options[:facets][:dates][:fields].each { |f|
+                if f.kind_of? Hash
+                  key = f.keys[0]
+                  query_options[:date_facets][:fields] << {"#{key}_d" => f[key]}
+                  validate_date_facet_other_options(f[key][:other]) if f[key][:other]
+                else
+                  query_options[:date_facets][:fields] << "#{f}_d"
+                end
+              }
+            end
+            
+            query_options[:date_facets][:start]   = options[:facets][:dates][:start] if options[:facets][:dates][:start]
+            query_options[:date_facets][:end]     = options[:facets][:dates][:end] if options[:facets][:dates][:end]
+            query_options[:date_facets][:gap]     = options[:facets][:dates][:gap] if options[:facets][:dates][:gap]
+            query_options[:date_facets][:hardend] = options[:facets][:dates][:hardend] if options[:facets][:dates][:hardend]
+            query_options[:date_facets][:filter]  = replace_types([*options[:facets][:dates][:filter]].collect{|k| "#{k.sub!(/ *:(?!\d) */,"_d:")}"}) if options[:facets][:dates][:filter]
+
+            if options[:facets][:dates][:other]
+              validate_date_facet_other_options(options[:facets][:dates][:other])
+              query_options[:date_facets][:other]   = options[:facets][:dates][:other]
+            end
+            
+          end          
+        end
+        
+        if models.nil?
+          # TODO: use a filter query for type, allowing Solr to cache it individually
+          models = "AND #{solr_type_condition}"
+          field_list = solr_configuration[:primary_key_field]
+        else
+          field_list = "id"
+        end
+        
+        query_options[:field_list] = [field_list, 'score']
+        query = "(#{query.gsub(/ *: */,"_t:")}) #{models}"
+        order = options[:order].split(/\s*,\s*/).collect{|e| e.gsub(/\s+/,'_t ').gsub(/\bscore_t\b/, 'score')  }.join(',') if options[:order] 
+        query_options[:query] = replace_types([query])[0] # TODO adjust replace_types to work with String or Array  
+
+        if options[:order]
+          # TODO: set the sort parameter instead of the old ;order. style.
+          query_options[:query] << ';' << replace_types([order], false)[0]
+        end
+        
+        ActsAsSolr::Post.execute(Solr::Request::Standard.new(query_options))
+      rescue
+        raise "There was a problem executing your search: #{$!} in #{$!.backtrace.first}"
+      end            
+    end
+    
+    def solr_type_condition
+      subclasses.inject("(#{solr_configuration[:type_field]}:#{self.name}") do |condition, subclass|
+        condition << " OR #{solr_configuration[:type_field]}:#{subclass.name}"
+      end << ')'
+    end
+    
+    # Parses the data returned from Solr
+    def parse_results(solr_data, options = {})
+      results = {
+        :docs => [],
+        :total => 0
+      }
+      
+      configuration = {
+        :format => :objects
+      }
+      results.update(:facets => {'facet_fields' => []}) if options[:facets]
+      return SearchResults.new(results) if (solr_data.nil? || solr_data.total_hits == 0)
+      
+      configuration.update(options) if options.is_a?(Hash)
+
+      ids = solr_data.hits.collect {|doc| doc["#{solr_configuration[:primary_key_field]}"]}.flatten
+      
+      result = find_objects(ids, options, configuration)
+      
+      add_scores(result, solr_data) if configuration[:format] == :objects && options[:scores]
+      
+      results.update(:facets => solr_data.data['facet_counts']) if options[:facets]
+      results.update({:docs => result, :total => solr_data.total_hits, :max_score => solr_data.max_score, :query_time => solr_data.data['responseHeader']['QTime']})
+      SearchResults.new(results)
+    end
+    
+    
+    def find_objects(ids, options, configuration)
+      result = if configuration[:lazy] && configuration[:format] != :ids
+        ids.collect {|id| ActsAsSolr::LazyDocument.new(id, self)}
+      elsif configuration[:format] == :objects
+        conditions = [ "#{self.table_name}.#{primary_key} in (?)", ids ]
+        find_options = {:conditions => conditions}
+        find_options[:include] = options[:include] if options[:include]
+        result = reorder(self.find(:all, find_options), ids)
+      else
+        ids
+      end
+        
+      result
+    end
+    
+    # Reorders the instances keeping the order returned from Solr
+    def reorder(things, ids)
+      ordered_things = Array.new(things.size)
+      raise "Out of sync! Found #{ids.size} items in index, but only #{things.size} were found in database!" unless things.size == ids.size
+      things.each do |thing|
+        position = ids.index(thing.id)
+        ordered_things[position] = thing
+      end
+      ordered_things
+    end
+
+    # Replaces the field types based on the types (if any) specified
+    # on the acts_as_solr call
+    def replace_types(strings, include_colon=true)
+      suffix = include_colon ? ":" : ""
+      if configuration[:solr_fields]
+        configuration[:solr_fields].each do |name, options|
+          solr_name = options[:as] || name.to_s
+          solr_type = get_solr_field_type(options[:type])
+          field = "#{solr_name}_#{solr_type}#{suffix}"
+          strings.each_with_index {|s,i| strings[i] = s.gsub(/#{solr_name.to_s}_t#{suffix}/,field) }
+        end
+      end
+      if configuration[:solr_includes]
+        configuration[:solr_includes].each do |association, options|
+          solr_name = options[:as] || association.to_s.singularize
+          solr_type = get_solr_field_type(options[:type])
+          field = "#{solr_name}_#{solr_type}#{suffix}"
+          strings.each_with_index {|s,i| strings[i] = s.gsub(/#{solr_name.to_s}_t#{suffix}/,field) }
+        end
+      end
+      strings
+    end
+    
+    # Adds the score to each one of the instances found
+    def add_scores(results, solr_data)
+      with_score = []
+      solr_data.hits.each do |doc|
+        with_score.push([doc["score"], 
+          results.find {|record| scorable_record?(record, doc) }])
+      end
+      with_score.each do |score, object| 
+        class << object; attr_accessor :solr_score; end
+        object.solr_score = score
+      end
+    end
+    
+    def scorable_record?(record, doc)
+      doc_id = doc["#{solr_configuration[:primary_key_field]}"]
+      if doc_id.nil?
+        doc_id = doc["id"]
+        "#{record.class.name}:#{record_id(record)}" == doc_id.first.to_s
+      else
+        record_id(record).to_s == doc_id.to_s
+      end
+    end
+    
+    def validate_date_facet_other_options(options)
+      valid_other_options = [:after, :all, :before, :between, :none]
+      options = [options] unless options.kind_of? Array
+      bad_options = options.map {|x| x.to_sym} - valid_other_options
+      raise "Invalid option#{'s' if bad_options.size > 1} for faceted date's other param: #{bad_options.join(', ')}. May only be one of :after, :all, :before, :between, :none" if bad_options.size > 0
+    end
+    
+  end
+end

data/lib/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/solr.rb

@@ -0,0 +1,21 @@
+# 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.
+
+module Solr; end
+require 'solr/exception'
+require 'solr/request'
+require 'solr/connection'
+require 'solr/response'
+require 'solr/util'
+require 'solr/xml'
+require 'solr/importer'
+require 'solr/indexer'

data/lib/solr/connection.rb

@@ -0,0 +1,179 @@
+# 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.
+
+require 'net/http'
+
+# 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