delsolr 0.0.1

data/History.txt

@@ -0,0 +1,5 @@
+== 0.0.1 2008-09-08
+
+* 1 major enhancement:
+  * Initial release
+  * No support for POST

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 FIXME full name
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,11 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/delsolr.rb
+lib/delsolr/configuration.rb
+lib/delsolr/extensions.rb
+lib/delsolr/query_builder.rb
+lib/delsolr/response.rb
+lib/delsolr/version.rb

data/README.txt

@@ -0,0 +1,49 @@
+= delsolr
+
+http://delsolr.rubyforge.org
+
+== DESCRIPTION:
+
+DelSolr is a light weight ruby wrapper for solr.  It's intention is to expose the full power of solr queries 
+while keeping the interface as ruby-esque as possible.
+
+== FEATURES/PROBLEMS:
+
+* Only supports querying (GET), no indexing (POST) support yet
+
+== SYNOPSIS:
+
+See http://delsolr.rubyforge.org for more info
+
+== REQUIREMENTS:
+
+You need Solr installed somewhere so you can query it ;)
+
+== INSTALL:
+
+sudo gem install delsolr
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 FIXME full name
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/lib/delsolr.rb

@@ -0,0 +1,97 @@
+#
+# DelSolr
+# 
+# ben@avvo.com 9.1.2008
+#
+# see README.txt
+#
+
+require 'net/http'
+
+require 'digest/md5'
+
+require File.join(File.dirname(__FILE__), 'delsolr', 'version')
+require File.join(File.dirname(__FILE__), 'delsolr', 'response')
+require File.join(File.dirname(__FILE__), 'delsolr', 'configuration')
+require File.join(File.dirname(__FILE__), 'delsolr', 'query_builder')
+require File.join(File.dirname(__FILE__), 'delsolr', 'extensions')
+
+module DelSolr
+  
+  class Client
+    
+    attr_reader :configuration, :connection, :logger
+    
+    # options
+    # :server - the server you want to connect to
+    # :port   - the port you want to connect to
+    # :cache  - [optional] a cache instance (any object the supports get and set)
+    # :shortcuts - [options] a list of values in the doc fields that generate short cuts for (defaults to [:id, :unique_id, :score]).
+    #           With the response you will then be able to do rsp.scores and have it return an array of scores.
+    def initialize(opts = {})
+      @configuration = DelSolr::Client::Configuration.new(opts[:server], opts[:port])
+      @cache = opts[:cache]
+      @shortcuts = opts[:shortcuts]
+    end
+    
+    #
+    #
+    # query_name - type of query to perform (should match up w/ queries defined in solrconfig.xml)
+    # 
+    # 
+    # Possible options
+    # :query   - [required] unescape user input or solr query (can also be a hash {:field_name => value}).
+    # :filters - [optional] array, string, or hash of additional filters to apply
+    # :facet   - [optional] array of hashes for all the facet params (ie: {:field => 'instock_b', :limit => 15, :mincount => 5})
+    #            You can also specify facets using a query (ie: {:query => 'city_idm:seattle', :name => 'seattle'} or even 
+    #            {:query => {:city => 'seattle'}, :name => 'seattle'}) and then get counts for that facet by calling
+    #            rsp.facet_query_count_by_name('seattle').
+    #            
+    # :sorts   - [optional] array or string of sorts
+    # :limit   - [optional] number to return (defaults to 10)
+    # :offset  - [optional] offset (defaults to 0)
+    # :enable_caching - [optional] switch to control whether or not to use the cache (for fetching or setting)
+    #
+    # Returns a DelSolr::Client::Response instance
+    def query(query_name, opts = {})
+
+      raise "query_name must be supplied" if query_name.blank?
+
+      enable_caching = opts.delete(:enable_caching) && !@cache.nil?
+      ttl = opts.delete(:ttl) || 1.hours
+
+      query_builder = DelSolr::Client::QueryBuilder.new(query_name, opts)
+
+      # it's important that the QueryBuilder returns strings in a deterministic fashion
+      # so that the cache keys will match for the same query.
+      cache_key = Digest::MD5.hexdigest(query_builder.request_string)
+      from_cache = false
+
+      # if we're caching, first try looking in the cache
+      if enable_caching
+        body = @cache.get(cache_key) rescue body = nil
+        from_cache = true unless body.blank?
+      end
+
+      if body.blank? # cache miss (or wasn't enabled)
+
+        # only bother to create the connection if we know we failed to hit the cache
+        @connection ||= Net::HTTP.new(configuration.server, configuration.port)      
+        raise "Failed to connect to #{configuration.server}:#{configuration.port}" if @connection.nil?
+
+        header, body = @connection.get(query_builder.request_string)
+
+        # add to the cache if caching
+        if enable_caching
+          begin
+            @cache.set(cache_key, body, ttl)
+          rescue
+          end
+        end
+      end
+
+      DelSolr::Client::Response.new(body, query_builder, :from_cache => from_cache, :shortcuts => @shortcuts)
+    end
+
+  end
+end

