freelancing-god-riddle 0.9.8.1371.1

data/spec/functional/excerpt_spec.rb

@@ -0,0 +1,102 @@
+require 'spec/spec_helper'
+
+describe "Sphinx Excepts" do
+  before :each do
+    @client = Riddle::Client.new("localhost", 3313)
+  end
+  
+  it "should highlight a single word multiple times in a document" do
+    @client.excerpts(
+      :index  => "people",
+      :words  => "Mary",
+      :docs   => ["Mary, Mary, quite contrary."]
+    ).should == [
+      '<span class="match">Mary</span>, <span class="match">Mary</span>, quite contrary.'
+    ]
+  end
+  
+  it "should use specified word markers" do
+    @client.excerpts(
+      :index        => "people",
+      :words        => "Mary",
+      :docs         => ["Mary, Mary, quite contrary."],
+      :before_match => "<em>",
+      :after_match  => "</em>"
+    ).should == [
+      "<em>Mary</em>, <em>Mary</em>, quite contrary."
+    ]
+  end
+  
+  it "should separate matches that are far apart by an ellipsis by default" do
+    @client.excerpts(
+      :index        => "people",
+      :words        => "Pat",
+      :docs         => [
+        <<-SENTENCE
+This is a really long sentence written by Pat. It has to be over 256
+characters long, between keywords. But what is the keyword? Well, I 
+can't tell you just yet... wait patiently until we've hit the 256 mark.
+It'll take a bit longer than you think. We're probably just hitting the
+200 mark at this point. But I think we've now arrived - so I can tell
+you what the keyword is. I bet you're really interested in finding out,
+yeah? Excerpts are particularly riveting. This keyword, however, is
+not. It's just my name: Pat.
+        SENTENCE
+        ],
+      :before_match => "<em>",
+      :after_match  => "</em>"
+    ).should == [
+      <<-SENTENCE
+This is a really long sentence written by <em>Pat</em>. It has to be over 256
+characters long, between keywords. But what is the keyword?  &#8230;  interested in finding out,
+yeah? Excerpts are particularly riveting. This keyword, however, is
+not. It's just my name: <em>Pat</em>.
+      SENTENCE
+    ]
+  end
+  
+  it "should use the provided separator" do
+    @client.excerpts(
+      :index           => "people",
+      :words           => "Pat",
+      :docs            => [
+        <<-SENTENCE
+This is a really long sentence written by Pat. It has to be over 256
+characters long, between keywords. But what is the keyword? Well, I 
+can't tell you just yet... wait patiently until we've hit the 256 mark.
+It'll take a bit longer than you think. We're probably just hitting the
+200 mark at this point. But I think we've now arrived - so I can tell
+you what the keyword is. I bet you're really interested in finding out,
+yeah? Excerpts are particularly riveting. This keyword, however, is
+not. It's just my name: Pat.
+        SENTENCE
+        ],
+      :before_match    => "<em>",
+      :after_match     => "</em>",
+      :chunk_separator => " --- "
+    ).should == [
+      <<-SENTENCE
+This is a really long sentence written by <em>Pat</em>. It has to be over 256
+characters long, between keywords. But what is the keyword?  ---  interested in finding out,
+yeah? Excerpts are particularly riveting. This keyword, however, is
+not. It's just my name: <em>Pat</em>.
+      SENTENCE
+    ]
+  end
+  
+  it "should return multiple results for multiple documents" do
+     @client.excerpts(
+        :index        => "people",
+        :words        => "Mary",
+        :docs         => [
+          "Mary, Mary, quite contrary.",
+          "The epithet \"Bloody Mary\" is associated with a number of historical and fictional women, most notably Queen Mary I of England"
+        ],
+        :before_match => "<em>",
+        :after_match  => "</em>"
+      ).should == [
+        "<em>Mary</em>, <em>Mary</em>, quite contrary.",
+        "The epithet \"Bloody <em>Mary</em>\" is associated with a number of historical and fictional women, most notably Queen <em>Mary</em> I of England"
+      ]
+  end
+end

data/spec/functional/keywords_spec.rb

