xapit 0.1.0

data/spec/xapit/facet_spec.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Xapit::Facet do
+  describe "with database" do
+    before(:each) do
+      XapitMember.xapit do |index|
+        index.facet :visible
+      end
+    end
+    
+    describe "indexed" do
+      before(:each) do
+        @visible1 = XapitMember.new(:visible => true)
+        @visible2 = XapitMember.new(:visible => true)
+        @invisible = XapitMember.new(:visible => false)
+        Xapit.index_all
+      end
+      
+      describe "facet from empty search" do
+        before(:each) do
+          @facet = XapitMember.search("").facets.first
+        end
+      
+        it "should have the name of 'Visible'" do
+          @facet.name.should == 'Visible'
+        end
+      
+        it "should have true and false options" do
+          @facet.options.map(&:name).sort.should == %w[false true]
+        end
+      
+        it "should have record count" do
+          @facet.options.detect { |o| o.name == 'true' }.count.should == 2
+          @facet.options.detect { |o| o.name == 'false' }.count.should == 1
+        end
+      
+        it "should have identifier for options" do
+          blueprint = Xapit::FacetBlueprint.new(XapitMember, 0, :visible)
+          @facet.options.detect { |o| o.name == 'true' }.identifier.should == blueprint.identifiers_for(@visible1).first
+          @facet.options.detect { |o| o.name == 'false' }.identifier.should == blueprint.identifiers_for(@invisible).first
+        end
+        
+        it "should have matching identifiers" do
+          blueprint = Xapit::FacetBlueprint.new(XapitMember, 0, :visible)
+          hash = { blueprint.identifiers_for(@visible1).first => 2, blueprint.identifiers_for(@invisible).first => 1 }
+          @facet.matching_identifiers.should == hash
+        end
+        
+        it "should not include matching identifiers that are current" do
+          blueprint = Xapit::FacetBlueprint.new(XapitMember, 0, :visible)
+          @facet.existing_facet_identifiers = blueprint.identifiers_for(@visible1)
+          @facet.matching_identifiers.should == { blueprint.identifiers_for(@invisible).first => 1 }
+        end
+      
+        it "should return identifier on to_param" do
+          blueprint = Xapit::FacetBlueprint.new(XapitMember, 0, :visible)
+          @facet.options.detect { |o| o.name == 'true' }.to_param.should == blueprint.identifiers_for(@visible1).first
+        end
+      
+        it "should sort options in alphabetical order" do
+          @facet.options.first.name.should == 'false'
+          @facet.options.last.name.should == 'true'
+        end
+      end
+      
+      it "should not list facets if only one option is found" do
+        blueprint = Xapit::FacetBlueprint.new(XapitMember, 0, :visible)
+        facets = XapitMember.search("", :facets => blueprint.identifiers_for(@visible1)).facets
+        facets.should be_empty
+      end
+    end
+  end
+end

data/spec/xapit/index_blueprint_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Xapit::IndexBlueprint do
+  before(:each) do
+    @index = Xapit::IndexBlueprint.new(XapitMember)
+  end
+  
+  it "should remember text attributes" do
+    @index.text(:foo)
+    @index.text(:bar, :blah)
+    @index.text(:custom) { |t| t*t }
+    @index.text_attributes.keys.should include(:foo, :bar, :blah, :custom)
+    @index.text_attributes[:foo][:proc].should be_nil
+    @index.text_attributes[:custom][:proc].should be_kind_of(Proc)
+  end
+  
+  it "should remember field attributes" do
+    @index.field(:foo)
+    @index.field(:bar, :blah)
+    @index.field_attributes.should include(:foo, :bar, :blah)
+  end
+  
+  it "should remember facets" do
+    @index.facet(:foo)
+    @index.facet(:bar, "Baz")
+    @index.facets.map(&:name).should == ["Foo", "Baz"]
+  end
+  
+  it "should remember sortable attributes" do
+    @index.sortable(:foo)
+    @index.sortable(:bar, :blah)
+    @index.sortable_attributes.should include(:foo, :bar, :blah)
+  end
+  
+  it "should have a sortable position offset by facets" do
+    @index.facet(:foo)
+    @index.facet(:test)
+    @index.sortable(:bar, :blah)
+    @index.sortable_position_for(:blah).should == 3
+  end
+  
+  it "should index member document into database" do
+    XapitMember.new
+    @index.index_all
+    Xapit::Config.writable_database.doccount.should >= 1
+    Xapit::Config.writable_database.flush
+  end
+  
+  it "should remember all blueprints and index each of them" do
+    stub(Xapit::Config.writable_database).add_document
+    mock(@index).index_all
+    Xapit::IndexBlueprint.index_all
+  end
+  
+  it "should pass in extra arguments to each method" do
+    index = Xapit::IndexBlueprint.new(Object, :foo, :bar => :blah)
+    mock(Object).find_each(:foo, :bar => :blah)
+    index.index_all
+  end
+end

