xapit 0.2.7 → 0.3.0

data/features/finding.feature

@@ -1,138 +1,196 @@
-Background:
-  Given an empty database at "tmp/xapiandatabase"
-
-Scenario: Query Matching No Records
-  Given indexed records named "John, Jane"
-  When I query for "Sam"
-  Then I should find 0 records
-
-Scenario: Query Matching One Record
-  Given indexed records named "John, Jane"
-  When I query for "John"
-  Then I should find record named "John"
-
-Scenario: Query Matching Two Records
-  Given indexed records named "John Smith, Jane Smith, John Smithsonian"
-  When I query for "Smith"
-  Then I should find records named "John Smith, Jane Smith"
-
-Scenario: Query Field Matching
-  Given the following indexed records
-    | name | age |
-    | John | 23  |
-    | Jane | 17  |
-    | Jack | 17  |
-  When I query "age" matching "17"
-  Then I should find records named "Jane, Jack"
-
-Scenario: Query for Page 1
-  Given 3 indexed records
-  When I query page 1 at 2 per page
-  Then I should find 2 records
-
-Scenario: Query for Page 2
-  Given 3 indexed records
-  When I query page 2 at 2 per page
-  Then I should find 1 record
-  And I should have 3 records total
-
-Scenario: Query for All Records Class Agnostic
-  Given indexed records named "John, Jane"
-  When I query for "John" on Xapit
-  Then I should find 1 record
-
-Scenario: Query Matching Or Query
-  Given indexed records named "John, Jane, Jacob"
-  When I query for "Jane OR John"
-  Then I should find records named "John, Jane"
-
-Scenario: Query Matching Not Query
-  Given indexed records named "John Smith, John Johnson"
-  When I query for "John NOT Smith"
-  Then I should find records named "John Johnson"
-
-Scenario: Unicode characters in search
-  Given indexed records named "über cool, uber hot"
-  When I query for "über"
-  Then I should find records named "über cool"
-
-Scenario: Query Field Not Matching
-  Given the following indexed records
-    | name | age |
-    | John | 23  |
-    | Jane | 17  |
-    | Jack | 17  |
-  When I query "age" not matching "17"
-  Then I should find records named "John"
-
-Scenario: Query Range of Integer
-  Given the following indexed records
-    | name | age |
-    | John | 8   |
-    | Jane | 13  |
-    | Jack | 24  |
-  When I query "age" between 8 and 15
-  Then I should find records named "John, Jane"
-
-Scenario: Query Partial Match on Condition
-  Given the following indexed records
-    | name | sirname  |
-    | John | Jacobson |
-    | Jane | Niel     |
-    | Jack | Striker  |
-  When I query "name" matching "Ja*"
-  Then I should find records named "Jane, Jack"
-
-Scenario: Query no partial match on conditions with one letter
-  Given the following indexed records
-    | name | sirname  |
-    | John | Jacobson |
-    | Jane | Niel     |
-    | Jack | Striker  |
-  When I query "name" matching " J*"
-  Then I should find 0 records
-
-Scenario: Query partial match in keywords
-  Given the following indexed records
-    | name | sirname  |
-    | John | Jacobson |
-    | Bill | Niel     |
-    | Jack | Striker  |
-  When I query for "Ja*"
-  Then I should find records named "John, Jack"
-
-Scenario: Query no partial match in keywords with one letter
-  Given the following indexed records
-    | name | sirname  |
-    | John | Jacobson |
-    | Bill | Niel     |
-    | Jack | J        |
-  When I query for " J*"
-  Then I should find records named "Jack"
-
-Scenario: Query for separate OR conditions
-  Given the following indexed records
-    | name | age |
-    | John | 23  |
-    | Jane | 17  |
-    | Jack | 18  |
-  When I query "age" matching "17" or "name" matching "Jack"
-  Then I should find records named "Jane, Jack"
-
-Scenario: Query for condition in keywords string
-  Given the following indexed records
-    | name | age |
-    | John | 23  |
-    | Jane | 17  |
-    | Jack | 17  |
-  When I query for "age:17"
-  Then I should find records named "Jane, Jack"
-
-Scenario: Query for separate OR conditions and keywords
-  Given the following indexed records
-    | name | age |
-    | John | 23  |
-    | Jane | 17  |
-    | Jack | 18  |
-  When I query for "John" or "age" matching "18" ordered by "name"
-  Then I should find records named "Jack, John"
+Feature: Finding
+
+  Scenario: Query Matching No Records
+    Given indexed records named "John, Jane"
+    When I query for "Sam"
+    Then I should find 0 records
+
+  Scenario: Query Matching One Record
+    Given indexed records named "John, Jane"
+    When I query for "John"
+    Then I should find record named "John"
+
+  Scenario: Query Matching Two Records
+    Given indexed records named "John Smith, Jane Smith, John Smithsonian"
+    When I query for "Smith"
+    Then I should find records named "John Smith, Jane Smith"
+
+  Scenario: Query for All Records Class Agnostic
+    Given indexed records named "John, Jane"
+    When I query for "John" on Xapit
+    Then I should find 1 record
+
+  Scenario: Query Field Matching
+    Given the following indexed records
+      | name | age |
+      | John | 23  |
+      | Jane | 17  |
+      | Jack | 17  |
+    When I query "age" matching "17"
+    Then I should find records named "Jane, Jack"
+
+  Scenario: Query Text and Field Matching
+    Given the following indexed records
+      | name | age |
+      | Jane | 23  |
+      | Jane | 17  |
+      | Jack | 17  |
+    When I query for "Jane" and "age" matching "17"
+    Then I should find records named "Jane"
+
+  Scenario: Query Field Not Matching
+    Given the following indexed records
+      | name | age |
+      | John | 23  |
+      | Jane | 17  |
+      | Jack | 17  |
+    When I query "age" not matching "17"
+    Then I should find records named "John"
+
+  Scenario: Query for separate OR conditions
+    Given the following indexed records
+      | name | age |
+      | John | 23  |
+      | Jane | 17  |
+      | Jack | 18  |
+    When I query "age" matching "17" or "name" matching "Jack"
+    Then I should find records named "Jane, Jack"
+
+  Scenario: Query Matching Or Query
+    Given indexed records named "John, Jane, Jacob"
+    When I query for "Jane OR John"
+    Then I should find records named "John, Jane"
+
+  Scenario: Query Matching Not Query
+    Given indexed records named "John Smith, John Johnson"
+    When I query for "John NOT Smith"
+    Then I should find records named "John Johnson"
+
+  Scenario: Unicode characters in search
+    Given indexed records named "über cool, uber hot"
+    When I query for "über"
+    Then I should find records named "über cool"
+
+  Scenario: Query for All Records Sorted by Name
+    Given indexed records named "Zebra, Apple, Banana"
+    When I query "" sorted by name
+    Then I should find records named "Apple, Banana, Zebra"
+
+  Scenario: Query for All Records Sorted by Age then Name
+    Given the following indexed records
+      | name   | age |
+      | Banana | 23  |
+      | Zebra  | 17  |
+      | Apple  | 17  |
+    When I query "" sorted by age, name
+    Then I should find records named "Apple, Zebra, Banana"
+
+  Scenario: Query for All Records Sorted by Name Descending
+    Given indexed records named "Zebra, Apple, Banana"
+    When I query "" sorted by name descending
+    Then I should find records named "Zebra, Banana, Apple"
+
+  Scenario: Query for Records Sorted Numerically
+    Given the following indexed records
+      | name   | age |
+      | Banana | 9   |
+      | Zebra  | 10  |
+    When I query "" sorted by age, name
+    Then I should find records named "Banana, Zebra"
+
+  Scenario: Query for Page 1
+    Given 3 indexed records
+    When I query page 1 at 2 per page
+    Then I should find 2 records
+
+  Scenario: Query for Page 2
+    Given 3 indexed records
+    When I query page 2 at 2 per page
+    Then I should find 1 record
+    And I should have 3 records total
+
+  Scenario: Query Range of Integer
+    Given the following indexed records
+      | name | age |
+      | John | 8   |
+      | Jane | 13  |
+      | Jack | 24  |
+    When I query "age" between 8 and 15
+    Then I should find records named "John, Jane"
+
+  Scenario: Query for condition in keywords string
+    Given the following indexed records
+      | name | age |
+      | John | 23  |
+      | Jane | 17  |
+      | Jack | 17  |
+    When I query for "age:17"
+    Then I should find records named "Jane, Jack"
+
+  Scenario: Query for separate OR conditions and keywords
+    Given the following indexed records
+      | name | age |
+      | John | 23  |
+      | Jane | 17  |
+      | Jack | 18  |
+    When I query for "John" or "age" matching "18" ordered by "name"
+    Then I should find records named "Jack, John"
+
+
+  Scenario: Query partial match in keywords
+    Given the following indexed records
+      | name | sirname  |
+      | John | Jacobson |
+      | Bill | Niel     |
+      | Jack | Striker  |
+    When I query for "Ja*"
+    Then I should find records named "John, Jack"
+
+  Scenario: Query no partial match in keywords with one letter
+    Given the following indexed records
+      | name | sirname  |
+      | John | Jacobson |
+      | Bill | Niel     |
+      | Jack | J        |
+    When I query for "J*"
+    Then I should find records named "Jack"
+
+  Scenario: Query no stemming
+    Given indexed records named "runs, sat, sits"
+    And no stemming
+    When I query for "run"
+    Then I should find 0 records
+
+  Scenario: Query with stemming by default
+    Given indexed records named "runs, sat, sits"
+    When I query for "run"
+    Then I should find records named "runs"
+
+  Scenario: Query ignore punctuation in keyword
+    Given the following indexed records
+      | name | sirname    |
+      | Jack | John-son's |
+      | Bill | Johnsons   |
+      | Jane | Johnson    |
+    When I query for "Johnsons"
+    Then I should find records named "Jack, Bill"
+    When I query for "Jo-hn'sons"
+    Then I should find records named "Jack, Bill"
+
+  # Scenario: Query Partial Match on Condition
+  #   Given the following indexed records
+  #     | name | sirname  |
+  #     | John | Jacobson |
+  #     | Jane | Niel     |
+  #     | Jack | Striker  |
+  #   When I query "name" matching "Ja*"
+  #   Then I should find records named "Jane, Jack"
+  #
+  # Scenario: Query no partial match on conditions with one letter
+  #   Given the following indexed records
+  #     | name | sirname  |
+  #     | John | Jacobson |
+  #     | Jane | Niel     |
+  #     | Jack | Striker  |
+  #   When I query "name" matching " J*"
+  #   Then I should find 0 records

