xapit 0.2.7 → 0.3.0

data/spec/xapit/client/facet_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Xapit::Client::Facet do
+  it "sets the name to capitalized attribute" do
+    facet = Xapit::Client::Facet.new("building_type", [])
+    facet.name.should eq("Building Type")
+  end
+
+  it "sets the name as symbol to capitalized attribute" do
+    facet = Xapit::Client::Facet.new(:building_type, [])
+    facet.name.should eq("Building Type")
+  end
+end

data/spec/xapit/client/index_builder_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+
+describe Xapit::Client::IndexBuilder do
+  it "stores text attributes with option" do
+    builder = Xapit::Client::IndexBuilder.new
+    builder.text :foo, :weight => 3
+    builder.text :bar, :blah
+    builder.attributes[:foo].should eq(:text => {:weight => 3})
+    builder.attributes[:bar].should eq(:text => {})
+    builder.attributes[:blah].should eq(:text => {})
+  end
+
+  it "stores field attribute with option" do
+    builder = Xapit::Client::IndexBuilder.new
+    builder.field :foo, :weight => 3
+    builder.field :bar, :blah
+    builder.attributes[:foo].should eq(:field => {:weight => 3})
+    builder.attributes[:bar].should eq(:field => {})
+    builder.attributes[:blah].should eq(:field => {})
+  end
+
+  it "stores sortable attribute with option" do
+    builder = Xapit::Client::IndexBuilder.new
+    builder.sortable :foo, :weight => 3
+    builder.sortable :bar, :blah
+    builder.attributes[:foo].should eq(:sortable => {:weight => 3})
+    builder.attributes[:bar].should eq(:sortable => {})
+    builder.attributes[:blah].should eq(:sortable => {})
+  end
+
+  it "stores facet attribute with options" do
+    builder = Xapit::Client::IndexBuilder.new
+    builder.facet :foo
+    builder.facet :bar, "Zap"
+    builder.attributes[:foo].should eq(:facet => {})
+    builder.attributes[:bar].should eq(:facet => {:name => "Zap"})
+  end
+
+  it "fetches facets back" do
+    builder = Xapit::Client::IndexBuilder.new
+    builder.text :test
+    builder.facet :foo
+    builder.facet :bar
+    builder.facets.should eq([:foo, :bar])
+  end
+
+  it "merges member values with attributes for index data" do
+    builder = Xapit::Client::IndexBuilder.new
+    builder.text :greeting, :weight => 3
+    builder.field :name
+    member = XapitMember.new(:greeting => "hello world", :name => "John")
+    data = builder.document_data(member)
+    data[:id].should eq(member.id)
+    data[:class].should eq("XapitMember")
+    data[:attributes].should eq(:greeting => {:value => "hello world", :text => {:weight => 3}}, :name => {:value => "John", :field => {}})
+  end
+
+  it "indexes an object by adding it to the current database" do
+    load_xapit_database
+    Xapit.database.xapian_database.doccount.should eq(0)
+    builder = Xapit::Client::IndexBuilder.new
+    member = XapitMember.new(:greeting => "Hello world")
+    builder.add_document(member)
+    Xapit.database.xapian_database.doccount.should eq(1)
+  end
+end

data/spec/xapit/client/membership_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Xapit::Client::Membership do
+  before(:each) do
+    @member_class = Class.new
+    @member_class.send(:include, Xapit::Client::Membership)
+  end
+
+  it "does not define search class method when xapit isn't called" do
+    @member_class.should_not respond_to(:search)
+  end
+
+  it "has a xapit method which makes an index builder" do
+    @member_class.xapit { text :foo }
+    @member_class.xapit_index_builder.attributes.keys.should eq([:foo])
+  end
+
+  it "returns collection with query on search" do
+    @member_class.xapit { text :foo }
+    @member_class.search("hello").clauses.should eq([{:in_classes => [@member_class]}, {:search => "hello"}])
+  end
+
+  it "returns collection with no search query" do
+    @member_class.xapit { text :foo }
+    @member_class.search.clauses.should eq([{:in_classes => [@member_class]}])
+    @member_class.search("").clauses.should eq([{:in_classes => [@member_class]}])
+  end
+
+  it "supports xapit_search instead of just search" do
+    @member_class.xapit { text :foo }
+    @member_class.xapit_search.clauses.should eq([{:in_classes => [@member_class]}])
+  end
+
+  it "includes facets" do
+    @member_class.xapit { facet :foo }
+    @member_class.search.clauses.should eq([{:in_classes => [@member_class]}, {:include_facets => [:foo]}])
+  end
+
+  it "has a model_adapter" do
+    @member_class.xapit { } # load up the xapit methods
+    @member_class.xapit_model_adapter.should be_kind_of(Xapit::Client::DefaultModelAdapter)
+  end
+end

