mwmitchell-rsolr 0.9.1 → 0.9.5

data/CHANGES.txt

@@ -1,3 +1,23 @@
+0.9.5 - September 4, 2009
+  Removed Array #extract_options!
+  Removed the Connection #send_request method (now #request)
+  Removed the Connection #select method -- still works, but this now ends up calling Connection #method_missing
+  Removed HTTPClient::Connector
+    - HTTPClient now uses a method called #connect (like RSolr.connect)
+    - This method accepts 1 or 2 args, see the #connect method comments
+  Changed the way the HTTP client adapter is set. Now just pass in when connecting:
+    - RSolr.connect(:http, :adapter=>curb, :url=>'http://solr.com')
+  Moved Message::Builders to Message::Adapter
+  Made Connection a module and moved class methods to "Base" class
+  Made HTTPClient a module and moved class methods to "Base" class
+  Removed the "adapter.rb" files -- Adapter modules are defined in the parent module file.
+  Moved Message module/singleton functionality to Message::Builder class
+  XML message adapter API change: no longer a singleton, must instantiate Message::Builder
+  Made RSolr::Connection #message public -- can change the adapter as needed; connection.message.adapter = RSolr::Message::Adapter::LibXML.new
+  More tests for HTTPClient::Util
+  Simplified url/query building in HTTPClient::Util
+  Updated tests accordingly
+
 0.9.1 - July 22, 2009
   Added LibXml builder support (Thanks to Mat Brown - github.com/outoftime)
 

data/LICENSE

@@ -10,58 +10,4 @@ Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
-limitations under the License.
-
-========================================================================
-
-For use of the lib/Mash/extlib code:
-
-========================================================================
-
-Copyright (c) 2008 Sam Smoot.
- 
-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.
- 
----
----
- 
-Some portions of blank.rb and mash.rb are verbatim copies of software
-licensed under the MIT license. That license is included below:
- 
-Copyright (c) 2005-2008 David Heinemeier Hansson
- 
-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.
+limitations under the License.

data/README.rdoc

@@ -1,83 +1,79 @@
 =RSolr
 
-A Ruby client for Apache Solr. Has transparent JRuby support by using "org.apache.solr.servlet.DirectSolrConnection" as a connection adapter.
+A Ruby client for Apache Solr. RSolr has been developed to be simple and extendable. It features transparent JRuby DirectSolrConnection support and a simple Hash-in, Hash-out architecture.
 
-==Installation:
+== Installation:
   gem sources -a http://gems.github.com
   sudo gem install mwmitchell-rsolr
 
