rsolr 1.1.2 → 2.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e401f0dcdd04d8215eec9b67a1e7c775c41ac7f4
-  data.tar.gz: 6e466531f33da1560869ce39586101dfc4bbb08e
+  metadata.gz: 6615cc15df2d2db90f952215c74c2c1215622f6d
+  data.tar.gz: 3b46e5c7953531a68c6dd596036f8b50d10c99d6
 SHA512:
-  metadata.gz: 29a5ac0f898a33e2d8efc2a0b0b7ed618c169e63597dcc283573ae9302183f0ee983ec18e30d3c9dc100bb13e06ff86358d02ad0df91515101efc8a26f82b7f8
-  data.tar.gz: 1a509a26c086ffbad2543154106584989d7c40d42b747a422a622ba77fe1dd87202373ae1cd8d10727a0b61b89ad16a5cfcdc5655375ebc7d4b5733d9fa7dcb0
+  metadata.gz: e4de23a7c03b4d3d81a765dd6be91abff61a6f8241bbe5a4e941df9d0c34855715fe077aa5d3b20d54c3e87781aa539a90cd6da8ba3e4cb9b87591c0523e59f7
+  data.tar.gz: d2ad073f1b1814b834facbeaa8268d803076645eae603ed751813fe73684d10172e26cec7d54d232e42e1d5052d159ec519f8be5fee5ec74ea2e309cd5bb37a7

data/.gitignore

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

data/.rspec

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

data/README.rdoc

@@ -155,14 +155,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

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/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

@@ -3,11 +3,13 @@ begin
 rescue LoadError
 end
 
+require 'faraday'
+
 class RSolr::Client
 
   class << self
     def default_wt
-      @default_wt || :ruby
+      @default_wt ||= :json
     end
 
     def default_wt= value
@@ -15,7 +17,7 @@ class RSolr::Client
     end
   end
 
-  attr_reader :connection, :uri, :proxy, :options, :update_path
+  attr_reader :uri, :proxy, :options, :update_path
 
   def initialize connection, options = {}
     @proxy = @uri = nil
@@ -23,15 +25,16 @@ class RSolr::Client
     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 = ::URI.parse(url)
       if options[:proxy]
         proxy_url = options[:proxy].dup
         proxy_url << "/" unless proxy_url.nil? or proxy_url[-1] == ?/
-        @proxy = RSolr::Uri.create proxy_url if proxy_url
+        @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) || :json
     @update_path = options.fetch(:update_path, 'update')
     @options = options
   end
@@ -41,7 +44,7 @@ class RSolr::Client
     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 +83,14 @@ class RSolr::Client
   #
   def update opts = {}
     opts[:headers] ||= {}
-    opts[:headers]['Content-Type'] ||= 'text/xml'
+    if @update_format == :json
+      opts[:headers]['Content-Type'] ||= 'application/json'
+    else
+      opts[:headers]['Content-Type'] ||= 'text/xml'
+    end
     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 +107,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 +116,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 +125,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 +134,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,14 +151,25 @@ 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
 
+  def builder
+    if @update_format == :json
+      json
+    else
+      xml
+    end
+  end
   # shortcut to RSolr::Xml::Generator
   def xml
     @xml ||= RSolr::Xml::Generator.new
   end
 
+  def json
+    @json ||= RSolr::JSON::Generator.new
+  end
+
   # +send_and_receive+ is the main request method responsible for sending requests to the +connection+ object.
   #
   # "path" : A string value that usually represents a solr request handler
@@ -177,48 +194,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 Faraday::ClientError => e
+      raise RSolr::Error::Http.new(request_context, e.response)
+    rescue Errno::ECONNREFUSED
+      raise RSolr::Error::ConnectionRefused, request_context.inspect
     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 +240,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 +271,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 +284,25 @@ class RSolr::Client
 
     result
   end
+  
+  def connection
+    @connection ||= begin
+      conn_opts = { request: {} }
+      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

data/lib/rsolr/document.rb

