xapit 0.2.7 → 0.3.0

data/lib/xapit/indexers/classic_indexer.rb

@@ -1,29 +0,0 @@
-module Xapit
-  class ClassicIndexer < AbstractIndexer
-    def index_text_attributes(member, document)
-      term_generator.document = document
-      @blueprint.text_attributes.each do |name, options|
-        content = member.send(name)
-        if options[:proc]
-          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.to_s)
-        end
-      end
-    end
-    
-    def term_generator
-      @term_generator ||= create_term_generator
-    end
-    
-    def create_term_generator
-      term_generator = Xapian::TermGenerator.new
-      term_generator.set_flags(Xapian::TermGenerator::FLAG_SPELLING, 0) if Config.spelling?
-      term_generator.database = database
-      term_generator.stemmer = Xapian::Stem.new(Config.stemming)
-      term_generator
-    end
-  end
-end

data/lib/xapit/indexers/simple_indexer.rb

@@ -1,38 +0,0 @@
-module Xapit
-  class SimpleIndexer < AbstractIndexer
-    def index_text_attributes(member, document)
-      @blueprint.text_attributes.map do |name, options|
-        terms_for_attribute(member, name, options).each do |term|
-          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 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(member, name, options)
-      content = member.send(name)
-      if options[:proc]
-        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.to_s.scan(/\w+/u).map(&:downcase)
-      end
-    end
-    
-    def stemmer
-      @stemmer ||= Xapian::Stem.new(Config.stemming)
-    end
-  end
-end

data/lib/xapit/membership.rb

@@ -1,137 +0,0 @@
-module Xapit
-  # Use "include Xapit::Membership" on a class to allow xapian searching on it. This is automatically included
-  # in ActiveRecord::Base so you do not need to do anything there.
-  module Membership
-    def self.included(base)
-      base.extend ClassMethods
-    end
-    
-    module ClassMethods
-      # Simply call "xapit" on a class and pass a block to define the indexed attributes.
-      # 
-      #   class Article < ActiveRecord::Base
-      #     xapit do |index|
-      #       index.text :name, :content
-      #       index.field :category_id
-      #       index.facet :author_name, "Author"
-      #       index.sortable :id, :category_id
-      #     end
-      #   end
-      # 
-      # First we index "name" and "content" attributes for full text searching. The "category_id" field is indexed for :conditions searching. The "author_name" is indexed as a facet with "Author" being the display name of the facet. See the facets section below for details. Finally the "id" and "category_id" attributes are indexed as sortable attributes so they can be included in the :order option in a search.
-      # 
-      # Because the indexing happens in Ruby these attributes do no have to be database columns. They can be simple Ruby methods. For example, the "author_name" attribute mentioned above can be defined like this.
-      # 
-      #   def author_name
-      #     author.name
-      #   end
-      # 
-      # This way you can create a completely custom facet by simply defining your own method
-      # 
-      # You can also pass any find options to the xapit method to determine what gets indexed and improve performance with eager loading or a different batch size.
-      # 
-      #   xapit(:batch_size => 100, :include => :author, :conditions => { :visible => true })
-      #
-      # If you pass in a block you can customize how the text words will be devided (instead of by simply white space).
-      # 
-      #   xapit do |index|
-      #     index.text(:keywords) { |words| words.split(', ') }
-      #   end
-      # 
-      # You can specify a :weight option to give a text attribute more importance. This will cause search terms matching
-      # that attribute to have a higher rank. The default weight is 1. Decimal (0.5) weight values are not supported.
-      #
-      #   index.text :name, :weight => 10
-      # 
-      def xapit(*args)
-        @xapit_index_blueprint = IndexBlueprint.new(self, *args)
-        yield(@xapit_index_blueprint)
-        include AdditionalMethods
-        include XapitSync::Membership if defined? XapitSync
-      end
-    end
-    
-    module AdditionalMethods
-      def self.included(base)
-        base.extend ClassMethods
-        base.send(:attr_accessor, :xapit_relevance) # is there a better way to do this?
-      end
-      
-      # Find similar records to the given model. It takes the same arguments as Membership::AdditionalMethods::ClassMethods#search to further narrow down the results.
-      def search_similar(*args)
-        Collection.search_similar(self, *args)
-      end
-    
-      module ClassMethods
-        # Used to perform a search on a model.
-        #   
-        #   # perform a simple full text search
-        #   @articles = Article.search("phone")
-        #   
-        #   # add pagination if you're using will_paginate
-        #   @articles = Article.search("phone", :per_page => 10, :page => params[:page])
-        #   
-        #   # 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)
-        #
-        #   # basic boolean matching is supported
-        #   @articles = Article.search("phone OR fax NOT email")
-        #
-        #   # field conditions in query string
-        #   @articles = Article.search("priority:3")
-        #
-        #   # no need to specify first query string when searching all records
-        #   @articles = Article.search(:conditions => { :category_id => params[:category_id] })
-        #
-        #   # search partial terms with asterisk (only supported at end of term)
-        #   @articles = Article.search("sab*", :conditions => { :name => "Din*" })
-        #
-        #   # search multiple conditions with OR by passing an array
-        #   @articles = Article.search(:conditions => [{ :category_id => 1 }, { :priority => 2 }])
-        #
-        def search(*args)
-          Collection.new(self, *args)
-        end
-      
-        # The Xapit::IndexBlueprint object used for this class.
-        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 }
-          raise "Unable to find facet blueprint for #{attribute} on #{name}" if result.nil?
-          result
-        end
-      end
-    end
-  end
-end
-
-if defined? ActiveRecord
-  ActiveRecord::Base.class_eval do
-    include Xapit::Membership
-  end
-end