data/spec/xapit/client/model_adapters/active_record_adapter_spec.rb

@@ -0,0 +1,62 @@
+if ENV["MODEL_ADAPTER"].nil? || ENV["MODEL_ADAPTER"] == "active_record"
+  require "spec_helper"
+  ActiveRecord::Base.send(:include, Xapit::Client::Membership) # normally done in Railtie
+
+  RSpec.configure do |config|
+    config.extend WithModel
+  end
+
+  ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+  describe Xapit::Client::ActiveRecordAdapter do
+    with_model :article do
+      table do |t|
+        t.string "name"
+      end
+    end
+
+    before(:each) do
+      load_xapit_database
+      Article.xapit { text :name }
+    end
+
+    it "is only for active record classes" do
+      Xapit::Client::ActiveRecordAdapter.should_not be_for_class(Object)
+      Xapit::Client::ActiveRecordAdapter.should be_for_class(Article)
+      Xapit::Client::AbstractModelAdapter.adapter_class(Article).should == Xapit::Client::ActiveRecordAdapter
+    end
+
+    it "creates document when saved" do
+      article = Article.create!(:name => "Foo Bar")
+      Article.search("Foo Bar").records.should eq([article])
+    end
+
+    it "deletes a document when removed" do
+      article = Article.create!(:name => "Foo Bar")
+      article.destroy
+      Article.search("Foo Bar").records.should eq([])
+    end
+
+    it "update a document when changed" do
+      article = Article.create!(:name => "Foo Bar")
+      article.update_attribute(:name, "Hello World")
+      Article.search("Foo Bar").records.should eq([])
+      Article.search("Hello World").records.should eq([article])
+    end
+
+    it "does not index records while disabled" do
+      Xapit.config[:enabled] = false
+      Article.create!(:name => "Foo Bar")
+      Xapit.config[:enabled] = true
+      Article.search("Foo Bar").records.should eq([])
+    end
+
+    it "reindexes all records for a model" do
+      Xapit.config[:enabled] = false
+      article = Article.create!(:name => "Foo Bar")
+      Xapit.config[:enabled] = true
+      Xapit.index(Article)
+      Article.search("Foo Bar").records.should eq([article])
+    end
+  end
+end

data/spec/xapit/client/model_adapters/default_model_adapter_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe Xapit::Client::DefaultModelAdapter do
+  it "should be default for generic classes" do
+    Xapit::Client::DefaultModelAdapter.adapter_class(Object).should == Xapit::Client::DefaultModelAdapter
+  end
+end

data/spec/xapit/client/remote_database_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Xapit::Client::RemoteDatabase do
+  before(:each) do
+    @database = Xapit::Client::RemoteDatabase.new("http://localhost:1234")
+  end
+
+  Xapit::Server::Database::COMMANDS.each do |command|
+    it "passes #{command} to remote server using Net::HTTP" do
+      http = Object.new
+      response = Object.new
+      uri = URI.parse("http://localhost:1234/xapit/#{command}")
+      Net::HTTP.should_receive(:start).with(uri.host, uri.port).and_yield(http)
+      http.should_receive(:request_post).with(uri.path, {:send => "request"}.to_json).and_return(response)
+      response.should_receive(:body).and_return({"receive" => "response"}.to_json)
+      @database.send(command, :send => "request").should eq(:receive => "response")
+    end
+  end
+end

data/spec/xapit/server/app_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe Xapit::Server::App do
+  before(:each) do
+    @app = Xapit::Server::App.new
+    @request = Rack::MockRequest.new(@app)
+  end
+
+  Xapit::Server::Database::COMMANDS.each do |command|
+    it "passes #{command} to database and returns response in JSON" do
+      Xapit.database.stub(command.to_sym).with(:foo => "bar") { {:some => "result"} }
+      response = @request.post("/xapit/#{command}", :params => {"foo" => "bar"}.to_json)
+      response.status.should eq(200)
+      response.body.should eq({:some => "result"}.to_json)
+    end
+  end
+
+  it "responds with 404 when unknown url" do
+    response = @request.post("/xapit/foo")
+    response.status.should eq(404)
+  end
+end

