xapit 0.2.7 → 0.3.0

data/spec/xapit/membership_spec.rb

@@ -1,55 +0,0 @@
-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
-      XapitMember.instance_variable_set("@xapit_adapter", nil)
-    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
-    
-    it "should have an adapter" do
-      XapitMember.xapit_adapter.class.should == Xapit::ActiveRecordAdapter
-    end
-    
-    it "should use DataMapper adapter if that is ancestor" do
-      stub(XapitMember).ancestors { ["DataMapper::Resource"] }
-      XapitMember.xapit_adapter.class.should == Xapit::DataMapperAdapter
-    end
-    
-    it "should raise an exception when no adapter is found" do
-      stub(XapitMember).ancestors { [] }
-      lambda { XapitMember.xapit_adapter }.should raise_error
-    end
-  end
-end

data/spec/xapit/query_parsers/abstract_query_parser_spec.rb

@@ -1,60 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Xapit::AbstractQueryParser do
-  before(:each) do
-  end
-    
-  it "should 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 "should 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 "should 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
-    
-  it "should give spelling suggestion on full term" do
-    Xapit::Config.writable_database.add_spelling("foo bar")
-    parser = Xapit::AbstractQueryParser.new(nil, "foo barr")
-    parser.spelling_suggestion.should == "foo bar"
-  end
-    
-  it "should allow an array of conditions to be specified and use OR xapian query." do
-    parser = Xapit::AbstractQueryParser.new(:not_conditions => { :foo => %w[hello world]})
-    parser.not_condition_terms.first.xapian_query.description.should == Xapit::Query.new(%w[Xfoo-hello Xfoo-world], :or).xapian_query.description
-  end
-    
-  it "should allow range condition to be specified and use VALUE_RANGE xapian query." do
-    XapitMember.xapit { |i| i.field :foo }
-    expected = Xapian::Query.new(Xapian::Query::OP_VALUE_RANGE, 0, Xapian.sortable_serialise(2), Xapian.sortable_serialise(5))
-    parser = Xapit::AbstractQueryParser.new(XapitMember, :conditions => { :foo => 2..5 })
-    parser.condition_terms.first.description.should == expected.description
-  end
-    
-  it "should allow range condition to be specified in array." do
-    XapitMember.xapit { |i| i.field :foo }
-    expected = Xapian::Query.new(Xapian::Query::OP_OR,
-      Xapian::Query.new(Xapian::Query::OP_VALUE_RANGE, 0, Xapian.sortable_serialise(2), Xapian.sortable_serialise(5)),
-      Xapian::Query.new(Xapian::Query::OP_AND, ["Xfoo-10"])
-    )
-    parser = Xapit::AbstractQueryParser.new(XapitMember, :conditions => { :foo => [2..5, 10] })
-    parser.condition_terms.first.xapian_query.description.should == expected.description
-  end
-    
-  it "should expand punctuated terms properly" do
-    XapitMember.xapit { |i| i.field :name }
-    bar = XapitMember.new(:name => "foo-bar")
-    baz = XapitMember.new(:name => "foo-baz")
-    zap = XapitMember.new(:name => "foo-zap")
-    Xapit.index_all
-    XapitMember.search(:conditions => { :name => "foo-b*"}).should == [bar, baz]
-  end
-end

data/spec/xapit/query_parsers/classic_query_parser_spec.rb

@@ -1,20 +0,0 @@
-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
-    Xapit::Config.writable_database # just so a database exists
-    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
-  
-  it "should remove asterisks from terms with one letter" do
-    @parser.cleanup_text("J*").should == "J"
-  end
-end

data/spec/xapit/query_parsers/simple_query_parser_spec.rb

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

data/spec/xapit/query_spec.rb