-==Community
-  http://groups.google.com/group/rsolr
+==Related Resources & Projects
+* {Solr}[http://lucene.apache.org/solr/]
+* {RSolr Google Group}[http://groups.google.com/group/rsolr]
+* {RSolr::Ext}[http://github.com/mwmitchell/rsolr-ext] -- an extension kit for RSolr
+* {Sunspot}[http://github.com/outoftime/sunspot] -- an awesome Solr DSL, built with RSolr
+* {Blacklight}[http://blacklightopac.org] -- a next generation Library OPAC, built with RSolr
+* {solr-ruby}[http://wiki.apache.org/solr/solr-ruby] -- the original Solr Ruby Gem
 
-==Related Projects
-  http://github.com/mwmitchell/rsolr-ext
-  http://wiki.apache.org/solr/solr-ruby
-
-==Simple usage:
+== Simple usage:
   require 'rubygems'
   require 'rsolr'
-  rsolr = RSolr.connect
+  solr = RSolr.connect :url=>'http://solrserver.com'
   
-  # sends a request to /select
-  response = rsolr.select(:q=>'*:*')
+  # send a request to /select
+  response = rsolr.select :q=>'*:*'
   
   # send a request to a custom request handler; /catalog
-  response = rsolr.send_request('/catalog', :q=>'*:*')
+  response = rsolr.request '/catalog', :q=>'*:*'
   
-  # alternative to above (uses Ruby's method_missing):
+  # alternative to above:
   response = rsolr.catalog :q=>'*:*'
-
-To run tests:
-  
-  Copy an Apache Solr 1.3.0/or later (http://apache.seekmeup.com/lucene/solr/1.3.0/) distribution into this directory and rename to "apache-solr"
-  Start Solr HTTP:    rake rsolr:start_test_server
-  MRI Ruby:           rake
-  JRuby:              jruby -S rake
-
-To get a connection in MRI/standard Ruby:
   
-  solr = RSolr.connect
-
-To change the Solr HTTP host:
+To use a DirectSolrConnection (no http) in JRuby:
   
-  solr = RSolr.connect(:url=>'http://solrserver.com')
-
-To get a direct connection (no http) in jRuby using DirectSolrConnection:
-  
-  solr = RSolr.connect({
-    :adapter=>:direct,
+  solr = RSolr.connect(:direct,
     :home_dir=>'/path/to/solr/home',
     :dist_dir=>'/path/to/solr/distribution'
-  })
+  )
 
-== Requests
-Once you have a connection, you can execute queries, updates etc..
+For more information about DirecSolrConnection, see the {API}[http://lucene.apache.org/solr/api/org/apache/solr/servlet/DirectSolrConnection.html].
 
-=== Querying
+
+== Querying
 Use the #select method to send requests to the /select handler:
   response = solr.select({
     :q=>'washington',
     :start=>0,
     :rows=>10
   })
+
+The params sent into the method are sent to Solr as-is. The one exception is if a value is an array. When an array is used, multiple parameters are generated for the Solr query. Example:
   
-Use the #send_request method to set a custom request handler path:
-  response = solr.send_request('/documents', {:q=>'test'})
+  solr.select :q=>'roses', :fq=>['red', 'violet']
 
+The above statement generates this Solr query:
+  
+  ?q=roses&fq=red&fq=violet
+
+Use the #request method for a custom request handler path:
+  response = solr.request '/documents', :q=>'test'
+
+A shortcut for the above example:
+  response = solr.documents :q=>'test'
 
-=== 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 can also be used of course.
+
+== 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.
 
 Raw XML via  #update
-  solr.update('</commit>')
-  solr.update('</optimize>')
+  solr.update '</commit>'
+  solr.update '</optimize>'
 
 Single document via #add
-  solr.add(:id=>1, :price=>1.00)
+  solr.add :id=>1, :price=>1.00
 
 Multiple documents via #add
   documents = [{:id=>1, :price=>1.00}, {:id=>2, :price=>10.50}]
-  solr.add(documents)
+  solr.add documents
 
 When adding, you can also supply "add" xml element attributes and/or a block for manipulating other "add" related elements (docs and fields) when using the #add method:
   
@@ -91,23 +87,27 @@ When adding, you can also supply "add" xml element attributes and/or a block for
   end
 
 Delete by id
-  solr.delete_by_id(1)
+  solr.delete_by_id 1
 or an array of ids
-  solr.delete_by_id([1, 2, 3, 4])
+  solr.delete_by_id [1, 2, 3, 4]
 
 Delete by query:
-  solr.delete_by_query('price:1.00')
+  solr.delete_by_query 'price:1.00'
 Delete by array of queries
-  solr.delete_by_query(['price:1.00', 'price:10.00'])
-
+  solr.delete_by_query ['price:1.00', 'price:10.00']
 
 Commit & optimize shortcuts
   solr.commit
   solr.optimize
 
+===XML Builders for RSolr
+As of version 0.9.1, RSolr can use LibXml to create the update messages sent to solr. To switch from Builder to LibXml, set the RSolr::Message.builder like:
+  solr = RSolr.connect
+  solr.message.adapter = RSolr::Message::Adapter::Libxml.new
+
 
 == Response Formats
-The default response format is Ruby. When the :wt param is set to :ruby, the response is eval'd and wrapped up in a nice Mash (Hash) class. You can get a raw response by setting the :wt to "ruby" - notice, the string -- not a symbol. All other response formats are available as expected, :wt=>'xml' etc..
+The default response format is Ruby. When the :wt param is set to :ruby, the response is eval'd resulting in a Hash. You can get a raw response by setting the :wt to "ruby" - notice, the string -- not a symbol. RSolr will eval the Ruby string ONLY if the :wt value is :ruby. All other response formats are available as expected, :wt=>'xml' etc..
 
 ===Evaluated Ruby (default)
   solr.select(:wt=>:ruby) # notice :ruby is a Symbol
@@ -120,7 +120,7 @@ The default response format is Ruby. When the :wt param is set to :ruby, the res
   solr.select(:wt=>:json)
 
 You can access the original request context (path, params, url etc.) by calling the #adapter_response method:
-  response = solr.select(:q=>'*:*')
+  response = solr.select :q=>'*:*'
   response.adapter_response[:status_code]
   response.adapter_response[:body]
   response.adapter_response[:url]
@@ -129,20 +129,20 @@ The adapter_response is a hash that contains the generated params, url, path, po
 
 
 == HTTP Client Adapter
-You can specify the http client adapter to use by setting solr.adapter.connector.adapter_name to one of:
+You can specify the http client adapter:
   :net_http     uses the standard Net::HTTP library
-  :curb         uses the Ruby "curl" bindings
+  :curb         uses the C based "curl" library
 
-Example:
-	
-  solr.adapter.connector.adapter_name = :curb
+NOTE: The Net::Http is the default adapter.
 
-Example of using the HTTP client only:
+Example:
   
-  hclient = RSolr::HTTPClient::Connector.new(:curb).connect(url)
-  hclient = RSolr::HTTPClient::Connector.new(:net_http).connect(url)
-  hclient.get('/')
+  RSolr.connect(:adapter => :curb)
+  RSolr.connect(:adapter => :net_http)
 
-After reading this http://apocryph.org/2008/11/09/more_indepth_analysis_ruby_http_client_performance - I would recommend using the :curb adapter. NOTE: You can't use the :curb adapter under jRuby. To install curb:
+Intereseting read about Ruby's Net::HTTP library:
+http://apocryph.org/2008/11/09/more_indepth_analysis_ruby_http_client_performance
 
+NOTE: You can't use the :curb adapter under jRuby. To install curb:
+  
   sudo gem install curb

data/Rakefile

@@ -29,24 +29,24 @@ Spec::Rake::SpecTask.new('spec') do |t|
   t.libs += ["lib", "spec"]
 end
 
-#desc 'Run specs' # this task runs each test in its own process
-#task :specs do
-#  require 'rubygems'
-#  require 'facets/more/filelist' unless defined?(FileList)
-#  files = FileList["**/*_spec.rb"]
-#  p files.to_a
-#  files.each do |filename|
-#    system "cd #{File.dirname(filename)} && ruby #{File.basename(filename)}"
-#  end
-#end
+desc 'Run specs' # this task runs each test in its own process
+task :specs do
+  require 'rubygems'
+  require 'facets/more/filelist' unless defined?(FileList)
+  files = FileList["**/*_spec.rb"]
+  p files.to_a
+  files.each do |filename|
+    system "cd #{File.dirname(filename)} && ruby #{File.basename(filename)}"
+  end
+end
 
-#desc "Run specs"
-#Rake::TestTask.new("specs") { |t|
-#  t.pattern = 'spec/**/*_spec.rb'
-#  t.verbose = true
-#  t.warning = true
-#  t.libs += ["lib", "spec"]
-#}
+desc "Run specs"
+Rake::TestTask.new("specs") { |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.verbose = true
+  t.warning = true
+  t.libs += ["lib", "spec"]
+}
 
 # Clean house
 desc 'Clean up tmp files.'

data/examples/direct.rb

@@ -5,13 +5,15 @@ base = File.expand_path( File.dirname(__FILE__) )
 dist = File.join(base, '..', 'apache-solr')
 home = File.join(dist, 'example', 'solr')
 
-solr = RSolr.connect(:adapter=>:direct, :home_dir=>home, :dist_dir=>dist)
+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

data/examples/http.rb

@@ -1,22 +1,24 @@
 require File.join(File.dirname(__FILE__), '..', 'lib', 'rsolr')
 
-solr = RSolr.connect
-
-# switch out the http adapter from curb to net_http (just for an example)
-solr.adapter.connector.adapter_name = :curb
+# switch out the http adapter from net_http to curb
+solr = RSolr.connect :adapter=>:curb
 
 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)
+response = solr.select(:q=>'ipod', :fq=>['price:[0 TO 50]'], :rows=>2, :start=>0)
 
 puts "URL : #{response.adapter_response[:url]} -> #{response.adapter_response[:status_code]}"
 
-solr_response['response']['docs'].each do |doc|
+puts
+
+response['response']['docs'].each do |doc|
   puts doc['timestamp']
 end
 

data/lib/rsolr/{adapter → connection/adapter}/direct.rb

@@ -5,7 +5,7 @@ require 'java'
 #
 # Connection for JRuby + DirectSolrConnection
 #
-class RSolr::Adapter::Direct
+class RSolr::Connection::Adapter::Direct
   
   include RSolr::HTTPClient::Util
   
@@ -52,8 +52,9 @@ class RSolr::Adapter::Direct
   end
   
   # send a request to the connection
+  # request '/select', :q=>'something'
   # request '/update', :wt=>:xml, '</commit>'
-  def send_request(path, params={}, data=nil)
+  def request(path, params={}, data=nil)
     data = data.to_xml if data.respond_to?(:to_xml)
     url = build_url(path, params)
     begin

data/lib/rsolr/{adapter → connection/adapter}/http.rb

@@ -1,25 +1,24 @@
 #
 # Connection for standard HTTP Solr server
 #
-class RSolr::Adapter::HTTP
+class RSolr::Connection::Adapter::HTTP
   
-  attr_reader :opts, :connector, :connection
+  attr_reader :opts
   
   # opts can have:
   #   :url => 'http://localhost:8080/solr'
   def initialize(opts={}, &block)
-    opts[:url]||='http://127.0.0.1:8983/solr'
+    opts[:url] ||= 'http://127.0.0.1:8983/solr'
     @opts = opts
-    @connector = RSolr::HTTPClient::Connector.new
   end
   
   def connection
-    @connection ||= @connector.connect(@opts[:url])
+    @connection ||= RSolr::HTTPClient.connect(@opts)
   end
   
   # send a request to the connection
   # request '/update', :wt=>:xml, '</commit>'
-  def send_request(path, params={}, data=nil)
+  def request(path, params={}, data=nil)
     data = data.to_xml if data.respond_to?(:to_xml)
     if data
       http_context = connection.post(path, data, params, post_headers)

data/lib/rsolr/connection.rb

@@ -1,124 +1,125 @@
-class RSolr::Connection
+module RSolr::Connection
   
-  attr_reader :adapter, :opts
-  
-  # "adapter" is instance of:
-  #   RSolr::Adapter::HTTP
-  #   RSolr::Adapter::Direct (jRuby only)
-  def initialize(adapter, opts={})
-    @adapter = adapter
-    @opts = opts
-  end
-  
-  # Send a request to a request handler using the method name.
-  # This does not handle data, only selects
-  def method_missing(method_name, params)
-    send_request("/#{method_name}", map_params(params))
-  end
-  
-  # send a request to the "select" handler
-  def select(params)
-    send_request('/select', map_params(params))
-  end
-  
-  # sends data to the update handler
-  # data can be a string of xml, or an object that returns xml from its #to_xml method
-  def update(data, params={})
-    send_request('/update', map_params(params), data)
+  module Adapter
+    autoload :Direct, 'rsolr/connection/adapter/direct'
+    autoload :HTTP, 'rsolr/connection/adapter/http'
   end
   
-  # send request solr
-  # params is hash with valid solr request params (:q, :fl, :qf etc..)
-  #   if params[:wt] is not set, the default is :ruby
-  #   if :wt is something other than :ruby, the raw response body is used
-  #   otherwise, a simple Hash is returned
-  #   NOTE: to get raw ruby, use :wt=>'ruby' <- a string, not a symbol like :ruby  
-  #
-  #
-  def send_request(path, params={}, data=nil)
-    response = @adapter.send_request(path, map_params(params), data)
-    adapt_response(response)
-  end
-  
-  # allow #request to be used like send_request
-  alias_method :request, :send_request
+  class Base
+    
+    attr_reader :adapter
+    
+    # "adapter" 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
+    end
   
-  # 
-  # single record:
-  # solr.update(:id=>1, :name=>'one')
-  #
-  # update using an array
-  # solr.update([{:id=>1, :name=>'one'}, {:id=>2, :name=>'two'}])
-  #
-  def add(doc, &block)
-    update message.add(doc, &block)
-  end
+    # Send a request to a request handler using the method name.
+    # This does not handle data/POSTs, only GET requests.
+    def method_missing(method_name, params, &blk)
+      request("/#{method_name}", map_params(params))
+    end
   
-  # send </commit>
-  def commit
-    update message.commit
-  end
+    # sends data to the update handler
+    # data can be a string of xml, or an object that returns xml from its #to_xml method
+    def update(data, params={})
+      request('/update', map_params(params), data)
+    end
   
-  # send </optimize>
-  def optimize
-    update message.optimize
-  end
+    # send request solr
+    # params is hash with valid solr request params (:q, :fl, :qf etc..)
+    #   if params[:wt] is not set, the default is :ruby
+    #   if :wt is something other than :ruby, the raw response body is used
+    #   otherwise, a simple Hash is returned
+    #   NOTE: to get raw ruby, use :wt=>'ruby' <- a string, not a symbol like :ruby  
+    #
+    #
+    def request(path, params={}, data=nil)
+      response = @adapter.request(path, map_params(params), data)
+      adapt_response(response)
+    end
   
-  # send </rollback>
-  # NOTE: solr 1.4 only
-  def rollback
-    update message.rollback
-  end
+    # 
+    # single record:
+    # solr.update(:id=>1, :name=>'one')
+    #
+    # update using an array
+    # solr.update([{:id=>1, :name=>'one'}, {:id=>2, :name=>'two'}])
+    #
+    def add(doc, &block)
+      update message.add(doc, &block)
+    end
   
-  # Delete one or many documents by id
-  #   solr.delete_by_id 10
-  #   solr.delete_by_id([12, 41, 199])
-  def delete_by_id(id)
-    update message.delete_by_id(id)
-  end
+    # send </commit>
+    def commit
+      update message.commit
+    end
   
-  # delete one or many documents by query
-  #   solr.delete_by_query 'available:0'
-  #   solr.delete_by_query ['quantity:0', 'manu:"FQ"']
-  def delete_by_query(query)
-    update message.delete_by_query(query)
-  end
+    # send </optimize>
+    def optimize
+      update message.optimize
+    end
   
-  protected
+    # send </rollback>
+    # NOTE: solr 1.4 only
+    def rollback
+      update message.rollback
+    end
   
-  # shortcut to solr::message
-  def message
-    RSolr::Message
-  end
+    # Delete one or many documents by id
+    #   solr.delete_by_id 10
+    #   solr.delete_by_id([12, 41, 199])
+    def delete_by_id(id)
+      update message.delete_by_id(id)
+    end
   
-  # sets default params etc.. - could be used as a mapping hook
-  # type of request should be passed in here? -> map_params(:query, {})
-  def map_params(params)
-    params||={}
-    {:wt=>:ruby}.merge(params)
-  end
+    # delete one or many documents by query
+    #   solr.delete_by_query 'available:0'
+    #   solr.delete_by_query ['quantity:0', 'manu:"FQ"']
+    def delete_by_query(query)
+      update message.delete_by_query(query)
+    end
+    
+    # shortcut to RSolr::Message::Builder
+    def message
+      @message ||= RSolr::Message::Builder.new
+    end
+    
+    protected
+    
+    # sets default params etc.. - could be used as a mapping hook
+    # type of request should be passed in here? -> map_params(:query, {})
+    def map_params(params)
+      params||={}
+      {:wt=>:ruby}.merge(params)
+    end
   
-  # "adapter_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,
-  # 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]
-    # if the wt is :ruby, evaluate the ruby string response
-    if adapter_response[:params][:wt] == :ruby
-      data = Kernel.eval(data)
+    # "adapter_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,
+    # 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]
+      # if the wt is :ruby, evaluate the ruby string response
+      if adapter_response[:params][:wt] == :ruby
+        data = Kernel.eval(data)
+      end
       # attach a method called #adapter_response that returns the original adapter response value
       def data.adapter_response
         @adapter_response
       end
       data.send(:instance_variable_set, '@adapter_response', adapter_response)
+      data
     end
-    data
+    
   end
   
 end

data/lib/rsolr/http_client/adapter/curb.rb

@@ -8,8 +8,8 @@ class RSolr::HTTPClient::Adapter::Curb
   attr :uri
   attr :connection
   
-  def initialize(url)
-    @uri = URI.parse(url)
+  def initialize(opts={})
+    @uri = URI.parse(opts[:url])
     @connection = ::Curl::Easy.new
   end