data/spec/xapit/server/database_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe Xapit::Server::Database do
+  before(:each) do
+    load_xapit_database
+    @database = Xapit.database
+  end
+
+  it "has a xapian database" do
+    @database.xapian_database.should be_kind_of(Xapian::WritableDatabase)
+  end
+
+  it "adds a document to the database" do
+    @database.xapian_database.doccount.should eq(0)
+    @database.add_document(:attributes => {:greeting => {:value => "hello world", :text => {}}})
+    @database.xapian_database.doccount.should eq(1)
+  end
+
+  it "queries the database for results" do
+    @database.add_document(:attributes => {:greeting => {:value => "hello world", :text => {}}}, :id => 123, :class => "Greeting")
+    @database.query([{:search => "hello"}])[:records].should eq([{:class => "Greeting", :id => "123", :relevance => 100}])
+  end
+
+  it "removes a document from the database" do
+    @database.xapian_database.doccount.should eq(0)
+    @database.add_document(:id => 123, :class => "Greeting")
+    @database.xapian_database.doccount.should eq(1)
+    @database.remove_document(:id => 123, :class => "Greeting")
+    @database.xapian_database.doccount.should eq(0)
+  end
+
+  it "updates a document in the database" do
+    @database.add_document(:attributes => {:greeting => {:value => "hello world", :text => {}}}, :id => 123, :class => "Greeting")
+    @database.update_document(:attributes => {:greeting => {:value => "aloha", :text => {}}}, :id => 123, :class => "Greeting")
+    @database.query([{:search => "aloha"}])[:records].should eq([{:class => "Greeting", :id => "123", :relevance => 100}])
+  end
+end

data/spec/xapit/server/indexer_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+describe Xapit::Server::Indexer do
+  before(:each) do
+    load_xapit_database
+  end
+
+  it "generates a xapian document with terms and values" do
+    indexer = Xapit::Server::Indexer.new(:attributes => {:greeting => {:value => "hello world", :text => {}}, :name => {:value => "John", :field => {}}})
+    document = indexer.document
+    document.should be_kind_of(Xapian::Document)
+    document.terms.map(&:term).should include(*%w[hello world])
+    document.values.map(&:value).should eq([Xapit.serialize_value("John")])
+  end
+
+  it "generates a xapian document with text weight data" do
+    indexer = Xapit::Server::Indexer.new(:attributes => {:greeting => {:value => "hello", :text => {:weight => 3}}})
+    indexer.document.terms.map(&:wdf).should include(3)
+  end
+
+  it "stores sortable attributes as serialized values" do
+    time = Time.now
+    indexer = Xapit::Server::Indexer.new(:attributes => {:greeting => {:value => time, :sortable => {}}})
+    document = indexer.document
+    document.values.map(&:value).should eq([Xapit.serialize_value(time)])
+  end
+
+  it "adds the id and class to xapian document data" do
+    indexer = Xapit::Server::Indexer.new(:class => "Foo", :id => "123")
+    document = indexer.document
+    document.should be_kind_of(Xapian::Document)
+    document.data.should eq("Foo-123")
+  end
+
+  it "includes class/id in terms list" do
+    indexer = Xapit::Server::Indexer.new(:class => "Foo", :id => "123")
+    indexer.terms.should include(["CFoo", 1], ["QFoo-123", 1])
+  end
+
+  it "includes fields in terms list" do
+    indexer = Xapit::Server::Indexer.new(:attributes => {:greeting => {:value => "Hello", :field => {}}})
+    indexer.terms.should include(["Xgreeting-hello", 1])
+  end
+
+  it "adds facets to values and terms" do
+    indexer = Xapit::Server::Indexer.new(:attributes => {:greeting => {:value => ["Hello", "Hey"], :facet => {}}})
+    document = indexer.document
+    document.values.map(&:value).should eq(["Hello\3Hey"])
+    indexer.terms.should include(["F#{Xapit.facet_identifier(:greeting, "Hello")}", 1])
+    indexer.terms.should include(["F#{Xapit.facet_identifier(:greeting, "Hey")}", 1])
+  end
+
+  it "indexes array values separately" do
+    indexer = Xapit::Server::Indexer.new(:attributes => {:greeting => {:value => ["Hello", "world"], :field => {}}})
+    indexer.terms.should include(["Xgreeting-hello", 1], ["Xgreeting-world", 1])
+  end
+
+  it "includes text attributes in terms list" do
+    indexer = Xapit::Server::Indexer.new(:attributes => {:greeting => {:value => "hello world", :text => {}}})
+    indexer.terms.should include(["hello", 1], ["world", 1])
+  end
+
+  it "handles odd text attributes correctly" do
+    indexer = Xapit::Server::Indexer.new(:attributes => {:greeting => {:value => [6, nil, ""], :text => {}}})
+    indexer.terms.should include(["6", 1])
+    indexer.terms.should_not include(["", 1])
+    indexer.terms.should_not include([nil, 1])
+  end
+
+  it "handles odd field attributes correctly" do
+    # TODO add date handling
+    time = Time.now
+    indexer = Xapit::Server::Indexer.new(:attributes => {:greeting => {:value => [6, nil, time], :field => {}}})
+    indexer.terms.should include(["Xgreeting-6", 1], ["Xgreeting-", 1], ["Xgreeting-#{time.to_i}", 1])
+  end
+
+  it "includes field and sortable values" do
+    indexer = Xapit::Server::Indexer.new(:attributes => {:greeting => {:value => "Hello", :field => {}, :sortable => {}}})
+    indexer.values[Xapit.value_index(:field, "greeting")].should eq(Xapit.serialize_value("Hello"))
+    indexer.values[Xapit.value_index(:sortable, "greeting")].should eq(Xapit.serialize_value("Hello"))
+  end
+end

