xapit 0.2.7 → 0.3.0

data/lib/xapit/query_parsers/classic_query_parser.rb

@@ -1,29 +0,0 @@
-module Xapit
-  class ClassicQueryParser < AbstractQueryParser
-    def xapian_query_from_text(text)
-      xapian_parser.parse_query(cleanup_text(text), Xapian::QueryParser::FLAG_WILDCARD | Xapian::QueryParser::FLAG_PHRASE | Xapian::QueryParser::FLAG_BOOLEAN | Xapian::QueryParser::FLAG_LOVEHATE)
-    end
-    
-    def xapian_parser
-      @xapian_parser ||= build_xapian_parser
-    end
-    
-    def cleanup_text(text)
-      text.gsub(/\b([a-z])\*/i) { $1 }
-    end
-    
-    def build_xapian_parser
-      parser = Xapian::QueryParser.new
-      parser.database = Config.database
-      parser.stemmer = Xapian::Stem.new(Config.stemming)
-      parser.stemming_strategy = Xapian::QueryParser::STEM_SOME
-      parser.default_op = Xapian::Query::OP_AND
-      if @member_class
-        @member_class.xapit_index_blueprint.field_attributes.each do |field|
-          parser.add_prefix(field.to_s, "X#{field}-")
-        end
-      end
-      parser
-    end
-  end
-end

data/lib/xapit/query_parsers/simple_query_parser.rb

@@ -1,75 +0,0 @@
-module Xapit
-  class SimpleQueryParser < AbstractQueryParser
-    # REFACTORME this is a bit complex for one method...
-    def xapian_query(instructions = nil)
-      instructions ||= parsed
-      instructions = [:add, instructions] if instructions.kind_of? String
-      operator = (instructions.first == :or ? Xapian::Query::OP_OR : Xapian::Query::OP_AND)
-      words = instructions[1..-1].select { |i| i.kind_of? String }
-      query = Xapian::Query.new(operator, words) unless words.empty?
-      instructions[1..-1].select { |i| i.kind_of? Array }.each do |sub_instructions|
-        if sub_instructions.first == :not
-          sub_operator = Xapian::Query::OP_AND_NOT
-        else
-          sub_operator = operator
-        end
-        if query
-          query = Xapian::Query.new(sub_operator, query, xapian_query(sub_instructions))
-        else
-          query = xapian_query(sub_instructions)
-        end
-      end
-      query
-    end
-    
-    def parsed
-      parse(@search_text.downcase)
-    end
-    
-    def xapian_query_from_text(text)
-      xapian_query(parse(text.downcase))
-    end
-    
-    private
-    
-    
-    def parse(text)
-      if text.kind_of? Array
-        [:and, *text]
-      else
-        text = text.strip
-        if text =~ /\sor\s/ui
-          [:or, *text.split(/\s+or\s+/ui).map { |t| parse(t) }]
-        elsif text =~ /\s+/u
-          words = text.scan(/(?:\bnot\s+)?[^\s]+/ui)
-          words.map! do |word|
-            if Config.stemming
-              if word =~ /^not\s/ui
-                [:not, "Z" + stemmer.call(word.sub(/^not\s+/ui, ''))]
-              else
-                "Z" + stemmer.call(word)
-              end
-            else
-              if word =~ /^not\s/ui
-                [:not, word.sub(/^not\s+/ui, '')]
-              else
-                word
-              end
-            end
-          end
-          [:and, *words]
-        else
-          if Config.stemming && !text.blank?
-            "Z" + stemmer.call(text)
-          else
-            text
-          end
-        end
-      end
-    end
-    
-    def stemmer
-      @stemmer ||= Xapian::Stem.new(Config.stemming)
-    end
-  end
-end

data/lib/xapit/rake_tasks.rb

@@ -1,13 +0,0 @@
-# TODO investigate why this is needed to ensure it doesn't load twice
-unless @xapit_rake_loaded
-  @xapit_rake_loaded = true
-  namespace :xapit do
-    desc "Index all xapit models."
-    task :index => :environment do
-      Xapit.remove_database
-      Xapit.index_all do |member_class|
-        puts "Indexing #{member_class.name}"
-      end
-    end
-  end
-end

data/rails_generators/xapit/USAGE

