xapit 0.2.7 → 0.3.0

data/spec/xapit/facet_blueprint_spec.rb

@@ -1,29 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Xapit::FacetBlueprint do
-  it "should generate unique identifier based on attribute and value" do
-    facet1 = Xapit::FacetBlueprint.new(XapitMember, 0, :to_s)
-    facet2 = Xapit::FacetBlueprint.new(XapitMember, 0, :length)
-    facet1.identifiers_for("foo").first.length.should == 7
-    facet1.identifiers_for("foo").should_not == facet1.identifiers_for("bar")
-    facet1.identifiers_for("foo").should_not == facet2.identifiers_for("foo")
-  end
-  
-  it "should generate unique identifiers for each value returned" do
-    facet = Xapit::FacetBlueprint.new(XapitMember, 0, :to_a)
-    facet.identifiers_for(["foo", "bar"]).size.should == 2
-  end
-  
-  it "should humanize attribute for name if one isn't given" do
-    Xapit::FacetBlueprint.new(XapitMember, 0, :visible).name.should == "Visible"
-  end
-  
-  it "should use custom name if given" do
-    Xapit::FacetBlueprint.new(XapitMember, 0, :visible, "custom").name.should == "custom"
-  end
-  
-  it "should not have identifiers for blank values" do
-    facet = Xapit::FacetBlueprint.new(XapitMember, 0, :to_a)
-    facet.identifiers_for(["", nil, "bar"]).size.should == 1
-  end
-end

data/spec/xapit/facet_option_spec.rb

@@ -1,80 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Xapit::FacetOption do
-  it "should combine previous identifiers with current one on to_param" do
-    option = Xapit::FacetOption.new(nil, nil, nil)
-    option.existing_facet_identifiers = ["abc", "123"]
-    stub(option).identifier { "foo" }
-    option.to_param.should == "abc-123-foo"
-  end
-  
-  it "should remove current identifier from previous identifiers if it exists" do
-    Xapit.setup(:breadcrumb_facets => false)
-    option = Xapit::FacetOption.new(nil, nil, nil)
-    option.existing_facet_identifiers = ["abc", "123", "foo"]
-    stub(option).identifier { "foo" }
-    option.to_param.should == "abc-123"
-  end
-  
-  it "should support breadcrumb style facets" do
-    Xapit.setup(:breadcrumb_facets => true)
-    option = Xapit::FacetOption.new(nil, nil, nil)
-    option.existing_facet_identifiers = ["abc", "123", "foo"]
-    stub(option).identifier { "123" }
-    option.to_param.should == "abc-123"
-  end
-  
-  describe "with database" do
-    before(:each) do
-      XapitMember.xapit do |index|
-        index.facet :age, "Person Age"
-        index.facet :category
-      end
-    end
-    
-    it "should have identifier hashing name and value" do
-      option = Xapit::FacetOption.new("XapitMember", "age", "17")
-      option.identifier.should == "0c93ee1"
-    end
-    
-    it "should find facet option from database given id" do
-      doc = Xapian::Document.new
-      doc.data = "XapitMember|||age|||17"
-      doc.add_term("QXapit::FacetOption-abc123")
-      Xapit::Config.writable_database.add_document(doc)
-      option = Xapit::FacetOption.find("abc123")
-      option.name.should == "17"
-      option.facet.name.should == "Person Age"
-    end
-    
-    it "should save facet to database" do
-      Xapit::Config.writable_database # make sure there's a database setup in case we try to read from it
-      option = Xapit::FacetOption.new(nil, nil, nil)
-      option.facet = XapitMember.xapit_facet_blueprint("age")
-      option.name = "23"
-      option.save
-      Xapit::FacetOption.find(option.identifier).should_not be_nil
-    end
-    
-    it "should not save facet if it already exists" do
-      doc = Xapian::Document.new
-      doc.data = "XapitMember|||age|||17"
-      doc.add_term("QXapit::FacetOption-abc123")
-      Xapit::Config.writable_database.add_document(doc)
-      stub(Xapit::Config.writable_database).add_document { raise "should not add doc" }
-      option = Xapit::FacetOption.new(XapitMember, nil, nil)
-      stub(option).identifier { "abc123" }
-      option.save
-    end
-    
-    it "should find facet option which doesn't have a value" do
-      doc = Xapian::Document.new
-      doc.data = "XapitMember|||age|||"
-      doc.add_term("QXapit::FacetOption-abc123")
-      Xapit::Config.writable_database.add_document(doc)
-      option = Xapit::FacetOption.find("abc123")
-      option.name.should == ""
-      option.facet.name.should == "Person Age"
-    end
-  end
-end

data/spec/xapit/facet_spec.rb

@@ -1,73 +0,0 @@
-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

