rsolr 0.9.7.2 → 0.10.0

data/CHANGES.txt

@@ -1,3 +1,24 @@
+0.9.10 - November 13, 2009
+  Changed RSolr.connect to return Http connection only:
+    RSolr.connect :url=>'xxx'
+  Added RSolr.direct_connect to handle the creation of SolrDirectConnections
+    rsolr = RSolr.direct_connect :home_dir=>''
+    
+    # can also use a block so the connection will get closed automatically:
+    RSolr.direct_connect :home_dir=>'' do |rsolr|
+      # query...
+    end
+  Added paginate method to RSolr::Client
+    - This method requires 2 new arguments: current page and per page:
+        solr.paginate 1, 10, :q=>''
+    - handler paths can be set:
+        solr.paginate 1, 10, '/music', :q=>''
+    - handler paths can also be set by method names:
+        solr.paginate_music 1, 10
+  Added required java libs to RSolr gem
+  Removed :dist_dir option from Direct connection options -- you gotta load your own java libs. See examples/direct.rb
+  Updated specs
+
 0.9.7.2 - November 6, 2009
   fixed gem spec, added client.rb
 

data/README.rdoc

@@ -30,12 +30,25 @@ A Ruby client for Apache Solr. RSolr has been developed to be simple and extenda
   
 To use a DirectSolrConnection (no http) in JRuby:
   
-  solr = RSolr.connect(:direct,
-    :home_dir=>'/path/to/solr/home',
-    :dist_dir=>'/path/to/solr/distribution'
-  )
+  # "apache-solr" should be a path to a solr build.
+  Dir['apache-solr/dist/*.jar'].each{|jar|require jar}
+  Dir['apache-solr/lib/*.jar'].each{|jar|require jar}
+  
+  opts = {:home_dir=>'/path/to/solr/home'}
+  
+  # note: you'll have to close the direct connection yourself unless using a block.
+  solr = RSolr.direct_connect(opts)
+  solr.select :q=>'*:*'
+  solr.connection.close
+  
+  # OR using a block for automatic connection closing:
+  RSolr.direct_connect opts do |solr|
+    solr.select :q=>'*:*'
+  end
+
+In general, the direct connection is less than ideal in most applications. You'll be missing out on Http caching, and it'll be impossible to do distributed searches. The direct connection could possibly come in handy though, for quickly indexing large numbers of documents.
 