data/spec/xapit/server/query_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Xapit::Server::Query do
+  before(:each) do
+    load_xapit_database
+  end
+
+  it "fetches results matching a simple search term" do
+    Xapit.database.add_document(:attributes => {:greeting => {:value => "hello world", :text => {}}}, :id => 123, :class => "Greeting")
+    query = Xapit::Server::Query.new([{:search => "hello"}])
+    query.records.should eq([{:class => "Greeting", :id => "123", :relevance => 100}])
+    query = Xapit::Server::Query.new([{:search => "matchnothing"}])
+    query.records.should eq([])
+  end
+
+  it "fetches results matching a simple where clause" do
+    Xapit.database.add_document(:attributes => {:priority => {:value => "3", :field => {}}}, :id => 123, :class => "Greeting")
+    query = Xapit::Server::Query.new([{:where => {:priority => 3}}])
+    query.records.should eq([{:class => "Greeting", :id => "123", :relevance => 100}])
+    query = Xapit::Server::Query.new([{:where => {:priority => 4}}])
+    query.records.should eq([])
+  end
+
+  it "fetches facets when told to include them" do
+    Xapit.database.add_document(:attributes => {:priority => {:value => "3", :facet => {}}}, :id => 123, :class => "Greeting")
+    query = Xapit::Server::Query.new([{:include_facets => [:priority]}])
+    query.facets.should eq(:priority => [{:value => "3", :count => 1}])
+  end
+
+  it "fetches results matching a given facet" do
+    Xapit.database.add_document(:attributes => {:priority => {:value => "3", :field => {}, :facet => {}}}, :id => 123, :class => "Greeting")
+    query = Xapit::Server::Query.new([{:with_facets => [Xapit.facet_identifier(:priority, "3")]}])
+    query.records.should eq([{:class => "Greeting", :id => "123", :relevance => 100}])
+    query = Xapit::Server::Query.new([{:with_facets => [Xapit.facet_identifier(:priority, "4")]}])
+    query.records.should eq([])
+  end
+
+  it "fetches results containing applied facets" do
+    Xapit.database.add_document(:attributes => {:priority => {:value => "3", :facet => {}}}, :id => 123, :class => "Greeting")
+    query = Xapit::Server::Query.new([{:with_facets => [Xapit.facet_identifier(:priority, "3")]}])
+    query.applied_facet_options.should eq([{:id => Xapit.facet_identifier(:priority, "3"), :name => "priority", :value => "3"}])
+  end
+end

