mwmitchell-rsolr 0.7.1 → 0.8.0

data/CHANGES.txt

@@ -1,3 +1,12 @@
+0.8.0 - March 6, 2009
+  Removed all response wrapper classes (now returning a simple hash for ruby responses)
+  Removed RSolr::Query - this library needs an external partner lib, RSolrExt etc..
+  changed query method to select
+  added send_request method to Connection for custom requests:
+    send_request '/my-handler', {:start=>0}, post_data=nil
+  moved Connection::Base to Connection
+  moved Connection::Adapter::* to Adapter::*
+  
 0.7.1 - February 27, 2009
   Added simple query helper module -> RSolr::Query
   Added tests for RSolr::Query

data/README.rdoc

@@ -2,17 +2,25 @@
 
 A Ruby client for Apache Solr. Has transparent JRuby support by using "org.apache.solr.servlet.DirectSolrConnection" as a connection adapter.
 
+=NOTE
+Please look at the latest code/branch here: http://github.com/mwmitchell/rsolr/tree/no-response-wrap
+The mapping/response helper stuff in master, will be extracted out into a separate Gem.
+
 ==Installation:
   gem sources -a http://gems.github.com
   sudo gem install mwmitchell-rsolr
 
-Simple usage:
+==Community
+http://groups.google.com/group/rsolr
+
+==Simple usage:
   require 'rubygems'
   require 'rsolr'
   rsolr = RSolr.connect
-  response = rsolr.query(:q=>'*:*') # becomes /solr/select?q=*:*
+  response = rsolr.select(:q=>'*:*') # becomes /solr/select?q=*:*
+  
   # can also set the request handler path like:
-  response = rsolr.query('catalog', :q=>'*:*') # becomes /solr/catalog?q=*:*
+  response = rsolr.send_request('/catalog', :q=>'*:*') # becomes /solr/catalog?q=*:*
 
 To run tests:
   
@@ -27,46 +35,15 @@ To get a connection in MRI/standard Ruby:
 
 To get a direct connection (no http) in jRuby using DirectSolrConnection:
   
-  solr = RSolr.connect(:adapter=>:direct, :home_dir=>'/path/to/solr/home', :dist_dir=>'/path/to/solr/distribution')
-
-You can set the request handler paths for every request:
-  
-  solr = RSolr.connect(:select_path=>'select', :update_path=>'update', :luke_path=>'admin/luke')
+  solr = RSolr.connect({:adapter=>:direct}, {:home_dir=>'/path/to/solr/home', :dist_dir=>'/path/to/solr/distribution'})
 
 
 == Requests
 Once you have a connection, you can execute queries, updates etc..
 
-You can optionally specify the request handler path by sending it in as the first argument:
-  solr.query 'catalog', :q=>'object_type:"book"'
-  solr.update 'my/update', '<xml/>'
-
-The default request handler path value for each of the different methods are as follows:
-  find_by_id, query == 'select'
-  add, update, commit, optimize, rollback, delete_by_id, delete_by_query == 'update'
-  index_info == 'admin/luke'
-
-Please note that the path you specify should be relative.
-
-
 === Querying
-Use the #query method to send requests to the /select handler:
-  response = solr.query(:q=>'washington', :facet=>true, 'facet.limit'=>-1, 'facet.field'=>'cat', 'facet.field'=>'inStock', :start=>0, :rows=>10)
-  response = solr.find_by_id(1)
-
-==== Pagination
-Pagination is simplified by having a few helpful response methods:
-  
-  response = solr.query(:start=>0, :rows=>10, :q=>'*:*')
-  response.per_page
-  response.total_pages
-  response.current_page
-  response.previous_page
-  response.next_page
-
-If you use WillPaginate, just pass-in the response to the #will_paginate view helper:
-
-  <%= will_paginate(@response) %>
+Use the #select method to send requests to the /select handler:
+  response = solr.select(:q=>'washington', :facet=>true, 'facet.limit'=>-1, 'facet.field'=>'cat', 'facet.field'=>'inStock', :start=>0, :rows=>10)
 
 
 === Updating Solr
@@ -102,24 +79,32 @@ Commit & Optimize
 
 
 == Response Formats
-The default response format is Ruby. When the :wt param is set to :ruby, the response is eval'd and wrapped up in a nice RSolr::Response class. You can get an unwrapped response by setting the :wt to "ruby" - notice, the string -- not a symbol. All other response formats are available as expected, :wt=>'xml' etc.. Currently, the only response format that gets eval'd and wrapped is :ruby.
+The default response format is Ruby. When the :wt param is set to :ruby, the response is eval'd and wrapped up in a nice Mash (Hash) class. You can get a raw response by setting the :wt to "ruby" - notice, the string -- not a symbol. All other response formats are available as expected, :wt=>'xml' etc..
+
+You can access the original request context (path, params, url etc.) by using a block:
+  solr.select(:q=>'*:*') do |solr_response, adapter_response|
+    adapter_response[:status_code]
+    adapter_response[:body]
+    adapter_response[:url]
+  end
 
-You can access the original request context (path, params, url etc.) from response.request. The response.request is a hash that contains the generated params, url, path, post data, headers etc., very useful for debugging and testing.
+The adapter_response is a hash that contains the generated params, url, path, post data, headers etc., very useful for debugging and testing.
 
 
 == HTTP Client Adapter
-You can specify the http client adapter to use by setting RSolr::Connection::Adapter::HTTP.client_adapter to one of:
+You can specify the http client adapter to use by setting solr.adapter.connector.adapter_name to one of:
   :net_http     uses the standard Net::HTTP library
   :curb         uses the Ruby "curl" bindings
 
 Example:
 	
-  RSolr::Connection::Adapter::HTTP.client_adapter = :curb
+  solr.adapter.connector.adapter_name = :curb
 
 Example of using the HTTP client only:
   
-  hclient = RSolr::HTTPClient.connect(url, :curb)
-  hclient = RSolr::HTTPClient.connect(url, :net_http)
+  hclient = RSolr::HTTPClient::Connector.new(:curb).connect(url)
+  hclient = RSolr::HTTPClient::Connector.new(:net_http).connect(url)
+  hclient.get('/')
 
 After reading this http://apocryph.org/2008/11/09/more_indepth_analysis_ruby_http_client_performance - I would recommend using the :curb adapter. NOTE: You can't use the :curb adapter under jRuby. To install curb:
 

data/Rakefile

@@ -2,8 +2,6 @@ require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
 
-require File.join(File.dirname(__FILE__), 'lib', 'rsolr')
-
 namespace :rsolr do
   
   desc "Starts the HTTP server used for running HTTP connection tests"
@@ -20,6 +18,7 @@ Rake::TestTask.new("test_units") { |t|
   t.pattern = 'test/**/*_test.rb'
   t.verbose = true
   t.warning = true
+  t.libs << "test"
 }
 
 # Clean house

data/examples/direct.rb

@@ -5,17 +5,16 @@ base = File.expand_path( File.dirname(__FILE__) )
 dist = File.join(base, '..', 'apache-solr')
 home = File.join(dist, 'example', 'solr')
 
-solr = RSolr.connect(:adapter=>:direct, :home_dir=>home, :dist_dir=>dist)
+solr = RSolr.connect({:adapter=>:direct}, {:home_dir=>home, :dist_dir=>dist})
 
 `cd ../apache-solr/example/exampledocs && ./post.sh ./*.xml`
 
-# the 'select' here is optional
-response = solr.query 'select', :q=>'ipod', :fq=>'price:[0 TO 50]', :rows=>2, :start=>0
+response = solr.select :q=>'ipod', :fq=>'price:[0 TO 50]', :rows=>2, :start=>0
 
-solr.delete_by_query('*:*')
+docs = response[:response][:docs]
 
-response.docs.each do |doc|
-  if doc.has?(:timestamp)
-    puts doc[:timestamp]
-  end
-end
+docs.each do |doc|
+  puts doc[:timestamp]
+end
+
+solr.delete_by_query('*:*') and solr.commit

data/examples/http.rb

@@ -1,16 +1,17 @@
-# Must be executed using jruby
 require File.join(File.dirname(__FILE__), '..', 'lib', 'rsolr')
 
 solr = RSolr.connect
 
-`cd ../apache-solr/example/exampledocs && ./post.sh ./*.xml`
-
-response = solr.query :q=>'ipod', :fq=>'price:[0 TO 50]', :rows=>2, :start=>0
+# switch out the http adapter from curb to net_http (just for an example)
+solr.adapter.connector.adapter_name = :net_http
 
-solr.delete_by_query('*:*')
+`cd ../apache-solr/example/exampledocs && ./post.sh ./*.xml`
 
-response.docs.each do |doc|
-  if doc.has?(:timestamp)
+solr.select(:q=>'ipod', :fq=>'price:[0 TO 50]', :rows=>2, :start=>0) do |solr_response,adapter_response|
+  puts "URL : #{adapter_response[:url]}"
+  solr_response[:response][:docs].each do |doc|
     puts doc[:timestamp]
   end
-end
+end
+
+solr.delete_by_query('*:*') and solr.commit

data/lib/rsolr.rb

@@ -7,30 +7,26 @@ proc {|base, files|
 
 module RSolr
   
-  VERSION = '0.7.1'
+  VERSION = '0.8.0'
   
   autoload :Message, 'rsolr/message'
-  autoload :Response, 'rsolr/response'
   autoload :Connection, 'rsolr/connection'
-  autoload :Indexer, 'rsolr/indexer'
+  autoload :Adapter, 'rsolr/adapter'
   autoload :HTTPClient, 'rsolr/http_client'
-  autoload :Query, 'rsolr/query'
   
   # factory for creating connections
-  # opts[:adapter] is either :http or :direct
-  # opts are sent to the adapter instance (:url for http, :dist_dir for :direct etc.)
-  # and to the connection instance
-  def self.connect(opts={})
-    adapter_name = opts[:adapter] ||= :http
+  # connection_opts[:adapter] is either :http or :direct
+  # connection_opts are sent to the connection instance
+  # adapter_opts are passed to the actually adapter instance
+  def self.connect(connection_opts={}, adapter_opts={})
+    adapter_name = connection_opts[:adapter] ||= :http
     types = {
       :http=>'HTTP',
       :direct=>'Direct'
     }
-    opts[:select_path] ||= 'select'
-    opts[:update_path] ||= 'update'
-    opts[:luke_path] ||= 'admin/luke'
-    adapter_class = RSolr::Connection::Adapter.const_get(types[adapter_name])
-    RSolr::Connection::Base.new(adapter_class.new(opts), opts)
+    adapter_class = RSolr::Adapter.const_get(types[adapter_name])
+    adapter = adapter_class.new(adapter_opts)
+    RSolr::Connection.new(adapter, connection_opts)
   end
   
   class RequestError < RuntimeError; end

data/lib/rsolr/adapter.rb

@@ -0,0 +1,6 @@
+module RSolr::Adapter
+  
+  autoload :Direct, 'rsolr/adapter/direct'
+  autoload :HTTP, 'rsolr/adapter/http'
+  
+end

data/lib/rsolr/{connection/adapter → adapter}/direct.rb

@@ -5,10 +5,9 @@ require 'java'
 #
 # Connection for JRuby + DirectSolrConnection
 #
-class RSolr::Connection::Adapter::Direct
+class RSolr::Adapter::Direct
   
   include RSolr::HTTPClient::Util
-  include RSolr::Connection::Adapter::CommonMethods
   
   attr_accessor :opts, :home_dir
   
@@ -58,13 +57,13 @@ class RSolr::Connection::Adapter::Direct
       raise RSolr::RequestError.new($!.message)
     end
     {
-      :status_code=>'',
+      :status_code=>nil,
       :body=>body,
       :url=>url,
       :path=>path,
       :params=>params,
       :data=>data,
-      :headers=>{}
+      :headers=>nil
     }
   end
   

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

@@ -1,17 +1,9 @@
 #
 # Connection for standard HTTP Solr server
 #
-class RSolr::Connection::Adapter::HTTP
+class RSolr::Adapter::HTTP
   
-  class << self
-    attr_accessor :client_adapter
-  end
-  
-  @client_adapter = :net_http
-  
-  include RSolr::Connection::Adapter::CommonMethods
-  
-  attr_reader :opts
+  attr_reader :opts, :connector, :connection
   
   # opts can have:
   #   :url => 'http://localhost:8080/solr'
@@ -22,10 +14,11 @@ class RSolr::Connection::Adapter::HTTP
   def initialize(opts={}, &block)
     opts[:url]||='http://127.0.0.1:8983/solr'
     @opts = opts
+    @connector = RSolr::HTTPClient::Connector.new
   end
   
   def connection
-    @connection ||= RSolr::HTTPClient.connect(@opts[:url], self.class.client_adapter)
+    @connection ||= @connector.connect(@opts[:url])
   end
   
   # send a request to the connection

data/lib/rsolr/connection.rb

@@ -1,6 +1,107 @@
-module RSolr::Connection
+class RSolr::Connection
   
-  autoload :Base, 'rsolr/connection/base'
-  autoload :Adapter, 'rsolr/connection/adapter'
+  attr_reader :adapter, :opts
+  
+  # "adapter" is instance of:
+  #   RSolr::Adapter::HTTP
+  #   RSolr::Adapter::Direct (jRuby only)
+  def initialize(adapter, opts={})
+    @adapter = adapter
+    @opts = opts
+  end
+  
+  # send a request to the "select" handler
+  def select(params, &blk)
+    send_request('/select', map_params(params), &blk)
+  end
+  
+  # sends data to the update handler
+  # data can be a string of xml, or an object that returns xml from its #to_s method
+  def update(data, params={}, &blk)
+    send_request('/update', map_params(params), data, &blk)
+  end
+  
+  # send request solr
+  # params is hash with valid solr request params (:q, :fl, :qf etc..)
+  #   if params[:wt] is not set, the default is :ruby
+  #   if :wt is something other than :ruby, the raw response body is used
+  #   otherwise, a simple Hash is returned
+  #   NOTE: to get raw ruby, use :wt=>'ruby' <- a string, not a symbol like :ruby  
+  # 
+  # use a block to get access to the adapter response:
+  # solr.send_request('/select', :q=>'blue') do |solr_response, adapter_response|
+  #   raise 'Woops!' if adapter_response[:status] != 200
+  #   solr_response[:response][:docs].each {|doc|}
+  # end
+  #
+  def send_request(path, params={}, data=nil, &blk)
+    response = @adapter.send_request(path, map_params(params), data)
+    adapt_response(response, &blk)
+  end
+  
+  # 
+  # single record:
+  # solr.update(:id=>1, :name=>'one')
+  #
+  # update using an array
+  # solr.update([{:id=>1, :name=>'one'}, {:id=>2, :name=>'two'}])
+  #
+  def add(doc, &block)
+    update message.add(doc, &block)
+  end
+  
+  # send </commit>
+  def commit
+    update message.commit
+  end
+  
+  # send </optimize>
+  def optimize
+    update message.optimize
+  end
+  
+  # send </rollback>
+  # NOTE: solr 1.4 only
+  def rollback
+    update message.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)
+    update message.delete_by_id(id)
+  end
+  
+  # delete one or many documents by query
+  #   solr.delete_by_query 'available:0'
+  #   solr.delete_by_query ['quantity:0', 'manu:"FQ"']
+  def delete_by_query(query)
+    update message.delete_by_query(query)
+  end
+  
+  protected
+  
+  # shortcut to solr::message
+  def message
+    RSolr::Message
+  end
+  
+  # sets default params etc.. - could be used as a mapping hook
+  # type of request should be passed in here? -> map_params(:query, {})
+  def map_params(params)
+    params||={}
+    {:wt=>:ruby}.merge(params)
+  end
+  
+  # 
+  def adapt_response(adapter_response)
+    if adapter_response[:params][:wt] == :ruby
+      data = Kernel.eval(adapter_response[:body]).to_mash
+    else
+      data = adapter_response[:body]
+    end
+    block_given? ? yield(data, adapter_response) : data
+  end
   
 end