@@ -1,112 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Xapit::IndexBlueprint do
-  before(:each) do
-    XapitMember.xapit { } # call so methods are generated
-    @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.position_of_sortable(:blah).should == 3
-  end
-  
-  it "should have a field position offset by facets + sortable" do
-    @index.facet(:foo)
-    @index.sortable(:bar, :blah)
-    @index.field(:bar, :blah)
-    @index.position_of_field(:blah).should == 4
-  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(XapitMember, :foo, :bar => :blah)
-    mock(XapitMember).find_each(:foo, :bar => :blah)
-    index.index_all
-  end
-  
-  it "should add a record from the index" do
-    member = XapitMember.new(:name => "New Record!")
-    @index.text :name
-    @index.create_record(member.id)
-    XapitMember.search("New Record").should == [member]
-  end
-  
-  it "should remove a record from the index" do
-    member = XapitMember.new(:name => "Bad Record!")
-    @index.text :name
-    @index.index_all
-    @index.destroy_record(member.id)
-    XapitMember.search("Bad Record").should == []
-  end
-  
-  it "should update a record in the index" do
-    member = XapitMember.new(:name => "New Record!")
-    @index.text :name
-    @index.index_all
-    member.update_attribute(:name, "Changed Record!")
-    @index.update_record(member.id)
-    XapitMember.search("Changed Record").should == [member]
-  end
-  
-  it "should not create record index if member isn't found" do
-    Xapit::Config.writable_database # make sure the database is built
-    member = XapitMember.new(:name => "New Record!")
-    stub(XapitMember).find { nil }
-    @index.text :name
-    @index.create_record(member.id)
-    XapitMember.search("New Record").should be_empty
-  end
-  
-  it "should remove record from index when updating a member which doesn't exist" do
-    member = XapitMember.new(:name => "New Record!")
-    @index.text :name
-    @index.index_all
-    stub(XapitMember).find { nil }
-    member.update_attribute(:name, "Changed Record!")
-    @index.update_record(member.id)
-    XapitMember.search("New Record").should be_empty
-    XapitMember.search("Changed Record").should be_empty
-  end
-end

data/spec/xapit/indexers/abstract_indexer_spec.rb

@@ -1,111 +0,0 @@
-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
-  
-  it "should use sortable_serialze for numeric sortable" do
-    member = Object.new
-    stub(member).age { 7.89 }
-    @index.sortable(:age)
-    @indexer.values(member).should == [Xapian.sortable_serialise(7.89)]
-  end
-  
-  it "should only use first value if sortable attribute is an array" do
-    member = Object.new
-    stub(member).age { [1, 2] }
-    @index.sortable(:age)
-    @indexer.values(member).should == [Xapian.sortable_serialise(1)]
-  end
-  
-  it "should add sortable_serialze value for numeric field" do
-    member = Object.new
-    stub(member).age { [1, 2] }
-    @index.field(:age)
-    @indexer.values(member).should == [Xapian.sortable_serialise(1)]
-  end
-  
-  it "should use sortable_serialze for date field" do
-    date = Date.today
-    member = Object.new
-    stub(member).age { date }
-    @index.field(:age)
-    @indexer.values(member).should == [Xapian.sortable_serialise(date.to_time.to_i)]
-  end
-  
-  it "should use sortable_serialze for time field" do
-    time = Time.now
-    member = Object.new
-    stub(member).age { time }
-    @index.field(:age)
-    @indexer.values(member).should == [Xapian.sortable_serialise(time.to_i)]
-  end
-end

data/spec/xapit/indexers/classic_indexer_spec.rb

@@ -1,35 +0,0 @@
-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
-  
-  it "should return terms separated by array" do
-    member = Object.new
-    stub(member).description { ["foo bar", 6, "", nil] }
-    @index.text(:description)
-    document = Xapian::Document.new
-    @indexer.index_text_attributes(member, document)
-    document.terms.map(&:term).sort.should == ["foo bar", "6"].sort
-  end
-end

data/spec/xapit/indexers/simple_indexer_spec.rb

@@ -1,69 +0,0 @@
-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(member, :description, {}).should == %w[this is a test]
-  end
-  
-  it "should return text terms with stemming added" do
-    member = Object.new
-    stub(member).description { "jumping high" }
-    @index.text(:description)
-    @indexer.stemmed_terms_for_attribute(member, :description, {}).should == %w[Zjump 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(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[Zlist Zterm list term].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(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
-  
-  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
-  
-  it "should return terms separated by array" do
-    member = Object.new
-    stub(member).description { ["foo bar", 6, "", nil] }
-    @index.text(:description)
-    @indexer.terms_for_attribute(member, :description, {}).should == ["foo bar", "6"]
-  end
-end