rsolr 1.0.0.beta → 1.0.0.beta2

data/lib/rsolr/http.rb

@@ -1,106 +1,99 @@
-module RSolr
-  
-  class Http
-    
-    attr_reader :uri, :proxy, :options
-    
-    def initialize base_url, options = {}
-      @options = options
-      @uri = base_url
-      @proxy = options[:proxy]
-    end
-    
-    def base_uri
-      @proxy ? @proxy.request_uri : @uri.request_uri
-    end
-    
-    def http
-      @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)
+require 'net/http'
+require 'net/https'
+
+class RSolr::Http
   
-        if options[:timeout] && options[:timeout].is_a?(Integer)
-          http.open_timeout = options[:timeout]
-          http.read_timeout = options[:timeout]
-        end
+  include RSolr::Connectable
   
-        if options[:pem] && http.use_ssl?
-          http.cert = OpenSSL::X509::Certificate.new(options[:pem])
-          http.key = OpenSSL::PKey::RSA.new(options[:pem])
-          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        else
-          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        end
-
-        if options[:debug_output]
-          http.set_debug_output(options[:debug_output])
-        end
-
-        http
-      )
-    end
+  def initialize *args, &block
+    # call the initialize method from RSolr::Connectable
+    super
+  end
   
-    # send in path w/query
-    def get request_uri, headers = {}
-      req = setup_raw_request Net::HTTP::Get, request_uri, headers
-      perform_request http, req
+  # using the request_context hash,
+  # issue a request,
+  # then return the standard rsolr response hash {:status, :body, :headers}
+  def execute request_context
+    request = setup_raw_request request_context
+    request.body = request_context[:data] if request_context[:method] == :post and request_context[:data]
+    begin
+      response = http.request request
+      {:status => response.code.to_i, :headers => response.to_hash, :body => response.body}
+    rescue NoMethodError
+      $!.message == "undefined method `closed?' for nil:NilClass" ?
+        raise(Errno::ECONNREFUSED.new) :
+        raise($!)
     end
+  end
   
-    # send in path w/query
-    def head request_uri, headers = {}
-      req = setup_raw_request Net::HTTP::Head, request_uri, headers
-      perform_request http, req
-    end
+  protected
   
-    # send in path w/query
-    def post request_uri, data, headers = {}
-      req = setup_raw_request Net::HTTP::Post, request_uri, headers
-      req.body = data if data
-      perform_request http, req
-    end
+  def http
+    @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
     
-    def perform_request http, request
-      begin
-        response = http.request request
-        {:status => response.code.to_i, :headers => response.to_hash, :body => response.body}
-      rescue NoMethodError
-        $!.message == "undefined method `closed?' for nil:NilClass" ?
-          raise(Errno::ECONNREFUSED.new) :
-          raise($!)
+      http.use_ssl = uri.port == 443 || uri.instance_of?(URI::HTTPS)
+
+      if options[:timeout] && options[:timeout].is_a?(Integer)
+        http.open_timeout = options[:timeout]
+        http.read_timeout = options[:timeout]
+      end
+
+      if options[:pem] && http.use_ssl?
+        http.cert = OpenSSL::X509::Certificate.new(options[:pem])
+        http.key = OpenSSL::PKey::RSA.new(options[:pem])
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      else
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      if options[:debug_output]
+        http.set_debug_output(options[:debug_output])
       end
+
+      http
+    )
+  end
+  
+  def setup_raw_request request_context
+    http_method = case request_context[:method]
+    when :get
+      Net::HTTP::Get
+    when :post
+      Net::HTTP::Post
+    when :head
+      Net::HTTP::Head
+    else
+      raise "Only :get, :post and :head http method types are allowed."
     end
-    
-    def setup_raw_request http_method, request_uri, headers = {}
-      raw_request = http_method.new "#{base_uri}#{request_uri}"
-      raw_request.initialize_http_header headers
-      raw_request.basic_auth username, password if options[:basic_auth]
-      if options[:digest_auth]
-        res = http.head(request_uri, headers)
-        if res['www-authenticate'] != nil && res['www-authenticate'].length > 0
-          raw_request.digest_auth username, password, res
-        end
+    headers = request_context[:headers] || {}
+    raw_request = http_method.new request_context[:uri].to_s
+    raw_request.initialize_http_header headers
+    raw_request.basic_auth username, password if options[:basic_auth]
+    if options[:digest_auth]
+      res = http.head(request_context[:uri].to_s, headers)
+      if res['www-authenticate'] != nil && res['www-authenticate'].length > 0
+        raw_request.digest_auth username, password, res
       end
-      raw_request
     end
