xapit 0.1.0 → 0.2.0

data/lib/xapit/adapters/abstract_adapter.rb

@@ -0,0 +1,46 @@
+module Xapit
+  # Adapters are used to support multiple ORMs (ActiveRecord, Datamapper, Sequel, etc.).
+  # It abstracts out all find calls so they can be handled differently for each ORM.
+  # To create your own adapter, subclass AbstractAdapter and override the placeholder methods.
+  # See ActiveRecordAdapter for an example.
+  class AbstractAdapter
+    def self.inherited(subclass)
+      @subclasses ||= []
+      @subclasses << subclass
+    end
+    
+    # Returns all adapter classes.
+    def self.subclasses
+      @subclasses
+    end
+    
+    # Sets the @target instance, this is the class the adapter needs to forward
+    # its messages to.
+    def initialize(target)
+      @target = target
+    end
+    
+    # Used to determine if the given adapter should be used for the passed in class.
+    # Usually one will see if it inherits from another class (ActiveRecord::Base)
+    def self.for_class?(member_class)
+      raise "To be implemented in subclass"
+    end
+    
+    # Fetch a single record by the given id.
+    def find_single(id)
+      raise "To be implemented in subclass"
+    end
+    
+    # Fetch multiple records from the passed in array of ids.
+    def find_multiple(ids)
+      raise "To be implemented in subclass"
+    end
+    
+    # Iiterate through all records using the given parameters.
+    # It should yield to the block and pass in each record individually.
+    # The args are the same as those passed from the XapitMember#xapit call.
+    def find_each(*args, &block)
+      raise "To be implemented in subclass"
+    end
+  end
+end

data/lib/xapit/adapters/active_record_adapter.rb

@@ -0,0 +1,20 @@
+module Xapit
+  # This adapter is used for all ActiveRecord models. See AbstractAdapter for details.
+  class ActiveRecordAdapter < AbstractAdapter
+    def self.for_class?(member_class)
+      member_class.ancestors.map(&:to_s).include? "ActiveRecord::Base"
+    end
+    
+    def find_single(id)
+      @target.find(id)
+    end
+    
+    def find_multiple(ids)
+      @target.find(ids)
+    end
+    
+    def find_each(*args, &block)
+      @target.find_each(*args, &block)
+    end
+  end
+end

data/lib/xapit/adapters/data_mapper_adapter.rb

@@ -0,0 +1,10 @@
+module Xapit
+  # This adapter is used for all DataMapper models. See AbstractAdapter for details.
+  class DataMapperAdapter < AbstractAdapter
+    def self.for_class?(member_class)
+      member_class.ancestors.map(&:to_s).include? "DataMapper::Resource"
+    end
+    
+    # TODO override the rest of the methods here...
+  end
+end

data/lib/xapit/collection.rb

@@ -18,7 +18,7 @@ module Xapit
       collection = new(member.class, *args)
       indexer = SimpleIndexer.new(member.class.xapit_index_blueprint)
       terms = indexer.text_terms(member) + indexer.field_terms(member)
-      collection.base_query.and_query(Xapian::Query.new(Xapian::Query::OP_OR, terms))
+      collection.base_query.and_query(terms, :or)
       collection.base_query.not_query("Q#{member.class}-#{member.id}")
       collection
     end
@@ -103,7 +103,7 @@ module Xapit
     # Xapit::Facet objects matching this search query. See class for details.
     def facets
       all_facets.select do |facet|
-        facet.options.size > 1
+        facet.options.size > 0
       end
     end
     
@@ -118,7 +118,7 @@ module Xapit
     # If you set :breadcrumb_facets option to true in Config#setup the link will drop leftover facets
     # instead of removing the current one. This makes it easy to add a breadcrumb style interface.
     #
-    #   Config.setup(:breadcrumb_facets => true)
+    #   Xapit.setup(:breadcrumb_facets => true)
     #   <% for option in @articles.applied_facet_options %>
     #     <%= link_to h(option.name), :overwrite_params => { :facets => option } %> &gt;
     #   <% end %>
