telvue-rsolr 2.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8206df30839209477712ca57220df5bc89ffef4502b343b7160a08ead5e18328
+  data.tar.gz: 173b7730bb208f49a3fa4745c06b087e9047437ca42393c48f41001b872c4582
+SHA512:
+  metadata.gz: 841eb4744fb76c3cf57490b90cf27532191a3bf3400c4dd1c39fa28261ea46810f23843aecb0a95ae870b96afc080f36e15e79f27d21dbb1e2dc3a807e46fc28
+  data.tar.gz: a02c86754b9bda6a4469dc22b3d8f0b5074e04dc4602380efea3dd78a2e8856f2b9e9c807b5a9695e5826163c74e3074ee7709a48a298515bdf34542e4f8a62e

data/.gitignore

@@ -0,0 +1,13 @@
+.DS_Store
+.yardoc/
+pkg/*
+apache-solr-3.3.0/
+coverage/
+doc/
+example/
+
+Gemfile.lock
+
+*.gem
+.bundle
+/spec/examples.txt

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+sudo: false
+rvm:
+  - 2.4.0
+  - 2.3.3
+  - 2.2.6
+  - jruby-9.1.7.0
+
+env:
+  global:
+    - JRUBY_OPTS="-J-Xms512m -J-Xmx1024m"
+    - NOKOGIRI_USE_SYSTEM_LIBRARIES=true
+
+jdk: oraclejdk8

data/CHANGES.txt

@@ -0,0 +1,47 @@
+2.0.0.pre1
+
+In this release, we've added many new features, including:
+
+- a new JSON request generator (enabled by default, replacing the XML-based requests) (@mootprinter)
+- using Faraday for added flexibility for HTTP configuration
+- native support for nested child documents and atomic updates in RSolr::Document and RSolr::Client.add
+- better support for custom field value converters (@solenko)
+- removing code deprecated in RSolr 1.x (@vipulnsward, and others)
+
+
+1.0.12
+   - Fix bug where specifying the wt property as a string, would add the supplied value to the default ('ruby') rather than overriding it.
+
+1.0.11
+   - add RSolr.solr_escape method and add deprecation messages to RSolr.escape (ndushay)
+   - use stdlib URI.escape methods instead of homegrown in RSolr::URI (ndushay)
+   - fix bug with Rsolr::Uri.create adding trailing slash if query params (ndushay)
+   - update rake tasks  (cbeer)
+   - add Ruby 2.2.0 to travis ci build (ndushay)
+   - Housekeeping (badges to README, license in gemspec, correct url in gemspec ...)  (ndushay)
+   - Improve rdoc styling (udaykadaboina)
+   - Support setting default_wt per connection via its options. (jcoleman)
+   - eliminates the usage of per-instance `extend` (jcoleman)
+   - Upgrade to RSpec 3 (blackwinter, adamjonas, cbeer)
+   - Fixed RSolr::Error to_s  (PofMagicfingers)
+1.0.10 xxx
+
+1.0.8
+   -  Fix connection refused errors in specs + add basic auth support (Denis Goeury)
+   - Ability to set :retry_503, the number of retry attempts for a 503 response
+     with a Retry-After header.
+1.0.7
+   - Response body encoding is set to response charset in Ruby >= 1.9
+   - Ability to set :read_timeout and :open_timeout when creating new instance of RSolr
+1.0.6
+   - More dependency fixups
+1.0.5
+   - Dependency fixups
+1.0.4
+   - The "builder" gem dependency is less strict: ~> 2.1.2
+   - RSolr.version is no longer read from a file
+   - Gemspec updated -- less strict dev/test versions
+   - Jeweler is no longer used for building the gemspec
+1.0.3
+   - Proper encodings in Ruby 1.9
+   - Applied pull request from https://github.com/mwmitchell/rsolr/pull/20

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "builder", ">= 2.1.2"

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2008-2010 Matt Mitchell
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+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.

data/README.rdoc

@@ -0,0 +1,229 @@
+== This is a TelVue Corp fork of the rsolr gem
+
+=RSolr
+{<img src="https://travis-ci.org/rsolr/rsolr.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/rsolr/rsolr] {<img src="https://badge.fury.io/rb/rsolr.svg" alt="Gem Version" />}[http://badge.fury.io/rb/rsolr]
+
+
+A simple, extensible Ruby client for Apache Solr.
+
+==Documentation
+The code docs http://www.rubydoc.info/gems/rsolr
+
+== Installation:
+  gem install telvue-rsolr
+
+== Example:
+  require 'rsolr'
+  
+  # Direct connection
+  solr = RSolr.connect :url => 'http://solrserver.com'
+  
+  # Connecting over a proxy server
+  solr = RSolr.connect :url => 'http://solrserver.com', :proxy=>'http://user:pass@proxy.example.com:8080'
+
+  # Using an alternate Faraday adapter
+  solr = RSolr.connect :url => 'http://solrserver.com', :adapter => :em_http
+  
+  # Using a custom Faraday connection
+  conn = Faraday.new do |faraday|
+    faraday.response :logger                  # log requests to STDOUT
+    faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+  end
+  solr = RSolr.connect conn, :url => 'http://solrserver.com'
+    
+  # 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.
+
+== Request formats
+
+By default, RSolr uses the Solr JSON command format for all requests.
+
+  RSolr.connect :url => 'http://solrserver.com', update_format: :json # the default
+  # or
+  RSolr.connect :url => 'http://solrserver.com', update_format: :xml
+
+== Timeouts
+The read and connect timeout settings can be set when creating a new instance of RSolr:
+  solr = RSolr.connect(:read_timeout => 120, :open_timeout => 120)
+
+== Retry 503s
+A 503 is usually a temporary error which RSolr may retry if requested. You may specify the number of retry attempts with the +:retry_503+ option.
+
+Only requests which specify a Retry-After header will be retried, after waiting the indicated retry interval, otherwise RSolr will treat the request as a 500. You may specify a maximum Retry-After interval to wait with the +:retry_after_limit+ option (default: one second).
+  solr = RSolr.connect(:retry_503 => 1, :retry_after_limit => 1)
+
+For additional control, consider using a custom Faraday connection (see above) using its `retry` middleware.
+
+== Querying
+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, 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.get 'select', :params => {:q=>'roses', :fq=>['red', 'violet']}
+
+The above statement generates this Solr query:
+  
+  select?q=roses&fq=red&fq=violet
+
+===Pagination
+To paginate through a set of Solr documents, use the paginate method:
+  solr.paginate 1, 10, "select", :params => {: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"] %>
+
+===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
+
+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
+
+Multiple documents via #add
+  documents = [{:id=>1, :price=>1.00}, {:id=>2, :price=>10.50}]
+  solr.add documents
+
+The optional +:add_attributes+ hash can also be used to set Solr "add" document attributes:
+  solr.add documents, :add_attributes => {:commitWithin => 10}
+
+Raw commands via  #update
+  solr.update data: '<commit/>', headers: { 'Content-Type' => 'text/xml' }
+  solr.update data: { optimize: true }.to_json, headers: { 'Content-Type' => 'application/json' }
+
+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}
+  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
+  solr.delete_by_id [1, 2, 3, 4]
+
+Delete by query:
+  solr.delete_by_query 'price:1.00'
+Delete by array of queries
+  solr.delete_by_query ['price:1.00', 'price:10.00']
+
+===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:
+  solr.get 'select', :params => {:wt => :ruby} # notice :ruby is a Symbol
+===Raw Ruby:
+  solr.get 'select', :params => {:wt => 'ruby'} # notice 'ruby' is a String
+===XML:
+  solr.get 'select', :params => {:wt => :xml}
+===JSON (default):
+  solr.get 'select', :params => {:wt => :json}
+
+==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/sunspot/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.
+
+==Contributors
+* Nathan Witmer
+* Magnus Bergmark
+* shima
+* Randy Souza
+* Mat Brown
+* Jeremy Hinegardner
+* Denis Goeury
+* shairon toledo
+* Rob Di Marco
+* Peter Kieltyka
+* Mike Perham
+* Lucas Souza
+* Dmitry Lihachev
+* Antoine Latter
+* Naomi Dushay
+
+==Author
+
+Matt Mitchell <mailto:goodieboy@gmail.com>
+
+==Copyright
+
+Copyright (c) 2008-2010 Matt Mitchell. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler/gem_tasks'
+
+task default: ['spec']
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+# Rdoc
+require 'rdoc/task'
+
+desc 'Generate documentation for the rsolr gem.'
+RDoc::Task.new(:doc) do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = 'RSolr'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/rsolr.rb

@@ -0,0 +1,52 @@
+module RSolr
+  require 'rsolr/version'
+
+  autoload :Char, 'rsolr/char'
+  autoload :Client, 'rsolr/client'
+  autoload :Document, 'rsolr/document'
+  autoload :Error, 'rsolr/error'
+  autoload :Field, 'rsolr/field'
+  autoload :Generator, 'rsolr/generator'
+  autoload :HashWithResponse, 'rsolr/response'
+  autoload :JSON, 'rsolr/json'
+  autoload :Response, 'rsolr/response'
+  autoload :Uri, 'rsolr/uri'
+  autoload :Xml, 'rsolr/xml'
+
+  def self.connect *args
+    opts = args.pop if args.last.is_a?(::Hash)
+    opts ||= {}
+
+    connection = args.first
+
+    Client.new connection, opts
+  end
+
+  # backslash escape characters that have special meaning to Solr query parser
+  # per http://lucene.apache.org/core/4_0_0/queryparser/org/apache/lucene/queryparser/classic/package-summary.html#Escaping_Special_Characters
+  #  + - & | ! ( ) { } [ ] ^ " ~ * ? : \ /
+  # see also http://svn.apache.org/repos/asf/lucene/dev/tags/lucene_solr_4_9_1/solr/solrj/src/java/org/apache/solr/client/solrj/util/ClientUtils.java
+  #   escapeQueryChars method
+  # @return [String] str with special chars preceded by a backslash
+  def self.solr_escape(str)
+    # note that the gsub will parse the escaped backslashes, as will the ruby code sending the query to Solr 
+    # so the result sent to Solr is ultimately a single backslash in front of the particular character 
+    str.gsub(/([+\-&|!\(\)\{\}\[\]\^"~\*\?:\\\/])/, '\\\\\1')
+  end
+
+  module Array
+    def self.wrap(object)
+      if object.nil?
+        [nil]
+      elsif object.respond_to?(:to_ary)
+        object.to_ary || [object]
+      elsif object.is_a? Hash
+        [object]
+      elsif object.is_a? Enumerable
+        object
+      else
+        [object]
+      end
+    end
+  end
+end

data/lib/rsolr/char.rb

@@ -0,0 +1,6 @@
+# :nodoc:
+module RSolr::Char
+  def self.included(*)
+    warn 'RSolr::Char is deprecated without replacement, and will be removed in RSolr 3.x'
+  end
+end

data/lib/rsolr/client.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'faraday'
+require 'uri'
+
+class RSolr::Client
+  DEFAULT_URL = 'http://127.0.0.1:8983/solr/'
+
+  class << self
+    def default_wt
+      @default_wt ||= :json
+    end
+
+    def default_wt= value
+      @default_wt = value
+    end
+  end
+
+  attr_reader :uri, :proxy, :update_format, :options, :update_path
+
+  def initialize connection, options = {}
+    @proxy = @uri = nil
+    @connection = connection
+    unless false === options[:url]
+      @uri = extract_url_from_options(options)
+      if options[:proxy]
+        proxy_url = options[:proxy].dup
+        proxy_url << "/" unless proxy_url.nil? or proxy_url[-1] == ?/
+        @proxy = ::URI.parse proxy_url if proxy_url
+      elsif options[:proxy] == false
+        @proxy = false  # used to avoid setting the proxy from the environment.
+      end
+    end
+    @update_format = options.delete(:update_format) || RSolr::JSON::Generator
+    @update_path = options.fetch(:update_path, 'update')
+    @options = options
+  end
+
+  def extract_url_from_options(options)
+    url = options[:url] ? options[:url].dup : DEFAULT_URL
+    url << "/" unless url[-1] == ?/
+    uri = ::URI.parse(url)
+    # URI::HTTPS is a subclass of URI::HTTP, so this check accepts HTTP(S)
+    raise ArgumentError, "You must provide an HTTP(S) url." unless uri.kind_of?(URI::HTTP)
+    uri
+  end
+
+  # returns the request uri object.
+  def base_request_uri
+    base_uri.request_uri if base_uri
+  end
+
+  # returns the URI uri object.
+  def base_uri
+    @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
+
+  # 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
+
+  # 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 update opts = {}
+    opts[:headers] ||= {}
+    opts[:headers]['Content-Type'] ||= builder.content_type
+    post opts.fetch(:path, update_path), 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.add(:id=>1, :name=>'one')
+  #
+  # add using an array
+  #
+  # solr.add(
+  #   [{: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 => builder.add(doc, add_attributes))
+  end
+
+  # 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 => builder.commit( commit_attrs ))
+  end
+
+  # 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 => builder.optimize(optimize_attributes))
+  end
+
+  # send </rollback>
+  #
+  # http://wiki.apache.org/solr/UpdateXmlMessages#A.22rollback.22
+  #
+  # NOTE: solr 1.4 only
+  def rollback opts = {}
+    update opts.merge(:data => builder.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, opts = {}
+    update opts.merge(:data => builder.delete_by_id(id))
+  end
+
+  # 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, opts = {}
+    update opts.merge(:data => builder.delete_by_query(query))
+  end
+
+  def builder
+    @builder ||= if update_format.is_a? Class
+                   update_format.new
+                 elsif update_format == :json
+                   RSolr::JSON::Generator.new
+                 elsif update_format == :xml
+                   RSolr::Xml::Generator.new
+                 else
+                   update_format
+                 end
+  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; charset=UTF-8"
+  #   :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
+
+  #
+  def execute request_context
+    raw_response = begin
+      response = connection.send(request_context[:method], request_context[:uri].to_s) do |req|
+        req.body = request_context[:data] if request_context[:method] == :post and request_context[:data]
+        req.headers.merge!(request_context[:headers]) if request_context[:headers]
+      end
+
+      { status: response.status.to_i, headers: response.headers, body: response.body.dup.force_encoding('utf-8') }
+    rescue Errno::ECONNREFUSED, Faraday::Error::ConnectionFailed
+      raise RSolr::Error::ConnectionRefused, request_context.inspect
+    rescue Faraday::Error => e
+      raise RSolr::Error::Http.new(request_context, e.response)
+    end
+    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] = params_with_wt(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; charset=UTF-8'
+    end
+    opts[:path] = path
+    opts[:uri] = base_uri.merge(path.to_s + (query ? "?#{query}" : "")) if base_uri
+
+    opts
+  end
+
+  def params_with_wt(params)
+    return { wt: default_wt } if params.nil?
+    return params if params.key?(:wt) || params.key?('wt')
+    { wt: default_wt }.merge(params)
+  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
+
+  # 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
+
+    result = if respond_to? "evaluate_#{request[:params][:wt]}_response", true
+      send "evaluate_#{request[:params][:wt]}_response", request, response
+    else
+      response[:body]
+    end
+
+    if result.is_a?(Hash) || request[:method] == :head
+      result = RSolr::HashWithResponse.new(request, response, result)
+    end
+
+    result
+  end
+  
+  def connection
+    @connection ||= begin
+      conn_opts = { request: {} }
+      conn_opts[:url] = uri.to_s
+      conn_opts[:proxy] = proxy if proxy
+      conn_opts[:request][:open_timeout] = options[:open_timeout] if options[:open_timeout]
+      conn_opts[:request][:timeout] = options[:read_timeout] if options[:read_timeout]
+      conn_opts[:request][:params_encoder] = Faraday::FlatParamsEncoder
+
+      Faraday.new(conn_opts) do |conn|
+        conn.basic_auth(uri.user, uri.password) if uri.user && uri.password
+        conn.response :raise_error
+        conn.request :retry, max: options[:retry_after_limit], interval: 0.05,
+                             interval_randomness: 0.5, backoff_factor: 2,
+                             exceptions: ['Faraday::Error', 'Timeout::Error'] if options[:retry_503]
+        conn.adapter options[:adapter] || Faraday.default_adapter
+      end
+    end
+  end
+
+  protected
+
+  # 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
+
+  # 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
+    Kernel.eval response[:body].to_s
+  rescue SyntaxError
+    raise RSolr::Error::InvalidRubyResponse.new request, response
+  end
+
+  def evaluate_json_response request, response
+    return if response[:body].nil? || response[:body].empty?
+
+    JSON.parse response[:body].to_s
+  rescue JSON::ParserError
+    raise RSolr::Error::InvalidJsonResponse.new request, response
+  end
+
+  def default_wt
+    self.options[:default_wt] || self.class.default_wt
+  end
+end