rsolr 1.1.1.pre1 → 1.1.1.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93c229e0cee96690d0cf15464b218bab708d4140
-  data.tar.gz: c910de4e9d7c29222713d671f37997eadbf51e4a
+  metadata.gz: bb1fa153ec3008beae75f53b9bb5e278bd68e2c3
+  data.tar.gz: ba02544b8e06337e000b58c659d0d253b7c1315d
 SHA512:
-  metadata.gz: 4f97b243fd8ce50b4b9ddcb401f511c3a7a10a59691774c39be08bdca527eab75741378b01410001bf403a6007030deb07161bfaa41f709c52d3d39dc422caf9
-  data.tar.gz: ecd3144115f9f3e2891d7a1c7e7b0c96cd789950d6e13cc3fa99e7d9cf15e464ffacc8abd0b1e7ce122779bc2e5667f2b9655b8817cb9ed6c472c9ab7916a9ec
+  metadata.gz: 3c4d111f9477a3f7d3e4b47295e33153e3c1579cc3814fc4d85245ee862f255c3b69e1e350d2d1464c0411d8d8a8aee0a3c0c307f0d47981c67cf239b3df8bd6
+  data.tar.gz: be60888b05bd5184e61c090e80d82a3b7389abb06af77eea06d75c1ea45c50eda1d2672cadcd2432f8e02d6a33f12895e9dbd55981857f7106c593499f35b3fb

data/lib/rsolr/client.rb

@@ -14,9 +14,9 @@ class RSolr::Client
       @default_wt = value
     end
   end
-  
+
   attr_reader :connection, :uri, :proxy, :options, :update_path
-  
+
   def initialize connection, options = {}
     @proxy = @uri = nil
     @connection = connection
@@ -28,23 +28,24 @@ class RSolr::Client
         proxy_url = options[:proxy].dup
         proxy_url << "/" unless proxy_url.nil? or proxy_url[-1] == ?/
         @proxy = RSolr::Uri.create proxy_url if proxy_url
+      elsif options[:proxy] == false
+        @proxy = false  # used to avoid setting the proxy from the environment.
       end
     end
     @update_path = options.fetch(:update_path, 'update')
     @options = options
   end
-  
+
   # returns the request uri object.
   def base_request_uri
     base_uri.request_uri if base_uri
   end
-  
-  # returns the uri proxy if present,
-  # otherwise just the uri object.
+
+  # returns the RSolr::URI uri object.
   def base_uri
-    @proxy ? @proxy : @uri
+    @uri
   end
-  
+
   # Create the get, post, and head methods
   %W(get post head).each do |meth|
     class_eval <<-RUBY
@@ -53,7 +54,7 @@ class RSolr::Client
     end
     RUBY
   end
-  
+
   # A paginated request method.
   # Converts the page and per_page
   # arguments into "rows" and "start".
@@ -63,9 +64,9 @@ class RSolr::Client
     raise "'rows' or 'start' params should not be set when using +paginate+" if ["start", "rows"].include?(opts[:params].keys)
     execute build_paginated_request(page, per_page, path, opts)
   end
-  
+
   # POST XML messages to /update with optional params.
-  # 
+  #
   # http://wiki.apache.org/solr/UpdateXmlMessages#add.2BAC8-update
   #
   # If not set, opts[:headers] will be set to a hash with the key
@@ -82,22 +83,22 @@ class RSolr::Client
     opts[:headers]['Content-Type'] ||= 'text/xml'
     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
-  # 
+  #
   # single record:
-  # solr.update(:id=>1, :name=>'one')
+  # solr.add(:id=>1, :name=>'one')
+  #
+  # add using an array
   #
-  # update using an array
-  # 
-  # solr.update(
+  # solr.add(
   #   [{:id=>1, :name=>'one'}, {:id=>2, :name=>'two'}],
   #   :add_attributes => {:boost=>5.0, :commitWithin=>10}
   # )
-  # 
+  #
   def add doc, opts = {}
     add_attributes = opts.delete :add_attributes
     update opts.merge(:data => xml.add(doc, add_attributes))
@@ -120,16 +121,16 @@ class RSolr::Client
     optimize_attributes = opts.delete :optimize_attributes
     update opts.merge(:data => xml.optimize(optimize_attributes))
   end
-  
+
   # send </rollback>
-  # 
+  #
   # http://wiki.apache.org/solr/UpdateXmlMessages#A.22rollback.22
-  # 
+  #
   # NOTE: solr 1.4 only
   def rollback opts = {}
     update opts.merge(:data => xml.rollback)
   end
-  
+
   # Delete one or many documents by id
   #   solr.delete_by_id 10
   #   solr.delete_by_id([12, 41, 199])