@@ -0,0 +1,40 @@
+require 'spec/spec_helper'
+
+describe "Sphinx Keywords" do
+  before :each do
+    @client = Riddle::Client.new("localhost", 3313)
+  end
+  
+  it "should return an array of hashes" do
+    results = @client.keywords("pat", "people")
+    results.should be_kind_of(Array)
+    
+    results.each do |result|
+      result.should be_kind_of(Hash)
+    end
+  end
+  
+  it "should have keys for normalised and tokenised versions of the keywords" do
+    results = @client.keywords("pat", "people")
+    results.each do |result|
+      result.keys.should include(:normalised)
+      result.keys.should include(:tokenised)
+    end
+  end
+  
+  it "shouldn't have docs or hits keys if not requested" do
+    results = @client.keywords("pat", "people")
+    results.each do |result|
+      result.keys.should_not include(:docs)
+      result.keys.should_not include(:hits)
+    end
+  end
+  
+  it "should have docs and hits keys if requested" do
+    results = @client.keywords("pat", "people", true)
+    results.each do |result|
+      result.keys.should include(:docs)
+      result.keys.should include(:hits)
+    end
+  end
+end

data/spec/functional/search_spec.rb

@@ -0,0 +1,69 @@
+require 'spec/spec_helper'
+
+describe "Sphinx Searches" do
+  before :each do
+    @client = Riddle::Client.new("localhost", 3313)
+  end
+  
+  it "should return a single hash if a single query" do
+    @client.query("smith").should be_kind_of(Hash)
+  end
+  
+  it "should return an array of hashs if multiple queries are run" do
+    @client.append_query "smith"
+    @client.append_query "jones"
+    results = @client.run
+    results.should be_kind_of(Array)
+    results.each { |result| result.should be_kind_of(Hash) }
+  end
+  
+  it "should return an array of matches" do
+    matches = @client.query("smith")[:matches]
+    matches.should be_kind_of(Array)
+    matches.each { |match| match.should be_kind_of(Hash) }
+  end
+  
+  it "should return an array of string fields" do
+    fields = @client.query("smith")[:fields]
+    fields.should be_kind_of(Array)
+    fields.each { |field| field.should be_kind_of(String) }
+  end
+  
+  it "should return an array of attribute names" do
+    attributes = @client.query("smith")[:attribute_names]
+    attributes.should be_kind_of(Array)
+    attributes.each { |a| a.should be_kind_of(String) }
+  end
+  
+  it "should return a hash of attributes" do
+    attributes = @client.query("smith")[:attributes]
+    attributes.should be_kind_of(Hash)
+    attributes.each do |key,value|
+      key.should be_kind_of(String)
+      value.should be_kind_of(Integer)
+    end
+  end
+  
+  it "should return the total number of results returned" do
+    @client.query("smith")[:total].should be_kind_of(Integer)
+  end
+  
+  it "should return the total number of results available" do
+    @client.query("smith")[:total_found].should be_kind_of(Integer)
+  end
+  
+  it "should return the time taken for the query as a float" do
+    @client.query("smith")[:time].should be_kind_of(Float)
+  end
+  
+  it "should return a hash of the words from the query, with the number of documents and the number of hits" do
+    words = @client.query("smith victoria")[:words]
+    words.should be_kind_of(Hash)
+    words.each do |word,hash|
+      word.should be_kind_of(String)
+      hash.should be_kind_of(Hash)
+      hash[:docs].should be_kind_of(Integer)
+      hash[:hits].should be_kind_of(Integer)
+    end
+  end
+end

data/spec/functional/update_spec.rb

@@ -0,0 +1,41 @@
+require 'spec/spec_helper'
+
+describe "Sphinx Updates" do
+  before :each do
+    @client = Riddle::Client.new("localhost", 3313)
+  end
+  
+  it "should update a single record appropriately" do
+    # check existing birthday
+    result = @client.query("Ellie K Ford")
+    result[:matches].should_not be_empty
+    result[:matches].length.should == 1
+    ellie = result[:matches].first
+    ellie[:attributes]["birthday"].should == Time.local(1970, 1, 23).to_i
+    
+    # make Ellie younger by 6 years
+    @client.update("people", ["birthday"], {ellie[:doc] => [Time.local(1976, 1, 23).to_i]})
+    
+    # check attribute's value
+    result = @client.query("Ellie K Ford")
+    result[:matches].should_not be_empty
+    result[:matches].length.should == 1
+    ellie = result[:matches].first
+    ellie[:attributes]["birthday"].should == Time.local(1976, 1, 23).to_i
+  end
+  
+  it "should update multiple records appropriately" do
+    result = @client.query("Steele")
+    pairs = {}
+    result[:matches].each do |match|
+      pairs[match[:doc]] = [match[:attributes]["birthday"] + (365*24*60*60)]
+    end
+    
+    @client.update "people", ["birthday"], pairs
+    
+    result = @client.query("Steele")
+    result[:matches].each do |match|
+      match[:attributes]["birthday"].should == pairs[match[:doc]].first
+    end
+  end
+end