-For more information about DirecSolrConnection, see the {API}[http://lucene.apache.org/solr/api/org/apache/solr/servlet/DirectSolrConnection.html].
+For more information about DirectSolrConnection, see the {API}[http://lucene.apache.org/solr/api/org/apache/solr/servlet/DirectSolrConnection.html].
 
 
 == Querying
@@ -61,6 +74,27 @@ A shortcut for the above example:
   response = solr.documents :q=>'test'
 
 
+===Doc Pagination
+RSolr is compatible with WillPaginate. To use pagination, call the "paginate" method:
+  response = solr.paginate current_page, per_page, :q=>'*:*'
+
+You can also set a handler path:
+  response = solr.paginate current_page, per_page, '/music', :q=>'*:*'
+
+Handler paths can also be set using a paginate_* method call like so:
+  response = solr.paginate_music current_page, per_page, :q=>'testing'
+
+====Pagination Responses
+The response['docs'] array from a paginate method has the following methods:
+  start, per_page, total, current_page, total_pages, previous_page, next_page, has_next?, has_previous?
+
+For example:
+  result = solr.paginate 1, 2, :q=>'*:*'
+  result['response']['docs'].has_next?
+
+To use with WillPaginate:
+  <%= will_paginate result['response']['docs'] %>
+
 == Updating Solr
 Updating can be done using native Ruby structures. Hashes are used for single documents and arrays are used for a collection of documents (hashes). These structures get turned into simple XML "messages". Raw XML strings can also be used.
 

data/lib/rsolr/client.rb

@@ -1,18 +1,41 @@
 class RSolr::Client
   
-  attr_reader :adapter
+  attr_reader :connection
   
-  # "adapter" is instance of:
+  # "connection" is instance of:
   #   RSolr::Adapter::HTTP
   #   RSolr::Adapter::Direct (jRuby only)
   # or any other class that uses the connection "interface"
-  def initialize(adapter)
-    @adapter = adapter
+  def initialize(connection)
+    @connection = connection
   end
-
+  
   # Send a request to a request handler using the method name.
+  # Also proxies to the #paginate method if the method starts with "paginate_"
   def method_missing(method_name, *args, &blk)
-    request("/#{method_name}", *args, &blk)
+    handler = method_name.to_s
+    if handler =~ /^paginate_/
+      handler = handler.sub(/^paginate_/, '')
+      page, per_page = args[0..1]
+      paginate(page, per_page, "/#{handler}", *args[2..-1], &blk)
+    else
+      request("/#{handler}", *args, &blk)
+    end
+  end
+  
+  # Accepts a page/per-page value for paginating docs
+  # Example:
+  #   solr.paginate 1, 10, :q=>'blah'
+  def paginate page, per_page, *request_args
+    if request_args.size == 2
+      params = request_args.last
+    elsif request_args.last.is_a? Hash
+      params = request_args.last
+    else
+      params = request_args.push({}).last
+    end
+    params[:start], params[:rows] = RSolr::Pagination.page_and_per_page_to_start_and_rows page, per_page
+    self.request(*request_args).extend RSolr::Pagination
   end
   
   # sends data to the update handler
@@ -30,7 +53,7 @@ class RSolr::Client
   #
   #
   def request(path, params={}, *extra)
-    response = @adapter.request(path, map_params(params), *extra)
+    response = @connection.request(path, map_params(params), *extra)
     adapt_response(response)
   end
   
@@ -89,24 +112,24 @@ class RSolr::Client
     {:wt=>:ruby}.merge(params)
   end
 
-  # "adapter_response" must be a hash with the following keys:
+  # "connection_response" must be a hash with the following keys:
   #   :params - a sub hash of standard solr params
   #   : body - the raw response body from the solr server
   # This method will evaluate the :body value if the params[:wt] == :ruby
   # otherwise, the body is returned
-  # The return object has a special method attached called #adapter_response
-  # This method gives you access to the original response from the adapter,
+  # The return object has a special method attached called #connection_response
+  # This method gives you access to the original response from the connection,
   # so you can access things like the actual :url sent to solr,
   # the raw :body, original :params and original :data
-  def adapt_response(adapter_response)
-    data = adapter_response[:body]
+  def adapt_response(connection_response)
+    data = connection_response[:body]
     # if the wt is :ruby, evaluate the ruby string response
-    if adapter_response[:params][:wt] == :ruby
+    if connection_response[:params][:wt] == :ruby
       data = Kernel.eval(data)
     end
-    # attach a method called #adapter_response that returns the original adapter response value
+    # attach a method called #connection_response that returns the original connection response value
     def data.raw; @raw end
-    data.send(:instance_variable_set, '@raw', adapter_response)
+    data.send(:instance_variable_set, '@raw', connection_response)
     data
   end
   

data/lib/rsolr/connection/direct.rb

@@ -15,13 +15,9 @@ class RSolr::Connection::Direct
   # if opts is NOT an instance of org.apache.solr.servlet.DirectSolrConnection
   # then...
   # required: opts[:home_dir] is absolute path to solr home (the directory with "data", "config" etc.)
-  # opts must also contain either
-  #   :dist_dir => 'absolute path to solr distribution root
-  # or
-  #   :jar_paths => ['array of directories containing the solr lib/jars']
-  # OTHER OPTS:
-  #   :select_path => 'the/select/handler'
-  #   :update_path => 'the/update/handler'
+  # 
+  # You can load your own solr java libs by setting :autoload_jars to false.
+  # When set to true (default), RSolr loads its own set of solr java libs.
   def initialize(opts, &block)
     if defined?(Java::OrgApacheSolrCore::SolrCore) and opts.is_a?(Java::OrgApacheSolrCore::SolrCore)
       @connection = org.apache.solr.servlet.DirectSolrConnection.new(opts)
@@ -29,19 +25,13 @@ class RSolr::Connection::Direct
       @connection = opts
     else
       opts[:data_dir] ||= File.join(opts[:home_dir].to_s, 'data')
-      if opts[:dist_dir] and ! opts[:jar_paths]
-        # add the standard lib and dist directories to the :jar_paths
-        opts[:jar_paths] = [File.join(opts[:dist_dir], 'lib'), File.join(opts[:dist_dir], 'dist')]
-      end
       @opts = opts
     end
   end
   
-  # loads/imports the java dependencies
   # sets the @connection instance variable if it has not yet been set
   def connection
     @connection ||= (
-      require_jars(@opts[:jar_paths]) if @opts[:jar_paths]
       org.apache.solr.servlet.DirectSolrConnection.new(opts[:home_dir], @opts[:data_dir], nil)
     )
   end
@@ -65,24 +55,15 @@ class RSolr::Connection::Direct
       raise RSolr::RequestError.new($!.message)
     end
     {
-      :body=>body,
+      :status_code => 200,
       :url=>url,
+      :body=>body,
       :path=>path,
       :params=>params,
       :data=>data,
+      :headers => {},
+      :message => ''
     }
   end
   
-  protected
-  
-  # require the jar files
-  def require_jars(paths)
-    paths = [paths] unless paths.is_a?(Array)
-    paths.each do |path|
-      raise "Invalid jar path: #{path}" unless File.exists?(path)
-      jar_pattern = File.join(path,"**", "*.jar")
-      Dir[jar_pattern].each {|jar_file| require jar_file }
-    end
-  end
-  
 end

data/lib/rsolr/connection/net_http.rb

@@ -34,7 +34,7 @@ class RSolr::Connection::NetHttp
         http_context = self.get(path, params)
       end
     end
-    raise RSolr::RequestError.new(http_context[:body]) unless http_context[:status_code] == 200
+    raise RSolr::RequestError.new("Solr Response: #{http_context[:message]}") unless http_context[:status_code] == 200
     http_context
   end
   
@@ -63,14 +63,23 @@ class RSolr::Connection::NetHttp
     {
       :status_code=>net_http_response.code.to_i,
       :url=>full_url,
-      :body=>net_http_response.body,
+      :body=> encode_utf8(net_http_response.body),
       :path=>path,
       :params=>params,
       :data=>data,
-      :headers=>headers
+      :headers=>headers,
+      :message => net_http_response.message
     }
   end
   
+  # encodes the string as utf-8 in Ruby 1.9
+  # returns the unaltered string in Ruby 1.8
+  def encode_utf8 string
+    (string.respond_to?(:force_encoding) and string.respond_to?(:encoding)) ?
+      string.force_encoding(Encoding::UTF_8) : string
+  end
+  
+  # accepts a path/string and optional hash of query params
   def build_url path, params={}
     full_path = @uri.path + path
     super full_path, params, @uri.query

data/lib/rsolr/pagination.rb

@@ -0,0 +1,59 @@
+module RSolr::Pagination
+  
+  def self.extended solr_response
+    d = solr_response['response']['docs']
+    d.extend Paginator
+    d.per_page = solr_response['responseHeader']['params']['rows'].to_s.to_i
+    d.start = solr_response['response']['start'].to_s.to_i
+    d.total = solr_response['response']['numFound'].to_s.to_i
+  end
+  
+  def self.page_and_per_page_to_start_and_rows page, per_page
+    rows = per_page.to_s.to_i
+    page = page.to_s.to_i-1
+    page = page < 1 ? 0 : page
+    start = page * rows
+    [start, rows]
+  end
+  
+  module Paginator
+    
+    attr_accessor :start, :per_page, :total
+    
+    # Returns the current page calculated from 'rows' and 'start'
+    # WillPaginate hook
+    def current_page
+      return 1 if start < 1
+      per_page_normalized = per_page < 1 ? 1 : per_page
+      @current_page ||= (start / per_page_normalized).ceil + 1
+    end
+
+    # Calcuates the total pages from 'numFound' and 'rows'
+    # WillPaginate hook
+    def total_pages
+      @total_pages ||= per_page > 0 ? (total / 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) ? total_pages : current_page+1
+    end
+
+    def has_next?
+      current_page < total_pages
+    end
+
+    def has_previous?
+      current_page > 1
+    end
+    
+  end
+  
+end

data/lib/rsolr.rb

@@ -8,38 +8,37 @@ require 'xout'
 
 module RSolr
   
-  VERSION = '0.9.7.2'
+  VERSION = '0.10.0'
   
   autoload :Message, 'rsolr/message'
   autoload :Client, 'rsolr/client'
   autoload :Connection, 'rsolr/connection'
+  autoload :Pagination, 'rsolr/pagination'
   
-  # Factory for creating connections.
-  # 2 modes of argument operations:
-  #   1. first argument is solr-adapter type, second arg is options hash for solr-adapter instance.
-  #   2. options hash for solr-adapter only (no adapter type as first arg)
-  #
-  # Examples:
-  # # default http connection
-  # RSolr.connect
-  # # http connection with custom url
-  # RSolr.connect :url=>'http://solr.web100.org'
-  # # direct connection
-  # RSolr.connect :direct, :home_dir=>'solr', :dist_dir=>'solr-nightly'
-  def self.connect(*args)
-    type = args.first.is_a?(Symbol) ? args.shift : :http
-    opts = args
-    type_class = case type
-      when :net_http,:http,nil
-        'NetHttp'
-      when :direct
-        'Direct'
-      else
-        raise "Invalid connection type: #{type} - use :http, :direct or leave nil for :http/default"
-      end
-    adapter_class = RSolr::Connection.const_get(type_class)
-    adapter = adapter_class.new(*opts)
-    RSolr::Client.new(adapter)
+  # returns path to this file directory
+  def self.dir
+    File.expand_path(File.dirname(__FILE__))
+  end
+  
+  # Http connection. Example:
+  #   RSolr.connect
+  #   RSolr.connect 'http://solr.web100.org'
+  def self.connect *args
+    Client.new(Connection::NetHttp.new(*args))
+  end
+  
+  # DirectSolrConnection (jruby only). Example:
+  #   RSolr.direct_connect 'path/to/solr/distribution'
+  #   RSolr.direct_connect :dist_dir=>'path/to/solr/distribution', :home_dir=>'/path/to/solrhome'
+  #   RSolr.direct_connect opts do |rsolr|
+  #     ###
+  #   end
+  # Note:
+  # if a block is used, the client is yielded and the solr core will be closed for you.
+  # if a block is NOT used, the the client is returned and the core is NOT closed.
+  def self.direct_connect *args, &blk
+    rsolr = Client.new(Connection::Direct.new(*args))
+    block_given? ? (yield rsolr and rsolr.connection.close) : rsolr
   end
   
   # A module that contains string related methods

data/rsolr.gemspec

@@ -0,0 +1,29 @@
+Gem::Specification.new do |s|
+  s.name = "rsolr"
+  s.version = "0.10.0"
+  s.date = "2009-11-13"
+  s.summary = "A Ruby client for Apache Solr"
+  s.email = "goodieboy@gmail.com"
+  s.homepage = "http://github.com/mwmitchell/rsolr"
+  s.description = "RSolr is a Ruby gem for working with Apache Solr!"
+  s.has_rdoc = true
+  s.authors = ["Matt Mitchell"]
+  
+  s.files = [
+    "CHANGES.txt",
+    "lib/rsolr/client.rb",
+    "lib/rsolr/connection/direct.rb",
+    "lib/rsolr/connection/net_http.rb",
+    "lib/rsolr/connection.rb",
+    "lib/rsolr/message.rb",
+    "lib/rsolr/pagination.rb",
+    "lib/rsolr.rb",
+    "lib/xout.rb",
+    "LICENSE",
+    "README.rdoc",
+    "rsolr.gemspec"
+  ]
+  
+  #s.rdoc_options = ["--main", "README.rdoc"]
+  s.extra_rdoc_files = %w(LICENSE README.rdoc CHANGES.txt)
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rsolr
 version: !ruby/object:Gem::Version 
-  version: 0.9.7.2
+  version: 0.10.0
 platform: ruby
 authors: 
 - Matt Mitchell
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-06 00:00:00 -05:00
+date: 2009-11-13 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -21,23 +21,21 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- Rakefile
 - README.rdoc
 - CHANGES.txt
 files: 
-- examples/direct.rb
-- examples/http.rb
+- CHANGES.txt
 - lib/rsolr/client.rb
 - lib/rsolr/connection/direct.rb
 - lib/rsolr/connection/net_http.rb
 - lib/rsolr/connection.rb
 - lib/rsolr/message.rb
+- lib/rsolr/pagination.rb
 - lib/rsolr.rb
 - lib/xout.rb
 - LICENSE
-- Rakefile
 - README.rdoc
-- CHANGES.txt
+- rsolr.gemspec
 has_rdoc: true
 homepage: http://github.com/mwmitchell/rsolr
 licenses: []
@@ -66,11 +64,5 @@ rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: A Ruby client for Apache Solr
-test_files: 
-- test/connection/direct_test.rb
-- test/connection/net_http_test.rb
-- test/connection/test_methods.rb
-- test/connection/utils_test.rb
-- test/helper.rb
-- test/message_test.rb
-- test/rsolr_test.rb
+test_files: []
+

data/Rakefile

@@ -1,14 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
-
-ENV['RUBYOPT'] = '-W1'
- 
-task :environment do
-  require File.dirname(__FILE__) + '/lib/rsolr'
-end
- 
-Dir['tasks/**/*.rake'].each { |t| load t }
-
-task :default => ['spec:api']

data/examples/direct.rb

@@ -1,29 +0,0 @@
-# Must be executed using jruby
-require File.join(File.dirname(__FILE__), '..', 'lib', 'rsolr')
-
-base = File.expand_path( File.dirname(__FILE__) )
-dist = File.join(base, '..', 'apache-solr')
-home = File.join(dist, 'example', 'solr')
-
-solr = RSolr.connect(:direct, :home_dir=>home, :dist_dir=>dist)
-
-Dir['../apache-solr/example/exampledocs/*.xml'].each do |xml_file|
-  puts "Updating with #{xml_file}"
-  solr.update File.read(xml_file)
-end
-
-solr.commit
-
-puts
-
-response = solr.select :q=>'ipod', :fq=>'price:[0 TO 50]', :rows=>2, :start=>0
-
-docs = response['response']['docs']
-
-docs.each do |doc|
-  puts doc['timestamp']
-end
-
-solr.delete_by_query('*:*') and solr.commit
-
-solr.adapter.close

data/examples/http.rb

@@ -1,24 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'lib', 'rsolr')
-
-solr = RSolr.connect
-
-Dir['../apache-solr/example/exampledocs/*.xml'].each do |xml_file|
-  puts "Updating with #{xml_file}"
-  solr.update File.read(xml_file)
-end
-
-solr.commit
-
-puts
-
-response = solr.select(:q=>'ipod', :fq=>['price:[0 TO 50]'], :rows=>2, :start=>0)
-
-puts "URL : #{response.raw[:url]} -> #{response.raw[:status_code]}"
-
-puts
-
-response['response']['docs'].each do |doc|
-  puts doc['timestamp']
-end
-
-solr.delete_by_query('*:*') and solr.commit

data/test/connection/direct_test.rb

@@ -1,37 +0,0 @@
-if defined?(JRUBY_VERSION)
-  
-  require 'helper'
-  require 'connection/test_methods'
-  
-  class ConnectionDirectTest < RSolrBaseTest
-    
-    include ConnectionTestMethods
-    
-    attr :dist
-    attr :home
-    
-    def setup
-      base = File.expand_path( File.dirname(__FILE__) )
-      @dist = File.join(base, '..', '..', 'solr')
-      @home = File.join(dist, 'example', 'solr')
-      @solr = RSolr.connect(:direct, :home_dir=>@home, :dist_dir=>@dist)
-      @solr.delete_by_query('*:*')
-      @solr.commit
-    end
-    
-    def teardown
-      @solr.adapter.close
-    end
-    
-    def test_new_connection_with_existing_core
-      Dir["#{@dist}/dist/*.jar"].each { |p| require p }
-      dc = org.apache.solr.servlet.DirectSolrConnection.new(@home, "#{@home}/data", nil)
-      adapter = RSolr::Connection::Direct.new dc
-      s = RSolr::Connection::Base.new(adapter)
-      assert_equal Hash, s.request('/admin/ping').class
-      adapter.close
-    end
-    
-  end
-  
-end

data/test/connection/net_http_test.rb

@@ -1,29 +0,0 @@
-unless defined?(JRUBY_VERSION)
-  
-  require 'helper'
-  require 'connection/test_methods'
-  
-  class NetHttpTest < RSolrBaseTest
-  
-    include ConnectionTestMethods
-    
-    def setup
-      @solr = RSolr.connect
-      @solr.delete_by_query('*:*')
-      @solr.commit
-    end
-    
-    # http://www.w3.org/TR/html4/interact/forms.html#submit-format
-    
-    # due to the way some servers implement their query string parsing,
-    # POST is sometimes needed for large query strings.
-    # This test simply shows that a large q value will not blow up solr.
-    def test_post_for_select
-      big_honkin_q = (['ipod']*1000).join(' OR ')
-      response = @solr.adapter.request '/select', {:q=>big_honkin_q}, :method=>:post
-      assert response
-    end
-    
-  end
-  
-end

data/test/connection/test_methods.rb

@@ -1,97 +0,0 @@
-# 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.select(:q=>'*:*')['response']['docs'].size
-  end
-  
-  # If :wt is NOT :ruby, the format doesn't get converted into a Mash (special Hash; see lib/mash.rb)
-  # Raw ruby can be returned by using :wt=>'ruby', not :ruby
-  def test_raw_response_formats
-    ruby_response = @solr.select(:q=>'*:*', :wt=>'ruby')
-    assert ruby_response.is_a?(String)
-    assert ruby_response =~ %r('wt'=>'ruby')
-    # xml?
-    xml_response = @solr.select(:q=>'*:*', :wt=>'xml')
-    assert xml_response.is_a?(String)
-    assert xml_response =~ %r(<str name="wt">xml</str>)
-    # json?
-    json_response = @solr.select(:q=>'*:*', :wt=>'json')
-    assert json_response.is_a?(String)
-    assert json_response =~ %r("wt":"json")
-  end
-  
-  def test_raise_on_invalid_query
-    assert_raise RSolr::RequestError do
-      @solr.select(:q=>'!')
-    end
-  end
-  
-  def test_select_response_docs
-    @solr.add(:id=>1, :price=>1.00, :cat=>['electronics', 'something else'])
-    @solr.commit
-    r = @solr.select(:q=>'*:*')
-    assert r.is_a?(Hash)
-    
-    docs = r['response']['docs']
-    assert_equal Array, docs.class
-    first = docs.first
-    
-    # test the has? method
-    assert_equal 1.00, first['price']
-    
-    assert_equal Array, first['cat'].class
-    assert first['cat'].include?('electronics')
-    assert first['cat'].include?('something else')
-    assert first['cat'].include?('something else')
-    
-  end
-  
-  def test_add
-    assert_equal 0, @solr.select(:q=>'*:*')['response']['numFound']
-    update_response = @solr.add({:id=>100})
-    assert update_response.is_a?(Hash)
-    #
-    @solr.commit
-    assert_equal 1, @solr.select(:q=>'*:*')['response']['numFound']
-  end
-  
-  def test_delete_by_id
-    @solr.add(:id=>100)
-    @solr.commit
-    total = @solr.select(:q=>'*:*')['response']['numFound']
-    assert_equal 1, total
-    delete_response = @solr.delete_by_id(100)
-    @solr.commit
-    assert delete_response.is_a?(Hash)
-    total = @solr.select(:q=>'*:*')['response']['numFound']
-    assert_equal 0, total
-  end
-  
-  def test_delete_by_query
-    @solr.add(:id=>1, :name=>'BLAH BLAH BLAH')
-    @solr.commit
-    assert_equal 1, @solr.select(:q=>'*:*')['response']['numFound']
-    response = @solr.delete_by_query('name:"BLAH BLAH BLAH"')
-    @solr.commit
-    assert response.is_a?(Hash)
-    assert_equal 0, @solr.select(:q=>'*:*')['response']['numFound']
-  end
-  
-  def test_admin_luke_index_info
-    response = @solr.request('/admin/luke', :numTerms=>0)
-    assert response.is_a?(Hash)
-    # make sure the ? methods are true/false
-    assert [true, false].include?(response['index']['current'])
-    assert [true, false].include?(response['index']['optimized'])
-    assert [true, false].include?(response['index']['hasDeletions'])
-  end
-  
-end

data/test/connection/utils_test.rb

@@ -1,83 +0,0 @@
-require 'helper'
-
-class HTTPUtilTest < RSolrBaseTest
-  
-  class DummyClass
-    include RSolr::Connection::Utils
-  end
-  
-  def setup
-    @c = DummyClass.new
-  end
-  
-  def test_build_url
-    assert_equal '/something', @c.build_url('/something')
-    assert_equal '/something?q=Testing', @c.build_url('/something', :q=>'Testing')
-    assert_equal '/something?array=1&array=2&array=3', @c.build_url('/something', :array=>[1, 2, 3])
-    result = @c.build_url('/something', :q=>'A', :array=>[1, 2, 3])
-    assert result=~/^\/something\?/
-    assert result=~/q=A/
-    assert result=~/array=1/
-    assert result=~/array=2/
-    assert result=~/array=3/
-  end
-  
-  def test_escape
-    assert_equal '%2B', @c.escape('+')
-    assert_equal 'This+is+a+test', @c.escape('This is a test')
-    assert_equal '%3C%3E%2F%5C', @c.escape('<>/\\')
-    assert_equal '%22', @c.escape('"')
-    assert_equal '%3A', @c.escape(':')
-  end
-  
-  def test_hash_to_query
-    my_params = {
-      :z=>'should be whatever',
-      :q=>'test',
-      :d=>[1, 2, 3, 4],
-      :b=>:zxcv,
-      :x=>['!', '*', nil]
-    }
-    result = @c.hash_to_query(my_params)
-    assert result=~/z=should\+be\+whatever/
-    assert result=~/q=test/
-    assert result=~/d=1/
-    assert result=~/d=2/
-    assert result=~/d=3/
-    assert result=~/d=4/
-    assert result=~/b=zxcv/
-    assert result=~/x=%21/
-    assert result=~/x=*/
-    assert result=~/x=&?/
-  end
-  
-  def test_ampersand_within_query_value
-    my_params = {
-      "fq" => "building_facet:\"Green (Humanities & Social Sciences)\""
-    }
-    expected = 'fq=building_facet%3A%22Green+%28Humanities+%26+Social+Sciences%29%22'
-    assert_equal expected, @c.hash_to_query(my_params)
-  end
-  
-  def test_brackets
-    assert_equal '%7B', @c.escape('{')
-    assert_equal '%7D', @c.escape('}')
-  end
-  
-  def test_exclamation
-    assert_equal '%21', @c.escape('!')
-  end
-  
-  def test_complex_solr_query1
-    my_params = {'fq' => '{!raw f=field_name}crazy+\"field+value'}
-    expected = 'fq=%7B%21raw+f%3Dfield_name%7Dcrazy%2B%5C%22field%2Bvalue'
-    assert_equal expected, @c.hash_to_query(my_params)
-  end
-  
-  def test_complex_solr_query2
-    my_params = {'q' => '+popularity:[10 TO *] +section:0'}
-    expected = 'q=%2Bpopularity%3A%5B10+TO+%2A%5D+%2Bsection%3A0'
-    assert_equal expected, @c.hash_to_query(my_params)
-  end
-  
-end

data/test/helper.rb

@@ -1,61 +0,0 @@
-
-require File.join(File.dirname(__FILE__), '..', 'lib', 'rsolr')
-require 'test/unit'
-
-# 
-class Test::Unit::TestCase
-  
-  def self.test(name, &block)
-    test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
-    defined = instance_method(test_name) rescue false
-    raise "#{test_name} is already defined in #{self}" if defined
-    if block_given?
-      define_method(test_name, &block)
-    else
-      define_method(test_name) do
-        flunk "No implementation provided for #{name}"
-      end
-    end
-  end
-  
-end
-
-class RSolrBaseTest < Test::Unit::TestCase
-  
-  def assert_class(expected, instance)
-    assert_equal expected, instance.class
-  end
-  
-  def default_test
-    
-  end
-  
-end
-
-begin
-  require 'rubygems'
-  require 'redgreen'
-rescue LoadError
-end
-
-def mock_query_response
-  %({'responseHeader'=>{
-    'status'=>0,'QTime'=>43,'params'=>{
-      'q'=>'*:*','wt'=>'ruby','echoParams'=>'EXPLICIT'
-    }
-  },
-  'response'=>{
-    'numFound'=>26,'start'=>0,'docs'=>[
-      {'id'=>'SP2514N','inStock'=>true,'manu'=>'Samsung Electronics Co. Ltd.','name'=>'Samsung SpinPoint P120 SP2514N - hard drive - 250 GB - ATA-133','popularity'=>6,'price'=>92.0,'sku'=>'SP2514N','timestamp'=>'2008-11-21T17:21:55.601Z','cat'=>['electronics','hard drive'],'spell'=>['Samsung SpinPoint P120 SP2514N - hard drive - 250 GB - ATA-133'],'features'=>['7200RPM, 8MB cache, IDE Ultra ATA-133','NoiseGuard, SilentSeek technology, Fluid Dynamic Bearing (FDB) motor']},
-      {'id'=>'6H500F0','inStock'=>true,'manu'=>'Maxtor Corp.','name'=>'Maxtor DiamondMax 11 - hard drive - 500 GB - SATA-300','popularity'=>6,'price'=>350.0,'sku'=>'6H500F0','timestamp'=>'2008-11-21T17:21:55.617Z','cat'=>['electronics','hard drive'],'spell'=>['Maxtor DiamondMax 11 - hard drive - 500 GB - SATA-300'],'features'=>['SATA 3.0Gb/s, NCQ','8.5ms seek','16MB cache']},
-      {'id'=>'F8V7067-APL-KIT','inStock'=>false,'manu'=>'Belkin','name'=>'Belkin Mobile Power Cord for iPod w/ Dock','popularity'=>1,'price'=>19.95,'sku'=>'F8V7067-APL-KIT','timestamp'=>'2008-11-21T17:21:55.652Z','weight'=>4.0,'cat'=>['electronics','connector'],'spell'=>['Belkin Mobile Power Cord for iPod w/ Dock'],'features'=>['car power adapter, white']},
-      {'id'=>'IW-02','inStock'=>false,'manu'=>'Belkin','name'=>'iPod & iPod Mini USB 2.0 Cable','popularity'=>1,'price'=>11.5,'sku'=>'IW-02','timestamp'=>'2008-11-21T17:21:55.657Z','weight'=>2.0,'cat'=>['electronics','connector'],'spell'=>['iPod & iPod Mini USB 2.0 Cable'],'features'=>['car power adapter for iPod, white']},
-      {'id'=>'MA147LL/A','inStock'=>true,'includes'=>'earbud headphones, USB cable','manu'=>'Apple Computer Inc.','name'=>'Apple 60 GB iPod with Video Playback Black','popularity'=>10,'price'=>399.0,'sku'=>'MA147LL/A','timestamp'=>'2008-11-21T17:21:55.681Z','weight'=>5.5,'cat'=>['electronics','music'],'spell'=>['Apple 60 GB iPod with Video Playback Black'],'features'=>['iTunes, Podcasts, Audiobooks','Stores up to 15,000 songs, 25,000 photos, or 150 hours of video','2.5-inch, 320x240 color TFT LCD display with LED backlight','Up to 20 hours of battery life','Plays AAC, MP3, WAV, AIFF, Audible, Apple Lossless, H.264 video','Notes, Calendar, Phone book, Hold button, Date display, Photo wallet, Built-in games, JPEG photo playback, Upgradeable firmware, USB 2.0 compatibility, Playback speed control, Rechargeable capability, Battery level indication']},
-      {'id'=>'TWINX2048-3200PRO','inStock'=>true,'manu'=>'Corsair Microsystems Inc.','name'=>'CORSAIR  XMS 2GB (2 x 1GB) 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) Dual Channel Kit System Memory - Retail','popularity'=>5,'price'=>185.0,'sku'=>'TWINX2048-3200PRO','timestamp'=>'2008-11-21T17:21:55.706Z','cat'=>['electronics','memory'],'spell'=>['CORSAIR  XMS 2GB (2 x 1GB) 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) Dual Channel Kit System Memory - Retail'],'features'=>['CAS latency 2,	2-3-3-6 timing, 2.75v, unbuffered, heat-spreader']},
-      {'id'=>'VS1GB400C3','inStock'=>true,'manu'=>'Corsair Microsystems Inc.','name'=>'CORSAIR ValueSelect 1GB 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) System Memory - Retail','popularity'=>7,'price'=>74.99,'sku'=>'VS1GB400C3','timestamp'=>'2008-11-21T17:21:55.71Z','cat'=>['electronics','memory'],'spell'=>['CORSAIR ValueSelect 1GB 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) System Memory - Retail']},
-      {'id'=>'VDBDB1A16','inStock'=>true,'manu'=>'A-DATA Technology Inc.','name'=>'A-DATA V-Series 1GB 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) System Memory - OEM','popularity'=>5,'sku'=>'VDBDB1A16','timestamp'=>'2008-11-21T17:21:55.712Z','cat'=>['electronics','memory'],'spell'=>['A-DATA V-Series 1GB 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) System Memory - OEM'],'features'=>['CAS latency 3,	 2.7v']},
-      {'id'=>'3007WFP','inStock'=>true,'includes'=>'USB cable','manu'=>'Dell, Inc.','name'=>'Dell Widescreen UltraSharp 3007WFP','popularity'=>6,'price'=>2199.0,'sku'=>'3007WFP','timestamp'=>'2008-11-21T17:21:55.724Z','weight'=>401.6,'cat'=>['electronics','monitor'],'spell'=>['Dell Widescreen UltraSharp 3007WFP'],'features'=>['30" TFT active matrix LCD, 2560 x 1600, .25mm dot pitch, 700:1 contrast']},
-      {'id'=>'VA902B','inStock'=>true,'manu'=>'ViewSonic Corp.','name'=>'ViewSonic VA902B - flat panel display - TFT - 19"','popularity'=>6,'price'=>279.95,'sku'=>'VA902B','timestamp'=>'2008-11-21T17:21:55.734Z','weight'=>190.4,'cat'=>['electronics','monitor'],'spell'=>['ViewSonic VA902B - flat panel display - TFT - 19"'],'features'=>['19" TFT active matrix LCD, 8ms response time, 1280 x 1024 native resolution']}]
-    }
-  })
-end

data/test/message_test.rb

@@ -1,140 +0,0 @@
-
-require 'helper'
-
-class BuilderMessageTest < RSolrBaseTest
-  
-  def builder
-    @builder ||= RSolr::Message::Builder.new
-  end
-  
-  # call all of the simple methods...
-  # make sure the xml string is valid
-  # ensure the class is actually Solr::XML
-  def test_simple_methods
-    [:optimize, :rollback, :commit].each do |meth|
-      result = self.builder.send(meth)
-      assert_equal "<#{meth}/>", result.to_s
-      assert_equal String, result.class
-    end
-  end
-
-  def test_add_yields_doc_objects_if_block_given
-    documents = [{:id=>1, :name=>'sam', :cat=>['cat 1', 'cat 2']}]
-    add_attrs = {:boost=>200.00}
-    result = self.builder.add(documents, add_attrs) do |doc|
-      doc.field_by_name(:name).attrs[:boost] = 10
-      assert_equal 4, doc.fields.size
-      assert_equal 2, doc.fields_by_name(:cat).size
-    end
-    #<add boost="200.0">
-      #<doc>
-        #<field name="cat">cat 1</field>
-        #<field name="cat">cat 2</field>
-        #<field name="name" boost="10">sam</field>
-        #<field name="id">1</field>
-      #</doc>
-    #</add>
-    assert result =~ %r(name="cat">cat 1</field>)
-    assert result =~ %r(name="cat">cat 2</field>)
-    assert result =~ %r(<add boost="200.0">)
-    assert result =~ %r(boost="10")
-    assert result =~ %r(<field name="id">1</field>)
-  end
-
-  def test_delete_by_id
-    result = self.builder.delete_by_id(10)
-    assert_equal String, result.class
-    assert_equal '<delete><id>10</id></delete>', result.to_s
-  end
-
-  def test_delete_by_multiple_ids
-    result = self.builder.delete_by_id([1, 2, 3])
-    assert_equal String, result.class
-    assert_equal '<delete><id>1</id><id>2</id><id>3</id></delete>', result.to_s
-  end
-
-  def test_delete_by_query
-    result = self.builder.delete_by_query('status:"LOST"')
-    assert_equal String, result.class
-    assert_equal '<delete><query>status:"LOST"</query></delete>', result.to_s
-  end
-
-  def test_delete_by_multiple_queries
-    result = self.builder.delete_by_query(['status:"LOST"', 'quantity:0'])
-    assert_equal String, result.class
-    assert_equal '<delete><query>status:"LOST"</query><query>quantity:0</query></delete>', result.to_s
-  end
-
-  # add a single hash ("doc")
-  def test_add_hash
-    data = {
-      :id=>1,
-      :name=>'matt'
-    }
-    assert self.builder.add(data).to_s =~ /<field name="name">matt<\/field>/
-    assert self.builder.add(data).to_s =~ /<field name="id">1<\/field>/
-  end
-
-  # add an array of hashes
-  def test_add_array
-    data = [
-      {
-        :id=>1,
-        :name=>'matt'
-      },
-      {
-        :id=>2,
-        :name=>'sam'
-      }
-    ]
-  
-    message = self.builder.add(data)
-    expected = '<add><doc><field name="id">1</field><field name="name">matt</field></doc><doc><field name="id">2</field><field name="name">sam</field></doc></add>'
-    
-    assert message.to_s=~/<field name="name">matt<\/field>/
-    assert message.to_s=~/<field name="name">sam<\/field>/
-  end
-
-  # multiValue field support test, thanks to Fouad Mardini!
-  def test_add_multi_valued_field
-    data = {
-      :id   => 1,
-      :name => ['matt1', 'matt2']
-    }
-  
-    result = self.builder.add(data)
-  
-    assert result.to_s =~ /<field name="name">matt1<\/field>/
-    assert result.to_s =~ /<field name="name">matt2<\/field>/
-  end
-
-  def test_add_single_document
-    document = RSolr::Message::Document.new
-    document.add_field('id', 1)
-    document.add_field('name', 'matt', :boost => 2.0)
-    result = self.builder.add(document)
-  
-    assert result.to_s =~ /<field name="id">1<\/field>/
-  
-    # depending on which ruby version, the attributes can be out of place
-    # so we need to test both... there's gotta be a better way to do this?
-    assert(
-      result.to_s =~ /<field name="name" boost="2.0">matt<\/field>/ || 
-      result.to_s =~ /<field boost="2.0" name="name">matt<\/field>/
-    )
-  end
-
-  def test_add_multiple_documents
-    documents = (1..2).map do |i|
-      doc = RSolr::Message::Document.new
-      doc.add_field('id', i)
-      doc.add_field('name', "matt#{i}")
-      doc
-    end
-    result = self.builder.add(documents)
-
-    assert result.to_s =~ /<field name="name">matt1<\/field>/
-    assert result.to_s =~ /<field name="name">matt2<\/field>/
-  end
-  
-end

data/test/rsolr_test.rb

@@ -1,21 +0,0 @@
-require 'helper'
-
-class SolrTest < RSolrBaseTest
-  
-  def setup
-    if defined?(JRUBY_VERSION)
-      @solr = RSolr.connect(:adapter=>:direct)
-    else
-      @solr = RSolr.connect
-    end
-  end
-  
-  def test_escape
-    expected = %q(http\:\/\/lucene\.apache\.org\/solr)
-    source = "http://lucene.apache.org/solr"
-    assert_equal expected, RSolr.escape(source)
-    assert @solr.respond_to?(:escape)
-    assert_equal expected, @solr.escape(source)
-  end
-  
-end