rsolr 2.6.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b7e170dd7fcd0bfd504562297b93a6fb504da5e95df0d356cd0d1c70a7515c8
-  data.tar.gz: b4d04a24455588c421f72d29b8e9e7ab255fb4bfde9457bc6ab5f64bb64c76a4
+  metadata.gz: 7cd06ee9f0201b75d69b9f7d02f5ad6641272e5ec8d6d1eaa1b57aaedc90daef
+  data.tar.gz: 277248ac909e888160f8addac51fa01d44dc26cb089b8bfcbdb3ed93263015c9
 SHA512:
-  metadata.gz: cd27dcd3369b5d1e4cd99604426927bf83a3a4c3ef7d8a06fb3cfc45676b33c920ce256ecb7fc577dedbbe910b6d50a45fdaa7dd0324516529c5705df8698385
-  data.tar.gz: 5a488c3aa5e5ca93e8fe2647baf313d8b5a94229e99d6a49820a3bf80b65fe9c19fd8ab05678ee402d3674d7a043ded6110acdf4ada5a2a1752b96f4080ceec1
+  metadata.gz: e095fbdf8f63f68eeb5b9919b6cf61d745b1dd044d819f2a762dbf82bf3b9bf813b0b022c61709f57e3f080ce96104e453d22db120d2d62f1a94453cf58b145c
+  data.tar.gz: 8ff5849b11a1bb25f315cd5373354dd2479d7c0725d8092b76e8360fb31886f3d406f4d2cecf898003d11124af0566528aa6f9dd860680510875008a10afe046

data/.github/workflows/ruby.yml

@@ -2,28 +2,30 @@ name: CI
 
 on:
   push:
-    branches: [ master ]
+    branches: [main]
   pull_request:
-    branches: [ master ]
+    branches: [main]
 
 jobs:
   tests:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: [jruby-9.3.3.0, '3.0', '3.1', '3.2', '3.3']
-        faraday: ['~> 0.17', '~> 1', '~>2']
+        ruby: [jruby-10.0.3.0, "3.2", "3.3", "3.4", "4.0"]
+        faraday: ["~> 1", "~>2"]
     steps:
-    - uses: actions/checkout@v2
-    - name: Set up Ruby
-      uses: ruby/setup-ruby@v1
-      with:
-        ruby-version: ${{ matrix.ruby }}
-    - name: Install dependencies
-      run: bundle install
-      env:
-        FARADAY_VERSION: ${{ matrix.faraday}}
-    - name: Run tests
-      run: bundle exec rake
-      env:
-        FARADAY_VERSION: ${{ matrix.faraday}}
+      - uses: actions/checkout@v7
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: Install dependencies
+        run: bundle install
+        env:
+          FARADAY_VERSION: ${{ matrix.faraday}}
+      - name: Start Solr
+        run: docker compose up -d --wait --wait-timeout 60
+      - name: Run tests
+        run: bundle exec rake
+        env:
+          FARADAY_VERSION: ${{ matrix.faraday}}

data/CHANGES.txt

@@ -1,3 +1,13 @@
+3.0.0
+
+- Drop faraday 0.x support by @jcoyne in https://github.com/rsolr/rsolr/pull/255
+- Allow for setting a default http method by @cjcolvar in https://github.com/rsolr/rsolr/pull/252
+- Move query params into data hash when using post and no data is provided by @cjcolvar in https://github.com/rsolr/rsolr/pull/253
+- Support HTTP Basic Auth via a basic_auth: option (in addition to URL-embedded) by @maxkadel in https://github.com/rsolr/rsolr/pull/259
+- Redact only basic auth credentials from Faraday's cause exception by @maxkadel in https://github.com/rsolr/rsolr/pull/261
+
+**Full Changelog**: https://github.com/rsolr/rsolr/compare/v2.6.0...v3.0.0
+
 2.6.0
 
 - Stop testing on Ruby 2. https://github.com/rsolr/rsolr/pull/237

data/Gemfile

@@ -4,10 +4,4 @@ gemspec
 
 gem "builder", ">= 2.1.2"
 
-if defined? JRUBY_VERSION
-  # HTTP.rb (used by solr_wrapper to download solr for integration testing) fails
-  # to download the full contents of files (under jruby)?
-  gem "http", '< 5', platforms: :jruby
-end
-
 gem 'faraday', ENV['FARADAY_VERSION'] if ENV['FARADAY_VERSION']