data/lib/delsolr/configuration.rb

@@ -0,0 +1,13 @@
+module DelSolr
+  class Client
+    class Configuration
+      attr_accessor :server, :port    
+
+      def initialize(server, port)
+        @server = server
+        @port = port.to_i
+      end
+
+    end
+  end
+end

data/lib/delsolr/extensions.rb

@@ -0,0 +1,35 @@
+#
+#  Common extensions that we need to define if they don't already exist...
+#
+
+String.class_eval do
+  if !''.respond_to?(:blank?)    
+    def blank?
+      self == ''
+    end
+  end
+end
+
+NilClass.class_eval do
+  if !nil.respond_to?(:blank?)
+    def blank?
+      true
+    end
+  end
+end
+
+Hash.class_eval do
+  if !{}.respond_to?(:blank?)
+    def blank?
+      self == {}
+    end
+  end
+end
+
+Fixnum.class_eval do
+  if !1.respond_to?(:hours)
+    def hours
+      self * 60 * 60
+    end
+  end
+end

data/lib/delsolr/query_builder.rb

@@ -0,0 +1,201 @@
+require 'cgi'
+
+module DelSolr
+  
+  class Client
+    
+    class QueryBuilder
+      
+      attr_accessor :query_name, :options
+
+      # ops can basically be straight solr URL params, but it also supports some other formats
+      # of different params to give it more of a "ruby" feel (ie: :filters can be an array, hash, or string, 
+      # but you can also just specify the fq params directly
+      def initialize(query_name, opts = {})
+        @query_name = query_name
+        @options = opts
+      end
+
+      def request_string
+        @request_string ||= build_request_string
+      end
+
+      # returns the query string of the facet query for the given query name (used for resolving counts for given queries)
+      def facet_query_by_name(query_name)
+        name_to_facet_query[query_name]
+      end
+      
+    private
+
+      def build_request_string()
+        raise "query_name must be set" if query_name.blank?
+
+        opts = self.options.dup
+
+        # cleanup the nils
+        opts.delete_if {|k,v| v.nil?}
+        
+        # resolve "rubyish" names to solr names
+        opts[:q] ||= opts[:query]
+        opts[:rows] ||= opts[:limit] || 10
+        opts[:start] ||= opts[:offset] || 0
+        opts[:fl] ||= opts[:fields] || 'id,unique_id,index_type,score'
+        opts[:bq] ||= opts[:boost]
+        opts[:suggestionCount] ||= opts[:suggestion_count]
+        opts[:onlyMorePopular] ||= opts[:only_more_popular]
+        
+        raise ":query or :q must be set" if opts[:q].blank?
+        
+        # clear out the "rubyish" versions, what's left will go straight to solr
+        opts.delete(:query)
+        opts.delete(:limit)
+        opts.delete(:offset)
+        opts.delete(:fields)
+        opts.delete(:boost)
+        opts.delete(:suggestion_count)
+        opts.delete(:only_more_popular)
+        
+        # needs to be an array of hashs because it's acceptable to have the same key present > once.
+        params = []
+
+        # remove params as we go so we can just pass whatever is left to solr...
+
+        params << build_query(:q, opts.delete(:q))
+        params << {:wt => 'ruby'}
+        params << {:qt => query_name}
+        params << {:rows => opts.delete(:rows)}
+        params << {:start => opts.delete(:start)}
+        params << {:fl => opts.delete(:fl)}
+
+        filters = opts.delete(:filters)
+        params += build_filters(:fq, filters)
+
+        facets = opts.delete(:facets)
+        if facets
+          if facets.is_a?(Array)
+            params << {:facet => true}
+            params += build_facets(facets)          
+          elsif facets.is_a?(Hash)
+            params << {:facet => true}
+            params += build_facet(facets)
+          elsif facets.is_a?(String)
+            params += facets
+          else
+            raise 'facets must either be a Hash or an Array'
+          end
+        end
+        
+        # handle friendly highlight name
+        if opts.delete(:highlight)
+          params << {:hl => 'true'}
+          params << {'hl.fl' => opts['hl.fl'] || opts[:fl] }
+        end
+
+        # just pass everything that's left to solr
+        opts.each { |k,v| params << {k => v} if !v.nil? }
+
+        # convert the params (array of hashes)
+        param_strings = params.collect do |h|
+          if h.is_a?(Hash)
+            ha = h.to_a
+            "#{ha[0][0]}=#{::CGI::escape(ha[0][1].to_s)}"
+          elsif h.is_a?(String)
+            h # just return the string
+          else
+            raise "All params should be a Hash or String"
+          end
+        end
+        
+        "/solr/select?#{param_strings.join('&')}"
+      end
+      
+      # returns the query param
+      def build_query(key, queries)
+        query_string = ''
+        case queries
+        when String
+          query_string = queries
+        when Array
+          query_string = queries.join(' ')
+        when Hash
+          query_string_array = []
+          queries.each do |k,v|
+            if v.is_a?(Array) # add a filter for each value
+              v.each do |val|
+                query_string_array << "#{k}:#{val}"
+              end
+            elsif v.is_a?(Range)
+              query_string_array << "#{k}:[#{v.min} TO #{v.max}]"
+            else
+              query_string_array << "#{k}:#{v}"
+            end
+          end
+          query_string = query_string_array.join(' ')
+        end
+        
+        {key => query_string}
+      end
+      
+      def build_filters(key, filters)
+        params = []
+        
+        # handle "ruby-ish" filters
+        case filters
+        when String
+          params << {key => filters}
+        when Array
+          filters.each { |f| params << {key => f} }
+        when Hash
+          filters.each do |k,v|
+            if v.is_a?(Array) # add a filter for each value
+              v.each do |val|
+                params << {key => "#{k}:#{val}"}
+              end
+            elsif v.is_a?(Range)
+              params << {key => "#{k}:[#{v.min} TO #{v.max}]"}
+            else
+              params << {key => "#{k}:#{v}"}
+            end
+          end
+        end
+        params
+      end
+      
+      def build_facets(facet_array)
+        params = []
+        facet_array.each do |facet_hash|
+          params += build_facet(facet_hash)
+        end
+        params
+      end
+      
+      def build_facet(facet_hash)
+        params = []
+        facet_name = facet_hash['name'] || facet_hash[:name]
+        facet_hash.each do |k,v|
+          # handle some cases specially
+          if 'field' == k.to_s
+            params << {"facet.field" => v}
+          elsif 'query' == k.to_s
+            q = build_query("facet.query", v)
+            params << q
+            if facet_name
+              # keep track of names => facet_queries
+              name_to_facet_query[facet_name] = q['facet.query']
+            end
+          elsif ['name', :name].include?(k.to_s)
+            # do nothing
+          else
+            params << {"f.#{facet_hash[:field]}.facet.#{k}" => v}
+          end
+        end
+        params
+      end
+      
+      def name_to_facet_query
+        @name_to_facet_query ||= {}
+      end
+      
+    end
+  end
+end

