mwmitchell-rsolr 0.5.7

data/lib/rsolr/response/index_info.rb

@@ -0,0 +1,22 @@
+# response for /admin/luke
+class RSolr::Response::IndexInfo < RSolr::Response::Base
+  
+  attr_reader :index, :directory, :has_deletions, :optimized, :current, :max_doc, :num_docs, :version
+  
+  alias :has_deletions? :has_deletions
+  alias :optimized? :optimized
+  alias :current? :current
+  
+  def initialize(data)
+    super(data)
+    @index = @data['index']
+    @directory = @data['directory']
+    @has_deletions = @index['hasDeletions']
+    @optimized = @index['optimized']
+    @current = @index['current']
+    @max_doc = @index['maxDoc']
+    @num_docs = @index['numDocs']
+    @version = @index['version']
+  end
+  
+end

data/lib/rsolr/response/query.rb

@@ -0,0 +1,170 @@
+# response module for queries
+module RSolr::Response::Query
+  
+  # module for adding helper methods to each Hash document
+  module DocExt
+    
+    def self.extended(base)
+      base.keys.each do |k,v|
+        base.instance_eval <<-EOF
+        def #{k}; self['#{k.to_s}']; end
+        EOF
+      end
+    end
+    
+    # Helper method to check if value/multi-values exist for a given key.
+    # The value can be a string, or a RegExp
+    # Example:
+    # doc.has?(:location_facet)
+    # doc.has?(:location_facet, 'Clemons')
+    # doc.has?(:id, 'h009', /^u/i)
+    def has?(k, *values)
+      return if self[k].nil?
+      return true if self.has_key?(k) and values.empty?
+      target = self[k]
+      if target.is_a?(Array)
+        values.each do |val|
+          return target.any?{|tv| val.is_a?(Regexp) ? (tv =~ val) : (tv==val)}
+        end
+      else
+        return values.any? {|val| val.is_a?(Regexp) ? (target =~ val) : (target == val)}
+      end
+    end
+
+  end
+  
+  # from the delsolr project -> http://github.com/avvo/delsolr/tree/master/lib/delsolr/response.rb
+  module Facets
+    
+    def facets
+      @facets ||= data['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
+
+    # Returns all of the facet queries
+    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 = []
+        return unless facet_field(field)
+        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
+    
+  end
+  
+  #
+  #
+  #
+  module Pagination
+    
+    # alias to the Solr param, 'rows'
+    def per_page
+      @per_page ||= params['rows'].to_s.to_i
+    end
+    
+    # Returns the current page calculated from 'rows' and 'start'
+    # WillPaginate hook
+    def current_page
+      @current_page ||= (self.start / self.per_page).ceil + 1
+    end
+    
+    # Calcuates the total pages from 'numFound' and 'rows'
+    # WillPaginate hook
+    def total_pages
+      @total_pages ||= self.per_page > 0 ? (self.total / self.per_page.to_f).ceil : 1
+    end
+    
+    # returns the previous page number or 1
+    # WillPaginate hook
+    def previous_page
+      @previous_page ||= (current_page > 1) ? current_page - 1 : 1
+    end
+    
+    # returns the next page number or the last
+    # WillPaginate hook
+    def next_page
+      @next_page ||= (current_page < total_pages) ? current_page + 1 : total_pages
+    end
+    
+  end
+  
+  # The base query response class
+  # adds to the Solr::Response::Base class by defining a few more attributes,
+  # includes the Pagination module, and extends each of the doc hashes
+  # with Solr::Response::Query::DocExt
+  class Base < RSolr::Response::Base
+    
+    include RSolr::Response::Query::Pagination
+    include RSolr::Response::Query::Facets
+    
+    attr_reader :response, :docs, :num_found, :start
+  
+    alias :total :num_found
+    alias :offset :start
+  
+    def initialize(data)
+      super(data)
+      @response = @data['response']
+      @docs = @response['docs']
+      @docs.each do |d|
+        d.extend RSolr::Response::Query::DocExt
+      end
+      @num_found = @response['numFound']
+      @start = @response['start']
+    end
+  
+  end
+  
+end

data/lib/rsolr/response/update.rb

@@ -0,0 +1,4 @@
+# response class for update requests - not sure if this is needed yet?
+class RSolr::Response::Update < RSolr::Response::Base
+  
+end

data/test/connection/direct_test.rb

@@ -0,0 +1,22 @@
+if defined?(JRUBY_VERSION)
+
+require File.join(File.dirname(__FILE__), '..', 'test_helpers')
+
+require File.join(File.dirname(__FILE__), 'test_methods')
+
+class ConnectionDirectTest < RSolrBaseTest
+  
+  include ConnectionTestMethods
+  
+  def setup
+    base = File.expand_path( File.dirname(__FILE__) )
+    dist = File.join(base, '..', '..', 'apache-solr')
+    home = File.join(dist, 'example', 'rsolr')
+    @solr = RSolr.connect(:direct, :home_dir=>home, :dist_dir=>dist)
+    @solr.delete_by_query('*:*')
+    @solr.commit
+  end
+  
+end
+
+end

data/test/connection/http_test.rb

@@ -0,0 +1,19 @@
+unless defined?(JRUBY_VERSION)
+
+  require File.join(File.dirname(__FILE__), '..', 'test_helpers')
+  
+  require File.join(File.dirname(__FILE__), 'test_methods')
+
+  class AdapterHTTPTest < RSolrBaseTest
+  
+    include ConnectionTestMethods
+  
+    def setup
+      @solr = RSolr.connect :http
+      @solr.delete_by_query('*:*')
+      @solr.commit
+    end
+  
+  end
+  
+end

data/test/connection/search_ext_test_methods.rb

@@ -0,0 +1,17 @@
+raise 'Not yet implemented!'
+
+module SearchExtTestMethods
+  
+  def test_facet_response_methods
+    @response.facets
+    @response.facet_fields
+    @response.facet_queries
+    @response.facet_fields_by_hash
+    @response.facet_field(:feed_language_facet)
+    @response.facet_field_values(:feed_language_facet)
+    @response.facet_field_by_hash(:feed_language_facet)
+    @response.facet_field_by_hash(:feed_language_facet)
+    @response.facet_field_count(:feed_title_facet, 'ScienceDaily: Latest Science News')
+  end
+  
+end

data/test/connection/test_methods.rb

@@ -0,0 +1,122 @@
+# These are all of the test methods used by the various connection + adapter tests
+# Currently: Direct and HTTP
+# By sharing these tests, we can make sure the adapters are doing what they're suppossed to
+# while staying "dry"
+
+module ConnectionTestMethods
+  
+  #def teardown
+  #  @solr.delete_by_query('id:[* TO *]')
+  #  @solr.commit
+  #  assert_equal 0, @solr.query(:q=>'*:*').docs.size
+  #end
+  
+  def test_default_options
+    target = {
+      :select_path => '/select',
+      :update_path => '/update',
+      :luke_path => '/admin/luke'
+    }
+    assert_equal target, @solr.adapter.default_options
+  end
+  
+  # setting adapter options in Solr.connect method should set them in the adapter
+  def test_set_adapter_options
+    solr = RSolr.connect(:http, :select_path=>'/select2')
+    assert_equal '/select2', solr.adapter.opts[:select_path]
+  end
+  
+  # setting connection options in Solr.connect method should set them in the connection
+  def test_set_connection_options
+    solr = RSolr.connect(:http, :default_wt=>:json)
+    assert_equal :json, solr.opts[:default_wt]
+  end
+  
+  # If :wt is NOT :ruby, the format doesn't get wrapped in a Solr::Response class
+  # Raw ruby can be returned by using :wt=>'ruby', not :ruby
+  def test_raw_response_formats
+    ruby_response = @solr.query(:q=>'*:*', :wt=>'ruby')
+    assert ruby_response[:body].is_a?(String)
+    assert ruby_response[:body]=~%r('wt'=>'ruby')
+    # xml?
+    xml_response = @solr.query(:q=>'*:*', :wt=>'xml')
+    assert xml_response[:body]=~%r(<str name="wt">xml</str>)
+    # json?
+    json_response = @solr.query(:q=>'*:*', :wt=>'json')
+    assert json_response[:body]=~%r("wt":"json")
+  end
+  
+  def test_query_responses
+    r = @solr.query(:q=>'*:*')
+    assert r.is_a?(RSolr::Response::Query::Base)
+    # catch exceptions for bad queries
+    assert_raise RSolr::RequestError do
+      @solr.query(:q=>'!')
+    end
+  end
+  
+  def test_query_response_docs
+    @solr.add(:id=>1, :price=>1.00, :cat=>['electronics', 'something else'])
+    @solr.commit
+    r = @solr.query(:q=>'*:*')
+    assert r.is_a?(RSolr::Response::Query::Base)
+    assert_equal Array, r.docs.class
+    first = r.docs.first
+    assert first.respond_to?(:price)
+    assert first.respond_to?(:cat)
+    assert first.respond_to?(:id)
+    assert first.respond_to?(:timestamp)
+    
+    # test the has? method
+    assert first.has?('price', 1.00)
+    assert first.has?('cat', 'electronics')
+    assert first.has?('cat', 'something else')
+    
+    assert first.has?('cat', /something/)
+    
+    # has? only works with strings at this time
+    assert_nil first.has?(:cat)
+    
+    assert false == first.has?('cat', /zxcv/)
+  end
+  
+  def test_add
+    assert_equal 0, @solr.query(:q=>'*:*').total
+    response = @solr.add(:id=>100)
+    @solr.commit
+    assert_equal 1, @solr.query(:q=>'*:*').total
+    assert response.is_a?(RSolr::Response::Update)
+  end
+  
+  def test_delete_by_id
+    @solr.add(:id=>100)
+    @solr.commit
+    total = @solr.query(:q=>'*:*').total
+    assert_equal 1, total
+    delete_response = @solr.delete_by_id(100)
+    @solr.commit
+    assert delete_response.is_a?(RSolr::Response::Update)
+    total = @solr.query(:q=>'*:*').total
+    assert_equal 0, total
+  end
+  
+  def test_delete_by_query
+    @solr.add(:id=>1, :name=>'BLAH BLAH BLAH')
+    @solr.commit
+    assert_equal 1, @solr.query(:q=>'*:*').total
+    response = @solr.delete_by_query('name:BLAH BLAH BLAH')
+    @solr.commit
+    assert response.is_a?(RSolr::Response::Update)
+    assert_equal 0, @solr.query(:q=>'*:*').total
+  end
+  
+  def test_index_info
+    response = @solr.index_info
+    assert response.is_a?(RSolr::Response::IndexInfo)
+    # make sure the ? methods are true/false
+    assert [true, false].include?(response.current?)
+    assert [true, false].include?(response.optimized?)
+    assert [true, false].include?(response.has_deletions?)
+  end
+  
+end

data/test/http_client/curb_test.rb

@@ -0,0 +1,19 @@
+# don't run this test in jruby,
+# the curb gem is a c extension based gem, jruby has no support for this
+unless defined?(JRUBY_VERSION)
+
+  require File.join(File.dirname(__FILE__), '..', 'test_helpers')
+  
+  require File.join(File.dirname(__FILE__), 'test_methods')
+
+  class CurbTest < RSolrBaseTest
+  
+    def setup
+      @c ||= RSolr::HTTPClient.connect(URL, :curb)
+    end
+  
+    include HTTPClientTestMethods
+  
+  end
+  
+end

data/test/http_client/net_http_test.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helpers')
+
+require File.join(File.dirname(__FILE__), 'test_methods')
+
+class NetHTTPTest < RSolrBaseTest
+  
+  def setup
+    @c ||= RSolr::HTTPClient.connect(URL, :net_http)
+  end
+  
+  include HTTPClientTestMethods
+  
+end

data/test/http_client/test_methods.rb

@@ -0,0 +1,40 @@
+module HTTPClientTestMethods
+  
+  URL = 'http://localhost:8983/solr/'
+  
+  def test_raise_unknown_adapter
+    assert_raise RSolr::HTTPClient::UnkownAdapterError do
+      c = RSolr::HTTPClient.connect(URL, :blah)
+    end
+  end
+  
+  # the responses from the HTTPClient adapter should return the same hash structure
+  def test_get_response
+    headers = {}
+    data = nil
+    response = @c.get('select', :q=>'*:*')
+    assert_equal data, response[:data]
+    assert_equal 200, response[:status_code]
+    expected_params = {:q=>'*:*'}
+    assert_equal expected_params, response[:params]
+    assert_equal 'select', response[:path]
+    assert response[:body] =~ /name="responseHeader"/
+    assert_equal 'http://localhost:8983/solr/select?q=%2A%3A%2A', response[:url]
+    assert_equal headers, response[:headers]
+  end
+  
+  def test_post_response
+    headers = {"Content-Type" => 'text/xml; charset=utf-8'}
+    data = '<add><doc><field name="id">1</field></doc></add>'
+    response = @c.post('update', data, {}, headers)
+    assert_equal data, response[:data]
+    assert_equal 200, response[:status_code]
+    expected_params = {}
+    assert_equal expected_params, response[:params]
+    assert_equal 'update', response[:path]
+    assert response[:body] =~ /name="responseHeader"/
+    assert_equal 'http://localhost:8983/solr/update', response[:url]
+    assert_equal headers, response[:headers]
+  end
+  
+end