data/features/indexing.feature

@@ -1,41 +1,39 @@
-Scenario: Save xapian database on index
-  Given no file exists at "tmp/xapiandb"
-  And I configured the database to be saved at "tmp/xapiandb"
-  And 3 records
-  When I index the database
-  Then I should find a directory at "tmp/xapiandb"
+Feature: Indexing
 
-Scenario: Fetch all records which are indexed
-  Given an empty database at "tmp/xapiandb"
-  And records named "John, Jane, Joe"
-  When I index the database
-  And I query for ""
-  Then I should find records named "John, Jane, Joe"
+  Scenario: Save xapian database on index
+    Given no file exists at "tmp/testdb"
+    And an empty database at "tmp/testdb"
+    And 3 records
+    When I index the database
+    Then I should find a directory at "tmp/testdb"
 
-Scenario: Split indexed text fields differently
-  Given an empty database at "tmp/xapiandb"
-  And records named "JohnXSmith, JaneXSmith, JoeXBlack"
-  When I index the database splitting name by "X"
-  And I query for "Smith"
-  Then I should find records named "JohnXSmith, JaneXSmith"
+  Scenario: Fetch all records which are indexed
+    And records named "John, Jane, Joe"
+    When I index the database
+    And I query for ""
+    Then I should find records named "John, Jane, Joe"
 