@@ -1,13 +0,0 @@
-Description:
-    Generates files necessary to setup Xapit. This includes an initializer
-    to specify the configuration (setup_xapit.rb) and a rake file to load
-    the rake tasks (xapit.rake).
-    
-    IMPORTANT: Only use this generator if you are using the gem version of
-    Xapit, it is not needed if you are installing via Rails plugin.
-
-Examples:
-    script/generate xapit
-
-        Initializer: config/initializers/setup_xapit.rb
-        Rake Tasks:  lib/tasks/xapit.rake

data/rails_generators/xapit/templates/setup_xapit.rb

@@ -1 +0,0 @@
-Xapit.setup(:database_path => "#{Rails.root}/db/xapiandb")

data/rails_generators/xapit/templates/xapit.rake

@@ -1,4 +0,0 @@
-begin
-  require 'xapit/rake_tasks'
-rescue MissingSourceFile
-end

data/rails_generators/xapit/xapit_generator.rb

@@ -1,20 +0,0 @@
-class XapitGenerator < Rails::Generator::Base
-  def manifest
-    record do |m|
-      m.directory "config/initializers"
-      m.file "setup_xapit.rb", "config/initializers/setup_xapit.rb"
-      
-      m.directory "lib/tasks"
-      m.file "xapit.rake", "lib/tasks/xapit.rake"
-    end
-  end
-
-  protected
-    def banner
-      <<-EOS
-Generates files necessary to setup Xapit.
-
-USAGE: #{$0} #{spec.name}
-EOS
-    end
-end

data/spec/xapit/adapters/active_record_adapter_spec.rb

@@ -1,31 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Xapit::ActiveRecordAdapter do
-  it "should be used for ActiveRecord::Base subclasses" do
-    Xapit::ActiveRecordAdapter.should_not be_for_class(Object)
-    klass = Object.new
-    stub(klass).ancestors { ["ActiveRecord::Base"] }
-    Xapit::ActiveRecordAdapter.should be_for_class(klass)
-  end
-  
-  it "should pass find_single to find method to target" do
-    target = Object.new
-    mock(target).find_by_id(1, :conditions => "foo") { :record }
-    adapter = Xapit::ActiveRecordAdapter.new(target)
-    adapter.find_single(1, :conditions => "foo").should == :record
-  end
-  
-  it "should pass find_multiple to find method to target" do
-    target = Object.new
-    mock(target).find([1, 2]) { :record }
-    adapter = Xapit::ActiveRecordAdapter.new(target)
-    adapter.find_multiple([1, 2]).should == :record
-  end
-  
-  it "should pass find_each to target" do
-    target = Object.new
-    mock(target).find_each(:args) { 5 }
-    adapter = Xapit::ActiveRecordAdapter.new(target)
-    adapter.find_each(:args).should == 5
-  end
-end

data/spec/xapit/adapters/data_mapper_adapter_spec.rb

@@ -1,10 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Xapit::DataMapperAdapter do
-  it "should be used for DataMapper::Resource model" do
-    Xapit::DataMapperAdapter.should_not be_for_class(Object)
-    klass = Object.new
-    stub(klass).ancestors { ["DataMapper::Resource"] }
-    Xapit::DataMapperAdapter.should be_for_class(klass)
-  end
-end

data/spec/xapit/collection_spec.rb