data/README.md

@@ -0,0 +1,370 @@
+# RSolr
+
+A simple, extensible Ruby client for Apache Solr.
+
+## Documentation
+
+The code docs: http://www.rubydoc.info/gems/rsolr
+
+## Installation
+
+```
+gem install rsolr
+```
+
+## Example
+
+```ruby
+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.
+
+## Basic Auth
+
+Credentials can be embedded in the URL:
+
+```ruby
+solr = RSolr.connect :url => 'http://user:pass@solrserver.com'
+```
+
+or passed explicitly via `:basic_auth`, which is useful if you'd rather keep
+secrets out of a URL string (logs, error messages, etc. tend to capture URLs
+more casually than headers):
+
+```ruby
+solr = RSolr.connect :url => 'http://solrserver.com', :basic_auth => { :user => 'user', :password => 'pass' }
+```
+
+`:basic_auth` accepts string or symbol keys (`'user'`/`'password'`
+work the same as `:user`/`:password`), so a hash loaded straight
+from YAML config works without re-symbolizing it yourself.
+
+If both are given, `:basic_auth` wins. Either way, this only protects the
+credential from casual logging - it doesn't encrypt anything in transit, so
+use `https://` if the connection isn't otherwise trusted (e.g. firewalled).
+
+## Request formats
+
+By default, RSolr uses the Solr JSON command format for all requests.
+
+```ruby
+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, and will
+be passed on to underlying Faraday instance:
+
+```ruby
+solr = RSolr.connect(: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).
+
+```ruby
+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:
+
+```ruby
+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:
+
+```ruby
+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:
+
+```ruby
+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:
+
+```erb
+<%= will_paginate @solr_response["response"]["docs"] %>
+```
+
+### Method Missing
+
+The `RSolr::Client` class also uses `method_missing` for setting the request handler/path:
+
+```ruby
+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:
+
+```ruby
+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:
+
+```ruby
+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:
+
+```ruby
+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:
+
+```ruby
+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.:
+
+```ruby
+request_context = solr.build_request "select", :data => {:q => "*:*"}, :method => :post, :headers => {}
+```
+
+To build a paginated request use build_paginated_request:
+
+```ruby
+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`
+
+```ruby
+solr.add :id=>1, :price=>1.00
+```
+
+Multiple documents via `#add`
+
+```ruby
+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:
+
+```ruby
+solr.add documents, :add_attributes => {:commitWithin => 10}
+```
+
+Raw commands via `#update`
+
+```ruby
+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:
+
+```ruby
+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:
+
+```ruby
+solr.update :data => add_xml
+```
+
+### Deleting
+
+Delete by id
+
+```ruby
+solr.delete_by_id 1
+```
+
+or an array of ids
+
+```ruby
+solr.delete_by_id [1, 2, 3, 4]
+```
+
+Delete by query:
+
+```ruby
+solr.delete_by_query 'price:1.00'
+```
+
+Delete by array of queries
+
+```ruby
+solr.delete_by_query ['price:1.00', 'price:10.00']
+```
+
+### Commit / Optimize
+
+```ruby
+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:
+
+```ruby
+solr.get 'select', :params => {:wt => :ruby} # notice :ruby is a Symbol
+```
+
+### Raw Ruby:
+
+```ruby
+solr.get 'select', :params => {:wt => 'ruby'} # notice 'ruby' is a String
+```
+
+### XML:
+
+```ruby
+solr.get 'select', :params => {:wt => :xml}
+```
+
+### JSON (default):
+
+```ruby
+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!
+
+## Running the tests
+
+The integration specs (`spec/integration`) need a Solr instance;
+run `docker compose up -d` before `bundle exec rspec` or
+`bundle exec rake`.
+
+## 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 <goodieboy@gmail.com>
+
+## Copyright
+
+Copyright (c) 2008-2010 Matt Mitchell. See LICENSE for details.

data/Rakefile

@@ -14,6 +14,6 @@ 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('README.md')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end

data/docker-compose.yaml

