websolr-rails 1.4.4 → 2.0.0

data/lib/lazy_document.rb

@@ -1,18 +0,0 @@
-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

@@ -1,230 +0,0 @@
-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, :highlight]
-      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]
-
-        if options[:highlight] == true
-          options[:highlight] = {:fields => "*"}
-        end
-        
-        if options[:highlight]
-          query_options[:highlighting] = {}
-          query_options[:highlighting][:field_list] = []
-          query_options[:highlighting][:field_list] << options[:highlight][:fields].collect {|k| "#{k}_t"} if options[:highlight][:fields]
-          query_options[:highlighting][:require_field_match] =  options[:highlight][:require_field_match] if options[:highlight][:require_field_match]
-          query_options[:highlighting][:max_snippets] = options[:highlight][:max_snippets] if options[:highlight][:max_snippets]
-          query_options[:highlighting][:prefix] = options[:highlight][:prefix] if options[:highlight][:prefix]
-          query_options[:highlighting][:suffix] = options[:highlight][:suffix] if options[:highlight][:suffix]
-        end
-        
-        # 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]
-      
-      highlighted = {}
-      solr_data.highlighting.map do |x,y| 
-        e={}
-        y1=y.map{|x1,y1| e[x1.gsub(/_[^_]*/,"")]=y1} unless y.nil?
-        highlighted[x.gsub(/[^:]*:/,"").to_i]=e
-      end unless solr_data.highlighting.nil?
-      
-      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']})
-      results.update({:highlights=>highlighted})
-      
-      
-      sr = SearchResults.new(results)
-
-      sr.records.each do |model|
-        model.init_solr(results)
-      end
-      
-      sr
-    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

@@ -1,72 +0,0 @@
-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
-    
-    def highlights
-      @solr_data[:highlights]
-    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

@@ -1,21 +0,0 @@
-# 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

@@ -1,190 +0,0 @@
-# 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
-  
-  ILLEGAL_XML_CHARS = /[\x00-\x1F]/
-
-  # 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)
-    if ENV["DEBUG"]
-      puts "POST #{@url.path + "/" + request.handler}"
-      puts "-- DATA -------------------"
-      puts request.to_s
-      puts "-- END DATA ---------------"
-    end
-    
-    request = request.to_s.gsub(ILLEGAL_XML_CHARS, '')
-    
-    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