@@ -0,0 +1,161 @@
+module RSolr
+  class Document
+    CHILD_DOCUMENT_KEY = '_childDocuments_'.freeze
+
+    # "attrs" is a hash for setting the "doc" xml attributes
+    # "fields" is an array of Field objects
+    attr_accessor :attrs, :fields
+
+    # "doc_hash" must be a Hash/Mash object
+    # If a value in the "doc_hash" is an array,
+    # a field object is created for each value...
+    def initialize(doc_hash = {})
+      @fields = []
+      doc_hash.each_pair do |field, values|
+        add_field(field, values)
+      end
+      @attrs={}
+    end
+
+    # returns an array of fields that match the "name" arg
+    def fields_by_name(name)
+      @fields.select{|f|f.name==name}
+    end
+
+    # returns the *first* field that matches the "name" arg
+    def field_by_name(name)
+      @fields.detect{|f|f.name==name}
+    end
+
+    #
+    # Add a field value to the document. Options map directly to
+    # XML attributes in the Solr <field> node.
+    # See http://wiki.apache.org/solr/UpdateXmlMessages#head-8315b8028923d028950ff750a57ee22cbf7977c6
+    #
+    # === Example:
+    #
+    #   document.add_field('title', 'A Title', :boost => 2.0)
+    #
+    def add_field(name, values, options = {})
+      wrap(values).each do |v|
+        next if v.nil?
+
+        field_attrs = { name: name }
+        field_attrs[:type] = DocumentField if name.to_s == CHILD_DOCUMENT_KEY
+
+        @fields << RSolr::Field.instance(options.merge(field_attrs), v)
+      end
+    end
+
+    def as_json
+      @fields.group_by(&:name).each_with_object({}) do |(field, values), result|
+        v = values.map(&:as_json)
+        v = v.first if v.length == 1
+        result[field] = v
+      end
+    end
+
+    private
+
+    def wrap(object)
+      if object.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
+
+  class Field
+
+    def self.instance(attrs, value)
+      attrs = attrs.dup
+      field_type = attrs.delete(:type) {  value.class.name }
+
+      klass = if field_type.is_a? String
+                class_for_field(field_type)
+              elsif field_type.is_a? Class
+                field_type
+              else
+                self
+              end
+
+      klass.new(attrs, value)
+    end
+
+    def self.class_for_field(field_type)
+      potential_class_name = field_type + 'Field'.freeze
+      search_scope = Module.nesting[1]
+      search_scope.const_defined?(potential_class_name, false) ? search_scope.const_get(potential_class_name) : self
+    end
+    private_class_method :class_for_field
+
+    # "attrs" is a hash for setting the "doc" xml attributes
+    # "value" is the text value for the node
+    attr_accessor :attrs, :source_value
+
+    # "attrs" must be a hash
+    # "value" should be something that responds to #_to_s
+    def initialize(attrs, source_value)
+      @attrs = attrs
+      @source_value = source_value
+    end
+
+    # the value of the "name" attribute
+    def name
+      attrs[:name]
+    end
+
+    def value
+      source_value
+    end
+
+    def as_json
+      if attrs[:update]
+        { attrs[:update] => value }
+      elsif attrs.any? { |k, _| k != :name }
+        hash = attrs.dup
+        hash.delete(:name)
+        hash.merge(value: value)
+      else
+        value
+      end
+    end
+  end
+
+  class DateField < Field
+    def value
+      Time.utc(source_value.year, source_value.mon, source_value.mday).iso8601
+    end
+  end
+
+  class TimeField < Field
+    def value
+      source_value.getutc.strftime('%FT%TZ')
+    end
+  end
+
+  class DateTimeField < Field
+    def value
+      source_value.to_time.getutc.iso8601
+    end
+  end
+
+  class DocumentField < Field
+    def value
+      return RSolr::Document.new(source_value) if source_value.respond_to? :each_pair
+
+      super
+    end
+
+    def as_json
+      value.as_json
+    end
+  end
+end

data/lib/rsolr/json.rb