@@ -153,10 +153,22 @@ module Xapit
       @query_parser.query.matchset(options)
     end
     
+    # TODO this could use some refactoring
+    # See issue #11 for why this is so complex.
     def fetch_results(options = {})
-      matchset(options).matches.map do |match|
+      matches = matchset(options).matches
+      records_by_class = {}
+      matches.each do |match|
         class_name, id = match.document.data.split('-')
-        member = class_name.constantize.find(id)
+        records_by_class[class_name] ||= []
+        records_by_class[class_name] << id
+      end
+      records_by_class.each do |class_name, ids|
+        records_by_class[class_name] = class_name.constantize.xapit_adapter.find_multiple(ids)
+      end
+      matches.map do |match|
+        class_name, id = match.document.data.split('-')
+        member = records_by_class[class_name].detect { |m| m.id == id.to_i }
         member.xapit_relevance = match.percent
         member
       end

data/lib/xapit/config.rb

@@ -4,15 +4,7 @@ module Xapit
     class << self
       attr_reader :options
       
-      # Setup configuration options. The following options are supported.
-      # 
-      # <tt>:database_path</tt>:     Where the database is stored.
-      # <tt>:stemming</tt>:          The language to use for stemming, defaults to "english".
-      # <tt>:spelling</tt>:          True or false to enable/disable spelling, defaults to true.
-      # <tt>:indexer</tt>:           Class to handle the indexing, defaults to SimpleIndexer.
-      # <tt>:query_parser</tt>:      Class to handle the parsing, defaults to ClassicQueryParser.
-      # <tt>:breadcrumb_facets</tt>: Use breadcrumb mode for applied facets. See Collection#applied_facet_options for details.
-      #
+      # See Xapit#setup
       def setup(options = {})
         if @options && options[:database_path] != @options[:database_path]
           @database = nil

data/lib/xapit/facet.rb

@@ -23,19 +23,22 @@ module Xapit
     # Xapit::FacetOption objects for this facet. This only lists the ones which match the current query.
     def options
       matching_identifiers.map do |identifier, count|
-        option = FacetOption.find(identifier)
-        option.count = count
-        option.existing_facet_identifiers = @existing_facet_identifiers
-        option
-      end.sort_by(&:name)
+        if count < @query.count
+          option = FacetOption.find(identifier)
+          if option.facet.attribute == @blueprint.attribute
+            option.count = count
+            option.existing_facet_identifiers = @existing_facet_identifiers
+            option
+          end
+        end
+      end.compact.sort_by(&:name)
     end
     
     def matching_identifiers
       result = {}
       matches.each do |match|
-        class_name, id = match.document.data.split('-')
-        record = class_name.constantize.find(id)
-        @blueprint.identifiers_for(record).each do |identifier|
+        identifiers = match.document.terms.map(&:term).grep(/^F/).map { |t| t[1..-1] }
+        identifiers.each do |identifier|
           unless existing_facet_identifiers.include? identifier
             result[identifier] ||= 0
             result[identifier] += (match.collapse_count + 1)

data/lib/xapit/index_blueprint.rb

@@ -72,19 +72,25 @@ module Xapit
     end
     
     # Indexes all records of this blueprint class. It does this using the ".find_each" method on the member class.
-    # You will likely want to call Xapit::Config.remove_database before this.
+    # You will likely want to call Xapit.remove_database before this.
     def index_all
-      @member_class.find_each(*@args) do |member|
+      @member_class.xapit_adapter.find_each(*@args) do |member|
         @indexer.add_member(member)
       end
     end
     
-    def sortable_position_for(sortable_attribute)
+    def position_of_sortable(sortable_attribute)
       index = sortable_attributes.map(&:to_s).index(sortable_attribute.to_s)
       raise "Unable to find indexed sortable attribute \"#{sortable_attribute}\" in #{@member_class} sortable attributes: #{sortable_attributes.inspect}" if index.nil?
       index + facets.size
     end
     