data/lib/xapit/query.rb

@@ -1,89 +0,0 @@
-module Xapit
-  # This class wraps a Xapian::Query for convenience purposes. You will likely not need to use
-  # this class unless you are trying to query the Xapian database directly.
-  # You may be looking for Xapit::Collection instead.
-  class Query
-    attr_reader :xapian_query
-    
-    def initialize(*args)
-      @xapian_query = build_xapian_query(*args)
-    end
-    
-    def and_query(*args)
-      merge_query(:and, *args)
-    end
-    
-    def or_query(*args)
-      merge_query(:or, *args)
-    end
-    
-    def not_query(*args)
-      merge_query(:not, *args)
-    end
-    
-    def matchset(options = {})
-      options.reverse_merge! :offset => 0, :sort_descending => false
-      enquire = Xapian::Enquire.new(Config.database)
-      if options[:sort_by_values]
-        sorter = Xapian::MultiValueSorter.new
-        options[:sort_by_values].each do |sort_value|
-          sorter.add(sort_value, !!options[:sort_descending])
-        end
-        enquire.set_sort_by_key_then_relevance(sorter)
-      end
-      enquire.collapse_key = options[:collapse_key] if options[:collapse_key]
-      enquire.query = @xapian_query
-      enquire.mset(options[:offset], options[:limit])
-    end
-    
-    def matches(options = {})
-      matchset(options).matches
-    end
-    
-    def count
-      # a bit of a hack to get more accurate count estimate
-      @count ||= matchset(:limit => Config.database.doccount).matches_estimated
-    end
-    
-    private
-    
-    def merge_query(operator, *args)
-      if args.first.blank?
-        self
-      else
-        Xapit::Query.new([@xapian_query, build_xapian_query(*args)], operator)
-      end
-    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
-        (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
-end

data/lib/xapit/query_parsers/abstract_query_parser.rb

@@ -1,174 +0,0 @@
-module Xapit
-  class AbstractQueryParser
-    attr_reader :member_class, :options
-    attr_writer :base_query
-    attr_accessor :extra_queries
-    
-    def initialize(*args)
-      @options = args.extract_options!
-      @member_class = args[0]
-      @search_text = args[1].to_s
-      @extra_queries = []
-    end
-    
-    def query
-      if @extra_queries.blank?
-        primary_query
-      else
-        Query.new([primary_query] + @extra_queries, :or)
-      end
-    end
-    
-    def primary_query
-      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).not_query(not_condition_terms)
-      end
-    end
-    
-    def current_page
-      @options[:page] ? @options[:page].to_i : 1
-    end
-    
-    def per_page
-      @options[:per_page] ? @options[:per_page].to_i : 20
-    end
-    
-    def offset
-      per_page*(current_page-1)
-    end
-    
-    def sort_by_values
-      if @options[:order] && @member_class
-        index = @member_class.xapit_index_blueprint
-        if @options[:order].kind_of? Array
-          @options[:order].map do |attribute|
-            index.position_of_sortable(attribute)
-          end
-        else
-          [index.position_of_sortable(@options[:order])]
-        end
-      end
-    end
-    
-    def base_query
-      @base_query ||= initial_query
-    end
-    
-    def initial_query
-      Query.new(initial_query_strings, :or)
-    end
-    
-    def initial_query_strings
-      if classes.empty?
-        [""]
-      else
-        classes.map { |klass| "C#{klass.name}" }
-      end
-    end
-    
-    def classes
-      (@options[:classes] || [@member_class]).compact
-    end
-    
-    def condition_terms
-      parse_conditions(@options[:conditions])
-    end
-    
-    def not_condition_terms
-      parse_conditions(@options[:not_conditions])
-    end
-    
-    def facet_terms
-      if @options[:facets]
-        facet_identifiers.map do |identifier|
-          "F#{identifier}"
-        end
-      else
-        []
-      end
-    end
-    
-    def facet_identifiers
-      @options[:facets].kind_of?(String) ? @options[:facets].split('-') : (@options[:facets] || [])
-    end
-    
-    def spelling_suggestion
-      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|
-          term_suggestion(term) || term
-        end
-      end
-    end
-    
-    def term_suggestion(term)
-      suggestion = Config.database.get_spelling_suggestion(term.downcase)
-      suggestion.blank? ? nil : suggestion
-    end
-    
-    def matchset(options = {})
-      query.matchset(query_options.merge(options))
-    end
-    
-    def query_options
-      {
-        :offset => offset,
-        :limit => per_page,
-        :sort_by_values => sort_by_values,
-        :sort_descending => @options[:descending]
-      }
-    end
-    
-    private
-    
-    def parse_conditions(conditions)
-      if conditions.kind_of? Array
-        [Query.new(conditions.map { |hash| Query.new(condition_terms_from_hash(hash)) }, :or)]
-      elsif conditions.kind_of? Hash
-        condition_terms_from_hash(conditions)
-      else
-        []
-      end
-    end
-    
-    def condition_terms_from_hash(conditions)
-      conditions.map do |name, value|
-        if value.kind_of? Array
-          Query.new(value.map { |v| condition_term(name, v) }, :or)
-        else
-          condition_term(name, value)
-        end
-      end.flatten
-    end
-    
-    def condition_term(name, value)
-      if 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))
-      elsif value.to_s.ends_with?("*") && value.to_s.strip.length > 2
-        wildcard_query(value, "X#{name}-")
-      else
-        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
-    
-    # Expands the wildcard in the term (just at the end) and returns a query
-    # which will match any term that starts with the given term.
-    def wildcard_query(term, prefix = "")
-      full_term = (prefix + term.downcase).sub(/\*$/, '') # remove asterisk at end if it exists
-      parser = Xapian::QueryParser.new
-      parser.database = Xapit::Config.database
-      parser.parse_query(full_term[-1..-1], Xapian::QueryParser::FLAG_PARTIAL, full_term[0..-2])
-    end
-  end
-end