+    raw_request
+  end
   
-    def credentials
-      options[:basic_auth] || options[:digest_auth]
-    end
+  def credentials
+    options[:basic_auth] || options[:digest_auth]
+  end
 
-    def username
-      credentials[:username]
-    end
+  def username
+    credentials[:username]
+  end
 
-    def password
-      credentials[:password]
-    end
-  
+  def password
+    credentials[:password]
   end
   
 end

data/lib/rsolr/uri.rb

@@ -1,3 +1,5 @@
+require 'uri'
+
 module RSolr::Uri
   
   def self.create url

data/lib/rsolr/xml.rb

@@ -1,3 +1,5 @@
+require 'builder'
+
 module RSolr::Xml
   
   class Document
@@ -102,7 +104,8 @@ module RSolr::Xml
     # The "nickname" field would have a boost="20.0"
     # if the doc had a "nickname" field with the value of "Tim".
     #
-    def add data, add_attrs={}, &block
+    def add data, add_attrs = nil, &block
+      add_attrs ||= {}
       data = [data] unless data.is_a?(Array)
       build do |xml|
         xml.add(add_attrs) do |add_node|
@@ -118,25 +121,27 @@ module RSolr::Xml
         end
       end
     end
-
+    
     # generates a <commit/> message
-    def commit(opts={})
-      build {|xml| xml.commit opts}
+    def commit opts = nil
+      opts ||= {}
+      build {|xml| xml.commit(opts) }
     end
-
+    
     # generates a <optimize/> message
-    def optimize(opts={})
-      build {|xml| xml.optimize opts}
+    def optimize opts = nil
+      opts ||= {}
+      build {|xml| xml.optimize(opts) }
     end
-
+    
     # generates a <rollback/> message
-    def rollback opts={}
-      build {|xml| xml.rollback opts}
+    def rollback
+      build {|xml| xml.rollback({}) }
     end
 
     # generates a <delete><id>ID</id></delete> message
     # "ids" can be a single value or array of values
-    def delete_by_id(ids)
+    def delete_by_id ids
       ids = [ids] unless ids.is_a?(Array)
       build do |xml|
         xml.delete do |delete_node|
@@ -151,7 +156,7 @@ module RSolr::Xml
       queries = [queries] unless queries.is_a?(Array)
       build do |xml|
         xml.delete do |delete_node|
-          queries.each { |query| delete_node.query query }
+          queries.each { |query| delete_node.query(query) }
         end
       end
     end

data/lib/rsolr.rb

@@ -1,14 +1,10 @@
-require 'uri'
-require 'net/http'
-require 'net/https'
-require 'rubygems'
-require 'builder'
+$: << "#{File.dirname(__FILE__)}" unless $:.include? File.dirname(__FILE__)
 
-$: << "#{File.dirname(__FILE__)}"
+require 'rubygems'
 
 module RSolr
   
-  %W(Char Client Error Http Uri Xml).each{|n|autoload n.to_sym, "rsolr/#{n.downcase}"}
+  %W(Char Client Connectable Error Http Uri Xml).each{|n|autoload n.to_sym, "rsolr/#{n.downcase}"}
   
   def self.version
     @version ||= File.read(File.join(File.dirname(__FILE__), '..', 'VERSION')).chomp
@@ -17,16 +13,10 @@ module RSolr
   VERSION = self.version
   
   def self.connect *args
-    opts = parse_options *args
-    Client.new Http.new(opts[0], opts[1])
+    Client.new Http.new(*args)
   end
   
-  def self.parse_options *args
-    opts = args[-1].kind_of?(Hash) ? args.pop : {}
-    url = args.empty? ? 'http://127.0.0.1:8983/solr/' : args[0]
-    uri = Uri.create url
-    proxy = Uri.create opts[:proxy] if opts[:proxy]
-    [uri, {:proxy => proxy}]
-  end
+  # RSolr.escape
+  extend Char
   
 end

data/spec/api/char_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+describe "RSolr::Char" do
+  
+  let(:char){Object.new.extend RSolr::Char}
+  
+  it 'should escape everything that is not a word with \\' do
+    (0..255).each do |ascii|
+      chr = ascii.chr
+      esc = char.escape(chr)
+      if chr =~ /\W/
+        esc.to_s.should == "\\#{chr}"
+      else
+        esc.to_s.should == chr
+      end
+    end
+  end
+  
+end

