honkster-acts_as_solr 0.1.0

data/lib/acts_as_solr/common_methods.rb

@@ -0,0 +1,89 @@
+module ActsAsSolr #:nodoc:
+  
+  module CommonMethods
+    
+    # Converts field types into Solr types
+    def get_solr_field_type(field_type)
+      if field_type.is_a?(Symbol)
+        case field_type
+          when :float
+            return "f"
+          when :integer
+            return "i"
+          when :boolean
+            return "b"
+          when :string
+            return "s"
+          when :date
+            return "d"
+          when :range_float
+            return "rf"
+          when :range_integer
+            return "ri"
+          when :facet
+            return "facet"
+          when :text
+            return "t"
+        else
+          raise "Unknown field_type symbol: #{field_type}"
+        end
+      elsif field_type.is_a?(String)
+        return field_type
+      else
+        raise "Unknown field_type class: #{field_type.class}: #{field_type}"
+      end
+    end
+    
+    # Sets a default value when value being set is nil.
+    def set_value_if_nil(field_type)
+      case field_type
+        when "b", :boolean
+          return "false"
+        when "s", "t", "d", :date, :string, :text
+          return ""
+        when "f", "rf", :float, :range_float
+          return 0.00
+        when "i", "ri", :integer, :range_integer
+          return 0
+      else
+        return ""
+      end
+    end
+    
+    # Sends an add command to Solr
+    def solr_add(add_xml)
+      ActsAsSolr::Post.execute(Solr::Request::AddDocument.new(add_xml))
+    end
+    
+    # Sends the delete command to Solr
+    def solr_delete(solr_ids)
+      ActsAsSolr::Post.execute(Solr::Request::Delete.new(:id => solr_ids))
+    end
+    
+    # Sends the commit command to Solr
+    def solr_commit
+      ActsAsSolr::Post.execute(Solr::Request::Commit.new)
+    end
+    
+    # Optimizes the Solr index. Solr says:
+    # 
+    # Optimizations can take nearly ten minutes to run. 
+    # We are presuming optimizations should be run once following large 
+    # batch-like updates to the collection and/or once a day.
+    # 
+    # One of the solutions for this would be to create a cron job that 
+    # runs every day at midnight and optmizes the index:
+    #   0 0 * * * /your_rails_dir/script/runner -e production "Model.solr_optimize"
+    # 
+    def solr_optimize
+      ActsAsSolr::Post.execute(Solr::Request::Optimize.new)
+    end
+    
+    # Returns the id for the given instance
+    def record_id(object)
+      eval "object.#{object.class.primary_key}"
+    end
+    
+  end
+  
+end

data/lib/acts_as_solr/deprecation.rb

@@ -0,0 +1,61 @@
+module ActsAsSolr #:nodoc:
+  
+  class Post
+    def initialize(body, mode = :search)
+      @body = body
+      @mode = mode
+      puts "The method ActsAsSolr::Post.new(body, mode).execute_post is depracated. " +
+           "Use ActsAsSolr::Post.execute(body, mode) instead!"
+    end
+    
+    def execute_post
+      ActsAsSolr::Post.execute(@body, @mode)
+    end    
+  end
+  
+  module ClassMethods
+    def find_with_facet(query, options={})
+      Deprecation.plog "The method find_with_facet is deprecated. Use find_by_solr instead, passing the " +
+                       "arguments the same way you used to do with find_with_facet."
+      find_by_solr(query, options)
+    end
+  end
+  
+  class Deprecation
+    # Validates the options passed during query
+    def self.validate_query options={}
+      if options[:field_types]
+        plog "The option :field_types for searching is deprecated. " +
+             "The field types are automatically traced back when you specify a field type in your model."
+      end
+      if options[:sort_by]
+        plog "The option :sort_by is deprecated, use :order instead!"
+        options[:order] ||= options[:sort_by]
+      end
+      if options[:start]
+        plog "The option :start is deprecated, use :offset instead!"
+        options[:offset] ||= options[:start]
+      end
+      if options[:rows]
+        plog "The option :rows is deprecated, use :limit instead!"
+        options[:limit] ||= options[:rows]
+      end
+    end
+    
+    # Validates the options passed during indexing
+    def self.validate_index options={}
+      if options[:background]
+        plog "The :background option is being deprecated. There are better and more efficient " +
+             "ways to handle delayed saving of your records."
+      end
+    end
+    
+    # This will print the text to stdout and log the text
+    # if rails logger is available
+    def self.plog text
+      puts text
+      RAILS_DEFAULT_LOGGER.warn text if defined? RAILS_DEFAULT_LOGGER
+    end
+  end
+  
+end

data/lib/acts_as_solr/instance_methods.rb