@@ -138,22 +139,22 @@ class RSolr::Client
   end
 
   # delete one or many documents by query.
-  # 
+  #
   # http://wiki.apache.org/solr/UpdateXmlMessages#A.22delete.22_by_ID_and_by_Query
-  # 
+  #
   #   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))
   end
-  
+
   # shortcut to RSolr::Xml::Generator
   def xml
     @xml ||= RSolr::Xml::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
   # "opts" : A hash, which can contain the following keys:
   #   :method : required - the http method (:get, :post or :head)
@@ -161,7 +162,7 @@ class RSolr::Client
   #   :data : optional - post data -- if a hash is given, it's sent as "application/x-www-form-urlencoded; charset=UTF-8"
   #   :headers : optional - hash of request headers
   # All other options are passed right along to the connection's +send_and_receive+ method (:get, :post, or :head)
-  # 
+  #
   # +send_and_receive+ returns either a string or hash on a successful ruby request.
   # When the :params[:wt] => :ruby, the response will be a hash, else a string.
   #
@@ -171,13 +172,10 @@ class RSolr::Client
   # then passes the request/response into +adapt_response+.
   def send_and_receive path, opts
     request_context = build_request path, opts
-    [:open_timeout, :read_timeout, :retry_503, :retry_after_limit].each do |k|
-      request_context[k] = @options[k]
-    end
     execute request_context
   end
-  
-  # 
+
+  #
   def execute request_context
 
     raw_response = connection.execute self, request_context
@@ -214,13 +212,13 @@ class RSolr::Client
         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 => e
+      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.
@@ -251,6 +249,11 @@ class RSolr::Client
     end
     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
 
@@ -307,7 +310,7 @@ class RSolr::Client
       send_and_receive name, *args
     end
   end
-  
+
   # evaluates the response[:body],
   # attempts to bring the ruby string to life.
   # If a SyntaxError is raised, then

data/lib/rsolr/connection.rb

@@ -15,7 +15,7 @@ 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 => e
+    rescue Errno::ECONNREFUSED
       raise RSolr::Error::ConnectionRefused, request_context.inspect
     # catch the undefined closed? exception -- this is a confirmed ruby bug
     rescue NoMethodError => e
@@ -29,22 +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
-      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
-    )
+    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
 
   #

data/lib/rsolr/version.rb

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

data/lib/rsolr/xml.rb

@@ -51,10 +51,13 @@ module RSolr::Xml
     private
 
     def format_value(v)
-      if v.is_a?(Date) && !v.is_a?(DateTime)
-        Time.utc(v.year, v.mon, v.mday).iso8601
-      elsif v.respond_to?(:to_time) && v.to_time
+      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

data/spec/api/client_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 describe "RSolr::Client" do
-  
+
   module ClientHelper
     def client
       @client ||= (
@@ -8,30 +8,52 @@ describe "RSolr::Client" do
         RSolr::Client.new connection, :url => "http://localhost:9999/solr", :read_timeout => 42, :open_timeout=>43
       )
     end
+
+    def client_with_proxy
+      @client_with_proxy ||= (
+        connection = RSolr::Connection.new
+        RSolr::Client.new connection, :url => "http://localhost:9999/solr", :proxy => 'http://localhost:8080', :read_timeout => 42, :open_timeout=>43
+      )
+    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)
     end
-    
+
     it "should use :update_path from options" do
       client = RSolr::Client.new(:whatevs, { update_path: 'update_test' })
       expect(client.update_path).to eql('update_test')
     end
-    
+
     it "should use 'update' for update_path by default" do
       client = RSolr::Client.new(:whatevs)
       expect(client.update_path).to eql('update')
     end
+
+    it "should use :proxy from options" do
+      client = RSolr::Client.new(:whatevs, { proxy: 'http://my.proxy/' })
+      expect(client.proxy.to_s).to eql('http://my.proxy/')
+    end
+
+    it "should use 'nil' for proxy by default" do
+      client = RSolr::Client.new(:whatevs)
+      expect(client.proxy).to be_nil
+    end
+
+    it "should use 'false' for proxy if passed 'false'" do
+      client = RSolr::Client.new(:whatevs, { proxy: false })
+      expect(client.proxy).to eq(false)
+    end
   end
-  
+
   context "send_and_receive" do
     include ClientHelper
     it "should forward these method calls the #connection object" do
       [:get, :post, :head].each do |meth|
         expect(client.connection).to receive(:execute).
-            and_return({:status => 200, :body => "{}", :headers => {}})
+          and_return({:status => 200, :body => "{}", :headers => {}})
         client.send_and_receive '', :method => meth, :params => {}, :data => nil, :headers => {}
       end
     end
@@ -87,17 +109,17 @@ describe "RSolr::Client" do
           :status => 200,
           :headers => {"Content-Type"=>"text/plain"}
         )