data/spec/api/client_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+describe "RSolr::Client" do
+  
+  module ClientHelper
+    def client
+      @client ||= (
+        connection = RSolr::Http.new :url => "http://localhost:9999/solr"
+        RSolr::Client.new connection
+      )
+    end
+  end
+  
+  context "initialize" do
+    it "should accept whatevs and set it as the @connection" do
+      RSolr::Client.new(:whatevs).connection.should == :whatevs
+    end
+  end
+  
+  context "send_request" do
+    include ClientHelper
+    it "should forward these method calls the #connection object" do
+      [:get, :post, :head].each do |meth|
+        client.connection.should_receive(:send_request).
+            and_return({:status => 200, :body => "{}", :headers => {}})
+        client.send_request '', :method => meth, :params => {}, :data => nil, :headers => {}
+      end
+    end
+  end
+
+  context "post" do
+    include ClientHelper
+    it "should pass the expected params to the connection's #post method" do
+      client.connection.should_receive(:send_request).
+        with(
+          "update", {:headers=>{"Content-Type"=>"text/plain"}, :method=>:post, :data=>"the data"}
+        ).
+          and_return(
+            :params=>{:wt=>:ruby},
+            :query=>"wt=ruby",
+            :path => "update",
+            :data=>"the data",
+            :method=>:post,
+            :headers=>{"Content-Type"=>"text/plain"}
+          )
+      client.post "update", :data => "the data", :headers => {"Content-Type" => "text/plain"}
+    end
+  end
+  
+  context "xml" do
+    include ClientHelper
+    it "should return an instance of RSolr::Xml::Generator" do
+      client.xml.should be_a RSolr::Xml::Generator
+    end
+  end
+  
+  context "add" do
+    include ClientHelper
+    it "should send xml to the connection's #post method" do
+      client.connection.should_receive(:send_request).
+        with(
+          "update", {:headers=>{"Content-Type"=>"text/xml"}, :method=>:post, :data=>"<xml/>"}
+        ).
+          and_return(
+            :path => "update",
+            :data => "<xml/>",
+            :headers => {"Content-Type"=>"text/xml"},
+            :method => :post,
+            :query => "wt=ruby",
+            :params => {:wt=>:ruby}
+          )
+      # the :xml attr is lazy loaded... so load it up first
+      client.xml
+      client.xml.should_receive(:add).
+        with({:id=>1}, {:commitWith=>10}).
+          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
+      client.connection.should_receive(:send_request).
+        with(
+          "update", {:headers=>{"Content-Type"=>"text/xml"}, :method=>:post, :data=>"<optimize/>"}
+        ).
+          and_return(
+            :path => "update",
+            :data => "<optimize/>",
+            :headers => {"Content-Type"=>"text/xml"},
+            :method => :post,
+            :query => "wt=ruby",
+            :params => {:wt=>:ruby}
+          )
+      client.update(:data => "<optimize/>")
+    end
+  end
+  
+  context "post based helper methods:" do
+    include ClientHelper
+    [:commit, :optimize, :rollback].each do |meth|
+      it "should send a #{meth} message to the connection's #post method" do
+        client.connection.should_receive(:send_request).
+          with(
+            "update", {:headers=>{"Content-Type"=>"text/xml"}, :method=>:post, :data=>"<?xml version=\"1.0\" encoding=\"UTF-8\"?><#{meth}/>"}
+          ).
+            and_return(
+              :path => "update",
+              :data => "<?xml version=\"1.0\" encoding=\"UTF-8\"?><#{meth}/>",
+              :headers => {"Content-Type"=>"text/xml"},
+              :method => :post,
+              :query => "wt=ruby",
+              :params => {:wt=>:ruby}
+            )
+        client.send meth
+      end
+    end
+  end
+  
+  context "delete_by_id" do
+    include ClientHelper
+    it "should send data to the connection's #post method" do
+      client.connection.should_receive(:send_request).
+        with(
+          "update", {:headers=>{"Content-Type"=>"text/xml"}, :method=>:post, :data=>"<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><id>1</id></delete>"}
+        ).
+          and_return(
+            :path => "update",
+            :data => "<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><id>1</id></delete>",
+            :headers => {"Content-Type"=>"text/xml"},
+            :method => :post,
+            :query => "wt=ruby",
+            :params => {:wt=>:ruby}
+          )
+      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
+      client.connection.should_receive(:send_request).
+        with(
+          "update", {:headers=>{"Content-Type"=>"text/xml"}, :method=>:post, :data=>"<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><query fq=\"category:&quot;trash&quot;\"/></delete>"}
+        ).
+          and_return(
+            :path => "update",
+            :data => "<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><query fq=\"category:&quot;trash&quot;\"/></delete>",
+            :headers => {"Content-Type"=>"text/xml"},
+            :method => :post,
+            :query => "wt=ruby",
+            :params => {:wt=>:ruby}
+          )
+      client.delete_by_query :fq => "category:\"trash\""
+    end
+  end
+  
+end

