rsolr 2.5.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f44e7e34b8e615204b49052907e322c46387d858f147b7e34bd4c53edf6b336e
-  data.tar.gz: b5ad262ba4b5777f18b817c529f9cb8768843972f394420a4798191f92a11b17
+  metadata.gz: 7cd06ee9f0201b75d69b9f7d02f5ad6641272e5ec8d6d1eaa1b57aaedc90daef
+  data.tar.gz: 277248ac909e888160f8addac51fa01d44dc26cb089b8bfcbdb3ed93263015c9
 SHA512:
-  metadata.gz: c230788c63b34623fa05608af73c25c5c7bd6fbab106afc62c63b1347a688bf302d0b03323204b0efd047f01ddc2d957722cd5ed0f98553ec3974b7ed2653c79
-  data.tar.gz: 606324146e3acb8cb86c726a528550fefd0bd57fdebce977fc260c5a38caf4b1c5aeca7c3f23637dcf4bf04e8fbc196e60e4cc63f9827ee7e88af01e816ce3a4
+  metadata.gz: e095fbdf8f63f68eeb5b9919b6cf61d745b1dd044d819f2a762dbf82bf3b9bf813b0b022c61709f57e3f080ce96104e453d22db120d2d62f1a94453cf58b145c
+  data.tar.gz: 8ff5849b11a1bb25f315cd5373354dd2479d7c0725d8092b76e8360fb31886f3d406f4d2cecf898003d11124af0566528aa6f9dd860680510875008a10afe046

data/.github/workflows/ruby.yml

@@ -2,43 +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, 2.7, '3.0', '3.1']
-        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}}
-  legacy_tests:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        ruby: [jruby-9.2.20.0, 2.4, 2.5, 2.6, 2.7]
-    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
-    - name: Run tests
-      run: bundle exec rake
+      - 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,25 @@
+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
+- Set solr version to 8.11.3. https://github.com/rsolr/rsolr/pull/238
+- Add newer rubies to the test matrix. https://github.com/rsolr/rsolr/pull/239
+- Sanitizing URIs displayed in error messages. https://github.com/rsolr/rsolr/pull/236
+
+2.5.0
+
+- Sorry, not human-edited: https://github.com/rsolr/rsolr/compare/v2.4.0...v2.5.0
+
+
 2.4.0
 
 - Raise specific timeout error for solr timeouts. https://github.com/rsolr/rsolr/pull/214

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, request_context.inspect
+      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