@@ -1,176 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Xapit::Collection do
-  describe "with database" do
-    before(:each) do
-      XapitMember.xapit do |index|
-        index.text :name
-        index.field :name
-        index.facet :name
-        index.sortable :name
-      end
-    end
-    
-    describe "indexed" do
-      before(:each) do
-        @hello = XapitMember.new(:name => "hello world")
-        @foo = XapitMember.new(:name => "foo bar")
-        Xapit.index_all
-      end
-      
-      it "should find all xapit members in database given nil" do
-        Xapit::Collection.new(XapitMember, nil).should == [@hello, @foo]
-      end
-      
-      it "should matching xapit member given a word" do
-        Xapit::Collection.new(XapitMember, "foo").should == [@foo]
-      end
-      
-      it "should not be case sensitive on query matching" do
-        Xapit::Collection.new(XapitMember, "BAR Foo").should == [@foo]
-      end
-      
-      it "should have 2 records for empty string" do
-        Xapit::Collection.new(XapitMember, "").size.should == 2
-      end
-      
-      it "should not be empty for blank query" do
-        Xapit::Collection.new(XapitMember, "").empty?.should be_false
-      end
-      
-      it "should filter by conditions, case insensitive" do
-        Xapit::Collection.new(XapitMember, "", :conditions => { :name => "HELLO world"}).should == [@hello]
-      end
-      
-      it "should know first entry" do
-        Xapit::Collection.new(XapitMember, "").first.should == @hello
-      end
-      
-      it "should know last entry" do
-        Xapit::Collection.new(XapitMember, "").last.should == @foo
-      end
-      
-      it "should support page and per_page options" do
-        Xapit::Collection.new(XapitMember, :page => 1, :per_page => 1).should == [@hello]
-        Xapit::Collection.new(XapitMember, :page => 2, :per_page => 1).should == [@foo]
-      end
-      
-      it "should have offset" do
-        Xapit::Collection.new(XapitMember, :page => 2, :per_page => 1).offset.should == 1
-      end
-      
-      it "should have total_entries, total_pages, current_page, per_page, previous_page, next_page" do
-        collection = Xapit::Collection.new(XapitMember, "", :per_page => 1, :page => 2)
-        collection.total_entries.should == 2
-        collection.total_pages.should == 2
-        collection.previous_page.should == 1
-        collection.next_page.should be_nil
-      end
-      
-      it "should set xapit_relevance in results" do
-        results = Xapit::Collection.new(XapitMember, "")
-        results.each do |record|
-          record.xapit_relevance.class.should == Fixnum
-        end
-      end
-      
-      it "should find nothing when searching unknown facet" do
-        Xapit::Collection.new(XapitMember, :facets => ["unknownfacet"]).should be_empty
-      end
-      
-      it "should find matching facet" do
-        ids = Xapit::FacetBlueprint.new(XapitMember, 0, :name).identifiers_for(@hello)
-        Xapit::Collection.new(XapitMember, :facets => ids*2).should == [@hello]
-      end
-      
-      it "should split facets string on dash" do
-        ids = Xapit::FacetBlueprint.new(XapitMember, 0, :name).identifiers_for(@hello)
-        Xapit::Collection.new(XapitMember, :facets => (ids*2).join("-")).should == [@hello]
-      end
-      
-      it "should have one facet with two options with blank keywords" do
-        facets = Xapit::Collection.new(XapitMember, "").facets
-        facets.size.should == 1
-        facets.first.options.size.should == 2
-      end
-      
-      it "should have no applied facets when there are no given facets" do
-        Xapit::Collection.new(XapitMember, "").applied_facet_options.should be_empty
-      end
-      
-      it "should list applied facets" do
-        ids = Xapit::FacetBlueprint.new(XapitMember, 0, :name).identifiers_for(@hello)
-        results = Xapit::Collection.new(XapitMember, "", :facets => (ids*2).join("-"))
-        results.applied_facet_options.map(&:name).should == ["hello world", "hello world"]
-      end
-      
-      it "should pass existing facet identifiers to applied options" do
-        ids = Xapit::FacetBlueprint.new(XapitMember, 0, :name).identifiers_for(@hello)
-        results = Xapit::Collection.new(XapitMember, "", :facets => (ids*2).join("-"))
-        results.applied_facet_options.first.existing_facet_identifiers.should == (ids*2)
-      end
-      
-      it "should sort records in specified order" do
-        Xapit::Collection.new(XapitMember, :order => :name).should == [@foo, @hello]
-      end
-      
-      it "should have no spelling suggestions for empty query" do
-        Xapit::Collection.new(XapitMember).spelling_suggestion.should == nil
-      end
-      
-      it "should have no spelling suggestion for very different query" do
-        Xapit::Collection.new(XapitMember, "match nothing").spelling_suggestion.should == nil
-      end
-      
-      it "should have spelling suggestion for single-word query" do
-        Xapit::Collection.new(XapitMember, "wrld").spelling_suggestion.should == "world"
-      end
-      
-      it "should have spelling suggestion for multi-word query" do
-        Xapit::Collection.new(XapitMember, "helo bat wrld").spelling_suggestion.should == "hello bar world"
-      end
-      
-      it "should raise error when fetching spelling suggestion if spelling is disabled" do
-        Xapit::Config.options[:spelling] = false
-        lambda { Xapit::Collection.new(XapitMember, "foo").spelling_suggestion }.should raise_error
-      end
-      
-      it "should find similar records" do
-        member = XapitMember.new(:name => "foo bar world")
-        Xapit::Collection.search_similar(member).should == [@foo, @hello]
-      end
-      
-      it "should be able to specify classes" do
-        Xapit::Collection.new(nil, "foo", :classes => [String, Array]).should == []
-        Xapit::Collection.new(nil, "foo", :classes => [String, Array, XapitMember]).should == [@foo]
-      end
-      
-      it "should support nested or_search" do
-        Xapit::Collection.new(XapitMember, "world", :order => :name).or_search("foo").should == [@foo, @hello]
-      end
-      
-      it "should override options in nested or_search" do
-        Xapit::Collection.new(XapitMember, "world", :order => :name, :per_page => 2).or_search("foo", :per_page => 1).should == [@foo]
-      end
-      
-      it "should combine multiple or_search" do
-        @buz = XapitMember.new(:name => "buz")
-        @zot = XapitMember.new(:name => "zot")
-        Xapit.remove_database
-        Xapit.index_all
-        Xapit::Collection.new(XapitMember, "world", :order => :name).or_search("foo").or_search("buz").should == [@buz, @foo, @hello]
-      end
-      
-      it "should support nested search" do
-        @zap = XapitMember.new(:name => "zap world")
-        Xapit.remove_database
-        Xapit.index_all
-        Xapit::Collection.new(XapitMember, "world").search("zap") == [@zap]
-      end
-      
-      it "should inherit options in nested collection search" do
-        Xapit::Collection.new(XapitMember, "world", :per_page => 3).search("zap").per_page.should == 3
-      end
-    end
-  end
-end

