rsolr 0.12.0 → 1.0.3

data/README.rdoc

@@ -1,63 +1,102 @@
 =RSolr
 
-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.
+A simple, extensible Ruby client for Apache Solr.
+
+Notice: This document is only for the the 1.0 in the master. The last pre 1.0 gem release documentation can be found here: http://github.com/mwmitchell/rsolr/tree/v0.12.1
+
+==Documentation
+The code docs for the last *release* can be viewed here : http://rdoc.info/projects/mwmitchell/rsolr
 
 == Installation:
-  gem sources -a http://gemcutter.org
   sudo gem install 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
-* {java_bin}[http://github.com/kennyj/java_bin] -- Provides javabin/binary parsing for Ruby
-
-== Simple usage:
+== Example:
   require 'rubygems'
   require 'rsolr'
-  solr = RSolr.connect :url=>'http://solrserver.com'
   
-  # send a request to /select
-  response = rsolr.select :q=>'*:*'
+  # Direct connection
+  solr = RSolr.connect :url => 'http://solrserver.com'
   
-  # send a request to a custom request handler; /catalog
-  response = rsolr.request '/catalog', :q=>'*:*'
+  # Connecting over a proxy server
+  solr = RSolr.connect :url => 'http://solrserver.com', :proxy=>'http://user:pass@proxy.example.com:8080'
   
-  # alternative to above:
-  response = rsolr.catalog :q=>'*:*'
+  # send a request to /select
+  response = solr.get 'select', :params => {:q => '*:*'}
+  
+  # send a request to /catalog
+  response = solr.get 'catalog', :params => {:q => '*:*'}
+
+When the Solr :wt is :ruby, then the response will be a Hash. This Hash is the same object returned by Solr, but evaluated as Ruby. If the :wt is not :ruby, then the response will be a String.
+
+The response also exposes 2 attribute readers (for any :wt value), :request and :response. Both are Hash objects with symbolized keys.
+
+The :request attribute contains the original request context. You can use this for debugging or logging. Some of the keys this object contains are :uri, :query, :method etc..
+
+The :response attribute contains the original response. This object contains the :status, :body and :headers keys.
 
 == Querying
-Use the #select method to send requests to the /select handler:
-  response = solr.select({
+Use the #get / #post method to send search requests to the /select handler:
+  response = solr.get 'select', :params => {
     :q=>'washington',
     :start=>0,
     :rows=>10
-  })
+  }
+  response["response"]["docs"].each{|doc| puts doc["id"] }
 
-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:
+The :params sent into the method are sent to Solr as-is, which is to say they are converted to Solr url style, but no special mapping is used.
+When an array is used, multiple parameters *with the same name* are generated for the Solr query. Example:
   
-  solr.select :q=>'roses', :fq=>['red', 'violet']
+  solr.get 'select', :params => {:q=>'roses', :fq=>['red', 'violet']}
 
 The above statement generates this Solr query:
   
-  ?q=roses&fq=red&fq=violet
+  select?q=roses&fq=red&fq=violet
 
-Use the #request method for a custom request handler path:
-  response = solr.request '/documents', :q=>'test'
+===Pagination
+To paginate through a set of Solr documents, use the paginate method:
+  solr.paginate 1, 10, "select", :params => {:q => "test"}
 
-A shortcut for the above example:
-  response = solr.documents :q=>'test'
+The first argument is the current page, the second is how many documents to return for each page. In other words, "page" is the "start" Solr param and "per-page" is the "rows" Solr param.
 
+The paginate method returns WillPaginate ready "docs" objects, so for example in a Rails application, paginating is as simple as:
+  <%= will_paginate @solr_response["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.
+===Method Missing
+The RSolr::Client class also uses method_missing for setting the request handler/path:
+  
+  solr.paintings :params => {:q=>'roses', :fq=>['red', 'violet']}
+  
+This is sent to Solr as:
+  paintings?q=roses&fq=red&fq=violet
 
-Raw XML via  #update
-  solr.update '</commit>'
-  solr.update '</optimize>'
+This works with pagination as well:
+  
+  solr.paginate_paintings 1, 10, {:q=>'roses', :fq=>['red', 'violet']}
+
+===Using POST for Search Queries
+There may be cases where the query string is too long for a GET request. RSolr solves this issue by converting hash objects into form-encoded strings:
+  response = solr.music :data => {:q => "*:*"}
+
+The :data hash is serialized as a form-encoded query string, and the correct content-type headers are sent along to Solr.
+
+===Sending HEAD Requests
+There may be cases where you'd like to send a HEAD request to Solr:
+  solr.head("admin/ping").response[:status] == 200
+
+==Sending HTTP Headers
+Solr responds to the request headers listed here: http://wiki.apache.org/solr/SolrAndHTTPCaches
+To send header information to Solr using RSolr, just use the :headers option:
+  response = solr.head "admin/ping", :headers => {"Cache-Control" => "If-None-Match"}
+
+===Building a Request
+RSolr::Client provides a method for building a request context, which can be useful for debugging or logging etc.:
+  request_context = solr.build_request "select", :data => {:q => "*:*"}, :method => :post, :headers => {}
+  
+To build a paginated request use build_paginated_request:
+  request_context = solr.build_paginated_request 1, 10, "select", ...
+  
+== Updating Solr
+Updating is done using native Ruby objects. Hashes are used for single documents and arrays are used for a collection of documents (hashes). These objects get turned into simple XML "messages". Raw XML strings can also be used.
 
 Single document via #add
   solr.add :id=>1, :price=>1.00
@@ -66,17 +105,28 @@ Multiple documents via #add
   documents = [{:id=>1, :price=>1.00}, {:id=>2, :price=>10.50}]
   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:
+The optional :add_attributes hash can also be used to set Solr "add" document attributes:
+  solr.add documents, :add_attributes => {:commitWithin => 10}
+
+Raw XML via  #update
+  solr.update :data => '<commit/>'
+  solr.update :data => '<optimize/>'
+
+When adding, you can also supply "add" xml element attributes and/or a block for manipulating other "add" related elements (docs and fields) by calling the +xml+ method directly:
   
   doc = {:id=>1, :price=>1.00}
-  add_attributes = {:allowDups=>false, :commitWithin=>10.0}
-  solr.add(doc, add_attributes) do |doc|
+  add_attributes = {:allowDups=>false, :commitWithin=>10}
+  add_xml = solr.xml.add(doc, add_attributes) do |doc|
     # boost each document
     doc.attrs[:boost] = 1.5
     # boost the price field:
     doc.field_by_name(:price).attrs[:boost] = 2.0
   end
 
+Now the "add_xml" object can be sent to Solr like:
+  solr.update :data => add_xml
+
+===Deleting
 Delete by id
   solr.delete_by_id 1
 or an array of ids
@@ -87,27 +137,73 @@ Delete by query:
 Delete by array of queries
   solr.delete_by_query ['price:1.00', 'price:10.00']
 
-Commit & optimize shortcuts
-  solr.commit
-  solr.optimize
+===Commit / Optimize
+  solr.commit, :commit_attributes => {}
+  solr.optimize, :optimize_attributes => {}
 
 == Response Formats
 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
+  solr.get 'select', :params => {:wt => :ruby} # notice :ruby is a Symbol
 ===Raw Ruby
-  solr.select(:wt=>'ruby') # notice 'ruby' is a String
+  solr.get 'select', :params => {:wt => 'ruby'} # notice 'ruby' is a String
 
 ===XML:
-  solr.select(:wt=>:xml)
+  solr.get 'select', :params => {:wt => :xml}
 ===JSON:
-  solr.select(:wt=>:json)
-
-You can access the original request context (path, params, url etc.) by calling the #raw method:
-  response = solr.select :q=>'*:*'
-  response.raw[:status_code]
-  response.raw[:body]
-  response.raw[:url]
+  solr.get 'select', :params => {:wt => :json}
 
-The raw is a hash that contains the generated params, url, path, post data, headers etc., very useful for debugging and testing.
+==Related Resources & Projects
+* {RSolr Google Group}[http://groups.google.com/group/rsolr] -- The RSolr discussion group
+* {rsolr-ext}[http://github.com/mwmitchell/rsolr-ext] -- An extension kit for RSolr
+* {rsolr-direct}[http://github.com/mwmitchell/rsolr-direct] -- JRuby direct connection for RSolr
+* {rsolr-nokogiri}[http://github.com/mwmitchell/rsolr-nokogiri] -- Gives RSolr Nokogiri for XML generation.
+* {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
+* {java_bin}[http://github.com/kennyj/java_bin] -- Provides javabin/binary parsing for RSolr
+* {Solr}[http://lucene.apache.org/solr/] -- The Apache Solr project
+* {solr-ruby}[http://wiki.apache.org/solr/solr-ruby] -- The original Solr Ruby Gem!
+
+== Note on Patches/Pull Requests
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+==Contributors
+* Jonathan Rochkind
+* Chris Beer
+* Craig Smith
+* Randy Souza
+* Colin Steele
+* Peter Kieltyka
+* Lorenzo Riccucci
+* Mike Perham
+* Mat Brown
+* Shairon Toledo
+* Matthew Rudy
+* Fouad Mardini
+* Jeremy Hinegardner
+* Nathan Witmer
+* "shima"
+
+==Author
+
+Matt Mitchell <mailto:goodieboy@gmail.com>
+
+==Copyright
+
+Copyright (c) 2008-2010 Matt Mitchell. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rake'
+require 'rake/testtask'
+
+require 'rubygems/package_task'
+
+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/VERSION

@@ -0,0 +1 @@
+1.0.3

data/lib/rsolr/char.rb

@@ -0,0 +1,21 @@
+# A module that contains (1) string related methods
+module RSolr::Char
+  
+  # backslash everything
+  # that isn't a word character
+  def escape value
+    value.gsub(/(\W)/, '\\\\\1')
+  end
+  
+  # LUCENE_CHAR_RX = /([\+\-\!\(\)\[\]\^\"\~\*\?\:\\]+)/
+  # LUCENE_WORD_RX = /(OR|AND|NOT)/
+  # 
+  # # More specific/lucene escape sequence
+  # def lucene_escape string
+  #   delim = " "
+  #   string.gsub(LUCENE_CHAR_RX, '\\\\\1').split(delim).map { |v|
+  #     v.gsub(LUCENE_WORD_RX, '\\\\\1')
+  #   }.join(delim)
+  # end
+  
+end

data/lib/rsolr/client.rb

@@ -1,114 +1,260 @@
 class RSolr::Client
   
-  attr_reader :connection
+  attr_reader :connection, :uri, :proxy, :options
   
-  # "connection" is instance of:
-  #   RSolr::Adapter::HTTP
-  #   RSolr::Adapter::Direct (jRuby only)
-  # or any other class that uses the connection "interface"
-  def initialize(connection)
+  def initialize connection, options = {}
+    @proxy = @uri = nil
     @connection = connection
+    unless false === options[:url]
+      url = options[:url] ? options[:url].dup : 'http://127.0.0.1:8983/solr/'
+      url << "/" unless url[-1] == ?/
+      @uri = RSolr::Uri.create url
+      if options[:proxy]
+        proxy_url = options[:proxy].dup
+        proxy_url << "/" unless proxy_url.nil? or proxy_url[-1] == ?/
+        @proxy = RSolr::Uri.create proxy_url if proxy_url
+      end
+    end
+    @options = options
+  end
+  
+  # returns the request uri object.
+  def base_request_uri
+    base_uri.request_uri if base_uri
   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)
+  # returns the uri proxy if present,
+  # otherwise just the uri object.
+  def base_uri
+    @proxy ? @proxy : @uri
+  end
+  
+  # Create the get, post, and head methods
+  %W(get post head).each do |meth|
+    class_eval <<-RUBY
+    def #{meth} path, opts = {}, &block
+      send_and_receive path, opts.merge(:method => :#{meth}), &block
+    end
+    RUBY
   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', params, data
+  # A paginated request method.
+  # Converts the page and per_page
+  # arguments into "rows" and "start".
+  def paginate page, per_page, path, opts = nil
+    opts ||= {}
+    opts[:params] ||= {}
+    raise "'rows' or 'start' params should not be set when using +paginate+" if ["start", "rows"].include?(opts[:params].keys)
+    execute build_paginated_request(page, per_page, path, opts)
   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  
+  # POST XML messages to /update with optional params.
+  # 
+  # http://wiki.apache.org/solr/UpdateXmlMessages#add.2BAC8-update
+  #
+  # If not set, opts[:headers] will be set to a hash with the key
+  # 'Content-Type' set to 'text/xml'
+  #
+  # +opts+ can/should contain:
   #
+  #  :data - posted data
+  #  :headers - http headers
+  #  :params - solr query parameter hash
   #
-  def request(path, params={}, *extra)
-    response = @connection.request(path, map_params(params), *extra)
-    adapt_response(response)
+  def update opts = {}
+    opts[:headers] ||= {}
+    opts[:headers]['Content-Type'] ||= 'text/xml'
+    post 'update', opts
   end
   
+  # 
+  # +add+ creates xml "add" documents and sends the xml data to the +update+ method
+  # 
+  # http://wiki.apache.org/solr/UpdateXmlMessages#add.2BAC8-update
   # 
   # 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)
+  # 
+  # solr.update(
+  #   [{:id=>1, :name=>'one'}, {:id=>2, :name=>'two'}],
+  #   :add_attributes => {:boost=>5.0, :commitWithin=>10}
+  # )
+  # 
+  def add doc, opts = {}
+    add_attributes = opts.delete :add_attributes
+    update opts.merge(:data => xml.add(doc, add_attributes))
   end
 
-  # send </commit>
-  def commit
-    update message.commit
+  # send "commit" xml with opts
+  #
+  # http://wiki.apache.org/solr/UpdateXmlMessages#A.22commit.22_and_.22optimize.22
+  #
+  def commit opts = {}
+    commit_attrs = opts.delete :commit_attributes
+    update opts.merge(:data => xml.commit( commit_attrs ))
   end
 
-  # send </optimize>
-  def optimize
-    update message.optimize
+  # send "optimize" xml with opts.
+  #
+  # http://wiki.apache.org/solr/UpdateXmlMessages#A.22commit.22_and_.22optimize.22
+  #
+  def optimize opts = {}
+    optimize_attributes = opts.delete :optimize_attributes
+    update opts.merge(:data => xml.optimize(optimize_attributes))
   end
-
+  
   # send </rollback>
+  # 
+  # http://wiki.apache.org/solr/UpdateXmlMessages#A.22rollback.22
+  # 
   # NOTE: solr 1.4 only
-  def rollback
-    update message.rollback
+  def rollback opts = {}
+    update opts.merge(:data => xml.rollback)
   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)
+  def delete_by_id id, opts = {}
+    update opts.merge(:data => xml.delete_by_id(id))
   end
 
-  # delete one or many documents by query
+  # delete one or many documents by query.
+  # 
+  # http://wiki.apache.org/solr/UpdateXmlMessages#A.22delete.22_by_ID_and_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)
+  def delete_by_query query, opts = {}
+    update opts.merge(:data => xml.delete_by_query(query))
+  end
+  
+  # shortcut to RSolr::Xml::Generator
+  def xml
+    @xml ||= RSolr::Xml::Generator.new
+  end
+  
+  # +send_and_receive+ is the main request method responsible for sending requests to the +connection+ object.
+  # 
+  # "path" : A string value that usually represents a solr request handler
+  # "opts" : A hash, which can contain the following keys:
+  #   :method : required - the http method (:get, :post or :head)
+  #   :params : optional - the query string params in hash form
+  #   :data : optional - post data -- if a hash is given, it's sent as "application/x-www-form-urlencoded"
+  #   :headers : optional - hash of request headers
+  # All other options are passed right along to the connection's +send_and_receive+ method (:get, :post, or :head)
+  # 
+  # +send_and_receive+ returns either a string or hash on a successful ruby request.
+  # When the :params[:wt] => :ruby, the response will be a hash, else a string.
+  #
+  # creates a request context hash,
+  # sends it to the connection's +execute+ method
+  # which returns a simple hash,
+  # then passes the request/response into +adapt_response+.
+  def send_and_receive path, opts
+    request_context = build_request path, opts
+    execute request_context
   end
   
-  # shortcut to RSolr::Message::Generator
-  def message *opts
-    @message ||= RSolr::Message::Generator.new
+  # 
+  def execute request_context
+    raw_response = connection.execute self, request_context
+    adapt_response(request_context, raw_response) unless raw_response.nil?
+  end
+  
+  # +build_request+ accepts a path and options hash,
+  # then prepares a normalized hash to return for sending
+  # to a solr connection driver.
+  # +build_request+ sets up the uri/query string
+  # and converts the +data+ arg to form-urlencoded,
+  # if the +data+ arg is a hash.
+  # returns a hash with the following keys:
+  #   :method
+  #   :params
+  #   :headers
+  #   :data
+  #   :uri
+  #   :path
+  #   :query
+  def build_request path, opts
+    raise "path must be a string or symbol, not #{path.inspect}" unless [String,Symbol].include?(path.class)
+    path = path.to_s
+    opts[:proxy] = proxy unless proxy.nil?
+    opts[:method] ||= :get
+    raise "The :data option can only be used if :method => :post" if opts[:method] != :post and opts[:data]
+    opts[:params] = opts[:params].nil? ? {:wt => :ruby} : {:wt => :ruby}.merge(opts[:params])
+    query = RSolr::Uri.params_to_solr(opts[:params]) unless opts[:params].empty?
+    opts[:query] = query
+    if opts[:data].is_a? Hash
+      opts[:data] = RSolr::Uri.params_to_solr opts[:data]
+      opts[:headers] ||= {}
+      opts[:headers]['Content-Type'] ||= 'application/x-www-form-urlencoded'
+    end
+    opts[:path] = path
+    opts[:uri] = base_uri.merge(path.to_s + (query ? "?#{query}" : "")) if base_uri
+    opts
+  end
+  
+  def build_paginated_request page, per_page, path, opts
+    per_page = per_page.to_s.to_i
+    page = page.to_s.to_i-1
+    page = page < 1 ? 0 : page
+    opts[:params]["start"] = page * per_page
+    opts[:params]["rows"] = per_page
+    build_request path, opts
+  end
+  
+  #  A mixin for used by #adapt_response
+  module Context
+    attr_accessor :request, :response
+  end
+  
+  # This method will evaluate the :body value
+  # if the params[:uri].params[:wt] == :ruby
+  # ... otherwise, the body is returned as is.
+  # The return object has methods attached, :request and :response.
+  # These methods give you access to the original
+  # request and response from the connection.
+  #
+  # +adapt_response+ will raise an InvalidRubyResponse
+  # if :wt == :ruby and the body
+  # couldn't be evaluated.
+  def adapt_response request, response
+    raise "The response does not have the correct keys => :body, :headers, :status" unless
+      %W(body headers status) == response.keys.map{|k|k.to_s}.sort
+    raise RSolr::Error::Http.new request, response unless [200,302].include? response[:status]
+    result = request[:params][:wt] == :ruby ? evaluate_ruby_response(request, response) : response[:body]
+    result.extend Context
+    result.request, result.response = request, response
+    result.is_a?(Hash) ? result.extend(RSolr::Response) : result
   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)
+  # converts the method name for the solr request handler path.
+  def method_missing name, *args
+    if name.to_s =~ /^paginated?_(.+)$/
+      paginate args[0], args[1], $1, *args[2..-1]
+    else
+      send_and_receive name, *args
+    end
   end
-
-  # "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 #raw
-  # 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(connection_response)
-    data = connection_response[:body]
-    # if the wt is :ruby, evaluate the ruby string response
-    if connection_response[:params][:wt] == :ruby
-      data = Kernel.eval(data)
+  
+  # evaluates the response[:body],
+  # attempts to bring the ruby string to life.
+  # If a SyntaxError is raised, then
+  # this method intercepts and raises a
+  # RSolr::Error::InvalidRubyResponse
+  # instead, giving full access to the
+  # request/response objects.
+  def evaluate_ruby_response request, response
+    begin
+      Kernel.eval response[:body].to_s
+    rescue SyntaxError
+      raise RSolr::Error::InvalidRubyResponse.new request, response
     end
-    # attach a method called #raw that returns the original connection response value
-    def data.raw; @raw end
-    data.send(:instance_variable_set, '@raw', connection_response)
-    data
   end
   
-end
+end