rsolr 1.0.8 → 1.1.2

data/lib/rsolr/connection.rb

@@ -15,11 +15,13 @@ class RSolr::Connection
       response = h.request request
       charset = response.type_params["charset"]
       {:status => response.code.to_i, :headers => response.to_hash, :body => force_charset(response.body, charset)}
+    rescue Errno::ECONNREFUSED
+      raise RSolr::Error::ConnectionRefused, request_context.inspect
     # catch the undefined closed? exception -- this is a confirmed ruby bug
-    rescue NoMethodError
-      $!.message == "undefined method `closed?' for nil:NilClass" ?
-        raise(Errno::ECONNREFUSED.new) :
-        raise($!)
+    rescue NoMethodError => e
+      e.message == "undefined method `closed?' for nil:NilClass" ?
+        raise(RSolr::Error::ConnectionRefused, request_context.inspect) :
+        raise(e)
     end
   end
 
@@ -27,18 +29,20 @@ class RSolr::Connection
 
   # This returns a singleton of a Net::HTTP or Net::HTTP.Proxy request object.
   def http uri, proxy = nil, read_timeout = nil, open_timeout = nil
-    @http ||= (
-      http = if proxy
-        proxy_user, proxy_pass = proxy.userinfo.split(/:/) if proxy.userinfo
-        Net::HTTP.Proxy(proxy.host, proxy.port, proxy_user, proxy_pass).new uri.host, uri.port
-      else
-        Net::HTTP.new uri.host, uri.port
-      end
-      http.use_ssl = uri.port == 443 || uri.instance_of?(URI::HTTPS)
-      http.read_timeout = read_timeout if read_timeout
-      http.open_timeout = open_timeout if open_timeout
-      http
-    )
+    http = if proxy
+      proxy_user, proxy_pass = proxy.userinfo.split(/:/) if proxy.userinfo
+      Net::HTTP.Proxy(proxy.host, proxy.port, proxy_user, proxy_pass).new uri.host, uri.port
+    elsif proxy == false
+      # If explicitly passing in false, make sure we set proxy_addr to nil
+      # to tell Net::HTTP to *not* use the environment proxy variables.
+      Net::HTTP.new uri.host, uri.port, nil
+    else
+      Net::HTTP.new uri.host, uri.port
+    end
+    http.use_ssl = uri.port == 443 || uri.instance_of?(URI::HTTPS)
+    http.read_timeout = read_timeout if read_timeout
+    http.open_timeout = open_timeout if open_timeout
+    http
   end
 
   #
@@ -67,4 +71,4 @@ class RSolr::Connection
     body.force_encoding(charset)
   end
 
-end
+end

data/lib/rsolr/error.rb

@@ -1,9 +1,9 @@
 module RSolr::Error
-  
+
   module SolrContext
-    
+
     attr_accessor :request, :response
-    
+
     def to_s
       m = "#{super.to_s}"
       if response
@@ -12,22 +12,25 @@ module RSolr::Error
         m << "\nError: #{details}\n" if details
       end
       p = "\nURI: #{request[:uri].to_s}"
-      p = "\nRequest Headers: #{request[:headers].inspect}" if request[:headers]
-      p = "\nRequest Data: #{request[:data].inspect}" if request[:data]
+      p << "\nRequest Headers: #{request[:headers].inspect}" if request[:headers]
+      p << "\nRequest Data: #{request[:data].inspect}" if request[:data]
       p << "\n"
       p << "\nBacktrace: " + self.backtrace[0..10].join("\n")
       m << p
       m
     end
-    
+
     protected
-    
+
     def parse_solr_error_response body
       begin
-        info = body.scan(/<pre>(.*)<\/pre>/mi)[0]
+        if body =~ /<pre>/
+          info = body.scan(/<pre>(.*)<\/pre>/mi)[0]
+        elsif body =~ /'msg'=>/
+          info = body.scan(/'msg'=>(.*)/)[0]
+        end
         info = info.join if info.respond_to? :join
-
-        info ||= body  # body may not contain <pre> elements
+        info ||= body  # body might not contain <pre> or msg elements
 
         partial = info.to_s.split("\n")[0..10]
         partial.join("\n").gsub("&gt;", ">").gsub("&lt;", "<")
@@ -35,13 +38,17 @@ module RSolr::Error
         nil
       end
     end
-    
+
+
+  end
+
+  class ConnectionRefused < ::Errno::ECONNREFUSED
   end
-  
+
   class Http < RuntimeError
-    
+
     include SolrContext
-    
+
     # ripped right from ActionPack
     # Defines the standard HTTP status codes, by integer, with their
     # corresponding default message texts.
@@ -101,17 +108,29 @@ module RSolr::Error
       507 => "Insufficient Storage",
       510 => "Not Extended"
     }
-    
+
     def initialize request, response
       @request, @response = request, response
     end