-      client.post "update", request_opts
+        client.post "update", request_opts
     end
   end
-  
+
   context "xml" do
     include ClientHelper
     it "should return an instance of RSolr::Xml::Generator" do
       expect(client.xml).to be_a RSolr::Xml::Generator
     end
   end
-  
+
   context "add" do
     include ClientHelper
     it "should send xml to the connection's #post method" do
@@ -109,19 +131,19 @@ describe "RSolr::Client" do
             :method => :post,
             :data => "<xml/>"
           })
-        ).
-          and_return(
-            :body => "",
-            :status => 200,
-            :headers => {"Content-Type"=>"text/xml"}
-          )
+      ).
+      and_return(
+        :body => "",
+        :status => 200,
+        :headers => {"Content-Type"=>"text/xml"}
+      )
       expect(client.xml).to receive(:add).
         with({:id=>1}, {:commitWith=>10}).
-          and_return("<xml/>")
+        and_return("<xml/>")
       client.add({:id=>1}, :add_attributes => {:commitWith=>10})
     end
   end
-  
+
   context "update" do
     include ClientHelper
     it "should send data to the connection's #post method" do
@@ -133,12 +155,12 @@ describe "RSolr::Client" do
             :method => :post,
             :data => "<optimize/>"
           })
-        ).
-          and_return(
-            :body => "",
-            :status => 200,
-            :headers => {"Content-Type"=>"text/xml"}
-          )
+      ).
+      and_return(
+        :body => "",
+        :status => 200,
+        :headers => {"Content-Type"=>"text/xml"}
+      )
       client.update(:data => "<optimize/>")
     end
 
@@ -147,14 +169,14 @@ describe "RSolr::Client" do
       expect(client).to receive(:update_path).and_return('update_test')
       client.update({})
     end
-    
+
     it "should use path from opts" do
       expect(client).to receive(:post).with('update_opts', any_args)
       allow(client).to receive(:update_path).and_return('update_test')
       client.update({path: 'update_opts'})
     end
   end
-  
+
   context "post based helper methods:" do
     include ClientHelper
     [:commit, :optimize, :rollback].each do |meth|
@@ -167,17 +189,17 @@ describe "RSolr::Client" do
               :method => :post,
               :data => "<?xml version=\"1.0\" encoding=\"UTF-8\"?><#{meth}/>"
             })
-          ).
-            and_return(
-              :body => "",
-              :status => 200,
-              :headers => {"Content-Type"=>"text/xml"}
-            )
+        ).
+        and_return(
+          :body => "",
+          :status => 200,
+          :headers => {"Content-Type"=>"text/xml"}
+        )
         client.send meth
       end
     end
   end
-  
+
   context "delete_by_id" do
     include ClientHelper
     it "should send data to the connection's #post method" do
@@ -189,16 +211,16 @@ describe "RSolr::Client" do
             :method => :post,
             :data => "<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><id>1</id></delete>"
           })
-        ).
-          and_return(
-            :body => "",
-            :status => 200,
-            :headers => {"Content-Type"=>"text/xml"}
-          )
+      ).
+      and_return(
+        :body => "",
+        :status => 200,
+        :headers => {"Content-Type"=>"text/xml"}
+      )
       client.delete_by_id 1
     end
   end
-  
+
   context "delete_by_query" do
     include ClientHelper
     it "should send data to the connection's #post method" do
@@ -210,16 +232,16 @@ describe "RSolr::Client" do
             :method => :post,
             :data => "<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><query fq=\"category:&quot;trash&quot;\"/></delete>"
           })
-        ).
-          and_return(
-            :body => "",
-            :status => 200,
-            :headers => {"Content-Type"=>"text/xml"}
-          )
+      ).
+      and_return(
+        :body => "",
+        :status => 200,
+        :headers => {"Content-Type"=>"text/xml"}
+      )
       client.delete_by_query :fq => "category:\"trash\""
     end
   end
-  
+
   context "adapt_response" do
     include ClientHelper
     it 'should not try to evaluate ruby when the :qt is not :ruby' do
@@ -227,13 +249,13 @@ describe "RSolr::Client" do
       result = client.adapt_response({:params=>{}}, {:status => 200, :body => body, :headers => {}})
       expect(result).to eq(body)
     end
-    
+
     it 'should evaluate ruby responses when the :wt is :ruby' do
       body = '{"time"=>"NOW"}'
       result = client.adapt_response({:params=>{:wt=>:ruby}}, {:status => 200, :body => body, :headers => {}})
       expect(result).to eq({"time"=>"NOW"})
     end
-    
+
     it 'should evaluate json responses when the :wt is :json' do
       body = '{"time": "NOW"}'
       result = client.adapt_response({:params=>{:wt=>:json}}, {:status => 200, :body => body, :headers => {}})