+    def position_of_field(field_attribute)
+      index = field_attributes.map(&:to_s).index(field_attribute.to_s)
+      raise "Unable to find indexed field attribute \"#{field_attribute}\" in #{@member_class} field attributes: #{field_attributes.inspect}" if index.nil?
+      index + facets.size + sortable_attributes.size
+    end
+    
     private
     
     # Make sure all models are loaded - without reloading any that

data/lib/xapit/indexers/abstract_indexer.rb

@@ -71,12 +71,23 @@ module Xapit
     end
     
     def values(member)
-      facet_values(member) + sortable_values(member)
+      facet_values(member) + sortable_values(member) + field_values(member)
     end
     
     def sortable_values(member)
       @blueprint.sortable_attributes.map do |sortable|
-        member.send(sortable).to_s.downcase
+        value = member.send(sortable)
+        value = value.first if value.kind_of? Array
+        Xapit.serialize_value(value)
+      end
+    end
+    
+    # TODO remove duplication with sortable_values
+    def field_values(member)
+      @blueprint.field_attributes.map do |sortable|
+        value = member.send(sortable)
+        value = value.first if value.kind_of? Array
+        Xapit.serialize_value(value)
       end
     end
     

data/lib/xapit/indexers/classic_indexer.rb

@@ -3,11 +3,13 @@ module Xapit
     def index_text_attributes(member, document)
       term_generator.document = document
       @blueprint.text_attributes.each do |name, options|
-        content = member.send(name).to_s
+        content = member.send(name)
         if options[:proc]
-          index_terms(options[:proc].call(content).reject(&:blank?).map(&:to_s).map(&:downcase), document)
+          index_terms(options[:proc].call(content.to_s).reject(&:blank?).map(&:to_s).map(&:downcase), document)
+        elsif content.kind_of? Array
+          index_terms(content.reject(&:blank?).map(&:to_s).map(&:downcase), document)
         else
-          term_generator.index_text(content)
+          term_generator.index_text(content.to_s)
         end
       end
     end

data/lib/xapit/indexers/simple_indexer.rb

@@ -6,21 +6,28 @@ module Xapit
           document.add_term(term, options[:weight] || 1)
           database.add_spelling(term) if Config.spelling?
         end
+        if Config.stemming
+          stemmed_terms_for_attribute(member, name, options).each do |term|
+            document.add_term(term, options[:weight] || 1)
+          end
+        end
       end
     end
     
-    def terms_for_attribute(member, name, options)
-      terms_for_attribute_without_stemming(member, name, options).map do |term|
-        [term, "Z#{stemmer.call(term)}"]
-      end.flatten
+    def stemmed_terms_for_attribute(member, name, options)
+      terms_for_attribute(member, name, options).map do |term|
+        "Z#{stemmer.call(term)}"
+      end
     end
     
-    def terms_for_attribute_without_stemming(member, name, options)
-      content = member.send(name).to_s
+    def terms_for_attribute(member, name, options)
+      content = member.send(name)
       if options[:proc]
-        options[:proc].call(content).reject(&:blank?).map(&:to_s).map(&:downcase)
+        options[:proc].call(content.to_s).reject(&:blank?).map(&:to_s).map(&:downcase)
+      elsif content.kind_of? Array
+        content.reject(&:blank?).map(&:to_s).map(&:downcase)
       else
-        content.scan(/\w+/u).map(&:downcase)
+        content.to_s.scan(/\w+/u).map(&:downcase)
       end
     end
     

data/lib/xapit/membership.rb

@@ -73,6 +73,12 @@ module Xapit
         #   # search based on indexed fields
         #   @articles = Article.search("phone", :conditions => { :category_id => params[:category_id] })
         #   