-    
+
+  end
+
+  # Thrown if the :wt is :ruby
+  # but the body wasn't succesfully parsed/evaluated
+  class InvalidResponse < Http
+
+  end
+
+  # Thrown if the :wt is :ruby
+  # but the body wasn't succesfully parsed/evaluated
+  class InvalidJsonResponse < InvalidResponse
+
   end
-  
+
   # Thrown if the :wt is :ruby
   # but the body wasn't succesfully parsed/evaluated
-  class InvalidRubyResponse < Http
-    
+  class InvalidRubyResponse < InvalidResponse
+
   end
-  
+
 end

data/lib/rsolr/response.rb

@@ -1,20 +1,55 @@
 module RSolr::Response
-  
-  def self.extended base
-    if base["response"] && base["response"]["docs"]
-      base["response"]["docs"].tap do |d|
-        d.extend PaginatedDocSet
-        d.per_page = base.request[:params]["rows"]
-        d.start = base.request[:params]["start"]
-        d.total = base["response"]["numFound"].to_s.to_i
+
+  def self.included(base)
+    unless base < Hash
+      raise ArgumentError, "RSolr::Response expects to included only in (sub)classes of Hash; got included in '#{base}' instead."
+    end
+    base.send(:attr_reader, :request, :response)
+  end
+
+  def initialize_rsolr_response(request, response, result)
+    @request = request
+    @response = response
+    self.merge!(result)
+    if self["response"] && self["response"]["docs"].is_a?(Array)
+      docs = PaginatedDocSet.new(self["response"]["docs"])
+      docs.per_page = request[:params]["rows"]
+      docs.page_start = request[:params]["start"]
+      docs.page_total = self["response"]["numFound"].to_s.to_i
+      self["response"]["docs"] = docs
+    end
+  end
+
+  def with_indifferent_access
+    if defined?(::RSolr::HashWithIndifferentAccessWithResponse)
+      ::RSolr::HashWithIndifferentAccessWithResponse.new(request, response, self)
+    else
+      if defined?(ActiveSupport::HashWithIndifferentAccess)
+        RSolr.const_set("HashWithIndifferentAccessWithResponse", Class.new(ActiveSupport::HashWithIndifferentAccess))
+        RSolr::HashWithIndifferentAccessWithResponse.class_eval <<-eos
+          include RSolr::Response
+          def initialize(request, response, result)
+            super()
+            initialize_rsolr_response(request, response, result)
+          end
+        eos
+        ::RSolr::HashWithIndifferentAccessWithResponse.new(request, response, self)
+      else
+        raise RuntimeError, "HashWithIndifferentAccess is not currently defined"
       end
     end
   end
-  
+
   # A response module which gets mixed into the solr ["response"]["docs"] array.
-  module PaginatedDocSet
+  class PaginatedDocSet < Array
 
-    attr_accessor :start, :per_page, :total
+    attr_accessor :page_start, :per_page, :page_total
+    if not (Object.const_defined?("RUBY_ENGINE") and Object::RUBY_ENGINE=='rbx')
+      alias_method(:start,:page_start)
+      alias_method(:start=,:page_start=)
+      alias_method(:total,:page_total)
+      alias_method(:total=,:page_total=)
+    end
 
     # Returns the current page calculated from 'rows' and 'start'
     def current_page
@@ -47,5 +82,14 @@ module RSolr::Response
     end
 
   end
-  
-end
+
+end
+
+class RSolr::HashWithResponse < Hash
+  include RSolr::Response
+
+  def initialize(request, response, result)
+    super()
+    initialize_rsolr_response(request, response, result || {})
+  end
+end

data/lib/rsolr/uri.rb

@@ -3,56 +3,73 @@ require 'uri'
 module RSolr::Uri
   
   def create url
-    ::URI.parse url[-1] == ?/ ? url : "#{url}/"
+    ::URI.parse (url[-1] == '/' || URI.parse(url).query) ? url : "#{url}/"
   end
   
-  # Returns a query string param pair as a string.
-  # Both key and value are escaped.
-  def build_param(k,v, escape = true)
-    escape ? 
-      "#{escape_query_value(k)}=#{escape_query_value(v)}" :
-      "#{k}=#{v}"
-  end
-
-  # Return the bytesize of String; uses String#size under Ruby 1.8 and
-  # String#bytesize under 1.9.
-  if ''.respond_to?(:bytesize)
-    def bytesize(string)
-      string.bytesize
-    end
-  else
-    def bytesize(string)
-      string.size
-    end
-  end
-
   # Creates a Solr based query string.
   # Keys that have arrays values are set multiple times:
   #   params_to_solr(:q => 'query', :fq => ['a', 'b'])
   # is converted to:
   #   ?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)
+    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
     mapped = params.map do |k, v|
       next if v.to_s.empty?
       if v.class == Array