data/lib/delsolr/response.rb

@@ -0,0 +1,171 @@
+module DelSolr
+  
+  class Client
+  
+    class Response
+
+      attr_reader :raw_response, :query_builder
+
+      def initialize(solr_response_buffer, query_builder, options = {})
+        @query_builder = query_builder
+        @from_cache = options[:from_cache]
+        begin
+          @raw_response = eval(solr_response_buffer)
+        rescue
+          @raw_response = nil
+        end
+
+        # now define the shortcuts
+        options[:shortcuts] ||= [:id, :unique_id, :score]
+        options[:shortcuts].each do |shortcut|
+          instance_eval %{
+            def #{shortcut}s
+              @#{shortcut}s ||= docs.collect {|d| d['#{shortcut}'] }
+            end
+          }
+        end
+      end
+
+      # returns the total number of matches
+      def total
+        @total ||= raw_response['response']['numFound']
+      end
+      
+      def blank?
+        total < 1
+      end
+      
+      alias_method :empty?, :blank?
+      
+      def from_cache?
+        @from_cache
+      end
+      
+      # returns the offset
+      def offset
+        @offset ||= raw_response['response']['start']
+      end
+
+      # returns the max score
+      def max_score
+        @max_score ||= raw_response['response']['maxScore'].to_f
+      end
+
+      # returns an array of all ids for the given search
+      def ids
+        @ids ||= docs.collect {|d| d['id']}
+      end
+      
+      def unique_ids
+        @unique_ids ||= docs.collect {|d| d['unique_id']}
+      end
+
+      # returns an array of all the docs
+      def docs
+        @docs ||= raw_response['response']['docs']
+      end
+      
+      # helper for displaying a given field (first tries the highlight, then the stored value)
+      def display_for(doc, field)
+        highlights_for(doc['unique_id'], field) || doc[field]
+      end
+      
+      # returns the highlights for a given id for a given field
+      def highlights_for(unique_id, field)
+        raw_response['highlighting'] ||= {}
+        raw_response['highlighting'][unique_id] ||= {}
+        raw_response['highlighting'][unique_id][field]
+      end
+      
+      def suggestions
+        @suggestions ||= raw_response['suggestions']
+      end
+
+      # returns the query time in ms
+      def qtime
+        @qtime ||= raw_response['responseHeader']['QTime'].to_i
+      end
+
+      # returns the status code (0 for success)
+      def status
+        @status ||= raw_response['responseHeader']['status']
+      end
+
+      # returns the params hash
+      def params
+        @params ||= raw_response['responseHeader']['params']
+      end
+      
+      # returns the entire facet hash
+      def facets
+        @facets ||= raw_response['facet_counts'] || {}
+      end
+      
+      # returns the hash of all the facet_fields (ie: {'instock_b' => ['true', 123, 'false', 20]}
+      def facet_fields
+        @facet_fields ||= facets['facet_fields'] || {}
+      end
+      
+      def facet_queries
+        @facet_queries ||= facets['facet_queries'] || {}
+      end
+      
+      # returns a hash of hashs rather than a hash of arrays (ie: {'instock_b' => {'true' => 123', 'false', => 20} })
+      def facet_fields_by_hash
+        @facet_fields_by_hash ||= begin
+          f = {}
+          if facet_fields
+            facet_fields.each do |field,value_and_counts|
+              f[field] = {}
+              value_and_counts.each_with_index do |v, i|              
+                if i % 2 == 0
+                  f[field][v] = value_and_counts[i+1]
+                end
+              end
+            end
+          end
+          f
+        end
+      end
+      
+      # returns an array of value/counts for a given field (ie: ['true', 123, 'false', 20]
+      def facet_field(field)
+        facet_fields[field.to_s]
+      end
+      
+      # returns the array of field values for the given field in the order they were returned from solr
+      def facet_field_values(field)
+        facet_field_values ||= {}
+        facet_field_values[field.to_s] ||= begin
+          a = []
+          facet_field(field).each_with_index do |val_or_count, i|
+            a << val_or_count if i % 2 == 0 && facet_field(field)[i+1] > 0
+          end
+          a
+        end
+      end
+      
+      # returns a hash of value/counts for a given field (ie: {'true' => 123, 'false' => 20}
+      def facet_field_by_hash(field)
+        facet_fields_by_hash(field.to_s)
+      end
+      
+      # returns the count for the given field/value pair
+      def facet_field_count(field, value)
+        facet_fields_by_hash[field.to_s][value.to_s] if facet_fields_by_hash[field.to_s]
+      end
+      
+      # returns the counts for a given facet_query_name
+      def facet_query_count_by_name(facet_query_name)
+        query_string = query_builder.facet_query_by_name(facet_query_name)
+        facet_queries[query_string] if query_string
+      end
+      
+      # returns the url send to solr
+      def request_url
+        query_builder.request_string
+      end
+      
+    end
+  end
+end

