rsolr 1.1.2 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e401f0dcdd04d8215eec9b67a1e7c775c41ac7f4
-  data.tar.gz: 6e466531f33da1560869ce39586101dfc4bbb08e
+SHA256:
+  metadata.gz: 1ca1fd66200c07e8e4ffc42bc8d71e6735a7294b7c53485ed8b49f8cfc99ac68
+  data.tar.gz: 3a0b50c5807543beed8ddc533cb8d446909176d61d1022ef0d8bb26ee1250648
 SHA512:
-  metadata.gz: 29a5ac0f898a33e2d8efc2a0b0b7ed618c169e63597dcc283573ae9302183f0ee983ec18e30d3c9dc100bb13e06ff86358d02ad0df91515101efc8a26f82b7f8
-  data.tar.gz: 1a509a26c086ffbad2543154106584989d7c40d42b747a422a622ba77fe1dd87202373ae1cd8d10727a0b61b89ad16a5cfcdc5655375ebc7d4b5733d9fa7dcb0
+  metadata.gz: 1a4bf74cc57d3523c4774f86c895b2e4a6bed229cc67499278fad4cf320575c68df1774d1fb0615108ca5ced0267798cea42a3e4c96723d6f2fb0f4294f38bcb
+  data.tar.gz: a51ec9142aba1761511058ed8614f600325e32551e6ae23b1638e2654b67e8a5ef3b8db1f6653171b67c492264079f368f95a0856ce1d7db5d1e5a06998b32d8

data/.gitignore

@@ -10,3 +10,4 @@ Gemfile.lock
 
 *.gem
 .bundle
+/spec/examples.txt

data/.rspec

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

data/.travis.yml

@@ -1,21 +1,14 @@
-addons:
-  apt:
-    packages:
-    - libgmp-dev
 language: ruby
 sudo: false
 rvm:
-  - 2.3.1
-  - 2.2.5
-  - jruby-9.0.5.0
-
-notifications:
-  irc: "irc.freenode.org#blacklight"
-  email:
-      - blacklight-commits@googlegroups.com
+  - 2.6
+  - 2.5
+  - 2.4
+  - jruby
 
 env:
   global:
     - JRUBY_OPTS="-J-Xms512m -J-Xmx1024m"
     - NOKOGIRI_USE_SYSTEM_LIBRARIES=true
-jdk: oraclejdk8
+
+jdk: openjdk8

data/CHANGES.txt

@@ -1,3 +1,14 @@
+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.
 

data/Gemfile

@@ -3,7 +3,3 @@ source "https://rubygems.org"
 gemspec
 
 gem "builder", ">= 2.1.2"
-
-if defined? RUBY_VERSION and RUBY_VERSION < "1.9"
-  gem 'nokogiri', "< 1.6"
-end

data/README.rdoc

@@ -11,7 +11,6 @@ The code docs http://www.rubydoc.info/gems/rsolr
   gem install rsolr
 
 == Example:
-  require 'rubygems'
   require 'rsolr'
   
   # Direct connection
@@ -19,7 +18,17 @@ The code docs http://www.rubydoc.info/gems/rsolr
   
   # 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 => '*:*'}
   
@@ -34,6 +43,14 @@ The +:request+ attribute contains the original request context. You can use this
 
 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)
@@ -44,6 +61,7 @@ A 503 is usually a temporary error which RSolr may retry if requested. You may s
 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:
@@ -119,9 +137,9 @@ Multiple documents via #add
 The optional +:add_attributes+ hash can also be used to set Solr "add" document attributes:
   solr.add documents, :add_attributes => {:commitWithin => 10}
 
-Raw XML via  #update
-  solr.update :data => '<commit/>'
-  solr.update :data => '<optimize/>'
+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:
   
@@ -155,14 +173,13 @@ Delete by array of queries
 == Response Formats
 The default response format is Ruby. When the +:wt+ param is set to +:ruby+, the response is eval'd resulting in a Hash. You can get a raw response by setting the +:wt+ to +"ruby"+ - notice, the string -- not a symbol. RSolr will eval the Ruby string ONLY if the :wt value is :ruby. All other response formats are available as expected, +:wt=>'xml'+ etc..
 
-===Evaluated Ruby (default)
+===Evaluated Ruby:
   solr.get 'select', :params => {:wt => :ruby} # notice :ruby is a Symbol
-===Raw Ruby
+===Raw Ruby:
   solr.get 'select', :params => {:wt => 'ruby'} # notice 'ruby' is a String
-
 ===XML:
   solr.get 'select', :params => {:wt => :xml}
-===JSON:
+===JSON (default):
   solr.get 'select', :params => {:wt => :json}
 
 ==Related Resources & Projects