-        params_to_solr(v.map { |x| [k, x] }, escape)
+        params_to_solr(v.map { |x| [k, x] }, false)
       else
-        build_param k, v, escape
+        "#{k}=#{v}"
       end
     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)
-    s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/u) {
-      '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
-    }.tr(' ', '+')
+    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

@@ -0,0 +1,7 @@
+module RSolr
+  VERSION = "1.1.2"
+
+  def self.version
+    VERSION
+  end
+end

data/lib/rsolr/xml.rb

@@ -1,4 +1,5 @@
-require 'builder'
+begin; require 'nokogiri'; rescue LoadError; end
+require 'time'
 
 module RSolr::Xml
   
@@ -15,11 +16,10 @@ module RSolr::Xml
       @fields = []
       doc_hash.each_pair do |field,values|
         # create a new field for each value (multi-valued)
-        # put non-array values into an array
-        values = [values] unless values.is_a?(Array)
-        values.each do |v|
-          next if v.to_s.empty?
-          @fields << RSolr::Xml::Field.new({:name=>field}, v.to_s)
+        wrap(values).each do |v|
+          v = format_value(v)
+          next if v.empty?
+          @fields << RSolr::Xml::Field.new({:name=>field}, v)
         end
       end
       @attrs={}
@@ -47,9 +47,35 @@ module RSolr::Xml
     def add_field(name, value, options = {})
       @fields << RSolr::Xml::Field.new(options.merge({:name=>name}), value)
     end
-    
+
+    private
+
+    def format_value(v)
+      case v
+      when Time
+        v.getutc.iso8601
+      when DateTime
+        v.to_time.getutc.iso8601
+      when Date
+        Time.utc(v.year, v.mon, v.mday).iso8601
+      else
+        v.to_s
+      end
+    end
+
+    def wrap(object)
+      if object.nil?
+        []
+      elsif object.respond_to?(:to_ary)
+        object.to_ary || [object]
+      elsif object.is_a? Enumerable
+        object
+      else
+        [object]
+      end
+    end
   end
-  
+
   class Field
     
     # "attrs" is a hash for setting the "doc" xml attributes
@@ -71,13 +97,40 @@ module RSolr::Xml
   end
   
   class Generator
+    class << self
+      attr_accessor :use_nokogiri
+
+      def builder_proc
+        if use_nokogiri 
+          require 'nokogiri' unless defined?(::Nokogiri::XML::Builder)
+          :nokogiri_build
+        else
+          require 'builder' unless defined?(::Builder::XmlMarkup)
+          :builder_build
+        end
+      end
+    end
+    self.use_nokogiri = (defined?(::Nokogiri::XML::Builder) and not defined?(JRuby)) ? true : false
+
+    def nokogiri_build &block
+      b = ::Nokogiri::XML::Builder.new do |xml|
+        block_given? ? yield(xml) : xml
+      end
+      '<?xml version="1.0" encoding="UTF-8"?>'+b.to_xml(:indent => 0, :encoding => 'UTF-8', :save_with => ::Nokogiri::XML::Node::SaveOptions::AS_XML | ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION).strip
+    end
+    protected :nokogiri_build
     
-    def build &block
+    def builder_build &block
       b = ::Builder::XmlMarkup.new(:indent => 0, :margin => 0, :encoding => 'UTF-8')
       b.instruct!
       block_given? ? yield(b) : b
     end
-
+    protected :builder_build
+    
+    def build &block
+      self.send(self.class.builder_proc,&block)
+    end
+    
     # generates "add" xml for updating solr
     # "data" can be a hash or an array of hashes.
     # - each hash should be a simple key=>value pair representing a solr doc.
@@ -111,11 +164,12 @@ module RSolr::Xml
           data.each do |doc|
             doc = RSolr::Xml::Document.new(doc) if doc.respond_to?(:each_pair)
             yield doc if block_given?
-            add_node.doc(doc.attrs) do |doc_node|
+            doc_node_builder = lambda do |doc_node|
               doc.fields.each do |field_obj|
                 doc_node.field field_obj.value, field_obj.attrs
               end
             end
+            self.class.use_nokogiri ? add_node.doc_(doc.attrs,&doc_node_builder) : add_node.doc(doc.attrs,&doc_node_builder)
           end
         end
       end
@@ -144,7 +198,9 @@ module RSolr::Xml
       ids = [ids] unless ids.is_a?(Array)
       build do |xml|
         xml.delete do |delete_node|
-          ids.each { |id| delete_node.id(id) }
+          ids.each do |id| 
+            self.class.use_nokogiri ? delete_node.id_(id) : delete_node.id(id)
+          end
         end
       end
     end
@@ -159,7 +215,5 @@ module RSolr::Xml
         end
       end
     end
-    
   end
-  
-end
+end