-Scenario: Index Multiple Field Values Separately
-  Given an empty database at "tmp/xapiandatabase"
-  And the following indexed records
-    | name | age    |
-    | John | 17, 16 |
-    | Jack | 17     |
-    | Jane | 16     |
-  When I query "age" matching "16"
-  Then I should find records named "Jane, John"
+  Scenario: Index Multiple Field Values Separately
+    And the following indexed records
+      | name | age    |
+      | John | 17, 16 |
+      | Jack | 17     |
+      | Jane | 16     |
+    When I query "age" matching "16"
+    Then I should find records named "Jane, John"
 
-Scenario: Index Weighted Attributes
-  Given an empty database at "tmp/xapiandatabase"
-  And the following indexed records with "name" weighted by "10"
-    | name | description |
-    | foo  | bar         |
-    | bar  | foo         |
-  When I query for "bar"
-  Then I should find records named "bar, foo"
-  When I query for "foo"
-  Then I should find records named "foo, bar"
+  Scenario: Index Weighted Attributes
+    And the following indexed records with "name" weighted by "10"
+      | name | description |
+      | foo  | bar         |
+      | bar  | foo         |
+    When I query for "bar"
+    Then I should find records named "bar, foo"
+    When I query for "foo"
+    Then I should find records named "foo, bar"
+
+  Scenario: Split indexed text fields differently
+    And records named "JohnXSmith, JaneXSmith, JoeXBlack"
+    When I index the database splitting name by "X"
+    And I query for "Smith"
+    Then I should find records named "JohnXSmith, JaneXSmith"