data/spec/unit/client_spec.rb

@@ -0,0 +1,194 @@
+require 'spec/spec_helper'
+
+describe Riddle::Client do
+  it "should have the same keys for both commands and versions" do
+    Riddle::Client::Commands.keys.should == Riddle::Client::Versions.keys
+  end
+  
+  it "should default to localhost as the server" do
+    Riddle::Client.new.server.should == "localhost"
+  end
+  
+  it "should default to port 3312" do
+    Riddle::Client.new.port.should == 3312
+  end
+  
+  it "should translate anchor arguments correctly" do
+    client = Riddle::Client.new
+    client.set_anchor "latitude", 10.0, "longitude", 95.0
+    client.anchor.should == {
+      :latitude_attribute   => "latitude",
+      :latitude             => 10.0,
+      :longitude_attribute  => "longitude",
+      :longitude            => 95.0
+    }
+  end
+  
+  it "should add queries to the queue" do
+    client = Riddle::Client.new
+    client.queue.should be_empty
+    client.append_query "spec"
+    client.queue.should_not be_empty
+  end
+  
+  it "should build a basic search message correctly" do
+    client = Riddle::Client.new
+    client.append_query "test "
+    client.queue.first.should == query_contents(:simple)
+  end
+  
+  it "should build a message with a specified index correctly" do
+    client = Riddle::Client.new
+    client.append_query "test ", "edition"
+    client.queue.first.should == query_contents(:index)
+  end
+  
+  it "should build a message using match mode :any correctly" do
+    client = Riddle::Client.new
+    client.match_mode = :any
+    client.append_query "test this "
+    client.queue.first.should == query_contents(:any)
+  end
+  
+  it "should build a message using sort by correctly" do
+    client = Riddle::Client.new
+    client.sort_by = 'id'
+    client.sort_mode = :extended
+    client.append_query "testing "
+    client.queue.first.should == query_contents(:sort)
+  end
+  
+  it "should build a message using match mode :boolean correctly" do
+    client = Riddle::Client.new
+    client.match_mode = :boolean
+    client.append_query "test "
+    client.queue.first.should == query_contents(:boolean)
+  end
+  
+  it "should build a message using match mode :phrase correctly" do
+    client = Riddle::Client.new
+    client.match_mode = :phrase
+    client.append_query "testing this "
+    client.queue.first.should == query_contents(:phrase)
+  end
+  
+  it "should build a message with a filter correctly" do
+    client = Riddle::Client.new
+    client.filters << Riddle::Client::Filter.new("id", [10, 100, 1000])
+    client.append_query "test "
+    client.queue.first.should == query_contents(:filter)
+  end
+  
+  it "should build a message with group values correctly" do
+    client = Riddle::Client.new
+    client.group_by       = "id"
+    client.group_function = :attr
+    client.group_clause   = "id"
+    client.append_query "test "
+    client.queue.first.should == query_contents(:group)
+  end
+  
+  it "should build a message with group distinct value correctly" do
+    client = Riddle::Client.new
+    client.group_distinct = "id"
+    client.append_query "test "
+    client.queue.first.should == query_contents(:distinct)
+  end
+  
+  it "should build a message with weights correctly" do
+    client = Riddle::Client.new
+    client.weights = [100, 1]
+    client.append_query "test "
+    client.queue.first.should == query_contents(:weights)
+  end
+  
+  it "should build a message with an anchor correctly" do
+    client = Riddle::Client.new
+    client.set_anchor "latitude", 10.0, "longitude", 95.0
+    client.append_query "test "
+    client.queue.first.should == query_contents(:anchor)
+  end
+  
+  it "should build a message with index weights correctly" do
+    client = Riddle::Client.new
+    client.index_weights = {"people" => 101}
+    client.append_query "test "
+    client.queue.first.should == query_contents(:index_weights)
+  end
+  
+  it "should build a message with field weights correctly" do
+    client = Riddle::Client.new
+    client.field_weights = {"city" => 101}
+    client.append_query "test "
+    client.queue.first.should == query_contents(:field_weights)
+  end
+  
+  it "should build a message with acomment correctly" do
+    client = Riddle::Client.new
+    client.append_query "test ", "*", "commenting"
+    client.queue.first.should == query_contents(:comment)
+  end
+  
+  it "should keep multiple messages in the queue" do
+    client = Riddle::Client.new
+    client.weights = [100, 1]
+    client.append_query "test "
+    client.append_query "test "
+    client.queue.length.should == 2
+    client.queue.each { |item| item.should == query_contents(:weights) }
+  end
+  
+  it "should keep multiple messages in the queue with different params" do
+    client = Riddle::Client.new
+    client.weights = [100, 1]
+    client.append_query "test "
+    client.weights = []
+    client.append_query "test ", "edition"
+    client.queue.first.should == query_contents(:weights)
+    client.queue.last.should  == query_contents(:index)
+  end
+  
+  it "should build a basic update message correctly" do
+    client = Riddle::Client.new
+    client.send(
+      :update_message,
+      "people",
+      ["birthday"],
+      {1 => [191163600]}
+    ).should == query_contents(:update_simple)
+  end
+  
+  it "should build a keywords request without hits correctly" do
+    client = Riddle::Client.new
+    client.send(
+      :keywords_message,
+      "pat",
+      "people",
+      false
+    ).should == query_contents(:keywords_without_hits)
+  end
+  
+  it "should build a keywords request with hits correctly" do
+    client = Riddle::Client.new
+    client.send(
+      :keywords_message,
+      "pat",
+      "people",
+      true
+    ).should == query_contents(:keywords_with_hits)
+  end
+  
+  it "should timeout after a specified time" do
+    client = Riddle::Client.new
+    client.port     = 3314
+    client.timeout  = 1
+    
+    server = TCPServer.new "localhost", 3314
+    
+    lambda {
+      client.send(:connect) { |socket| }
+    }.should raise_error(Riddle::ConnectionError)
+    
+    server.close
+  end
+end