data/lib/delsolr/version.rb

@@ -0,0 +1,9 @@
+module DelSolr
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/test/test_client.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ClientTest < Test::Unit::TestCase
+
+  include Test::Unit::Assertions
+  
+  def test_create
+    s = nil
+    assert_nothing_raised do
+      s = DelSolr::Client.new(:server => 'localhost', :port => 8983)
+    end
+    assert(s)
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/delsolr'

data/test/test_query_builder.rb

@@ -0,0 +1,161 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class QueryBuilderTest < Test::Unit::TestCase
+
+  include Test::Unit::Assertions
+  
+  def test_001
+    qb = nil
+    
+    opts = {}
+    opts[:limit] = 13
+    opts[:offset] = 3
+    opts[:fl] = 'id'
+    opts[:query] = 'good book'
+    
+    assert_nothing_raised { qb = DelSolr::Client::QueryBuilder.new('query_name', opts) }
+    
+    assert(qb)
+    
+    p = get_params(qb.request_string)
+    assert_equal(p['start'], '3')
+    assert_equal(p['rows'], '13')
+    assert_equal(p['fl'], 'id')
+    assert_equal(p['q'], 'good book')
+  end
+  
+  def test_002
+    qb = nil
+    
+    opts = {}
+    opts[:query] = "blahblah"
+    opts[:fields] = 'id,unique_id,score'
+    
+    assert_nothing_raised { qb = DelSolr::Client::QueryBuilder.new('query_name', opts) }
+    
+    assert(qb)
+    
+    p = get_params(qb.request_string)
+    assert_equal(p['fl'], 'id,unique_id,score')
+    assert_equal(p['q'], 'blahblah')
+  end
+  
+  def test_003
+    qb = nil
+    
+    opts = {}
+    opts[:query] = {:index_type => 'books'}
+    opts[:fields] = 'id,unique_id,score'
+    
+    assert_nothing_raised { qb = DelSolr::Client::QueryBuilder.new('query_name', opts) }
+    
+    assert(qb)
+    
+    p = get_params(qb.request_string)
+    assert_equal(p['fl'], 'id,unique_id,score')
+    assert_equal(p['q'], 'index_type:books')
+  end
+  
+  def test_004
+    qb = nil
+    
+    opts = {}
+    opts[:query] = {:index_type => 'books'}
+    opts[:filters] = {:location => 'seattle'}
+    
+    assert_nothing_raised { qb = DelSolr::Client::QueryBuilder.new('query_name', opts) }
+    
+    assert(qb)
+    
+    p = get_params(qb.request_string)
+    assert_equal(p['fq'], 'location:seattle')
+    assert_equal(p['q'], 'index_type:books')
+  end
+
+  def test_005
+    qb = nil
+    
+    opts = {}
+    opts[:query] = {:index_type => 'books'}
+    opts[:filters] = "location:seattle"
+    
+    assert_nothing_raised { qb = DelSolr::Client::QueryBuilder.new('query_name', opts) }
+    
+    assert(qb)
+
+    p = get_params(qb.request_string)
+    
+    assert_equal(p['fq'], 'location:seattle')
+    assert_equal(p['q'], 'index_type:books')
+  end
+  
+  def test_facets
+    qb = nil
+    opts = {}
+    opts[:query] = "games"
+    opts[:facets] = [{:field => 'instock_b'}, {:field => 'on_sale_b', :limit => 1}]
+    
+    assert_nothing_raised { qb = DelSolr::Client::QueryBuilder.new('onebox-books', opts) }
+    
+    assert(qb)
+    
+    p = get_params(qb.request_string)
+    
+    assert_equal(p['facet'], 'true')
+    assert_equal(p['facet.field'].sort, ['instock_b', 'on_sale_b'].sort)
+    assert_equal(p['f.on_sale_b.facet.limit'], '1')
+  end
+  
+  def test_facets
+    qb = nil
+    opts = {}
+    opts[:query] = "games"
+    opts[:facets] = [{:query => {:city_idm => 19596}, :name => 'seattle'}, {:field => 'language_idm'}]
+    
+    assert_nothing_raised { qb = DelSolr::Client::QueryBuilder.new('onebox-books', opts) }
+    
+    assert(qb)
+    
+    p = get_params(qb.request_string)
+    
+    assert_equal(p['facet'], 'true')
+    assert_equal(p['facet.field'], 'language_idm')
+    assert_equal(p['facet.query'], 'city_idm:19596')
+  end
+  
+  def test_range
+    qb = nil
+    opts = {}
+    opts[:query] = "games"
+    opts[:filters] = {:id => (1..3)}
+    
+    assert_nothing_raised { qb = DelSolr::Client::QueryBuilder.new('onebox-books', opts) }
+    
+    assert(qb)
+    
+    p = get_params(qb.request_string)
+    
+    assert_equal('id:[1 TO 3]', p['fq'])
+  end
+
+  
+private
+  
+  # given a url returns a hash of the query params (for each duplicate key, it returns an array)
+  def get_params(url)
+    query = URI.parse(url).query
+    query = query.split('&')
+    h = {}
+    query.each do |p|
+      a = p.split('=')
+      if h[a[0]]
+        h[a[0]] = (Array(h[a[0]]) << CGI::unescape(a[1])) # convert it to an array
+      else
+        h[a[0]] = CGI::unescape(a[1])
+      end
+    end
+    h
+  end
+
+  
+end