@@ -0,0 +1,166 @@
+module ActsAsSolr #:nodoc:
+  
+  module InstanceMethods
+
+    # Solr id is <class.name>:<id> to be unique across all models
+    def solr_id
+      "#{self.class.name}:#{record_id(self)}"
+    end
+
+    # saves to the Solr index
+    def solr_save
+      return true if indexing_disabled?
+      if evaluate_condition(:if, self) 
+        logger.debug "solr_save: #{self.class.name} : #{record_id(self)}"
+        solr_add to_solr_doc
+        solr_commit if configuration[:auto_commit]
+        true
+      else
+        solr_destroy
+      end
+    end
+
+    def indexing_disabled?
+      evaluate_condition(:offline, self) || !configuration[:if]
+    end
+
+    # remove from index
+    def solr_destroy
+      return true if indexing_disabled?
+      logger.debug "solr_destroy: #{self.class.name} : #{record_id(self)}"
+      solr_delete solr_id
+      solr_commit if configuration[:auto_commit]
+      true
+    end
+
+    # convert instance to Solr document
+    def to_solr_doc
+      logger.debug "to_solr_doc: creating doc for class: #{self.class.name}, id: #{record_id(self)}"
+      doc = Solr::Document.new
+      doc.boost = validate_boost(configuration[:boost]) if configuration[:boost]
+      
+      doc << {:id => solr_id,
+              solr_configuration[:type_field] => self.class.name,
+              solr_configuration[:primary_key_field] => record_id(self).to_s}
+
+      # iterate through the fields and add them to the document,
+      configuration[:solr_fields].each do |field_name, options|
+        #field_type = configuration[:facets] && configuration[:facets].include?(field) ? :facet : :text
+        
+        field_boost = options[:boost] || solr_configuration[:default_boost]
+        field_type = get_solr_field_type(options[:type])
+        solr_name = options[:as] || field_name
+        
+        value = self.send("#{field_name}_for_solr")
+        value = set_value_if_nil(field_type) if value.to_s == ""
+        
+        # add the field to the document, but only if it's not the id field
+        # or the type field (from single table inheritance), since these
+        # fields have already been added above.
+        if field_name.to_s != self.class.primary_key and field_name.to_s != "type"
+          suffix = get_solr_field_type(field_type)
+          # This next line ensures that e.g. nil dates are excluded from the 
+          # document, since they choke Solr. Also ignores e.g. empty strings, 
+          # but these can't be searched for anyway: 
+          # http://www.mail-archive.com/solr-dev@lucene.apache.org/msg05423.html
+          next if value.nil? || value.to_s.strip.empty?
+          [value].flatten.each do |v|
+            v = set_value_if_nil(suffix) if value.to_s == ""
+            field = Solr::Field.new("#{solr_name}_#{suffix}" => ERB::Util.html_escape(v.to_s))
+            field.boost = validate_boost(field_boost)
+            doc << field
+          end
+        end
+      end
+      
+      add_includes(doc)
+      logger.debug doc.to_xml
+      doc
+    end
+    
+    private
+    def add_includes(doc)
+      if configuration[:solr_includes].respond_to?(:each)
+        configuration[:solr_includes].each do |association, options|
+          data = options[:multivalued] ? [] : ""
+          field_name = options[:as] || association.to_s.singularize
+          field_type = get_solr_field_type(options[:type])
+          field_boost = options[:boost] || solr_configuration[:default_boost]
+          suffix = get_solr_field_type(field_type)
+          case self.class.reflect_on_association(association).macro
+          when :has_many, :has_and_belongs_to_many
+            records = self.send(association).to_a
+            unless records.empty?
+              records.each {|r| data << include_value(r, options)}
+              [data].flatten.each do |value|
+                field = Solr::Field.new("#{field_name}_#{suffix}" => value)
+                field.boost = validate_boost(field_boost)
+                doc << field
+              end
+            end
+          when :has_one, :belongs_to
+            record = self.send(association)
+            unless record.nil?
+              doc["#{field_name}_#{suffix}"] = include_value(record, options)
+            end
+          end
+        end
+      end
+    end
+    
+    def include_value(record, options)
+      if options[:using].is_a? Proc
+        options[:using].call(record)
+      elsif options[:using].is_a? Symbol
+        record.send(options[:using])
+      else
+        record.attributes.inject([]){|k,v| k << "#{v.first}=#{ERB::Util.html_escape(v.last)}"}.join(" ")
+      end
+    end
+
+    def validate_boost(boost)
+      boost_value = case boost
+      when Float
+        return solr_configuration[:default_boost] if boost < 0
+        boost
+      when Proc
+        boost.call(self)
+      when Symbol
+        if self.respond_to?(boost)
+          self.send(boost)
+        end
+      end
+      
+      boost_value || solr_configuration[:default_boost]
+    end
+    
+    def condition_block?(condition)
+      condition.respond_to?("call") && (condition.arity == 1 || condition.arity == -1)
+    end
+    
+    def evaluate_condition(which_condition, field)
+      condition = configuration[which_condition]
+      case condition
+        when Symbol
+          field.send(condition)
+        when String
+          eval(condition, binding)
+        when FalseClass, NilClass
+          false
+        when TrueClass
+          true
+        else
+          if condition_block?(condition)
+            condition.call(field)
+          else
+            raise(
+              ArgumentError,
+              "The :#{which_condition} option has to be either a symbol, string (to be eval'ed), proc/method, true/false, or " +
+              "class implementing a static validation method"
+            )
+          end
+        end
+    end
+    
+  end
+end

data/lib/acts_as_solr/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/acts_as_solr/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