data/spec/unit/filter_spec.rb

@@ -0,0 +1,33 @@
+require 'spec/spec_helper'
+
+describe Riddle::Client::Filter do
+  it "should render a filter that uses an array of ints correctly" do
+    filter = Riddle::Client::Filter.new("field", [1, 2, 3])
+    filter.query_message.should == query_contents(:filter_array)
+  end
+  
+  it "should render a filter that has exclude set correctly" do
+    filter = Riddle::Client::Filter.new("field", [1, 2, 3], true)
+    filter.query_message.should == query_contents(:filter_array_exclude)
+  end
+  
+  it "should render a filter that is a range of ints correctly" do
+    filter = Riddle::Client::Filter.new("field", 1..3)
+    filter.query_message.should == query_contents(:filter_range)
+  end
+  
+  it "should render a filter that is a range of ints as exclude correctly" do
+    filter = Riddle::Client::Filter.new("field", 1..3, true)
+    filter.query_message.should == query_contents(:filter_range_exclude)
+  end
+  
+  it "should render a filter that is a range of floats correctly" do
+    filter = Riddle::Client::Filter.new("field", 5.4..13.5)
+    filter.query_message.should == query_contents(:filter_floats)
+  end
+  
+  it "should render a filter that is a range of floats as exclude correctly" do
+    filter = Riddle::Client::Filter.new("field", 5.4..13.5, true)
+    filter.query_message.should == query_contents(:filter_floats_exclude)
+  end
+end

data/spec/unit/message_spec.rb

@@ -0,0 +1,63 @@
+require 'spec/spec_helper'
+
+describe Riddle::Client::Message do
+  it "should start with an empty string" do
+    Riddle::Client::Message.new.to_s.should == ""
+  end
+  
+  it "should append raw data correctly" do
+    data = [1, 2, 3].pack('NNN')
+    message = Riddle::Client::Message.new
+    message.append data
+    message.to_s.should == data
+  end
+  
+  it "should append strings correctly - with length first" do
+    str = "something to test with"
+    message = Riddle::Client::Message.new
+    message.append_string str
+    message.to_s.should == [str.length].pack('N') + str
+  end
+  
+  it "should append integers correctly - packed with N" do
+    message = Riddle::Client::Message.new
+    message.append_int 234
+    message.to_s.should == [234].pack('N')
+  end
+  
+  it "should append floats correctly - packed with f" do
+    message = Riddle::Client::Message.new
+    message.append_float 1.4
+    message.to_s.should == [1.4].pack('f').unpack('L*').pack('N')
+  end
+  
+  it "should append a collection of integers correctly" do
+    message = Riddle::Client::Message.new
+    message.append_ints 1, 2, 3, 4
+    message.to_s.should == [1, 2, 3, 4].pack('NNNN')
+  end
+  
+  it "should append a collection of floats correctly" do
+    message = Riddle::Client::Message.new
+    message.append_floats 1.0, 1.1, 1.2, 1.3
+    message.to_s.should == [1.0, 1.1, 1.2, 1.3].pack('ffff').unpack('L*L*L*L*').pack('NNNN')
+  end
+  
+  it "should append an array of strings correctly" do
+    arr = ["a", "bb", "ccc"]
+    message = Riddle::Client::Message.new
+    message.append_array arr
+    message.to_s.should == [3, 1].pack('NN') + "a" + [2].pack('N') + "bb" +
+      [3].pack('N') + "ccc"
+  end
+  
+  it "should append a variety of objects correctly" do
+    message = Riddle::Client::Message.new
+    message.append_int 4
+    message.append_string "test"
+    message.append_array ["one", "two"]
+    message.append_floats 1.5, 1.7
+    message.to_s.should == [4, 4].pack('NN') + "test" + [2, 3].pack('NN') +
+      "one" + [3].pack('N') + "two" + [1.5, 1.7].pack('ff').unpack('L*L*').pack('NN')
+  end
+end