+        #   # search for multiple negative conditions (doesn't match 3, 5, or 8)
+        #   @articles = Article.search(:not_conditions => { :category_id => [3, 5, 8] })
+        #   
+        #   # search for range of conditions by number
+        #   @articles = Article.search(:conditions => { :released_at => 2.years.ago..Time.now })
+        #   
         #   # manually sort based on any number of indexed fields, sort defaults to most relevant
         #   @articles = Article.search("phone", :order => [:category_id, :id], :descending => true)
         #
@@ -90,7 +96,19 @@ module Xapit
         def xapit_index_blueprint
           @xapit_index_blueprint
         end
-      
+        
+        # The Xapit::AbstractAdapter used to perform database queries on.
+        def xapit_adapter
+          @xapit_adapter ||= begin
+            adapter_class = AbstractAdapter.subclasses.detect { |a| a.for_class?(self) }
+            if adapter_class
+              adapter_class.new(self)
+            else
+              raise "Unable to find Xapit adapter for class #{self.name}"
+            end
+          end
+        end
+        
         # Finds a Xapit::FacetBlueprint for the given attribute.
         def xapit_facet_blueprint(attribute)
           result = xapit_index_blueprint.facets.detect { |f| f.attribute.to_s == attribute.to_s }

data/lib/xapit/query.rb

@@ -5,24 +5,21 @@ module Xapit
   class Query
     attr_reader :default_options, :xapian_query
     
-    def initialize(query)
-      @xapian_query = build_xapian_query(query)
+    def initialize(*args)
+      @xapian_query = build_xapian_query(*args)
       @default_options = { :offset => 0, :sort_descending => false }
     end
     
-    def and_query(query)
-      @xapian_query = Xapian::Query.new(Xapian::Query::OP_AND, @xapian_query, build_xapian_query(query)) unless query.blank?
-      self
+    def and_query(*args)
+      merge_query(:and, *args)
     end
     
-    def or_query(query)
-      @xapian_query = Xapian::Query.new(Xapian::Query::OP_OR, @xapian_query, build_xapian_query(query)) unless query.blank?
-      self
+    def or_query(*args)
+      merge_query(:or, *args)
     end
     
-    def not_query(query)
-      @xapian_query = Xapian::Query.new(Xapian::Query::OP_AND_NOT, @xapian_query, build_xapian_query(query)) unless query.blank?
-      self
+    def not_query(*args)
+      merge_query(:not, *args)
     end
     
     def matchset(options = {})
@@ -51,11 +48,39 @@ module Xapit
     
     private
     
-    def build_xapian_query(query)
-      if query.kind_of? Xapian::Query
-        query
+    def merge_query(operator, *args)
+      @xapian_query = Xapian::Query.new(xapian_operator(operator), @xapian_query, build_xapian_query(*args)) unless args.first.blank?
+      self
+    end
+    
+    def build_xapian_query(query, operator = :and)
+      extract_queries(query, operator).inject(nil) do |query, extra_query|
+        if query
+          extra_query = extra_query.xapian_query if extra_query.respond_to? :xapian_query
+          Xapian::Query.new(xapian_operator(operator), query, extra_query)
+        else
+          extra_query = extra_query.xapian_query if extra_query.respond_to? :xapian_query
+          extra_query
+        end
+      end
+    end
+    
+    def extract_queries(query, operator)
+      queries = [query].flatten
+      terms = queries.select { |q| q.kind_of? String }
+      if terms.empty?
+        queries
       else
-        Xapian::Query.new(Xapian::Query::OP_AND, [query].flatten)
+        (queries - terms) + [Xapian::Query.new(xapian_operator(operator), terms)]
+      end
+    end
+    
+    def xapian_operator(operator)
+      case operator
+      when :and then Xapian::Query::OP_AND
+      when :or then Xapian::Query::OP_OR
+      when :not then Xapian::Query::OP_AND_NOT
+      else raise "Unknown Xapian operator #{operator}"
       end
     end
   end

data/lib/xapit/query_parsers/abstract_query_parser.rb