@@ -0,0 +1,52 @@
+module RSolr::JSON
+  class Generator
+    def add data, add_attrs = {}
+      add_attrs ||= {}
+      data = [data] unless data.is_a?(Array)
+
+      if add_attrs.empty? && data.none? { |doc| doc.is_a?(RSolr::Document) && !doc.attrs.empty? }
+        data.map do |doc|
+          doc = RSolr::Document.new(doc) if doc.respond_to?(:each_pair)
+          yield doc if block_given?
+          doc.as_json
+        end.to_json
+      else
+        i = 0
+        data.each_with_object({}) do |doc, hash|
+          doc = RSolr::Document.new(doc) if doc.respond_to?(:each_pair)
+          yield doc if block_given?
+          hash["add__UNIQUE_RSOLR_SUFFIX_#{i += 1}"] = add_attrs.merge(doc.attrs).merge(doc: doc.as_json)
+        end.to_json.gsub(/__UNIQUE_RSOLR_SUFFIX_\d+/, '')
+      end
+    end
+
+    # generates a commit message
+    def commit(opts = {})
+      opts ||= {}
+      { commit: opts }.to_json
+    end
+
+    # generates a optimize message
+    def optimize(opts = {})
+      opts ||= {}
+      { optimize: opts }.to_json
+    end
+
+    # generates a rollback message
+    def rollback
+      { rollback: {} }.to_json
+    end
+
+    # generates a delete message
+    # "ids" can be a single value or array of values
+    def delete_by_id(ids)
+      { delete: ids }.to_json
+    end
+
+    # generates a delete message
+    # "queries" can be a single value or an array of values
+    def delete_by_query(queries)
+      { delete: { query: queries } }.to_json
+    end
+  end
+end

data/lib/rsolr/uri.rb

@@ -1,11 +1,6 @@
 require 'uri'
 
 module RSolr::Uri
-  
-  def create url
-    ::URI.parse (url[-1] == '/' || URI.parse(url).query) ? url : "#{url}/"
-  end
-  
   # Creates a Solr based query string.
   # Keys that have arrays values are set multiple times:
   #   params_to_solr(:q => 'query', :fq => ['a', 'b'])
@@ -13,7 +8,7 @@ module RSolr::Uri
   #   ?q=query&fq=a&fq=b
   # @param [boolean] escape false if no URI escaping is to be performed.  Default true.
   # @return [String] Solr query params as a String, suitable for use in a url
-  def params_to_solr(params, escape = true)
+  def self.params_to_solr(params, escape = true)
     return URI.encode_www_form(params.reject{|k,v| k.to_s.empty? || v.to_s.empty?}) if escape
 
     # escape = false if we are here
@@ -27,49 +22,4 @@ module RSolr::Uri
     end
     mapped.compact.join("&")
   end
-  
-  # Returns a query string param pair as a string.
-  # Both key and value are URI escaped, unless third param is false
-  # @param [boolean] escape false if no URI escaping is to be performed.  Default true.
-  # @deprecated - used to be called from params_to_solr before 2015-02-25
-  def build_param(k, v, escape = true)
-    warn "[DEPRECATION] `RSolr::Uri.build_param` is deprecated.  Use `URI.encode_www_form_component` or k=v instead."
-    escape ? 
-      "#{URI.encode_www_form_component(k)}=#{URI.encode_www_form_component(v)}" :
-      "#{k}=#{v}"
-  end
-
-  # 2015-02  Deprecated: use URI.encode_www_form_component(s)
-  #
-  # Performs URI escaping so that you can construct proper
-  # query strings faster.  Use this rather than the cgi.rb
-  # version since it's faster.
-  # (Stolen from Rack).
-  #  http://www.rubydoc.info/github/rack/rack/URI.encode_www_form_component
-  # @deprecated
-  def escape_query_value(s)
-    warn "[DEPRECATION] `RSolr::Uri.escape_query_value` is deprecated.  Use `URI.encode_www_form_component` instead."
-    URI.encode_www_form_component(s)
-#    s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/u) {
-#      '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
-#    }.tr(' ', '+')
-  end
-
-  # Return the bytesize of String; uses String#size under Ruby 1.8 and
-  # String#bytesize under 1.9.
-  # @deprecated  as bytesize was only used by escape_query_value which is itself deprecated
-  if ''.respond_to?(:bytesize)
-    def bytesize(string)
-      warn "[DEPRECATION] `RSolr::Uri.bytesize` is deprecated.  Use String.bytesize"
-      string.bytesize
-    end
-  else
-    def bytesize(string)
-      warn "[DEPRECATION] `RSolr::Uri.bytesize` is deprecated.  Use String.size"
-      string.size
-    end
-  end
-
-  extend self
-  
 end

data/lib/rsolr/version.rb

@@ -1,5 +1,5 @@
 module RSolr
-  VERSION = "1.1.2"
+  VERSION = "2.0.0.pre1"
 
   def self.version
     VERSION