gsolr_ext 0.12.3

data/lib/gsolr_ext/response/facets.rb

@@ -0,0 +1,58 @@
+module GSolr::Ext::Response::Facets
+  
+  # represents a facet value; which is a field value and its hit count
+  class FacetItem
+    attr_reader :value, :hits
+    def initialize value, hits
+      @value, @hits = value, hits
+    end
+  end
+  
+  # represents a facet; which is a field and its values
+  class FacetField
+    attr_reader :name, :items
+    def initialize name, items
+      @name, @items = name, items
+    end
+  end
+  
+  # @response.facets.each do |facet|
+  #   facet.name
+  #   facet.items
+  # end
+  # "caches" the result in the @facets instance var
+  def facets
+    @facets ||= (
+      facet_fields.map do |(facet_field_name,values_and_hits)|
+        items = []
+        (values_and_hits.size/2).times do |index|
+          items << FacetItem.new(values_and_hits[index*2], values_and_hits[index*2+1])
+        end
+        FacetField.new(facet_field_name, items)
+      end
+    )
+  end
+  
+  # pass in a facet field name and get back a Facet instance
+  def facet_by_field_name(name)
+    @facets_by_field_name ||= {}
+    @facets_by_field_name[name] ||= (
+      facets.detect{|facet|facet.name.to_s == name.to_s}
+    )
+  end
+  
+  def facet_counts
+    @facet_counts ||= self['facet_counts'] || {}
+  end
+
+  # Returns the hash of all the facet_fields (ie: {'instock_b' => ['true', 123, 'false', 20]}
+  def facet_fields
+    @facet_fields ||= facet_counts['facet_fields'] || {}
+  end
+
+  # Returns all of the facet queries
+  def facet_queries
+    @facet_queries ||= facet_counts['facet_queries'] || {}
+  end
+  
+end # end Facets

data/lib/gsolr_ext/response/spelling.rb

@@ -0,0 +1,92 @@
+# A mixin for making access to the spellcheck component data easy.
+#
+# response.spelling.words
+#
+module GSolr::Ext::Response::Spelling
+
+  def spelling
+    @spelling ||= Base.new(self)
+  end
+
+  class Base
+
+    attr :response
+
+    def initialize(response)
+      @response = response
+    end
+
+    # returns an array of spelling suggestion for specific query words,
+    # as provided in the solr response.  Only includes words with higher
+    # frequency of occurrence than word in original query.
+    # can't do a full query suggestion because we only get info for each word;
+    # combination of words may not have results.
+    # Thanks to Naomi Dushay!
+    def words
+      @words ||= (
+        word_suggestions = []
+        spellcheck = self.response[:spellcheck]
+        if spellcheck && spellcheck[:suggestions]
+          suggestions = spellcheck[:suggestions]
+          unless suggestions.nil?
+            # suggestions is an array:
+            #    (query term)
+            #    (hash of term info and term suggestion)
+            #    ...
+            #    (query term)
+            #    (hash of term info and term suggestion)
+            #    'correctlySpelled'
+            #    true/false
+            #    collation
+            #    (suggestion for collation)
+            if suggestions.index("correctlySpelled") #if extended results
+              i_stop = suggestions.index("correctlySpelled")
+            elsif suggestions.index("collation")
+              i_stop = suggestions.index("collation")
+            else
+              i_stop = suggestions.length
+            end
+              # step through array in 2s to get info for each term
+              0.step(i_stop-1, 2) do |i|
+                term = suggestions[i]
+                term_info = suggestions[i+1]
+                # term_info is a hash:
+                #   numFound =>
+                #   startOffset =>
+                #   endOffset =>
+                #   origFreq =>
+                #   suggestion =>  [{ frequency =>, word => }] # for extended results
+                #   suggestion => ['word'] # for non-extended results
+                origFreq = term_info['origFreq']
+                if suggestions.index("correctlySpelled")
+                  word_suggestions << term_info['suggestion'].map do |suggestion|
+                    suggestion['word'] if suggestion['freq'] > origFreq
+                  end
+                else
+                  # only extended suggestions have frequency so we just return all suggestions
+                  word_suggestions << term_info['suggestion']
+                end
+              end
+          end
+        end
+        word_suggestions.flatten.compact.uniq
+      )
+    end
+
+    def collation
+      # FIXME: DRY up with words
+      spellcheck = self.response[:spellcheck]
+        if spellcheck && spellcheck[:suggestions]
+          suggestions = spellcheck[:suggestions]
+          unless suggestions.nil?
+            if suggestions.index("collation")
+              suggestions[suggestions.index("collation") + 1]
+            end
+          end
+        end
+    end
+
+  end
+
+end
+

data/lib/mash.rb