data/spec/xapit/indexers/abstract_indexer_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Xapit::AbstractIndexer do
+  before(:each) do
+    XapitMember.xapit { } # to ensure methods are included
+    @index = Xapit::IndexBlueprint.new(XapitMember)
+    @indexer = Xapit::SimpleIndexer.new(@index)
+  end
+  
+  it "should map field to term with 'X' prefix" do
+    member = Object.new
+    stub(member).category { "Water" }
+    @index.field(:category)
+    @indexer.field_terms(member).should == %w[Xcategory-water]
+  end
+  
+  it "should add terms separately when array is returned" do
+    member = Object.new
+    stub(member).category { ["Water", "Liquid"] }
+    @index.field(:category)
+    @indexer.field_terms(member).should == %w[Xcategory-water Xcategory-liquid]
+  end
+  
+  it "should have base terms with class name and id" do
+    member = Object.new
+    stub(member).id { 123 }
+    @indexer.base_terms(member).should == %w[CObject QObject-123]
+  end
+  
+  it "should add terms, values and options for facets" do
+    Xapit::Config.writable_database # force xapit to use a writable database at the beginning
+    stub(XapitMember).xapit_index_blueprint { @index }
+    member = XapitMember.new(:foo => ["ABC", "DEF"])
+    ids = Xapit::FacetBlueprint.new(XapitMember, 0, :foo).identifiers_for(member)
+    @index.facet(:foo)
+    @indexer.facet_terms(member).should == ids.map { |id| "F#{id}" }
+    @indexer.values(member).should == [ids.join('-')]
+    @indexer.save_facet_options_for(member)
+    ids.map { |id| Xapit::FacetOption.find(id).name }.should == ["ABC", "DEF"]
+  end
+  
+  it "should add values for sortable fields" do
+    member = Object.new
+    stub(member).name { "Foo" }
+    @index.sortable(:name)
+    @indexer.values(member).should == ["foo"]
+  end
+  
+  it "should add terms and values to xapian document" do
+    member = Object.new
+    stub(member).id { 123 }
+    stub(@indexer).values.returns(%w[value list])
+    stub(@indexer).other_terms { %w[term list] }
+    doc = @indexer.document_for(member)
+    doc.should be_kind_of(Xapian::Document)
+    doc.data.should == "Object-123"
+    doc.values.map(&:value).sort.should == %w[value list].sort
+    doc.terms.map(&:term).sort.should == %w[term list].sort
+  end
+  
+  it "should convert time to integer before saving as field term" do
+    member = Object.new
+    stub(member).created_at { Time.now }
+    @index.field(:created_at)
+    @indexer.field_terms(member).should == ["Xcreated_at-#{member.created_at.to_i}"]
+  end
+  
+  it "should convert date to time then integer before saving as field term" do
+    member = Object.new
+    stub(member).created_on { Date.today }
+    @index.field(:created_on)
+    @indexer.field_terms(member).should == ["Xcreated_on-#{member.created_on.to_time.to_i}"]
+  end
+end

data/spec/xapit/indexers/classic_indexer_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Xapit::ClassicIndexer do
+  before(:each) do
+    @index = Xapit::IndexBlueprint.new(XapitMember)
+    @indexer = Xapit::ClassicIndexer.new(@index)
+  end
+  
+  it "should add text terms to document when indexing attributes" do
+    member = Object.new
+    stub(member).name { "jumping high" }
+    @index.text(:name)
+    document = Xapian::Document.new
+    @indexer.index_text_attributes(member, document)
+    document.terms.map(&:term).sort.should == %w[Zjump Zhigh jumping high].sort
+  end
+  
+  it "should use given block to generate text terms" do
+    member = Object.new
+    stub(member).name { "foobar" }
+    @index.text(:name) { |t| [t.length] }
+    document = Xapian::Document.new
+    @indexer.index_text_attributes(member, document)
+    document.terms.map(&:term).sort.should == %w[6].sort
+  end
+end