@@ -0,0 +1,32 @@
+services:
+  solr:
+    image: solr:9
+    ports:
+      - "8983:8983"
+    volumes:
+      - ./spec/fixtures/basic_configs:/basic_configs_config/conf:ro
+    command: ["solr-precreate", "basic_configs", "/basic_configs_config"]
+    healthcheck:
+      test: ["CMD", "curl", "-sf", "http://localhost:8983/solr/basic_configs/admin/ping"]
+      interval: 2s
+      timeout: 5s
+      retries: 30
+
+  solr_auth:
+    image: solr:9
+    ports:
+      - "8984:8983"
+    volumes:
+      - ./spec/fixtures/basic_configs:/basic_configs_config/conf:ro
+      - ./spec/fixtures/security/security.json:/security-fixture/security.json:ro
+    entrypoint: ["bash", "-c"]
+    command:
+      - |
+        mkdir -p /var/solr/data &&
+        cp /security-fixture/security.json /var/solr/data/security.json &&
+        exec /opt/solr/docker/scripts/solr-precreate basic_configs /basic_configs_config
+    healthcheck:
+      test: ["CMD", "curl", "-sf", "-u", "rsolr:RSolrTest123", "http://localhost:8983/solr/basic_configs/admin/ping"]
+      interval: 2s
+      timeout: 5s
+      retries: 30

data/lib/rsolr/client.rb

@@ -3,10 +3,24 @@
 require 'json'
 require 'faraday'
 require 'uri'
+require 'base64'
 
 class RSolr::Client
+  include RSolr::Error::URICleanup
+
   DEFAULT_URL = 'http://127.0.0.1:8983/solr/'
 
+  # HTTP Basic Auth credentials, and how to render them as an Authorization header.
+  BasicAuth = Struct.new(:user, :password) do
+    def present?
+      !!(user && password)
+    end
+
+    def header_value
+      "Basic #{Base64.strict_encode64("#{user}:#{password}")}"
+    end
+  end
+
   class << self
     def default_wt
       @default_wt ||= :json
@@ -15,6 +29,14 @@ class RSolr::Client
     def default_wt= value
       @default_wt = value
     end
+
+    def default_http_method
+      @default_http_method ||= :get
+    end
+
+    def default_http_method= method
+      @default_http_method = method
+    end
   end
 
   attr_reader :uri, :proxy, :update_format, :options, :update_path
@@ -213,11 +235,11 @@ class RSolr::Client
 
       { status: response.status.to_i, headers: response.headers, body: response.body.force_encoding('utf-8') }
     rescue Faraday::TimeoutError => e
-      raise RSolr::Error::Timeout.new(request_context, e.response)
+      raise RSolr::Error::Timeout.new(request_context, e.response), cause: redact_basic_auth(e)
     rescue Errno::ECONNREFUSED, defined?(Faraday::ConnectionFailed) ? Faraday::ConnectionFailed : Faraday::Error::ConnectionFailed
       raise RSolr::Error::ConnectionRefused.new(request_context)
     rescue Faraday::Error => e
-      raise RSolr::Error::Http.new(request_context, e.response)
+      raise RSolr::Error::Http.new(request_context, e.response), cause: redact_basic_auth(e)
     end
     adapt_response(request_context, raw_response) unless raw_response.nil?
   end
@@ -240,11 +262,17 @@ class RSolr::Client
     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
+    opts[:method] ||= default_http_method
     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[:method] == :post && (opts[:data].nil? || opts[:data].empty?)
+      # If no data hash is provided move query into data hash
+      # This is useful if the query string is larger than the max url length
+      opts[:data] = opts[:params]
+    else
+      query = RSolr::Uri.params_to_solr(opts[:params]) unless opts[:params].empty?
+      opts[:query] = query
+    end
     if opts[:data].is_a? Hash
       opts[:data] = RSolr::Uri.params_to_solr opts[:data]
       opts[:headers] ||= {}
@@ -314,28 +342,48 @@ class RSolr::Client
       conn_opts[:request][:params_encoder] = Faraday::FlatParamsEncoder
 
       Faraday.new(conn_opts) do |conn|
-        if uri.user && uri.password
-          case Faraday::VERSION
-          when /^0/
-            conn.basic_auth uri.user, uri.password
-          when /^1/
-            conn.request :basic_auth, uri.user, uri.password
-          else
-            conn.request :authorization, :basic_auth, uri.user, uri.password
-          end
-        end
+        conn.headers['Authorization'] = basic_auth.header_value if basic_auth.present?
 
         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 || :net_http
+        conn.adapter(*Array(options[:adapter] || Faraday.default_adapter || :net_http))
       end
     end
   end
 
   protected
 