@@ -1,60 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Xapit::Query do
-  it "should use query passed in" do
-    expected = Xapian::Query.new(Xapian::Query::OP_AND, ["foo bar"])
-    query = Xapit::Query.new(expected)
-    query.xapian_query.should == expected
-  end
-  
-  it "should build a query from a string parameter" do
-    expected = Xapian::Query.new(Xapian::Query::OP_AND, ["foo bar"])
-    query = Xapit::Query.new("foo bar")
-    query.xapian_query.description.should == expected.description
-  end
-  
-  it "should build a query from an array of strings" do
-    expected = Xapian::Query.new(Xapian::Query::OP_AND, %w[foo bar])
-    query = Xapit::Query.new(%w[foo bar])
-    query.xapian_query.description.should == expected.description
-  end
-  
-  it "should build a query from an array of strings with :or operator" do
-    expected = Xapian::Query.new(Xapian::Query::OP_OR, %w[foo bar])
-    query = Xapit::Query.new(%w[foo bar], :or)
-    query.xapian_query.description.should == expected.description
-  end
-  
-  it "should AND two queries together" do
-    expected = Xapian::Query.new(Xapian::Query::OP_AND,
-      Xapian::Query.new(Xapian::Query::OP_AND, ["foo"]),
-      Xapian::Query.new(Xapian::Query::OP_AND, ["bar"])
-    )
-    query = Xapit::Query.new("foo")
-    query.and_query("bar").xapian_query.description.should == expected.description
-  end
-  
-  it "should OR two queries together" do
-    expected = Xapian::Query.new(Xapian::Query::OP_OR,
-      Xapian::Query.new(Xapian::Query::OP_AND, ["foo"]),
-      Xapian::Query.new(Xapian::Query::OP_AND, ["bar"])
-    )
-    query = Xapit::Query.new("foo")
-    query.or_query("bar").xapian_query.description.should == expected.description
-  end
-  
-  it "should build a query from an array of mixed strings and queries" do
-    expected = Xapian::Query.new(Xapian::Query::OP_AND,
-      Xapian::Query.new(Xapian::Query::OP_AND, ["foo"]),
-      Xapian::Query.new(Xapian::Query::OP_AND, ["bar"])
-    )
-    query = Xapit::Query.new([Xapit::Query.new("foo"), Xapian::Query.new(Xapian::Query::OP_AND, ["bar"])])
-    query.xapian_query.description.should == expected.description
-  end
-  
-  it "should use xapit query passed in" do
-    expected = Xapian::Query.new(Xapian::Query::OP_AND, ["foo bar"])
-    query = Xapit::Query.new(Xapit::Query.new("foo bar"))
-    query.xapian_query.description.should == expected.description
-  end
-end

data/tasks/spec.rb

@@ -1,9 +0,0 @@
-require 'spec/rake/spectask'
-
-spec_files = Rake::FileList["spec/**/*_spec.rb"]
-
-desc "Run specs"
-Spec::Rake::SpecTask.new do |t|
-  t.spec_files = spec_files
-  t.spec_opts = ["-c"]
-end

data/tasks/xapit.rake

@@ -1 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../lib/xapit/rake_tasks')

data/uninstall.rb

@@ -1,5 +0,0 @@
-path = "#{Rails.root}/config/initializers/setup_xapit.rb"
-if File.exist? path
-  puts "Removing setup_xapit.rb initializer."
-  File.delete(path)
-end

data/xapit.gemspec

@@ -1,30 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{xapit}
-  s.version = "0.2.7"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Ryan Bates"]
-  s.date = %q{2009-07-07}
-  s.description = %q{Ruby library for interacting with Xapian, a full text search engine.}
-  s.email = %q{ryan (at) railscasts (dot) com}
-  s.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"]
-  s.files = ["CHANGELOG", "features/facets.feature", "features/finding.feature", "features/indexing.feature", "features/sorting.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", "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"]
-  s.homepage = %q{http://github.com/ryanb/xapit}
-  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Xapit", "--main", "README.rdoc"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{xapit}
-  s.rubygems_version = %q{1.3.3}
-  s.summary = %q{Ruby library for interacting with Xapian, a full text search engine.}
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
-end