data/spec/xapit/indexers/simple_indexer_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Xapit::SimpleIndexer do
+  before(:each) do
+    @index = Xapit::IndexBlueprint.new(XapitMember)
+    @indexer = Xapit::SimpleIndexer.new(@index)
+  end
+  
+  it "should return terms for text attributes" do
+    member = Object.new
+    stub(member).description { "This is a test" }
+    @index.text(:description)
+    @indexer.terms_for_attribute_without_stemming(member, :description, {}).should == %w[this is a test]
+  end
+  
+  it "should return text term with stemming added" do
+    member = Object.new
+    stub(member).description { "jumping high" }
+    @index.text(:description)
+    @indexer.terms_for_attribute(member, :description, {}).should == %w[jumping Zjump high Zhigh]
+  end
+  
+  it "should convert attribute to string when converting text to terms" do
+    member = Object.new
+    stub(member).num { 123 }
+    @index.text(:num)
+    @indexer.terms_for_attribute_without_stemming(member, :num, {}).should == %w[123]
+  end
+  
+  it "should add text terms to document when indexing attributes" do
+    @index.text(:description)
+    stub(@indexer).terms_for_attribute { %w[term list] }
+    document = Xapian::Document.new
+    @indexer.index_text_attributes(nil, document)
+    document.terms.map(&:term).sort.should == %w[term list].sort
+  end
+  
+  it "should use given block to generate text terms" do
+    member = Object.new
+    stub(member).name { "foobar" }
+    proc = lambda { |t| [t.length] }
+    @indexer.terms_for_attribute_without_stemming(member, :name, { :proc => proc }).should == ["6"]
+  end
+  
+  it "should increment term frequency by weight option" do
+    member = Object.new
+    stub(member).description { "This is a test" }
+    @index.text(:description, :weight => 10)
+    document = Xapian::Document.new
+    @indexer.index_text_attributes(member, document)
+    document.terms.first.wdf.should == 10
+  end
+end

data/spec/xapit/membership_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class OtherMember
+  include Xapit::Membership
+end
+
+describe XapitMember do
+  it "should have xapit method" do
+    OtherMember.should respond_to(:xapit)
+  end
+  
+  it "should not respond to xapit_index_blueprint if xapit isn't called" do
+    OtherMember.should_not respond_to(:xapit_index_blueprint)
+    OtherMember.should_not respond_to(:search)
+    OtherMember.new.should_not respond_to(:search_similar)
+    OtherMember.new.should_not respond_to(:xapit_relevance)
+  end
+  
+  describe "with description indexed" do
+    before(:each) do
+      XapitMember.xapit do |index|
+        index.text :description
+      end
+    end
+    
+    it "should have xapit index blueprint" do
+      XapitMember.xapit_index_blueprint.should be_kind_of(Xapit::IndexBlueprint)
+    end
+    it "should return collection from search" do
+      XapitMember.search("foo").class.should == Xapit::Collection
+    end
+  
+    it "should store xapit_relevance" do
+      member = XapitMember.new
+      member.xapit_relevance = 123
+      member.xapit_relevance.should == 123
+    end
+  end
+end

data/spec/xapit/query_parsers/abstract_query_parser_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Xapit::AbstractQueryParser do
+  before(:each) do
+  end
+    
+  it "parse conditions hash into terms" do
+    parser = Xapit::AbstractQueryParser.new(:conditions => { :foo => 'bar', 'hello' => :world })
+    parser.condition_terms.sort.should == ["Xfoo-bar", "Xhello-world"].sort
+  end
+    
+  it "convert time into integer before placing in condition term" do
+    time = Time.now
+    parser = Xapit::AbstractQueryParser.new(:conditions => { :time => time })
+    parser.condition_terms.should == ["Xtime-#{time.to_i}"]
+  end
+    
+  it "convert date into time then integer before placing in condition term" do
+    date = Date.today
+    parser = Xapit::AbstractQueryParser.new(:conditions => { :date => date })
+    parser.condition_terms.should == ["Xdate-#{date.to_time.to_i}"]
+  end
+end

data/spec/xapit/query_parsers/classic_query_parser_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Xapit::ClassicQueryParser do
+  before(:each) do
+    @parser = Xapit::ClassicQueryParser.new(nil, nil)
+  end
+  
+  it "should have an initial xapian parser with stemming and default operator support" do
+    expected = Xapian::QueryParser.new
+    expected.stemmer = Xapian::Stem.new("english")
+    expected.stemming_strategy = Xapian::QueryParser::STEM_SOME
+    expected.default_op = Xapian::Query::OP_AND
+    @parser.xapian_query_from_text("foo bar").description.should == expected.parse_query("foo bar").description
+  end
+end

data/spec/xapit/query_parsers/simple_query_parser_spec.rb