data/spec/xapit/config_spec.rb

@@ -1,62 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Xapit::Config do
-  it "should be able to set database path and fetch writable or readable" do
-    Xapit::Config.writable_database.should be_kind_of(Xapian::WritableDatabase)
-    Xapit::Config.database.should be_kind_of(Xapian::Database)
-  end
-  
-  it "should default query parser to SimpleQueryParser" do
-    Xapit::Config.setup
-    Xapit::Config.query_parser.should == Xapit::ClassicQueryParser
-  end
-  
-  it "should be able to set query parser on setup" do
-    Xapit::Config.setup(:query_parser => Xapit::SimpleQueryParser)
-    Xapit::Config.query_parser.should == Xapit::SimpleQueryParser
-  end
-  
-  it "should default indexer to SimpleIndexer" do
-    Xapit::Config.setup
-    Xapit::Config.indexer.should == Xapit::SimpleIndexer
-  end
-  
-  it "should be able to set indexer on setup" do
-    Xapit::Config.setup(:indexer => Xapit::ClassicIndexer)
-    Xapit::Config.indexer.should == Xapit::ClassicIndexer
-  end
-  
-  it "should have spelling enabled by default" do
-    Xapit::Config.setup
-    Xapit::Config.spelling?.should be_true
-  end
-  
-  it "should be able to specify spelling setting at setup" do
-    Xapit::Config.setup(:spelling => false)
-    Xapit::Config.spelling?.should be_false
-  end
-  
-  it "should default stemming to english" do
-    Xapit::Config.setup
-    Xapit::Config.stemming == "english"
-  end
-  
-  it "should be able to specify stemming setting at setup" do
-    Xapit::Config.setup(:stemming => "german")
-    Xapit::Config.stemming == "german"
-  end
-  
-  it "should remove the database if it is a true xapian database" do
-    Xapit::Config.writable_database # load the database
-    Xapit::Config.remove_database
-    File.exist?(Xapit::Config.path).should be_false
-  end
-  
-  it "should NOT remove the database if it is not a xapian database" do
-    path = Xapit::Config.path + "/testing"
-    FileUtils.mkdir_p(path)
-    Xapit::Config.remove_database
-    File.exist?(Xapit::Config.path).should be_true
-    FileUtils.rm_rf(Xapit::Config.path)
-  end
-end