data/spec/xapit/xapit_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Xapit do
+  it "has default config settings" do
+    Xapit.config[:enabled].should eq(true)
+    Xapit.config[:spelling].should eq(true)
+    Xapit.config[:stemming].should eq("english")
+  end
+
+  it "can be enabled" do
+    Xapit.config[:enabled] = false
+    Xapit.enable
+    Xapit.config[:enabled].should eq(true)
+  end
+
+  it "loads and reloads a configuration file via load_config" do
+    Xapit.load_config("spec/fixtures/xapit.yml", "development")
+    Xapit.config[:database_path].should eq("development_database")
+    Xapit.config[:database_path] = "foo"
+    Xapit.reload
+    Xapit.config[:database_path].should eq("development_database")
+  end
+
+  it "raises an exception when accessing the database while disabled" do
+    Xapit.config[:enabled] = false
+    lambda { Xapit.database }.should raise_exception(Xapit::Disabled)
+  end
+end

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: xapit
 version: !ruby/object:Gem::Version 
-  version: 0.2.7
+  hash: 19
+  prerelease: 
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Ryan Bates
@@ -9,135 +15,160 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-07 00:00:00 -07:00
+date: 2011-08-17 00:00:00 -07:00
 default_executable: 
-dependencies: []
-
-description: Ruby library for interacting with Xapian, a full text search engine.
-email: ryan (at) railscasts (dot) com
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 2
+        - 2
+        version: 1.2.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 51
+        segments: 
+        - 0
+        - 10
+        - 2
+        version: 0.10.2
+  type: :development
+  version_requirements: *id003
+description: Ruby library for interacting with Xapian. Includes full text search, faceted options, spelling suggestions, and more.
+email: ryan@railscasts.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- CHANGELOG
-- lib/xapit/adapters/abstract_adapter.rb
-- lib/xapit/adapters/active_record_adapter.rb
-- lib/xapit/adapters/data_mapper_adapter.rb
-- lib/xapit/collection.rb
-- lib/xapit/config.rb
-- lib/xapit/facet.rb
-- lib/xapit/facet_blueprint.rb
-- lib/xapit/facet_option.rb
-- lib/xapit/index_blueprint.rb
-- lib/xapit/indexers/abstract_indexer.rb
-- lib/xapit/indexers/classic_indexer.rb
-- lib/xapit/indexers/simple_indexer.rb
-- lib/xapit/membership.rb
-- lib/xapit/query.rb
-- lib/xapit/query_parsers/abstract_query_parser.rb
-- lib/xapit/query_parsers/classic_query_parser.rb
-- lib/xapit/query_parsers/simple_query_parser.rb
-- lib/xapit/rake_tasks.rb
-- lib/xapit.rb
-- LICENSE
-- README.rdoc
-- tasks/spec.rb
-- tasks/xapit.rake
+extra_rdoc_files: []
+
 files: 
-- CHANGELOG
+- lib/generators/xapit/install_generator.rb
+- lib/generators/xapit/templates/xapit.ru
+- lib/generators/xapit/templates/xapit.yml
+- lib/xapit/client/collection.rb
+- lib/xapit/client/facet.rb
+- lib/xapit/client/facet_option.rb
+- lib/xapit/client/index_builder.rb
+- lib/xapit/client/membership.rb
+- lib/xapit/client/model_adapters/abstract_model_adapter.rb
+- lib/xapit/client/model_adapters/active_record_adapter.rb
+- lib/xapit/client/model_adapters/default_model_adapter.rb
+- lib/xapit/client/railtie.rb
+- lib/xapit/client/remote_database.rb
+- lib/xapit/client/tasks.rb
+- lib/xapit/server/app.rb
+- lib/xapit/server/database.rb
+- lib/xapit/server/indexer.rb
+- lib/xapit/server/query.rb
+- lib/xapit.rb
+- spec/fixtures/blankdb/flintlock
+- spec/fixtures/blankdb/iamchert
+- spec/fixtures/blankdb/postlist.baseA
+- spec/fixtures/blankdb/postlist.DB
+- spec/fixtures/blankdb/record.baseA
+- spec/fixtures/blankdb/record.DB
+- spec/fixtures/blankdb/termlist.baseA
+- spec/fixtures/blankdb/termlist.DB
+- spec/fixtures/xapit.ru
+- spec/fixtures/xapit.yml
+- spec/spec_helper.rb
+- spec/support/spec_macros.rb
+- spec/support/xapit_member.rb
+- spec/xapit/client/collection_spec.rb
+- spec/xapit/client/facet_option_spec.rb
+- spec/xapit/client/facet_spec.rb
+- spec/xapit/client/index_builder_spec.rb
+- spec/xapit/client/membership_spec.rb
+- spec/xapit/client/model_adapters/active_record_adapter_spec.rb
+- spec/xapit/client/model_adapters/default_model_adapter_spec.rb
+- spec/xapit/client/remote_database_spec.rb
+- spec/xapit/server/app_spec.rb
+- spec/xapit/server/database_spec.rb
+- spec/xapit/server/indexer_spec.rb
+- spec/xapit/server/query_spec.rb
+- spec/xapit/xapit_spec.rb
 - features/facets.feature
 - features/finding.feature
 - features/indexing.feature