@@ -0,0 +1,86 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Xapit::SimpleQueryParser do
+  describe "with stemming" do
+    it "should include stemmed variation for single word" do
+      Xapit::SimpleQueryParser.new(nil, "jumping").parsed.should == "Zjump"
+    end
+    
+    it "should include stemmed variations for multiple words" do
+      Xapit::SimpleQueryParser.new(nil, "jumping high").parsed.should == [:and, "Zjump", "Zhigh"]
+    end
+    
+    it "should add stemmed variation for 'not' option" do
+      Xapit::SimpleQueryParser.new(nil, "jumping not high").parsed.should == [:and, "Zjump", [:not, "Zhigh"]]
+    end
+  end
+  
+  describe "without stemming" do
+    before(:each) do
+      Xapit::Config.options[:stemming] = false
+    end
+    
+    it "should parse nothing for simple string" do
+      Xapit::SimpleQueryParser.new(nil, "foobar").parsed.should == "foobar"
+    end
+  
+    it "should parse empty string as blank string" do
+      Xapit::SimpleQueryParser.new(nil, "").parsed.should == ""
+      Xapit::SimpleQueryParser.new(nil, "  \t  ").parsed.should == ""
+    end
+  
+    it "should parse white space as AND" do
+      Xapit::SimpleQueryParser.new(nil, "foo bar").parsed.should == [:and, "foo", "bar"]
+      Xapit::SimpleQueryParser.new(nil, "\t foo  \t bar  ").parsed.should == [:and, "foo", "bar"]
+    end
+  
+    it "should parse simple 'or' query" do
+      Xapit::SimpleQueryParser.new(nil, "foo or bar").parsed.should == [:or, "foo", "bar"]
+      Xapit::SimpleQueryParser.new(nil, " foo or\t bar \t ").parsed.should == [:or, "foo", "bar"]
+      Xapit::SimpleQueryParser.new(nil, "foo OR bar").parsed.should == [:or, "foo", "bar"]
+    end
+  
+    it "should parse 'and' within 'or' giving 'or' presedence" do
+      Xapit::SimpleQueryParser.new(nil, "foo or bar blah").parsed.should == [:or, "foo", [:and, "bar", "blah"]]
+      Xapit::SimpleQueryParser.new(nil, "foo bar or blah").parsed.should == [:or, [:and, "foo", "bar"], "blah"]
+    end
+  
+    it "should parse simple 'not' query" do
+      Xapit::SimpleQueryParser.new(nil, "foo not bar").parsed.should == [:and, "foo", [:not, "bar"]]
+      Xapit::SimpleQueryParser.new(nil, "foo  NOT  bar blah").parsed.should == [:and, "foo", [:not, "bar"], "blah"]
+    end
+  
+    it "should convert simple query to xapian query" do
+      Xapit::SimpleQueryParser.new(nil, "foo bar").xapian_query.description.should == Xapian::Query.new(Xapian::Query::OP_AND, "foo", "bar").description
+      Xapit::SimpleQueryParser.new(nil, "foo OR bar").xapian_query.description.should == Xapian::Query.new(Xapian::Query::OP_OR, "foo", "bar").description
+    end
+  
+    it "should convert deep query to xapian query" do
+      query = Xapian::Query.new(Xapian::Query::OP_OR,
+        Xapian::Query.new(Xapian::Query::OP_OR, ["foo"]),
+        Xapian::Query.new(Xapian::Query::OP_AND, ["bar", "blah"])
+      )
+      Xapit::SimpleQueryParser.new(nil, "foo or bar blah").xapian_query.description.should == query.description
+    end
+  
+    it "should convert multi-deep query to xapian query" do
+      query = Xapian::Query.new(Xapian::Query::OP_OR,
+        Xapian::Query.new(Xapian::Query::OP_AND, ["foo", "bar"]),
+        Xapian::Query.new(Xapian::Query::OP_AND, ["test", "blah"])
+      )
+      Xapit::SimpleQueryParser.new(nil, "foo bar or test blah").xapian_query.description.should == query.description
+    end
+  
+    it "should convert single word query to xapian query" do
+      Xapit::SimpleQueryParser.new(nil, "foo").xapian_query.description.should == Xapian::Query.new(Xapian::Query::OP_AND, ["foo"]).description
+    end
+  
+    it "should convert negative query to xapian query" do
+      query = Xapian::Query.new(Xapian::Query::OP_AND_NOT,
+        Xapian::Query.new(Xapian::Query::OP_AND, ["foo"]),
+        Xapian::Query.new(Xapian::Query::OP_AND, ["bar"])
+      )
+      Xapit::SimpleQueryParser.new(nil, "foo not bar").xapian_query.description.should == query.description
+    end
+  end
+end