@@ -0,0 +1,143 @@
+# This class has dubious semantics and we only have it so that people can write
+# params[:key] instead of params['key'].
+class Mash < Hash
+
+  # @param constructor<Object>
+  #   The default value for the mash. Defaults to an empty hash.
+  #
+  # @details [Alternatives]
+  #   If constructor is a Hash, a new mash will be created based on the keys of
+  #   the hash and no default value will be set.
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash) 
+      super() 
+      update(constructor) 
+    else 
+      super(constructor) 
+    end 
+  end
+
+  # @param key<Object> The default value for the mash. Defaults to nil.
+  #
+  # @details [Alternatives]
+  #   If key is a Symbol and it is a key in the mash, then the default value will
+  #   be set to the value matching the key.
+  def default(key = nil) 
+    if key.is_a?(Symbol) && include?(key = key.to_s) 
+      self[key] 
+    else 
+      super 
+    end 
+  end 
+ 
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer) 
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  # @param key<Object> The key to set.
+  # @param value<Object>
+  #   The value to set the key to.
+  #
+  # @see Mash#convert_key
+  # @see Mash#convert_value
+  def []=(key, value) 
+    regular_writer(convert_key(key), convert_value(value)) 
+  end
+
+  # @param other_hash<Hash>
+  #   A hash to update values in the mash with. The keys and the values will be
+  #   converted to Mash format.
+  #
+  # @return <Mash> The updated mash.
+  def update(other_hash) 
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) } 
+    self 
+  end 
+ 
+  alias_method :merge!, :update
+
+  # @param key<Object> The key to check for. This will be run through convert_key.
+  #
+  # @return <TrueClass, FalseClass> True if the key exists in the mash.
+  def key?(key) 
+    super(convert_key(key)) 
+  end 
+
+  # def include? def has_key? def member?
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  # @param key<Object> The key to fetch. This will be run through convert_key.
+  # @param *extras<Array> Default value.
+  #
+  # @return <Object> The value at key or the default value.
+  def fetch(key, *extras) 
+    super(convert_key(key), *extras) 
+  end
+
+  # @param *indices<Array>
+  #   The keys to retrieve values for. These will be run through +convert_key+.
+  #
+  # @return <Array> The values at each of the provided keys
+  def values_at(*indices) 
+    indices.collect {|key| self[convert_key(key)]} 
+  end
+
+  # @return <Mash> A duplicate of this mash.
+  def dup 
+    Mash.new(self) 
+  end
+
+  # @param hash<Hash> The hash to merge with the mash.
+  #
+  # @return <Mash> A new mash with the hash values merged in.
+  def merge(hash) 
+    self.dup.update(hash) 
+  end
+
+  # @param key<Object>
+  #   The key to delete from the mash.\
+  def delete(key) 
+    super(convert_key(key)) 
+  end
+
+  # Used to provide the same interface as Hash.
+  #
+  # @return <Mash> This mash unchanged.
+  def stringify_keys!; self end
+ 
+  # @return <Hash> The mash as a Hash with string keys.
+  def to_hash 
+    Hash.new(default).merge(self) 
+  end 
+ 
+  protected
+  # @param key<Object> The key to convert.
+  #
+  # @param <Object>
+  #   The converted key. If the key was a symbol, it will be converted to a
+  #   string.
+  #
+  # @api private
+  def convert_key(key) 
+    key.kind_of?(Symbol) ? key.to_s : key 
+  end
+
+  # @param value<Object> The value to convert.
+  #
+  # @return <Object>
+  #   The converted value. A Hash or an Array of hashes, will be converted to
+  #   their Mash equivalents.
+  #
+  # @api private
+  def convert_value(value) 
+    case value 
+    when Hash 
+      value.to_mash 
+    when Array 
+      value.collect { |e| convert_value(e) } 
+    else 
+      value 
+    end 
+  end
+end

data/spec/gsolr_ext_spec.rb