data/features/remote_server.feature

@@ -0,0 +1,10 @@
+# Feature: Remote Server
+#
+#   Background:
+#     Given a remote database
+#
+#   Scenario: Basic index and search
+#     Given records named "John Smith, John Doe, Jane, Joe"
+#     When I index the database
+#     And I query for "John"
+#     Then I should find records named "John Smith, John Doe"

data/features/step_definitions/xapit_steps.rb

@@ -1,11 +1,27 @@
-Given /^I configured the database to be saved at "([^\"]*)"$/ do |path|
-  Xapit.setup(:database_path => File.dirname(__FILE__) + "/../../#{path}")
+Given /^an empty database at "([^\"]*)"$/ do |path|
+  path = File.expand_path("../../../#{path}", __FILE__)
+  template = File.expand_path("../../../spec/fixtures/blankdb", __FILE__)
+  FileUtils.rm_rf(path) if File.exist? path
+  FileUtils.cp_r(template, path)
+  Xapit.config[:database_path] = path
+  XapitMember.delete_all
+  GC.start
 end
 
-Given /^an empty database at "([^\"]*)"$/ do |path|
-  Xapit.setup(:database_path => File.dirname(__FILE__) + "/../../#{path}")
-  Xapit.remove_database
+Given /^a remote database$/ do
+  $server = IO.popen("rackup spec/fixtures/xapit.ru -p 9797") if $server.nil?
+  Xapit.reset_config
+  Xapit.config[:server] = "http://localhost:9797"
   XapitMember.delete_all
+  sleep 5
+end
+
+Given /^no stemming$/ do
+  Xapit.config[:stemming] = nil
+end
+
+Given /^spelling is enabled$/ do
+  Xapit.config[:spelling] = true
 end
 
 Given /^(indexed )?records? named "([^\"]*)"$/ do |indexed, joined_names|
@@ -32,14 +48,18 @@ Given /^the following indexed records with "([^\"]*)" weighted by "([^\"]*)"$/ d
 end
 
 When /^I index the database$/ do
-  Xapit.index_all
+  XapitMember.find_each do |member|
+    member.class.xapit_index_builder.add_document(member)
+  end
 end
 
 When /^I index the database splitting name by "([^\"]*)"$/ do |divider|
   XapitMember.xapit do |index|
     index.text(:name) { |name| name.split(divider) }
   end
-  Xapit.index_all
+  XapitMember.find_each do |member|
+    member.class.xapit_index_builder.add_document(member)
+  end
 end
 
 When /^I query for "([^\"]*)"$/ do |query|
@@ -51,51 +71,58 @@ When /^I query for "([^\"]*)" on Xapit$/ do |query|
 end
 
 When /^I query "([^\"]*)" with facets "([^\"]*)"$/ do |keywords, facets|
-  @records = XapitMember.search(keywords, :facets => facets)
+  @records = XapitMember.search(keywords).with_facets(facets)
 end
 
 Then /^I should find records? named "([^\"]*)"$/ do |joined_names|
-  @records.map(&:name).join(", ").should == joined_names
+  @records.map(&:name).join(", ").should eq(joined_names)
 end
 
 Then /^I should find ([0-9]+) records?$/ do |num|