+  def basic_auth
+    if options[:basic_auth]
+      auth = options[:basic_auth]
+      BasicAuth.new(auth[:user] || auth['user'], auth[:password] || auth['password'])
+    else
+      BasicAuth.new(uri.user, uri.password)
+    end
+  end
+
+  # Faraday's own exception (kept as +cause+) embeds the request unredacted; rebuild it with just the credentials scrubbed.
+  def redact_basic_auth(error)
+    response = error.response
+    return error unless response.is_a?(Hash) && response[:request].is_a?(Hash)
+
+    request = response[:request].dup
+    request[:url] = clean_uri(request[:url]) if request[:url].respond_to?(:user)
+    request[:headers] = redact_authorization_header(request[:headers]) if request[:headers]
+
+    error.class.new(response.merge(request: request))
+  end
+
+  def redact_authorization_header(headers)
+    return headers unless headers['Authorization']
+
+    headers = headers.dup
+    headers['Authorization'] = 'REDACTED'
+    headers
+  end
+
   # converts the method name for the solr request handler path.
   def method_missing name, *args
     if name.to_s =~ /^paginated?_(.+)$/
@@ -369,4 +417,8 @@ class RSolr::Client
   def default_wt
     self.options[:default_wt] || self.class.default_wt
   end
+
+  def default_http_method
+    self.options[:default_http_method] || self.class.default_http_method
+  end
 end

data/lib/rsolr/version.rb

@@ -1,5 +1,5 @@
 module RSolr
-  VERSION = "2.6.0"
+  VERSION = "3.0.0"
 
   def self.version
     VERSION

data/rsolr.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |s|
   s.requirements << 'Apache Solr'
 
   s.add_dependency 'builder', '>= 2.1.2'
-  s.add_dependency 'faraday', '>= 0.9', '!= 2.0.0', '< 3'
+  s.add_dependency 'faraday', '>= 1.0', '< 3'
 
   s.add_development_dependency 'activesupport'
   s.add_development_dependency 'nokogiri', '>= 1.4.0'
@@ -41,5 +41,4 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rdoc', '>= 4.0'
   s.add_development_dependency 'rspec', '~> 3.0'
   s.add_development_dependency 'simplecov'
-  s.add_development_dependency 'solr_wrapper'
 end

data/spec/api/client_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'base64'
 
 RSpec.describe RSolr::Client do
   let(:connection) { nil }
@@ -13,6 +14,106 @@ RSpec.describe RSolr::Client do
     RSolr::Client.new connection, connection_options.merge(proxy: 'http://localhost:8080')
   end
 