data/spec/api/connectable_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "RSolr::Connectable" do
+  
+  def connectable
+    Object.new.extend RSolr::Connectable
+  end
+  
+  context "adapt_response" do
+    
+    it 'should not try to evaluate ruby when the :qt is not :ruby' do
+      body = '{:time=>"NOW"}'
+      result = connectable.adapt_response({:params=>{}}, {:status => 200, :body => body, :headers => {}})
+      result.should be_a(String)
+      result.should == body
+    end
+    
+    it 'should evaluate ruby responses when the :wt is :ruby' do
+      body = '{:time=>"NOW"}'
+      result = connectable.adapt_response({:params=>{:wt=>:ruby}}, {:status => 200, :body => body, :headers => {}})
+      result.should be_a(Hash)
+      result.should == {:time=>"NOW"}
+    end
+    
+    it "ought raise a RSolr::Error::InvalidRubyResponse when the ruby is indeed frugged" do
+      lambda {
+        connectable.adapt_response({:params=>{:wt => :ruby}}, {:status => 200, :body => "<woops/>", :headers => {}})
+      }.should raise_error RSolr::Error::InvalidRubyResponse
+    end
+  
+  end
+
+  context "build_request" do
+    
+    it 'should return a request context array' do
+      result = connectable.build_request 'select', :method => :post, :params => {:q=>'test', :fq=>[0,1]}, :data => "data", :headers => {}
+      [/fq=0/, /fq=1/, /q=test/, /wt=ruby/].each do |pattern|
+        result[:query].should match pattern
+      end
+      result[:data].should == "data"
+      result[:headers].should == {}
+    end
+    
+    it "should set the Content-Type header to application/x-www-form-urlencoded if a hash is passed in to the data arg" do
+      result = connectable.build_request 'select', :method => :post, :data => {:q=>'test', :fq=>[0,1]}, :headers => {}
+      result[:query].should == "wt=ruby"
+      [/fq=0/, /fq=1/, /q=test/].each do |pattern|
+        result[:data].should match pattern
+      end
+      result[:data].should_not match /wt=ruby/
+      result[:headers].should == {"Content-Type" => "application/x-www-form-urlencoded"}
+    end
+    
+  end
+  
+end

data/spec/api/http_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+describe "RSolr::Http" do
+  # it "should raise an Http error if the response status code aint right" do
+  #   client.connection.should_receive(:get).
+  #     and_return({:status => 400, :body => "", :headers => {}})
+  #   lambda{
+  #     client.send_request '', :method => :get
+  #   }.should raise_error(RSolr::Error::Http) {|error|
+  #     error.should be_a(RSolr::Error::Http)
+  #     error.should respond_to(:request)
+  #     error.should respond_to(:response)
+  #   }
+  # end
+end

data/spec/api/{rsolr_xml_spec.rb → xml_spec.rb}

@@ -9,7 +9,7 @@ describe "RSolr::Xml" do
   [:optimize, :rollback, :commit].each do |meth|
     it "#{meth} should generator xml" do
       result = generator.send(meth)
-      result.should match(Regexp.escape("<#{meth}/>"))
+      result.should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?><#{meth}/>"
     end
   end
   

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 1
   - 0
   - 0
-  - beta
-  version: 1.0.0.beta
+  - beta2
+  version: 1.0.0.beta2
 platform: ruby
 authors: 
 - Matt Mitchell
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-29 00:00:00 -04:00
+date: 2010-07-12 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -48,6 +48,7 @@ files:
 - lib/rsolr.rb
 - lib/rsolr/char.rb
 - lib/rsolr/client.rb
+- lib/rsolr/connectable.rb
 - lib/rsolr/error.rb
 - lib/rsolr/http.rb
 - lib/rsolr/uri.rb
@@ -85,12 +86,12 @@ signing_key:
 specification_version: 3
 summary: A Ruby client for Apache Solr
 test_files: 
-- spec/api/rsolr_client_spec.rb
-- spec/api/rsolr_error_spec.rb
-- spec/api/rsolr_http_spec.rb
-- spec/api/rsolr_spec.rb
-- spec/api/rsolr_uri_spec.rb
-- spec/api/rsolr_xml_spec.rb
+- spec/api/char_spec.rb
+- spec/api/client_spec.rb
+- spec/api/connectable_spec.rb
+- spec/api/http_spec.rb
+- spec/api/uri_spec.rb
+- spec/api/xml_spec.rb
 - spec/spec_helper.rb
 - Rakefile
 - tasks/spec.rake