@@ -0,0 +1,276 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe GSolr::Ext do
+
+  context GSolr::Client do
+
+    let(:client){GSolr.connect}
+
+    it 'should now have a #find method' do
+      client.should respond_to(:find)
+    end
+
+    it 'should produce results from the #find method' do
+      c = client
+      c.should_receive(:request).
+        with('/select', {:rows=>10, :start=>20, :q=>"*:*"}).
+          and_return({'response'=>{'docs' => []}, 'responseHeader' => {}})
+      response = c.find :page=>3, :per_page=>10, :q=>'*:*'#, :page=>1, :per_page=>10
+      response.should be_a(Mash)
+    end
+
+    it 'should call the #find method with a custom request handler' do
+      c = client
+      expected_response = {'response'=>{'docs' => []}, 'responseHeader' => {}}
+      # ok this is hacky... the raw method needs to go into a mixin dude
+      def expected_response.raw
+        {:path => '/select'}
+      end
+      c.should_receive(:request).
+        with('/select', {:q=>'*:*'}).
+          and_return(expected_response)
+      response = c.find '/select', :q=>'*:*'
+      response.raw[:path].should match(/\/select/)
+    end
+
+    it 'should be ok' do
+      c = client
+      c.should_receive(:request).
+        with('/select', :q=>'*:*').
+          and_return({'response'=>{'docs' => []}, 'responseHeader' => {'status'=>0}})
+      response = c.find :q=>'*:*'
+      response.should respond_to(:ok?)
+      response.ok?.should == true
+    end
+
+    it 'should call the #luke method' do
+      c = client
+      c.should_receive(:request).
+        with('/admin/luke', {"numTerms"=>0}).
+          and_return({"fields"=>nil, "index"=>nil, "info" => nil})
+      info = c.luke
+      info.should be_a(Mash)
+      info.should have_key('fields')
+      info.should have_key('index')
+      info.should have_key('info')
+    end
+
+    it 'should forwad #ping? calls to the connection' do
+      client.connection.should_receive(:request).
+        with('/admin/ping', :wt => :ruby ).
+        and_return( :params => { :wt => :ruby },
+                    :status_code => 200,
+                    :body => "{'responseHeader'=>{'status'=>0,'QTime'=>44,'params'=>{'echoParams'=>'all','echoParams'=>'all','q'=>'solrpingquery','qt'=>'standard','wt'=>'ruby'}},'status'=>'OK'}" )
+      client.ping?
+    end
+
+    it 'should raise an error if the ping service is not available' do
+      client.connection.should_receive(:request).
+        with('/admin/ping', :wt => :ruby ).
+        # the first part of the what the message would really be
+        and_raise( GSolr::RequestError.new("Solr Response: pingQuery_not_configured_consider_registering_PingRequestHandler_with_the_name_adminping_instead__") )
+        lambda { client.ping? }.should raise_error( GSolr::RequestError )
+    end
+
+  end
+
+  context 'requests' do
+
+    it 'should create a valid request' do
+      solr_params = GSolr::Ext::Request.map(
+        :page=>'2',
+        :per_page=>'10',
+        :phrases=>{:name=>'This is a phrase'},
+        :filters=>['test', {:price=>(1..10)}],
+        :phrase_filters=>{:manu=>['Apple']},
+        :queries=>'ipod',
+        :facets=>{:fields=>['cat', 'blah']},
+        :spellcheck => true
+      )
+      ["test", "price:[1 TO 10]", "manu:\"Apple\""].should == solr_params[:fq]
+      solr_params[:start].should == 10
+      solr_params[:rows].should == 10
+      solr_params[:q].should == "ipod name:\"This is a phrase\""
+      solr_params['facet.field'].should == ['cat', 'blah']
+      solr_params[:facet].should == true
+    end
+
+    it 'should map fq using the phrase_filters mapping' do
+      solr_params = GSolr::Ext::Request.map(
+        :phrase_filters=>{:manu=>['Apple', 'ASG'], :color=>['red', 'blue']}
+      )
+
+      solr_params[:fq].size.should == 4
+      solr_params[:fq].should include("color:\"red\"")
+      solr_params[:fq].should include("color:\"blue\"")
+      solr_params[:fq].should include("manu:\"Apple\"")
+      solr_params[:fq].should include("manu:\"ASG\"")
+
+    end
+
+    it 'should map :filters and :phrase_filters while keeping an existing :fq' do
+      solr_params = GSolr::Ext::Request.map(
+        :fq => 'blah blah',
+        :phrase_filters=>{:manu=>['Apple', 'ASG'], :color=>['red', 'blue']}
+      )
+
+      solr_params[:fq].size.should == 5
+      solr_params[:fq].should include("blah blah")
+      solr_params[:fq].should include("color:\"red\"")
+      solr_params[:fq].should include("color:\"blue\"")
+      solr_params[:fq].should include("manu:\"Apple\"")
+      solr_params[:fq].should include("manu:\"ASG\"")
+    end
+
+    it 'should map arrays of ranges in :phrase_filters' do
+        solr_params = GSolr::Ext::Request.map(
+          :phrase_filters=>{:range=>[1940..2020]}
+        )
+
+        solr_params[:fq].size.should == 1
+        solr_params[:fq].should include("range:[1940 TO 2020]")
+    end
+
+  end
+
+  context 'response' do
+
+    def create_response
+      raw_response = eval(mock_query_response)
+      GSolr::Ext::Response::Base.new(raw_response, '/select', raw_response['params'])
+    end
+
+    it 'should create a valid response' do
+      r = create_response
+      r.should respond_to(:header)
+      r.ok?.should == true
+    end
+
+    it 'should have accurate pagination numbers' do
+      r = create_response
+      r.rows.should == 11
+      r.total.should == 26
+      r.start.should == 0
+      r.docs.per_page.should == 11
+    end
+
+    it 'should create a valid response class' do
+      r = create_response
+
+      r.should respond_to(:response)
+      r.ok?.should == true
+      r.docs.size.should == 11
+      r.params[:echoParams].should == 'EXPLICIT'
+      r.docs.previous_page.should == 1
+      r.docs.next_page.should == 2
+      #
+      r.should be_a(GSolr::Ext::Response::Docs)
+      r.should be_a(GSolr::Ext::Response::Facets)
+    end
+
+    it 'should create a doc with gsolr_ext methods' do
+      r = create_response
+
+      doc = r.docs.first
+      doc.has?(:cat, /^elec/).should == true
+      doc.has?(:cat, 'elec').should_not == true
+      doc.has?(:cat, 'electronics').should == true
+
+      doc.get(:cat).should == 'electronics, hard drive'
+      doc.get(:xyz).should == nil
+      doc.get(:xyz, :default=>'def').should == 'def'
+    end
+
+    it 'should provide facet helpers' do
+      r = create_response
+      r.facets.size.should == 2
+
+      field_names = r.facets.collect{|facet|facet.name}
+      field_names.include?('cat').should == true
+      field_names.include?('manu').should == true
+
+      first_facet = r.facets.first
+      first_facet.name.should == 'cat'
+
+      first_facet.items.size.should == 10
+
+      expected = "electronics - 14, memory - 3, card - 2, connector - 2, drive - 2, graphics - 2, hard - 2, monitor - 2, search - 2, software - 2"
+      received = first_facet.items.collect do |item|
+        item.value + ' - ' + item.hits.to_s
+      end.join(', ')
+
+      expected.should == received
+
+      r.facets.each do |facet|
+        facet.respond_to?(:name).should == true
+        facet.items.each do |item|
+          item.respond_to?(:value).should == true
+          item.respond_to?(:hits).should == true
+        end
+      end
+
+    end
+
+    it 'should return the correct value when calling facet_by_field_name' do
+      r = create_response
+      facet = r.facet_by_field_name('cat')
+      facet.name.should == 'cat'
+    end
+
+    it 'should provide the responseHeader params' do
+      raw_response = eval(mock_query_response)
+      raw_response['responseHeader']['params']['test'] = :test
+      r = GSolr::Ext::Response::Base.new(raw_response, '/catalog', raw_response['params'])
+      r.params['test'].should == :test
+    end
+
+    it 'should provide the solr-returned params and "rows" should be 11' do
+      raw_response = eval(mock_query_response)
+      r = GSolr::Ext::Response::Base.new(raw_response, '/catalog', {})
+      r.params[:rows].to_s.should == '11'
+    end
+
+    it 'should provide the ruby request params if responseHeader["params"] does not exist' do
+      raw_response = eval(mock_query_response)
+      raw_response.delete 'responseHeader'
+      r = GSolr::Ext::Response::Base.new(raw_response, '/catalog', :rows => 999)
+      r.params[:rows].to_s.should == '999'
+    end
+
+    it 'should provide spelling suggestions for regular spellcheck results' do
+      raw_response = eval(mock_response_with_spellcheck)
+      r = GSolr::Ext::Response::Base.new(raw_response, '/catalog', {})
+      r.spelling.words.should include("dell")
+      r.spelling.words.should include("ultrasharp")
+    end
+
+    it 'should provide spelling suggestions for extended spellcheck results' do
+      raw_response = eval(mock_response_with_spellcheck_extended)
+      r = GSolr::Ext::Response::Base.new(raw_response, '/catalog', {})
+      r.spelling.words.should include("dell")
+      r.spelling.words.should include("ultrasharp")
+    end
+
+    it 'should provide no spelling suggestions when extended results and suggestion frequency is the same as original query frequency' do
+      raw_response = eval(mock_response_with_spellcheck_same_frequency)
+      r = GSolr::Ext::Response::Base.new(raw_response, '/catalog', {})
+      r.spelling.words.should == []
+    end
+
+    it 'should provide spelling suggestions for a regular spellcheck results with a collation' do
+      raw_response = eval(mock_response_with_spellcheck_collation)
+      r = GSolr::Ext::Response::Base.new(raw_response, '/catalog', {})
+      r.spelling.words.should include("dell")
+      r.spelling.words.should include("ultrasharp")
+    end
+
+    it 'should provide spelling suggestion collation' do
+      raw_response = eval(mock_response_with_spellcheck_collation)
+      r = GSolr::Ext::Response::Base.new(raw_response, '/catalog', {})
+      r.spelling.collation.should == 'dell ultrasharp'
+    end
+
+  end
+
+end
+