@@ -10,10 +10,10 @@ module Xapit
     end
     
     def query
-      if (@search_text.split + condition_terms + facet_terms).empty?
+      if (@search_text.split + condition_terms + not_condition_terms + facet_terms).empty?
         base_query
       else
-        @query ||= base_query.and_query(xapian_query_from_text(@search_text)).and_query(condition_terms + facet_terms)
+        @query ||= base_query.and_query(xapian_query_from_text(@search_text)).and_query(condition_terms + facet_terms).not_query(not_condition_terms)
       end
     end
     
@@ -34,10 +34,10 @@ module Xapit
         index = @member_class.xapit_index_blueprint
         if @options[:order].kind_of? Array
           @options[:order].map do |attribute|
-            index.sortable_position_for(attribute)
+            index.position_of_sortable(attribute)
           end
         else
-          [index.sortable_position_for(@options[:order])]
+          [index.position_of_sortable(@options[:order])]
         end
       end
     end
@@ -47,7 +47,7 @@ module Xapit
     end
     
     def initial_query
-      query = Query.new(Xapian::Query.new(Xapian::Query::OP_OR, initial_query_strings))
+      query = Query.new(initial_query_strings, :or)
       query.default_options[:offset] = offset
       query.default_options[:limit] = per_page
       query.default_options[:sort_by_values] = sort_by_values
@@ -68,18 +68,11 @@ module Xapit
     end
     
     def condition_terms
-      if @options[:conditions]
-        @options[:conditions].map do |name, value|
-          if value.kind_of? Time
-            value = value.to_i
-          elsif value.kind_of? Date
-            value = value.to_time.to_i
-          end
-          "X#{name}-#{value.to_s.downcase}"
-        end
-      else
-        []
-      end
+      condition_terms_from_hash(@options[:conditions])
+    end
+    
+    def not_condition_terms
+      condition_terms_from_hash(@options[:not_conditions])
     end
     
     def facet_terms
@@ -97,19 +90,48 @@ module Xapit
     end
     
     def spelling_suggestion
-      raise "Spelling has been disabled. Enable spelling in Xapit::Config.setup." unless Config.spelling?
-      if @search_text.downcase.scan(/\w+/).all? { |term| Config.database.get_spelling_suggestion(term).empty? }
+      raise "Spelling has been disabled. Enable spelling in Xapit.setup." unless Config.spelling?
+      if [@search_text, *@search_text.scan(/\w+/)].all? { |term| term_suggestion(term).nil? }
         nil
       else
+        return term_suggestion(@search_text) unless term_suggestion(@search_text).blank?
         @search_text.downcase.gsub(/\w+/) do |term|
-          suggestion = Config.database.get_spelling_suggestion(term)
-          if suggestion.blank?
-            term
+          term_suggestion(term) || term
+        end
+      end
+    end
+    
+    def term_suggestion(term)
+      suggestion = Config.database.get_spelling_suggestion(term.downcase)
+      suggestion.blank? ? nil : suggestion
+    end
+    
+    private
+    
+    def condition_terms_from_hash(conditions)
+      if conditions
+        conditions.map do |name, value|
+          if value.kind_of? Array
+            Query.new(value.map { |v| condition_term(name, v) }, :or)
+          elsif value.kind_of?(Range) && @member_class
+            position = @member_class.xapit_index_blueprint.position_of_field(name)
+            Xapian::Query.new(Xapian::Query::OP_VALUE_RANGE, position, Xapit.serialize_value(value.begin), Xapit.serialize_value(value.end))
           else
-            suggestion
+            condition_term(name, value)
           end
-        end
+        end.flatten
+      else
+        []
+      end
+    end
+    
+    def condition_term(name, value)
+      if value.kind_of? Time
+        value = value.to_i
+      elsif value.kind_of? Date
+        value = value.to_time.to_i
       end
+      "X#{name}-#{value.to_s.downcase}"
     end
   end
 end