@@ -170,7 +187,7 @@ The default response format is Ruby. When the +:wt+ param is set to +:ruby+, the
 * {rsolr-ext}[http://github.com/mwmitchell/rsolr-ext] -- An extension kit for RSolr
 * {rsolr-direct}[http://github.com/mwmitchell/rsolr-direct] -- JRuby direct connection for RSolr
 * {rsolr-nokogiri}[http://github.com/mwmitchell/rsolr-nokogiri] -- Gives RSolr Nokogiri for XML generation.
-* {SunSpot}[http://github.com/outoftime/sunspot] -- An awesome Solr DSL, built with RSolr
+* {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

data/Rakefile

@@ -1,6 +1,19 @@
-require 'rake'
 require 'bundler/gem_tasks'
 
-Dir['tasks/**/*.rake'].each { |t| load t }
+task default: ['spec']
 
-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

@@ -1,16 +1,27 @@
 module RSolr
-  
-  Dir.glob(File.expand_path("../rsolr/*.rb", __FILE__)).each{|rb_file| require(rb_file)}
-  
+  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
-    driver = Class === args[0] ? args[0] : RSolr::Connection
-    opts = Hash === args[-1] ? args[-1] : {}
-    Client.new driver.new, opts
+    opts = args.pop if args.last.is_a?(::Hash)
+    opts ||= {}
+
+    connection = args.first
+
+    Client.new connection, opts
   end
-  
-  # RSolr.escape, which is deprecated as of 2015-02
-  extend Char
-  
+
   # 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
   #  + - & | ! ( ) { } [ ] ^ " ~ * ? : \ /
@@ -22,5 +33,20 @@ module RSolr
     # so the result sent to Solr is ultimately a single backslash in front of the particular character 
     str.gsub(/([+\-&|!\(\)\{\}\[\]\^"~\*\?:\\\/])/, '\\\\\1')
   end
-  
-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

@@ -1,24 +1,6 @@
-# A module that contains (1) string related methods
-# @deprecated remove this module when we remove the method (duh)
+# :nodoc:
 module RSolr::Char
-  
-  # backslash everything
-  # that isn't a word character
-  # @deprecated - this is incorrect Solr escaping
-  def escape value
-    warn "[DEPRECATION] `RSolr.escape` is deprecated (and incorrect).  Use `RSolr.solr_escape` instead."
-    value.gsub(/(\W)/, '\\\\\1')
+  def self.included(*)
+    warn 'RSolr::Char is deprecated without replacement, and will be removed in RSolr 3.x'
   end
-  
-  # LUCENE_CHAR_RX = /([\+\-\!\(\)\[\]\^\"\~\*\?\:\\]+)/
-  # LUCENE_WORD_RX = /(OR|AND|NOT)/
-  # 
-  # # More specific/lucene escape sequence
-  # def lucene_escape string
-  #   delim = " "
-  #   string.gsub(LUCENE_CHAR_RX, '\\\\\1').split(delim).map { |v|
-  #     v.gsub(LUCENE_WORD_RX, '\\\\\1')
-  #   }.join(delim)
-  # end
-  
 end

data/lib/rsolr/client.rb

@@ -1,13 +1,15 @@
-begin
-  require 'json'
-rescue LoadError
-end
+# 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 || :ruby
+      @default_wt ||= :json
     end
 
     def default_wt= value
@@ -15,33 +17,41 @@ class RSolr::Client
     end
   end
 
-  attr_reader :connection, :uri, :proxy, :options, :update_path
+  attr_reader :uri, :proxy, :update_format, :options, :update_path
 
   def initialize connection, options = {}
     @proxy = @uri = nil
     @connection = connection
     unless false === options[:url]
-      url = options[:url] ? options[:url].dup : 'http://127.0.0.1:8983/solr/'
-      url << "/" unless url[-1] == ?/
-      @uri = RSolr::Uri.create url
+      @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 = RSolr::Uri.create proxy_url if proxy_url
+        @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 RSolr::URI uri object.
+  # returns the URI uri object.
   def base_uri
     @uri
   end
@@ -80,11 +90,10 @@ class RSolr::Client
   #
   def update opts = {}
     opts[:headers] ||= {}
-    opts[:headers]['Content-Type'] ||= 'text/xml'
+    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
@@ -101,7 +110,7 @@ class RSolr::Client
   #
   def add doc, opts = {}
     add_attributes = opts.delete :add_attributes
-    update opts.merge(:data => xml.add(doc, add_attributes))
+    update opts.merge(:data => builder.add(doc, add_attributes))
   end
 
   # send "commit" xml with opts
@@ -110,7 +119,7 @@ class RSolr::Client
   #
   def commit opts = {}
     commit_attrs = opts.delete :commit_attributes
-    update opts.merge(:data => xml.commit( commit_attrs ))
+    update opts.merge(:data => builder.commit( commit_attrs ))
   end
 
   # send "optimize" xml with opts.
@@ -119,7 +128,7 @@ class RSolr::Client
   #
   def optimize opts = {}
     optimize_attributes = opts.delete :optimize_attributes
-    update opts.merge(:data => xml.optimize(optimize_attributes))
+    update opts.merge(:data => builder.optimize(optimize_attributes))
   end
 
   # send </rollback>
@@ -128,14 +137,14 @@ class RSolr::Client
   #
   # NOTE: solr 1.4 only
   def rollback opts = {}
-    update opts.merge(:data => xml.rollback)
+    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 => xml.delete_by_id(id))
+    update opts.merge(:data => builder.delete_by_id(id))
   end
 
   # delete one or many documents by query.
@@ -145,12 +154,19 @@ class RSolr::Client
   #   solr.delete_by_query 'available:0'
   #   solr.delete_by_query ['quantity:0', 'manu:"FQ"']
   def delete_by_query query, opts = {}
-    update opts.merge(:data => xml.delete_by_query(query))
+    update opts.merge(:data => builder.delete_by_query(query))
   end
 
-  # shortcut to RSolr::Xml::Generator
-  def xml
-    @xml ||= RSolr::Xml::Generator.new
+  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.
@@ -177,48 +193,21 @@ class RSolr::Client
 
   #
   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
 
-    raw_response = connection.execute self, request_context
-
-    while retry_503?(request_context, raw_response)
-      request_context[:retry_503] -= 1
-      sleep retry_after(raw_response)
-      raw_response = connection.execute self, request_context
+      { status: response.status.to_i, headers: response.headers, body: response.body.force_encoding('utf-8') }
+    rescue Errno::ECONNREFUSED, defined?(Faraday::ConnectionFailed) ? Faraday::ConnectionFailed : 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
 
-  def retry_503?(request_context, response)
-    return false if response.nil?
-    status = response[:status] && response[:status].to_i
-    return false unless status == 503
-    retry_503 = request_context[:retry_503]
-    return false unless retry_503 && retry_503 > 0
-    retry_after_limit = request_context[:retry_after_limit] || 1
-    retry_after = retry_after(response)
-    return false unless retry_after && retry_after <= retry_after_limit
-    true
-  end
-
-  # Retry-After can be a relative number of seconds from now, or an RFC 1123 Date.
-  # If the latter, attempt to convert it to a relative time in seconds.
-  def retry_after(response)
-    retry_after = Array(response[:headers]['Retry-After'] || response[:headers]['retry-after']).flatten.first.to_s
-    if retry_after =~ /\A[0-9]+\Z/
-      retry_after = retry_after.to_i
-    else
-      begin
-        retry_after_date = DateTime.parse(retry_after)
-        retry_after = retry_after_date.to_time - Time.now
-        retry_after = nil if retry_after < 0
-      rescue ArgumentError
-        retry_after = retry_after.to_i
-      end
-    end
-    retry_after
-  end
-
   # +build_request+ accepts a path and options hash,
   # then prepares a normalized hash to return for sending
   # to a solr connection driver.
@@ -250,10 +239,6 @@ class RSolr::Client
     opts[:path] = path
     opts[:uri] = base_uri.merge(path.to_s + (query ? "?#{query}" : "")) if base_uri
 
-    [:open_timeout, :read_timeout, :retry_503, :retry_after_limit].each do |k|
-      opts[k] = @options[k]
-    end
-
     opts
   end
 
@@ -285,7 +270,6 @@ class RSolr::Client
   def adapt_response request, response
     raise "The response does not have the correct keys => :body, :headers, :status" unless
       %W(body headers status) == response.keys.map{|k|k.to_s}.sort
-    raise RSolr::Error::Http.new request, response unless [200,302].include? response[:status]
 
     result = if respond_to? "evaluate_#{request[:params][:wt]}_response", true
       send "evaluate_#{request[:params][:wt]}_response", request, response
@@ -299,6 +283,26 @@ class RSolr::Client
 
     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
 
@@ -319,21 +323,17 @@ class RSolr::Client
   # instead, giving full access to the
   # request/response objects.
   def evaluate_ruby_response request, response
-    begin
-      Kernel.eval response[:body].to_s
-    rescue SyntaxError
-      raise RSolr::Error::InvalidRubyResponse.new request, response
-    end
+    Kernel.eval response[:body].to_s
+  rescue SyntaxError
+    raise RSolr::Error::InvalidRubyResponse.new request, response
   end
 
   def evaluate_json_response request, response
-    return response[:body] unless defined? JSON
+    return if response[:body].nil? || response[:body].empty?
 
-    begin
-      JSON.parse response[:body].to_s
-    rescue JSON::ParserError
-      raise RSolr::Error::InvalidJsonResponse.new request, response
-    end
+    JSON.parse response[:body].to_s
+  rescue JSON::ParserError
+    raise RSolr::Error::InvalidJsonResponse.new request, response
   end
 
   def default_wt