data/spec/unit/response_spec.rb

@@ -0,0 +1,64 @@
+require 'spec/spec_helper'
+
+describe Riddle::Client::Response do
+  it "should interpret an integer correctly" do
+    Riddle::Client::Response.new([42].pack('N')).next_int.should == 42
+  end
+  
+  it "should interpret a string correctly" do
+    str = "this is a string"
+    Riddle::Client::Response.new(
+      [str.length].pack('N') + str
+    ).next.should == str
+  end
+  
+  # Comparing floats with decimal places doesn't seem to be exact
+  it "should interpret a float correctly" do
+    Riddle::Client::Response.new([1.0].pack('f').unpack('L*').pack('N')).next_float.should == 1.0
+  end
+  
+  it "should interpret an array of strings correctly" do
+    arr = ["a", "b", "c", "d"]
+    Riddle::Client::Response.new(
+      [arr.length].pack('N') + arr.collect { |str|
+        [str.length].pack('N') + str
+      }.join("")
+    ).next_array.should == arr
+  end
+  
+  it "should interpret an array of ints correctly" do
+    arr = [1, 2, 3, 4]
+    Riddle::Client::Response.new(
+      [arr.length].pack('N') + arr.collect { |int|
+        [int].pack('N')
+      }.join("")
+    ).next_int_array.should == arr
+  end
+  
+  it "should reflect the length of the incoming data correctly" do
+    data = [1, 2, 3, 4].pack('NNNN')
+    Riddle::Client::Response.new(data).length.should == data.length
+  end
+  
+  it "should handle a combination of strings and ints correctly" do
+    data = [1, 3, 5, 1].pack('NNNN') + 'a' + [2, 4].pack('NN') + 'test'
+    response = Riddle::Client::Response.new(data)
+    response.next_int.should == 1
+    response.next_int.should == 3
+    response.next_int.should == 5
+    response.next.should == 'a'
+    response.next_int.should == 2
+    response.next.should == 'test'
+  end
+  
+  it "should handle a combination of strings, ints, floats and string arrays correctly" do
+    data = [1, 2, 2].pack('NNN') + 'aa' + [2].pack('N') + 'bb' + [4].pack('N') +
+      "word" + [7].pack('f').unpack('L*').pack('N') + [3, 2, 2, 2].pack('NNNN')
+    response = Riddle::Client::Response.new(data)
+    response.next_int.should == 1
+    response.next_array.should == ['aa', 'bb']
+    response.next.should == "word"
+    response.next_float.should == 7
+    response.next_int_array.should == [2, 2, 2]
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: freelancing-god-riddle
+version: !ruby/object:Gem::Version 
+  version: 0.9.8.1371.1
+platform: ruby
+authors: 
+- Pat Allan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-13 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: API for Sphinx, written in and for Ruby.
+email: pat@freelancing-gods.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/riddle/client/filter.rb
+- lib/riddle/client/message.rb
+- lib/riddle/client/response.rb
+- lib/riddle/client.rb
+- lib/riddle.rb
+- MIT-LICENCE
+- README
+has_rdoc: true
+homepage: http://riddle.freelancing-gods.com
+post_install_message: 
+rdoc_options: 
+- --title
+- Riddle -- Ruby Sphinx Client
+- --main
+- Riddle::Client
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: riddle
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: API for Sphinx, written in and for Ruby.
+test_files: 
+- spec/functional/excerpt_spec.rb
+- spec/functional/keywords_spec.rb
+- spec/functional/search_spec.rb
+- spec/functional/update_spec.rb
+- spec/unit/client_spec.rb
+- spec/unit/filter_spec.rb
+- spec/unit/message_spec.rb
+- spec/unit/response_spec.rb