data/test/test_response.rb

@@ -0,0 +1,131 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ResponseTest < Test::Unit::TestCase
+
+  include Test::Unit::Assertions
+
+  @@test_001 = %{
+    {
+     'responseHeader'=>{
+      'status'=>0,
+      'QTime'=>151,
+      'params'=>{
+            'wt'=>'ruby',
+            'rows'=>'10',
+            'explainOther'=>'',
+            'start'=>'0',
+            'hl.fl'=>'',
+            'indent'=>'on',
+            'hl'=>'on',
+            'q'=>'index_type:widget',
+            'fl'=>'*,score',
+            'qt'=>'standard',
+            'version'=>'2.2'}},
+     'response'=>{'numFound'=>1522698,'start'=>0,'maxScore'=>1.5583541,'docs'=>[
+            {
+             'index_type'=>'widget',
+             'id'=>1,
+             'unique_id'=>'1_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>3,
+             'unique_id'=>'3_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>4,
+             'unique_id'=>'4_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>5,
+             'unique_id'=>'5_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>7,
+             'unique_id'=>'7_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>8,
+             'unique_id'=>'8_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>9,
+             'unique_id'=>'9_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>10,
+             'unique_id'=>'10_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>11,
+             'unique_id'=>'11_widget',
+             'score'=>1.5583541},
+            {
+             'index_type'=>'widget',
+             'id'=>12,
+             'unique_id'=>'12_widget',
+             'score'=>1.5583541}]
+     },
+     'facet_counts'=>{
+      'facet_queries'=>{
+        'city_idm:19596' => 392},
+      'facet_fields'=>{
+        'available_b'=>[
+          'false',1328],
+        'onsale_b'=>[
+          'false',1182,
+          'true',174]}},
+     'highlighting'=>{
+      '1_widget'=>{},
+      '3_widget'=>{},
+      '4_widget'=>{},
+      '5_widget'=>{},
+      '7_widget'=>{},
+      '8_widget'=>{},
+      '9_widget'=>{},
+      '10_widget'=>{},
+      '11_widget'=>{},
+      '12_widget'=>{}}}
+  }
+  
+  def test_001
+    r = nil
+    qb = DelSolr::Client::QueryBuilder.new('standard', :query => {:index_type => 'widget'}, :facets => {:query => 'city_idm:19596', :name => 19596} )
+    qb.request_string # need to generate this...
+    assert_nothing_raised { r = DelSolr::Client::Response.new(@@test_001, qb) }
+    
+    assert_equal(151, r.qtime)
+    assert_equal(1.5583541, r.max_score)
+    assert_equal(10, r.docs.length)
+    assert_equal([1, 3, 4, 5, 7, 8, 9, 10, 11, 12], r.ids)
+    assert_equal({
+        'available_b'=>[
+          'false',1328],
+        'onsale_b'=>[
+          'false',1182,
+          'true',174]}, r.facet_fields)
+    assert_equal(1182, r.facet_field_count('onsale_b', false))
+    assert_equal(174, r.facet_field_count('onsale_b', true))
+    assert_equal(1328, r.facet_field_count('available_b', false))
+    assert_equal(392, r.facet_query_count_by_name(19596))
+  end
+  
+  def test_shortcuts
+    r = nil
+    qb = DelSolr::Client::QueryBuilder.new('standard', :query => {:index_type => 'widget'}, :facets => {:query => 'city_idm:19596', :name => 19596} )
+    qb.request_string # need to generate this...
+    assert_nothing_raised { r = DelSolr::Client::Response.new(@@test_001, qb, :shortcuts => [:index_type, :id]) }
+    
+    assert(r.respond_to?(:index_types))
+    assert(r.respond_to?(:ids))
+    assert(!r.respond_to?(:scores))
+  end
+
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: delsolr
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Ben VandenBos
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-09-08 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
+description: Wrapper for querying Lucene Solr
+email: 
+- bvandenbos@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/delsolr.rb
+- lib/delsolr/configuration.rb
+- lib/delsolr/extensions.rb
+- lib/delsolr/query_builder.rb
+- lib/delsolr/response.rb
+- lib/delsolr/version.rb
+has_rdoc: true
+homepage: http://delsolr.rubyforge.org
+post_install_message: |+
+  
+  For more information on delsolr, see http://delsolr.rubyforge.org
+  
+  NOTE: Change this information in PostInstall.txt 
+  You can also delete it if you don't want it.
+  
+  
+rdoc_options: 
+- --main
+- README.txt
+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: delsolr
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Wrapper for querying Lucene Solr
+test_files: 
+- test/test_response.rb
+- test/test_query_builder.rb
+- test/test_helper.rb
+- test/test_client.rb