@@ -255,9 +277,9 @@ describe "RSolr::Client" do
         client.adapt_response({:params=>{:wt => :ruby}}, {:status => 200, :body => "<woops/>", :headers => {}})
       }.to raise_error RSolr::Error::InvalidRubyResponse
     end
-  
+
   end
-  
+
   context "indifferent access" do
     include ClientHelper
     it "should raise a RuntimeError if the #with_indifferent_access extension isn't loaded" do
@@ -322,5 +344,14 @@ describe "RSolr::Client" do
         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,
+        :data => {:q=>'test', :fq=>[0,1]},
+        :headers => {}
+      )
+      result[:uri].to_s.should match /^http:\/\/localhost:9999\/solr\//
+    end 
   end
 end

data/spec/api/connection_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'base64'
 
 describe "RSolr::Connection" do
-  
+
   context "setup_raw_request" do
     it "should set the correct request parameters" do
       c = RSolr::Connection.new
@@ -35,7 +35,7 @@ describe "RSolr::Connection" do
 
     let(:http) { double(Net::HTTP).as_null_object }
 
-    subject { RSolr::Connection.new } 
+    subject { RSolr::Connection.new }
 
     before do
       allow(Net::HTTP).to receive(:new) { http }
@@ -57,7 +57,7 @@ describe "RSolr::Connection" do
 
     let(:http) { double(Net::HTTP).as_null_object }
 
-    subject { RSolr::Connection.new } 
+    subject { RSolr::Connection.new }
 
     before do
       allow(Net::HTTP).to receive(:new) { http }
@@ -74,6 +74,32 @@ describe "RSolr::Connection" do
     end
   end
 
+  context "proxy configuration" do
+    let(:client) { double.as_null_object }
+
+    let(:http) { double(Net::HTTP).as_null_object }
+
+    let(:uri) { URI.parse("http://localhost/some_url") }
+    let(:proxy) { URI.parse("http://my.proxy/") }
+
+    subject { RSolr::Connection.new }
+
+    it "should use the default if no proxy is provided" do
+      expect(Net::HTTP).to receive(:new).with(uri.host, uri.port) { http }
+      subject.execute client, { :uri => uri, :method => :get }
+    end
+
+    it "should use the proxy if one is provided" do
+      expect(Net::HTTP).to receive(:Proxy).with(proxy.host, proxy.port, nil, nil) { http }
+      subject.execute client, { :uri => uri, :proxy => proxy, :method => :get }
+    end
+
+    it "should not use a proxy if proxy setting is false" do
+      expect(Net::HTTP).to receive(:new).with(uri.host, uri.port, nil) { http }
+      subject.execute client, { :uri => uri, :proxy => false, :method => :get }
+    end
+  end
+
   context "connection refused" do
     let(:client) { double.as_null_object }
 
@@ -81,7 +107,7 @@ describe "RSolr::Connection" do
     let(:request_context) {
       {:uri => URI.parse("http://localhost/some_uri"), :method => :get, :open_timeout => 42}
     }
-    subject { RSolr::Connection.new } 
+    subject { RSolr::Connection.new }
 
     before do
       allow(Net::HTTP).to receive(:new) { http }
@@ -95,14 +121,14 @@ describe "RSolr::Connection" do
       }.to raise_error(Errno::ECONNREFUSED, /#{request_context}/)
     end
   end
-  
+
   describe "basic auth support" do
     let(:http) { double(Net::HTTP).as_null_object }
-    
+
     before do
       allow(Net::HTTP).to receive(:new) { http }
     end
-    
+
     it "sets the authorization header" do
       expect(http).to receive(:request) do |request|
         expect(request.fetch('authorization')).to eq("Basic #{Base64.encode64("joe:pass")}".strip)

data/spec/api/pagination_spec.rb

@@ -11,6 +11,13 @@ describe "RSolr::Pagination" do
       expect(r[:uri].query).to match(/rows=25/)
       expect(r[:uri].query).to match(/start=50/)
     end
+
+    it 'passes through client options' do
+      c = RSolr::Client.new(nil, open_timeout: 5, read_timeout: 7)
+      r = c.build_paginated_request 3, 25, "select", {:params => {:q => "test"}}
+      expect(r[:open_timeout]).to eq(5)
+      expect(r[:read_timeout]).to eq(7)
+    end
   end
   context "paginate" do
     it "should build a paginated request context and call execute" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rsolr
 version: !ruby/object:Gem::Version
-  version: 1.1.1.pre1
+  version: 1.1.1.pre2
 platform: ruby
 authors:
 - Antoine Latter
@@ -29,7 +29,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-11 00:00:00.000000000 Z
+date: 2016-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder