rsolr 1.0.0.beta3 → 1.0.0.beta4

data/VERSION

@@ -1 +1 @@
-1.0.0.beta3
+1.0.0.beta4

data/lib/rsolr/client.rb

@@ -1,24 +1,42 @@
 class RSolr::Client
   
-  attr_reader :connection
+  attr_reader :connection, :uri, :proxy, :options
   
-  def initialize connection
+  def initialize connection, options = {}
     @connection = connection
+    url = options[:url] || 'http://127.0.0.1:8983/solr/'
+    url << "/" unless url[-1] == ?/
+    proxy_url = options[:proxy]
+    proxy_url << "/" unless proxy_url.nil? or proxy_url[-1] == ?/
+    @uri = RSolr::Uri.create url
+    @proxy = RSolr::Uri.create proxy_url if proxy_url
+    @options = options
+    extend RSolr::Pagination::Client
   end
   
+  # returns the actual request uri object.
+  def base_request_uri
+    base_uri.request_uri
+  end
+  
+  # returns the uri proxy if present,
+  # otherwise just the uri object.
+  def base_uri
+    @proxy || @uri
+  end
+  
+  # Create the get, post, and head methods
   %W(get post head).each do |meth|
     class_eval <<-RUBY
     def #{meth} path, opts = {}, &block
-      send_request path, opts.merge(:method => :#{meth}), &block
+      send_and_receive path, opts.merge(:method => :#{meth}), &block
     end
     RUBY
   end
   
-  def method_missing name, *args
-    send_request name, *args
-  end
-  
-  # POST XML messages to /update with optional params
+  # 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
   # 'Content-Type' set to 'text/xml'
@@ -27,7 +45,7 @@ class RSolr::Client
   #
   #  :data - posted data
   #  :headers - http headers
-  #  :params - query parameter hash
+  #  :params - solr query parameter hash
   #
   def update opts = {}
     opts[:headers] ||= {}
@@ -37,6 +55,9 @@ class RSolr::Client
   
   # 
   # +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')
   #
@@ -54,14 +75,7 @@ class RSolr::Client
 
   # send "commit" xml with opts
   #
-  # opts recognized by solr
-  #
-  #   :maxSegments    => N - optimizes down to at most N number of segments
-  #   :waitFlush      => true|false - do not return until changes are flushed to disk
-  #   :waitSearcher   => true|false - do not return until a new searcher is opened and registered
-  #   :expungeDeletes => true|false - merge segments with deletes into other segments #NOT
-  #
-  # *NOTE* :expungeDeletes is Solr 1.4 only
+  # http://wiki.apache.org/solr/UpdateXmlMessages#A.22commit.22_and_.22optimize.22
   #
   def commit opts = {}
     commit_attrs = opts.delete :commit_attributes
@@ -70,14 +84,7 @@ class RSolr::Client
 
   # send "optimize" xml with opts.
   #
-  # opts recognized by solr
-  #
-  #   :maxSegments    => N - optimizes down to at most N number of segments
-  #   :waitFlush      => true|false - do not return until changes are flushed to disk
-  #   :waitSearcher   => true|false - do not return until a new searcher is opened and registered
-  #   :expungeDeletes => true|false - merge segments with deletes into other segments
-  #
-  # *NOTE* :expungeDeletes is Solr 1.4 only
+  # http://wiki.apache.org/solr/UpdateXmlMessages#A.22commit.22_and_.22optimize.22
   #
   def optimize opts = {}
     optimize_attributes = opts.delete :optimize_attributes
@@ -85,11 +92,14 @@ class RSolr::Client
   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])
@@ -97,7 +107,10 @@ class RSolr::Client
     update opts.merge(:data => xml.delete_by_id(id))
   end
 
-  # delete one or many documents by query
+  # 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 = {}
@@ -109,7 +122,7 @@ class RSolr::Client
     @xml ||= RSolr::Xml::Generator.new
   end
   
-  # +send_request+ is the main request method.
+  # +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
   # "opt" : A hash, which can contain the following keys:
@@ -117,25 +130,109 @@ class RSolr::Client
   #   :params : optional - the query string params in hash form
   #   :data : optional - post data -- if a hash is given, it's sent as "application/x-www-form-urlencoded"
   #   :headers : optional - hash of request headers
-  # All other options are passed right along to the connection request method (:get, :post, or :head)
+  # All other options are passed right along to the connection's +send_and_receive+ method (:get, :post, or :head)
   # 
-  # +send_request+ returns either a string or hash on a successful ruby request.
+  # +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.
+  #
+  # creates a request context hash,
+  # sends it to the connection's +execute+ method
+  # which returns a simple hash,
+  # then passes the request/response into +adapt_response+.
+  def send_and_receive path, opts
+    request_context = build_request path, opts
+    execute request_context
+  end
+  
   # 
-  def send_request path, opts = {}
-    connection.send_request path, opts
+  def execute request_context
+    raw_response = connection.execute self, request_context
+    adapt_response(request_context, raw_response) unless raw_response.nil?
+  end
+  
+  # +build_request+ accepts a path and options hash,
+  # then prepares a normalized hash to return for sending
+  # to a solr connection driver.
+  # +build_request+ sets up the uri/query string
+  # and converts the +data+ arg to form-urlencoded,
+  # if the +data+ arg is a hash.
+  # returns a hash with the following keys:
+  #   :method
+  #   :params
+  #   :headers
+  #   :data
+  #   :uri
+  #   :path
+  #   :query
+  def build_request path, opts
+    raise "path must be a string or symbol, not #{path.inspect}" unless [String,Symbol].include?(path.class)
+    path = path.to_s
+    opts[:proxy] = proxy unless proxy.nil?
+    opts[:method] ||= :get
+    raise "The :data option can only be used if :method => :post" if opts[:method] != :post and opts[:data]
+    opts[:params] = opts[:params].nil? ? {:wt => :ruby} : {:wt => :ruby}.merge(opts[:params])
+    query = RSolr::Uri.params_to_solr(opts[:params]) unless opts[:params].empty?
+    opts[:query] = query
+    if opts[:data].is_a? Hash
+      opts[:data] = RSolr::Uri.params_to_solr opts[:data]
+      opts[:headers] ||= {}
+      opts[:headers]['Content-Type'] ||= 'application/x-www-form-urlencoded'
+    end
+    opts[:path] = path
+    opts[:uri] = base_uri.merge(path.to_s + (query ? "?#{query}" : "")) if base_uri
+    opts
   end
   
-  # used for debugging/inspection
-  # - accepts the same args as send_request
-  def build_request path, opts = {}
-    connection.build_request path, opts
+  #  A mixin for used by #adapt_response
+  # This module essentially
+  # allows the raw response access to
+  # the original response and request.
+  module Context
+    attr_accessor :request, :response
   end
   
-  # used for debugging/inspection
-  # - accepts the same args as send_request
-  def adapt_response request_context, response
-    connection.adapt_response request_context, response
+  # This method will evaluate the :body value
+  # if the params[:uri].params[:wt] == :ruby
+  # ... otherwise, the body is returned as is.
+  # The return object has methods attached, :request and :response.
+  # These methods give you access to the original
+  # request and response from the connection.
+  #
+  # +adapt_response+ will raise an InvalidRubyResponse
+  # if :wt == :ruby and the body
+  # couldn't be evaluated.
+  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 = request[:params][:wt] == :ruby ? evaluate_ruby_response(request, response) : response[:body]
+    result.extend Context
+    result.request = request
+    result.response = response
+    result
+  end
+  
+  protected
+  
+  # converts the method name for the solr request handler path.
+  def method_missing name, *args
+    send_and_receive name, *args
+  end
+  
+  # evaluates the response[:body],
+  # attemps to bring the ruby string to life.
+  # If a SyntaxError is raised, then
+  # this method intercepts and raises a
+  # RSolr::Error::InvalidRubyResponse
+  # 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
   end
   
 end

data/lib/rsolr/{http.rb → connection.rb}

@@ -1,24 +1,20 @@
 require 'net/http'
 require 'net/https'
 
-class RSolr::Http
-  
-  include RSolr::Connectable
-  
-  def initialize *args, &block
-    # call the initialize method from RSolr::Connectable
-    super
-  end
+# The default/Net::Http adapter for RSolr.
+class RSolr::Connection
   
   # using the request_context hash,
-  # issue a request,
+  # send a request,
   # then return the standard rsolr response hash {:status, :body, :headers}
-  def execute request_context
+  def execute client, request_context
+    h = http request_context[:uri], request_context[:proxy]
     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
+      response = h.request request
       {:status => response.code.to_i, :headers => response.to_hash, :body => response.body}
+    # catch the undefined closed? exception -- this is a confirmed ruby bug
     rescue NoMethodError
       $!.message == "undefined method `closed?' for nil:NilClass" ?
         raise(Errno::ECONNREFUSED.new) :
@@ -28,7 +24,8 @@ class RSolr::Http
   
   protected
   
-  def http
+  # This returns a singleton of a Net::HTTP or Net::HTTP.Proxy request object.
+  def http uri, proxy = nil
     @http ||= (
       http = if proxy
         proxy_user, proxy_pass = proxy.userinfo.split(/:/) if proxy.userinfo
@@ -36,30 +33,12 @@ class RSolr::Http
       else
         Net::HTTP.new uri.host, uri.port
       end
-    
-      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.use_ssl = uri.port == 443 || uri.instance_of?(URI::HTTPS)      
       http
     )
   end
   
+  # 
   def setup_raw_request request_context
     http_method = case request_context[:method]
     when :get
@@ -74,26 +53,7 @@ class RSolr::Http
     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
-    end
     raw_request
   end
   
-  def credentials
-    options[:basic_auth] || options[:digest_auth]
-  end
-
-  def username
-    credentials[:username]
-  end
-
-  def password
-    credentials[:password]
-  end
-  
 end

data/lib/rsolr/pagination.rb

@@ -0,0 +1,127 @@
+module RSolr::Pagination
+  
+  # Calculates the "start" and "rows" Solr params
+  # by inspecting the :per_page and :page params.
+  def self.calculate_start_and_rows page, per_page
+    per_page ||= 10
+    page = page.to_s.to_i-1
+    page = page < 1 ? 0 : page
+    start = page * per_page
+    [start, per_page]
+  end
+  
+  # A mixin module for RSolr::Client
+  # -- note, this must mixed-in via
+  # "extend" on a RSolr::Client instance.
+  module Client
+    
+    # A paginated request method.
+    def paginate page, per_page, path, opts = {}
+      request_context = build_paginated_request page, per_page, path, opts = {}
+      puts request_context.inspect
+      execute request_context
+    end
+    
+    # Just like RSolr::Client #build_request
+    # but converts the page and per_page
+    # arguments into :rows and :start.
+    def build_paginated_request page, per_page, path, opts = {}
+      opts[:page] = page
+      opts[:per_page] = per_page
+      opts[:params] ||= {}
+      values = RSolr::Pagination.calculate_start_and_rows(page, per_page)
+      opts[:params][:start] = values[0]
+      opts[:params][:rows] = values[1]
+      build_request path, opts
+    end
+    
+    protected
+    
+    # Checks if the called method starts
+    # with "paginate_" and
+    # converts the paginate_* to the solr
+    # request path. It then calls paginate
+    # with the appropriate arguments.
+    # If the called method doesn't
+    # start with "paginate_",
+    # the original/super
+    # RSolr::Client #method_missing
+    # method is called.
+    def method_missing name, *args
+      if name.to_s =~ /^paginate_(.+)$/
+        paginate args[0], args[1], $1, *args[2..-1]
+      else
+        super name, *args
+      end
+    end
+    
+    # Overrides the RSolr::Client #evaluate_ruby_response method.
+    # Calls the original/super
+    # RSolr::Client #evaluate_ruby_response method.
+    # Mixes in the PaginatedResponse if
+    # the request[:page] and request[:per_page]
+    # opts are set.
+    def evaluate_ruby_response request, response
+      result = super request, response
+      result.extend(PaginatedResponse) if request[:page] && request[:per_page]
+      result
+    end
+    
+  end
+  
+  module PaginatedResponse
+    # TODO: self["responseHeader"]["params"]["rows"]
+    # will not be available if omitHeader is false...
+    # so, a simple "extend" probably isn't going to cut it.
+    def self.extended base
+      return unless base["response"] && base["response"]["docs"]
+      d = base['response']['docs']
+      d.extend PaginatedDocSet
+      d.per_page = self["responseHeader"]["params"]["rows"].to_s.to_i rescue 10
+      d.start = base["response"]["start"].to_s.to_i
+      d.total = base["response"]["numFound"].to_s.to_i
+    end
+  end
+  
+  # A response module which gets mixed into the solr ["response"]["docs"] array.
+  module PaginatedDocSet
+
+    attr_accessor :start, :per_page, :total
+
+    # Returns the current page calculated from 'rows' and 'start'
+    # WillPaginate hook
+    def current_page
+      return 1 if start < 1
+      per_page_normalized = per_page < 1 ? 1 : per_page
+      @current_page ||= (start / per_page_normalized).ceil + 1
+    end
+
+    # Calcuates the total pages from 'numFound' and 'rows'
+    # WillPaginate hook
+    def total_pages
+      @total_pages ||= per_page > 0 ? (total / per_page.to_f).ceil : 1
+    end
+
+    # returns the previous page number or 1
+    # WillPaginate hook
+    def previous_page
+      @previous_page ||= (current_page > 1) ? current_page - 1 : 1
+    end
+
+    # returns the next page number or the last
+    # WillPaginate hook
+    def next_page
+      @next_page ||= (current_page == total_pages) ? total_pages : current_page+1
+    end
+
+    def has_next?
+      current_page < total_pages
+    end
+
+    def has_previous?
+      current_page > 1
+    end
+
+  end
+  
+end

data/lib/rsolr.rb

@@ -4,7 +4,7 @@ require 'rubygems'
 
 module RSolr
   
-  %W(Char Client Connectable Error Http Uri Xml).each{|n|autoload n.to_sym, "rsolr/#{n.downcase}"}
+  %W(Char Client Error Connection Pagination Uri Xml).each{|n|autoload n.to_sym, "rsolr/#{n.downcase}"}
   
   def self.version
     @version ||= File.read(File.join(File.dirname(__FILE__), '..', 'VERSION')).chomp
@@ -13,7 +13,7 @@ module RSolr
   VERSION = self.version
   
   def self.connect *args
-    Client.new Http.new(*args)
+    Client.new Connection.new, *args
   end
   
   # RSolr.escape

data/spec/api/client_spec.rb

@@ -4,8 +4,8 @@ describe "RSolr::Client" do
   module ClientHelper
     def client
       @client ||= (
-        connection = RSolr::Http.new :url => "http://localhost:9999/solr"
-        RSolr::Client.new connection
+        connection = RSolr::Connection.new
+        RSolr::Client.new connection, :url => "http://localhost:9999/solr"
       )
     end
   end
@@ -16,13 +16,13 @@ describe "RSolr::Client" do
     end
   end
   
-  context "send_request" do
+  context "send_and_receive" 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).
+        client.connection.should_receive(:execute).
             and_return({:status => 200, :body => "{}", :headers => {}})
-        client.send_request '', :method => meth, :params => {}, :data => nil, :headers => {}
+        client.send_and_receive '', :method => meth, :params => {}, :data => nil, :headers => {}
       end
     end
   end
@@ -30,19 +30,16 @@ describe "RSolr::Client" do
   context "post" do
     include ClientHelper
     it "should pass the expected params to the connection's #post method" do
-      client.connection.should_receive(:send_request).
+      client.connection.should_receive(:execute).
         with(
-          "update", {:headers=>{"Content-Type"=>"text/plain"}, :method=>:post, :data=>"the data"}
+          client, hash_including({:path => "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"}
+            :body => "",
+            :status => 200,
+            :headers => {"Content-Type"=>"text/plain"}
           )
-      client.post "update", :data => "the data", :headers => {"Content-Type" => "text/plain"}
+      client.post "update", :data => "the data", :method=>:post, :headers => {"Content-Type" => "text/plain"}
     end
   end
   
@@ -56,17 +53,14 @@ describe "RSolr::Client" do
   context "add" do
     include ClientHelper
     it "should send xml to the connection's #post method" do
-      client.connection.should_receive(:send_request).
+      client.connection.should_receive(:execute).
         with(
-          "update", {:headers=>{"Content-Type"=>"text/xml"}, :method=>:post, :data=>"<xml/>"}
+          client, hash_including({:path => "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}
+            :body => "",
+            :status => 200,
+            :headers => {"Content-Type"=>"text/xml"}
           )
       # the :xml attr is lazy loaded... so load it up first
       client.xml
@@ -80,17 +74,14 @@ describe "RSolr::Client" do
   context "update" do
     include ClientHelper
     it "should send data to the connection's #post method" do
-      client.connection.should_receive(:send_request).
+      client.connection.should_receive(:execute).
         with(
-          "update", {:headers=>{"Content-Type"=>"text/xml"}, :method=>:post, :data=>"<optimize/>"}
+          client, hash_including({:path => "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}
+            :body => "",
+            :status => 200,
+            :headers => {"Content-Type"=>"text/xml"}
           )
       client.update(:data => "<optimize/>")
     end
@@ -100,17 +91,14 @@ describe "RSolr::Client" 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).
+        client.connection.should_receive(:execute).
           with(
-            "update", {:headers=>{"Content-Type"=>"text/xml"}, :method=>:post, :data=>"<?xml version=\"1.0\" encoding=\"UTF-8\"?><#{meth}/>"}
+            client, hash_including({:path => "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}
+              :body => "",
+              :status => 200,
+              :headers => {"Content-Type"=>"text/xml"}
             )
         client.send meth
       end
@@ -120,17 +108,14 @@ describe "RSolr::Client" do
   context "delete_by_id" do
     include ClientHelper
     it "should send data to the connection's #post method" do
-      client.connection.should_receive(:send_request).
+      client.connection.should_receive(:execute).
         with(
-          "update", {:headers=>{"Content-Type"=>"text/xml"}, :method=>:post, :data=>"<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><id>1</id></delete>"}
+          client, hash_including({:path => "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}
+            :body => "",
+            :status => 200,
+            :headers => {"Content-Type"=>"text/xml"}
           )
       client.delete_by_id 1
     end
@@ -139,20 +124,64 @@ describe "RSolr::Client" do
   context "delete_by_query" do
     include ClientHelper
     it "should send data to the connection's #post method" do
-      client.connection.should_receive(:send_request).
+      client.connection.should_receive(:execute).
         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>"}
+          client, hash_including({:path => "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}
+            :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
+      body = '{:time=>"NOW"}'
+      result = client.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 = client.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 {
+        client.adapt_response({:params=>{:wt => :ruby}}, {:status => 200, :body => "<woops/>", :headers => {}})
+      }.should raise_error RSolr::Error::InvalidRubyResponse
+    end
+  
+  end
+  
+  context "build_request" do
+    include ClientHelper
+    it 'should return a request context array' do
+      result = client.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 = client.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

@@ -1,29 +1,4 @@
 require 'spec_helper'
 describe "RSolr::Http" do
-  it "Should be an RSolr::Connectable and implement an execute method" do
-    http = RSolr::Http.new
-    http.should be_a(RSolr::Connectable)
-    http.should respond_to(:execute)
-  end
   
-  context "execute" do
-    it "should require a request_context hash" do
-      http = RSolr::Http.new
-      lambda {
-        http.execute
-      }.should raise_error(ArgumentError)
-    end
-  end
-  
-  # 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

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 1
   - 0
   - 0
-  - beta3
-  version: 1.0.0.beta3
+  - beta4
+  version: 1.0.0.beta4
 platform: ruby
 authors: 
 - Matt Mitchell
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-18 00:00:00 -04:00
+date: 2010-10-17 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -48,9 +48,9 @@ files:
 - lib/rsolr.rb
 - lib/rsolr/char.rb
 - lib/rsolr/client.rb
-- lib/rsolr/connectable.rb
+- lib/rsolr/connection.rb
 - lib/rsolr/error.rb
-- lib/rsolr/http.rb
+- lib/rsolr/pagination.rb
 - lib/rsolr/uri.rb
 - lib/rsolr/xml.rb
 has_rdoc: true
@@ -88,7 +88,6 @@ summary: A Ruby client for Apache Solr
 test_files: 
 - spec/api/char_spec.rb
 - spec/api/client_spec.rb
-- spec/api/connectable_spec.rb
 - spec/api/error_spec.rb
 - spec/api/http_spec.rb
 - spec/api/uri_spec.rb

data/lib/rsolr/connectable.rb

@@ -1,97 +0,0 @@
-# Connectable is designed to be shared across solr driver implementations.
-# If the driver uses an http url/proxy and returns the standard http respon
-# data (status, body, headers) then this module could be used. 
-module RSolr::Connectable
-  
-  attr_reader :uri, :proxy, :options
-  
-  def initialize options = {}
-    url = options[:url] || 'http://127.0.0.1:8983/solr/'
-    url << "/" unless url[-1] == ?/
-    proxy_url = options[:proxy]
-    proxy_url << "/" unless proxy_url.nil? or proxy_url[-1] == ?/
-    @uri = RSolr::Uri.create url
-    @proxy = RSolr::Uri.create proxy_url if proxy_url
-    @options = options
-  end
-  
-  # 
-  def base_request_uri
-    base_uri.request_uri
-  end
-  
-  def base_uri
-    @proxy || @uri
-  end
-  
-  # creates a request context hash,
-  # sends it to the connection.execute method
-  # which returns a simple hash,
-  # then passes the request/response into adapt_response.
-  def send_request path, opts
-    request_context = build_request path, opts
-    raw_response = execute request_context
-    adapt_response request_context, raw_response
-  end
-  
-  # all connection imlementations that use this mixin need to create an execute method 
-  def execute request_context
-    raise "You gotta implement this method and return a hash like => {:status => <integer>, :body => <string>, :headers => <hash>}"
-  end
-  
-  # build_request sets up the uri/query string
-  # and converts the +data+ arg to form-urlencoded
-  # if the +data+ arg is a hash.
-  # returns a hash with the following keys:
-  #   :method
-  #   :params
-  #   :headers
-  #   :data
-  #   :uri
-  #   :path
-  #   :query
-  def build_request path, opts
-    raise "path must be a string or symbol, not #{path.inspect}" unless [String,Symbol].include?(path.class)
-    path = path.to_s
-    opts[:method] ||= :get
-    raise "The :data option can only be used if :method => :post" if opts[:method] != :post and opts[:data]
-    opts[:params] = opts[:params].nil? ? {:wt => :ruby} : {:wt => :ruby}.merge(opts[:params])
-    query = RSolr::Uri.params_to_solr(opts[:params]) unless opts[:params].empty?
-    opts[:query] = query
-    if opts[:data].is_a? Hash
-      opts[:data] = RSolr::Uri.params_to_solr opts[:data]
-      opts[:headers] ||= {}
-      opts[:headers]['Content-Type'] ||= 'application/x-www-form-urlencoded'
-    end
-    opts[:path] = path
-    opts[:uri] = base_uri.merge(path.to_s + (query ? "?#{query}" : "")) if base_uri
-    opts
-  end
-  
-  # This method will evaluate the :body value
-  # if the params[:uri].params[:wt] == :ruby
-  # ... otherwise, the body is returned as is.
-  # The return object has methods attached, :request and :response.
-  # These methods give you access to the original
-  # request and response from the connection.
-  #
-  # +adapt_response+ will raise an InvalidRubyResponse
-  # if :wt == :ruby and the body
-  # couldn't be evaluated.
-  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]
-    data = response[:body]
-    if request[:params][:wt] == :ruby
-      begin
-        data = Kernel.eval data.to_s
-      rescue SyntaxError
-        raise RSolr::Error::InvalidRubyResponse.new request, response
-      end
-    end
-    data
-  end
-  
-end

data/spec/api/connectable_spec.rb

@@ -1,56 +0,0 @@
-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