+  context "basic auth" do
+    let(:stubs) { Faraday::Adapter::Test::Stubs.new }
+
+    def authorization_header_for(url:, **client_opts)
+      seen_header = nil
+      stubs.get('/solr/admin/ping') do |env|
+        seen_header = env.request_headers['Authorization']
+        [200, {}, '']
+      end
+
+      RSolr::Client.new(nil, { url: url, adapter: [:test, stubs] }.merge(client_opts)).get('admin/ping')
+      stubs.verify_stubbed_calls
+      seen_header
+    end
+
+    it "sends credentials embedded in the URL as a Basic Authorization header" do
+      header = authorization_header_for(url: "http://someuser:somepass@localhost:9999/solr")
+      expect(header).to eq("Basic #{Base64.strict_encode64('someuser:somepass')}")
+    end
+
+    it "sends no Authorization header when the URL has no credentials" do
+      header = authorization_header_for(url: "http://localhost:9999/solr")
+      expect(header).to be_nil
+    end
+
+    it "sends credentials given via the basic_auth: option" do
+      header = authorization_header_for(
+        url: "http://localhost:9999/solr",
+        basic_auth: { user: 'optuser', password: 'optpass' }
+      )
+      expect(header).to eq("Basic #{Base64.strict_encode64('optuser:optpass')}")
+    end
+
+    it "prefers the basic_auth: option over credentials embedded in the URL" do
+      header = authorization_header_for(
+        url: "http://urluser:urlpass@localhost:9999/solr",
+        basic_auth: { user: 'optuser', password: 'optpass' }
+      )
+      expect(header).to eq("Basic #{Base64.strict_encode64('optuser:optpass')}")
+    end
+
+    it "accepts a basic_auth: option with string keys, as loaded from YAML" do
+      header = authorization_header_for(
+        url: "http://localhost:9999/solr",
+        basic_auth: { 'user' => 'optuser', 'password' => 'optpass' }
+      )
+      expect(header).to eq("Basic #{Base64.strict_encode64('optuser:optpass')}")
+    end
+
+    context 'when a connection error is raised' do
+      def error_raised_for(url:, **client_opts)
+        stubs.get('/solr/admin/ping') { |_env| [500, {}, 'boom'] }
+        RSolr::Client.new(nil, { url: url, adapter: [:test, stubs] }.merge(client_opts)).get('admin/ping')
+        nil
+      rescue RSolr::Error::Http => e
+        e
+      end
+
+      context 'with credentials in url' do
+        it 'already redacts the url in RSolr::Error::Http#message' do
+          error = error_raised_for(url: "http://someuser:somepass@localhost:9999/solr")
+
+          expect(error.message).not_to include('somepass')
+          expect(error.message).to include('REDACTED')
+        end
+
+        it 'does not leak basic auth info' do
+          error = error_raised_for(url: "http://someuser:somepass@localhost:9999/solr")
+
+          expect(error.cause.message).not_to include('somepass')
+          expect(error.cause.inspect).not_to include('somepass')
+          expect(error.cause.inspect).to include('REDACTED')
+        end
+      end
+
+      context 'with credentials in header' do
+        it 'already omits credentials from RSolr::Error::Http#message' do
+          error = error_raised_for(
+            url: "http://localhost:9999/solr",
+            basic_auth: { user: 'optuser', password: 'optpass' }
+          )
+          encoded_credentials = Base64.strict_encode64('optuser:optpass')
+
+          expect(error.message).not_to include(encoded_credentials)
+        end
+
+        it 'does not leak basic auth info' do
+          error = error_raised_for(
+            url: "http://localhost:9999/solr",
+            basic_auth: { user: 'optuser', password: 'optpass' }
+          )
+          encoded_credentials = Base64.strict_encode64('optuser:optpass')
+
+          expect(error.cause.inspect).not_to include(encoded_credentials)
+          expect(error.cause.inspect).to include('REDACTED')
+        end
+      end
+    end
+  end
+
   context "initialize" do
     it "should accept whatevs and set it as the @connection" do
       expect(RSolr::Client.new(:whatevs).connection).to eq(:whatevs)
@@ -92,7 +193,7 @@ RSpec.describe RSolr::Client do
       it "removes credentials from uri" do
         expect {
           client.execute({ uri: uri })
-        }.to raise_error(RSolr::Error::ConnectionRefused, /http:\/\/REDACTED:REDACTED@hostname\.local:8983/)
+        }.to raise_error(RSolr::Error::ConnectionRefused, /http:\/\/(?:REDACTED:)?REDACTED@hostname\.local:8983/)
       end
     end
   end
@@ -411,6 +512,18 @@ RSpec.describe RSolr::Client do
       end
     end
 
+    context "when post but no hash is passed in as data" do
+      let(:data) { nil }
+
+      it "sets the Content-Type header to application/x-www-form-urlencoded; charset=UTF-8" do
+        expect(subject[:query]).to be_nil
+        [/fq=0/, /fq=1/, /q=test/, /wt=json/].each do |pattern|
+          expect(subject[:data]).to match pattern
+        end
+        expect(subject[:headers]).to eq({"Content-Type" => "application/x-www-form-urlencoded; charset=UTF-8"})
+      end
+    end
+
     it "should properly handle proxy configuration" do
       result = client_with_proxy.build_request('select',
         :method => :post,
@@ -419,5 +532,24 @@ RSpec.describe RSolr::Client do
       )
       expect(result[:uri].to_s).to match %r{^http://localhost:9999/solr/}
     end
+
+    context "http method" do
+      it "uses get by default" do
+        expect(client.build_request('select', { params: params })[:method]).to eq :get
+      end
+      it "uses the instance default if set" do
+        client = RSolr::Client.new connection, connection_options.merge(default_http_method: :post)
+        expect(client.build_request('select', { data: params })[:method]).to eq :post
+      end
+      it "uses the class default if set" do
+        RSolr::Client.default_http_method = :post
+        expect(client.build_request('select', { data: params })[:method]).to eq :post
+        RSolr::Client.default_http_method = nil
+      end
+      it "uses the method passed in opts" do
+        expect(client.build_request('select', { params: params, method: :get })[:method]).to eq :get
+        expect(client.build_request('select', { data: params, method: :post })[:method]).to eq :post
+      end
+    end
   end
 end

data/spec/api/error_spec.rb

@@ -148,11 +148,13 @@ RSpec.describe RSolr::Error do
   end
 
   context "when request uri contains credentials" do
-    let(:request) { { uri: URI.parse('http://admin:admin@hostname.local:8983/solr/admin/update?wt=json&q=test') } }
+    let(:request) { { uri: URI.parse('http://user:pass@hostname.local:8983/solr/admin/update?wt=json&q=test') } }
 
 
     it 'includes redacted url' do
-      expect(subject).to include 'http://REDACTED:REDACTED@hostname.local:8983/solr/admin/update?wt=json&q=test'
+      expect(subject).to include 'REDACTED@hostname.local:8983/solr/admin/update?wt=json&q=test'
+      expect(subject).not_to include 'user'
+      expect(subject).not_to include 'pass'
     end
   end
 end

data/spec/api/json_spec.rb

@@ -68,32 +68,10 @@ RSpec.describe RSolr::JSON do
           },
         ]
 