-  @records.should have(num.to_i).records
+  @records.records.size.should eq(num.to_i)
 end
 
 Then /^I should have ([0-9]+) records? total$/ do |num|
-  @records.total_entries.should == num.to_i
+  @records.total_entries.should eq(num.to_i)
 end
 
 When /^I query "([^\"]*)" matching "([^\"]*)"$/ do |field, value|
-  @records = XapitMember.search(:conditions => { field.to_sym => value })
+  @records = XapitMember.search.where(field.to_sym => value)
+end
+
+When /^I query for "([^\"]*)" and "([^\"]*)" matching "([^\"]*)"$/ do |text, field, value|
+  @records = XapitMember.search(text).where(field.to_sym => value)
 end
 
 When /^I query "([^\"]*)" not matching "([^\"]*)"$/ do |field, value|
-  @records = XapitMember.search(:not_conditions => { field.to_sym => value })
+  @records = XapitMember.search.not_where(field.to_sym => value)
 end
 
 When /^I query "([^\"]*)" matching "([^\"]*)" or "([^\"]*)" matching "([^\"]*)"$/ do |field1, value1, field2, value2|
-  @records = XapitMember.search(:conditions => [{ field1.to_sym => value1 }, { field2.to_sym => value2 }])
+  @records = XapitMember.search.where(field1.to_sym => value1).or_where(field2.to_sym => value2)
 end
 
 When /^I query for "([^\"]*)" or "([^\"]*)" matching "([^\"]*)" ordered by "([^\"]*)"$/ do |keywords, field, value, order|
-  @records = XapitMember.search(keywords, :order => order).or_search(:conditions => { field.to_sym => value })
+  @records = XapitMember.search(keywords).order(order).or_where(field.to_sym => value)
 end
 
 When /^I query "([^\"]*)" between (\d+) and (\d+)$/ do |field, beginning, ending|
-  @records = XapitMember.search(:conditions => { field.to_sym => beginning.to_i..ending.to_i })
+  @records = XapitMember.search.where(field.to_sym => beginning.to_i..ending.to_i)
 end
 
 When /^I query page ([0-9]+) at ([0-9]+) per page$/ do |page, per_page|
-  @records = XapitMember.search(:page => page, :per_page => per_page.to_i)
+  @records = XapitMember.search.page(page).per(per_page)
 end
 
 When /^I query facets "([^\"]*)"$/ do |facets|
-  @records = XapitMember.search(:facets => facets)
+  @records = XapitMember.search.with_facets(facets)
 end
 
 When /^I query "([^\"]*)" sorted by (.*?)( descending)?$/ do |keywords, sort, descending|
-  @records = XapitMember.search(:order => sort.split(', '), :descending => descending)
+  @records = XapitMember.search
+  sort.split(', ').each do |sort|
+    @records = @records.order(sort, (descending ? :desc : :asc))
+  end
 end
 
 When /^I query for similar records for "([^\"]*)"$/ do |keywords|
@@ -106,28 +133,29 @@ Then /^I should have the following facets$/ do |facets_table|
   result = []
   @records.facets.each do |facet|
     facet.options.each do |option|
-      result << {
+      hash = {
         "facet" => facet.name,
         "option" => option.name,
         "count" => option.count.to_s
       }
+      hash["param"] = option.to_param if facets_table.headers.include? "param"
+      result << hash
     end
   end
-  result.should == facets_table.hashes # this is somewhat fragile because it depends on order of hash result
+  result.map(&:inspect).sort.should eq(facets_table.hashes.map(&:inspect).sort)
 end
 
 Then /^I should have the following applied facets$/ do |facets_table|
   result = []
   @records.applied_facet_options.each do |option|
     result << {
-      "facet" => option.facet.name,
+      "facet" => option.attribute.sub(/^(.)/) { |c| c.upcase }, # quick hack
       "option" => option.name
     }
   end
-  result.should == facets_table.hashes # this is somewhat fragile because it depends on order of hash result
+  result.map(&:inspect).sort.should eq(facets_table.hashes.map(&:inspect).sort)
 end
 
 Then /^I should have "([^\"]*)" as a spelling suggestion$/ do |term|
-  @records.spelling_suggestion.should == term
+  @records.spelling_suggestion.to_s.should eq(term)
 end
-