data/lib/rsolr/http_client.rb

@@ -1,7 +1,7 @@
 # A simple wrapper for different http client implementations.
 # Supports #get and #post
 # This was motivated by: http://apocryph.org/2008/11/09/more_indepth_analysis_ruby_http_client_performance/
-# Net::HTTP is the default adapter
+# Curb is the default adapter
 
 # Each adapters response should be a hash with the following keys:
 #   :status_code
@@ -13,31 +13,45 @@
 #   :headers
 
 # Example:
-#   hclient = RSolr::HTTPClient.connect('http://www.google.com', :net_http)
+#   connector = RSolr::HTTPClient.Connector.new
+#   connector.adapter_name = :net_http # switch to Net::HTTP before calling "connect"
+#   hclient = connector.connect('http://www.google.com')
 #   response = hclient.get('/search', :hl=>:en, :q=>:ruby, :btnG=>:Search)
 #   puts response[:status_code]
 #   puts response[:body]
 
+require 'uri'
+
 module RSolr::HTTPClient
   
   autoload :Adapter, 'rsolr/http_client/adapter'
   
   class UnkownAdapterError < RuntimeError; end
   
-  def self.connect(url, adapter_name=:net_http)
-    case adapter_name
-    when :curb
-      klass = 'Curb'
-    when :net_http
-      klass = 'NetHTTP'
-    else
-      raise UnkownAdapterError.new("Name: #{adapter_name}")
+  class Connector
+    
+    attr_accessor :adapter_name
+    
+    def initialize(adapter_name = :curb)
+      @adapter_name = adapter_name
     end
-    begin
-      Base.new RSolr::HTTPClient::Adapter.const_get(klass).new(url)
-    rescue URI::InvalidURIError
-      raise "#{$!} == #{url}"
+    
+    def connect(url)
+      case adapter_name
+      when :curb
+        klass = 'Curb'
+      when :net_http
+        klass = 'NetHTTP'
+      else
+        raise UnkownAdapterError.new("Name: #{adapter_name}")
+      end
+      begin
+        RSolr::HTTPClient::Base.new RSolr::HTTPClient::Adapter.const_get(klass).new(url)
+      rescue ::URI::InvalidURIError
+        raise "#{$!} == #{url}"
+      end
     end
+    
   end
   
   class Base