-- features/sorting.feature
+- features/remote_server.feature
 - features/step_definitions/common_steps.rb
 - features/step_definitions/xapit_steps.rb
 - features/suggestions.feature
 - features/support/env.rb
 - features/support/xapit_helpers.rb
-- init.rb
-- install.rb
-- lib/xapit/adapters/abstract_adapter.rb
-- lib/xapit/adapters/active_record_adapter.rb
-- lib/xapit/adapters/data_mapper_adapter.rb
-- lib/xapit/collection.rb
-- lib/xapit/config.rb
-- lib/xapit/facet.rb
-- lib/xapit/facet_blueprint.rb
-- lib/xapit/facet_option.rb
-- lib/xapit/index_blueprint.rb
-- lib/xapit/indexers/abstract_indexer.rb
-- lib/xapit/indexers/classic_indexer.rb
-- lib/xapit/indexers/simple_indexer.rb
-- lib/xapit/membership.rb
-- lib/xapit/query.rb
-- lib/xapit/query_parsers/abstract_query_parser.rb
-- lib/xapit/query_parsers/classic_query_parser.rb
-- lib/xapit/query_parsers/simple_query_parser.rb
-- lib/xapit/rake_tasks.rb
-- lib/xapit.rb
+- CHANGELOG.rdoc
+- Gemfile
 - LICENSE
-- Manifest
-- rails_generators/xapit/templates/setup_xapit.rb
-- rails_generators/xapit/templates/xapit.rake
-- rails_generators/xapit/USAGE
-- rails_generators/xapit/xapit_generator.rb
 - Rakefile
 - README.rdoc
-- spec/spec_helper.rb
-- spec/xapit/adapters/active_record_adapter_spec.rb
-- spec/xapit/adapters/data_mapper_adapter_spec.rb
-- spec/xapit/collection_spec.rb
-- spec/xapit/config_spec.rb
-- spec/xapit/facet_blueprint_spec.rb
-- spec/xapit/facet_option_spec.rb
-- spec/xapit/facet_spec.rb
-- spec/xapit/index_blueprint_spec.rb
-- spec/xapit/indexers/abstract_indexer_spec.rb
-- spec/xapit/indexers/classic_indexer_spec.rb
-- spec/xapit/indexers/simple_indexer_spec.rb
-- spec/xapit/membership_spec.rb
-- spec/xapit/query_parsers/abstract_query_parser_spec.rb
-- spec/xapit/query_parsers/classic_query_parser_spec.rb
-- spec/xapit/query_parsers/simple_query_parser_spec.rb
-- spec/xapit/query_spec.rb
-- spec/xapit_member.rb
-- tasks/spec.rb
-- tasks/xapit.rake
-- uninstall.rb
-- xapit.gemspec
 has_rdoc: true
 homepage: http://github.com/ryanb/xapit
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --line-numbers
-- --inline-source
-- --title
-- Xapit
-- --main
-- README.rdoc
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: "1.2"
-  version: 
+      hash: 19
+      segments: 
+      - 1
+      - 3
+      - 4
+      version: 1.3.4
 requirements: []
 
 rubyforge_project: xapit
-rubygems_version: 1.3.3
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: Ruby library for interacting with Xapian, a full text search engine.
+summary: Ruby library for interacting with the Xapian full text search engine.
 test_files: []