-        # custom JSON object class to handle Solr's non-standard JSON command format
-        tmp = Class.new do
-          def initialize
-            @source ||= {}
-          end
-
-          def []=(k, v)
-            if k == :add
-              @source[k] ||= []
-              @source[k] << v.to_h
-            elsif v.class == self.class
-              @source[k] = v.to_h
-            else
-              @source[k] = v
-            end
-          end
-
-          def to_h
-            @source
-          end
-        end
-
         request = generator.add(data, boost: 1)
-        message = JSON.parse(request, object_class: tmp, symbolize_names: true).to_h
-        expect(message[:add].length).to eq 2
-        expect(message[:add].map { |x| x[:doc] }).to eq data
+
+        expect(request).to match(/"add":{"boost":1,"doc":{"id":"1","name":"matt"}}/)
+        expect(request).to match(/"add":{"boost":1,"doc":{"id":"2","name":"sam"}}/)
       end
     end
 

data/spec/fixtures/basic_configs/schema.xml

@@ -498,7 +498,7 @@
     <fieldType name="point" class="solr.PointType" dimension="2" subFieldSuffix="_d"/>
 
     <!-- A specialized field for geospatial search. If indexed, this fieldType must not be multivalued. -->
-    <fieldType name="location" class="solr.LatLonType" subFieldSuffix="_coordinate"/>
+    <fieldType name="location" class="solr.LatLonPointSpatialField"/> 
 
     <!-- An alternative geospatial field type new to Solr 4.  It supports multiValued and polygon shapes.
       For more information about this and other Spatial fields new to Solr 4, see:

data/spec/fixtures/basic_configs/solrconfig.xml

@@ -315,8 +315,8 @@
          background concurrently.  An error is returned if this limit
          is exceeded.
 
-         Recommend values of 1-2 for read-only slaves, higher for
-         masters w/o cache warming.
+         Recommend values of 1-2 for read-only followers, higher for
+         leaders w/o cache warming.
       -->
     <maxWarmingSearchers>2</maxWarmingSearchers>
 

data/spec/fixtures/security/security.json

@@ -0,0 +1,16 @@
+{
+  "authentication": {
+    "blockUnknown": true,
+    "class": "solr.BasicAuthPlugin",
+    "credentials": {
+      "rsolr": "yBxMT8Js4iwRuqWHqW7eQcF1iNDaSbI8ZQtQc5nZyYg= 57WDp52Vgp2LrB9BT5/iFnGY7txUMdTlyM9rVT9XwcA="
+    },
+    "realm": "rsolr test",
+    "forwardCredentials": false
+  },
+  "authorization": {
+    "class": "solr.RuleBasedAuthorizationPlugin",
+    "permissions": [{ "name": "security-edit", "role": "admin" }],
+    "user-role": { "rsolr": "admin" }
+  }
+}

data/spec/integration/basic_auth_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+RSpec.describe "Solr basic auth" do
+  let(:port) { ENV.fetch('SOLR_AUTH_TEST_PORT', 8984) }
+  let(:base_url) { "http://localhost:#{port}/solr/basic_configs/" }
+  let(:user) { 'rsolr' }
+  let(:password) { 'RSolrTest123' }
+
+  it "succeeds using the basic_auth: option" do
+    solr = RSolr.connect(url: base_url, basic_auth: { user: user, password: password })
+    expect { solr.head('admin/ping') }.not_to raise_error
+  end
+
+  it "succeeds using credentials embedded in the URL" do
+    url = "http://#{user}:#{password}@localhost:#{port}/solr/basic_configs/"
+    solr = RSolr.connect(url: url)
+    expect { solr.head('admin/ping') }.not_to raise_error
+  end
+
+  it "raises RSolr::Error::Http with no credentials" do
+    solr = RSolr.connect(url: base_url)
+    expect { solr.head('admin/ping') }.to raise_error(RSolr::Error::Http, /401/)
+  end
+
+  it "raises RSolr::Error::Http with the wrong credentials" do
+    solr = RSolr.connect(url: base_url, basic_auth: { user: user, password: 'wrong' })
+    expect { solr.head('admin/ping') }.to raise_error(RSolr::Error::Http, /401/)
+  end
+end

data/spec/integration/solr5_spec.rb

@@ -1,22 +1,9 @@
 require 'spec_helper'
-require 'solr_wrapper'
 
 RSpec.describe "Solr basic_configs" do
-  SolrWrapper.default_instance_options = {
-    port: SolrWrapper.default_solr_port,
-    version: '8.11.3'
-  } 
-  SOLR_INSTANCE =  SolrWrapper.default_instance({})
-  before(:all) { SOLR_INSTANCE.start }
-  after(:all) { SOLR_INSTANCE.stop }
-
   context "basic configs" do
-    subject { RSolr.connect url: "http://localhost:#{SOLR_INSTANCE.port}/solr/basic_configs/"}
-    around(:each) do |example|
-      SOLR_INSTANCE.with_collection(name: "basic_configs", dir: File.join(FIXTURES_DIR, "basic_configs")) do |coll|
-        example.run
-      end
-    end
+    subject { RSolr.connect url: "http://localhost:#{ENV.fetch('SOLR_TEST_PORT', 8983)}/solr/basic_configs/" }
+
     describe "HEAD admin/ping" do
       it "should not raise an exception" do
         expect { subject.head('admin/ping') }.not_to raise_error

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 require 'simplecov'
 SimpleCov.start do
-  add_filter "/spec/"
+  skip "/spec/"
 end
 
 require 'rsolr'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rsolr
 version: !ruby/object:Gem::Version
-  version: 2.6.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Antoine Latter
@@ -26,10 +26,9 @@ authors:
 - Nathan Witmer
 - Naomi Dushay
 - '"shima"'
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-25 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -51,10 +50,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
-    - - "!="
-      - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '1.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '3'
@@ -64,10 +60,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
-    - - "!="
-      - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '1.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '3'
@@ -155,20 +148,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: solr_wrapper
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: RSolr aims to provide a simple and extensible library for working with
   Solr
 email:
@@ -183,8 +162,9 @@ files:
 - CHANGES.txt
 - Gemfile
 - LICENSE
-- README.rdoc
+- README.md
 - Rakefile
+- docker-compose.yaml
 - lib/rsolr.rb
 - lib/rsolr/char.rb
 - lib/rsolr/client.rb
@@ -214,6 +194,8 @@ files:
 - spec/fixtures/basic_configs/solrconfig.xml
 - spec/fixtures/basic_configs/stopwords.txt
 - spec/fixtures/basic_configs/synonyms.txt
+- spec/fixtures/security/security.json
+- spec/integration/basic_auth_spec.rb
 - spec/integration/solr5_spec.rb
 - spec/lib/rsolr/client_spec.rb
 - spec/spec_helper.rb
@@ -221,7 +203,6 @@ homepage: https://github.com/rsolr/rsolr
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -237,8 +218,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements:
 - Apache Solr
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 4.0.18
 specification_version: 4
 summary: A Ruby client for Apache Solr
 test_files: []

data/README.rdoc

@@ -1,227 +0,0 @@
-=RSolr
-
-A simple, extensible Ruby client for Apache Solr.
-
-==Documentation
-The code docs http://www.rubydoc.info/gems/rsolr
-
-== Installation:
-  gem install 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, and will
-be passed on to underlying Faraday instance:
-
-  solr = RSolr.connect(: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.