mwmitchell-rsolr 0.9.1 → 0.9.5

data/lib/rsolr/http_client/adapter/net_http.rb

@@ -7,8 +7,8 @@ class RSolr::HTTPClient::Adapter::NetHTTP
   attr :uri
   attr :connection
   
-  def initialize(url)
-    @uri = URI.parse(url)
+  def initialize(opts={})
+    @uri = URI.parse(opts[:url])
     @connection = Net::HTTP.new(@uri.host, @uri.port)
   end
   

data/lib/rsolr/http_client.rb

@@ -12,9 +12,10 @@
 #   :headers
 
 # Example:
-#   connector = RSolr::HTTPClient.Connector.new
-#   connector.adapter_name = :net_http # switch to Net::HTTP before calling "connect"
-#   hclient = connector.connect('http://www.google.com')
+#   hclient = RSolr::HTTPClient.connect('http://www.google.com')
+#   # SAME AS
+#   hclient = RSolr::HTTPClient.connect(:net_http, 'http://www.google.com')
+#   hclient = RSolr::HTTPClient.connect(:curb, 'http://www.google.com')
 #   response = hclient.get('/search', :hl=>:en, :q=>:ruby, :btnG=>:Search)
 #   puts response[:status_code]
 #   puts response[:body]
@@ -23,53 +24,23 @@ require 'uri'
 
 module RSolr::HTTPClient
   
-  autoload :Adapter, 'rsolr/http_client/adapter'
-  
-  class UnkownAdapterError < RuntimeError; end
+  module Adapter
+    autoload :Curb, 'rsolr/http_client/adapter/curb'
+    autoload :NetHTTP, 'rsolr/http_client/adapter/net_http'
+  end
   
-  class Connector
-    
-    attr_accessor :adapter_name
-    
-    def initialize(adapter_name = :curb)
-      @adapter_name = adapter_name
-    end
-    
-    # Creates and returns an instance of RSolr::HTTPClient::Adapter::*
-    # The "url" is a full/valid url.
-    # Example:
-    # connector = RSolr::HTTPClient::Connector.new
-    # client = connector.connect('http://google.com')
-    #
-    # TODO: this should be less verbose... something like RSolr:HTTPClient.connect(url, adapter=:curb)
-    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
-    
+  class UnkownAdapterError < RuntimeError
   end
   
-  # The base class for interacting with one of the HTTP client adapters
   class Base
-    
+
     attr_reader :adapter
-    
+  
     # requires an instace of RSolr::HTTPClient::*
     def initialize(adapter)
       @adapter = adapter
     end
-    
+  
     # sends a GET reqest to the "path" variable
     # an optional hash of "params" can be used,
     # which is later transformed into a GET query string
@@ -81,7 +52,7 @@ module RSolr::HTTPClient
       end
       http_context
     end
-    
+  
     # sends a POST request to the "path" variable
     # "data" is required, and must be a string
     # "params" is an optional hash for query string params...
@@ -97,13 +68,43 @@ module RSolr::HTTPClient
     
   end
   
+  # Factory for creating connections.
+  # Can specify the connection type by
+  # using :net_http or :curb for the first argument.
+  # The ending arguments are always used for the connection adapter instance.
+  #
+  # Examples:
+  # # default net_http connection
+  # RSolr::HTTPClient.connect :url=>''
+  # # SAME AS
+  # RSolr::HTTPClient.connect :net_http, :url=>''
+  # # curb connection
+  # RSolr.connect :curb, :url=>''
+  def self.connect(*args)
+    type = args.first.is_a?(Symbol) ? args.shift : :net_http
+    opts = args
+    klass = case type
+    when :net_http,nil
+      'NetHTTP'
+    when :curb
+      'Curb'
+    else
+      raise UnkownAdapterError.new("Invalid adapter type: #{type} - use :curb or :net_http or blank for :net_http/default")
+    end
+    begin
+      Base.new Adapter.const_get(klass).new(*args)
+    end
+  end
+  
   module Util
     
-    # escapes a query key/value for http
+    # 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).
     def escape(s)
       s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
         '%'+$1.unpack('H2'*$1.size).join('%').upcase
-      }.tr(' ', '+') 
+      }.tr(' ', '+')
     end
     
     # creates and returns a url as a string
@@ -112,7 +113,7 @@ module RSolr::HTTPClient
     # "string_query" is an extra query string that will be appended to the 
     # result of "url" and "params".
     def build_url(url='', params={}, string_query='')
-      queries = [string_query, hash_to_params(params)]
+      queries = [string_query, hash_to_query(params)]
       queries.delete_if{|i| i.to_s.empty?}
       url += "?#{queries.join('&')}" unless queries.empty?
       url
@@ -124,38 +125,23 @@ module RSolr::HTTPClient
     def build_param(k,v)
       "#{escape(k)}=#{escape(v)}"
     end
-
+    
     #
     # converts hash into URL query string, keys get an alpha sort
     # if a value is an array, the array values get mapped to the same key:
-    #   hash_to_params(:q=>'blah', :fq=>['blah', 'blah'], :facet=>{:field=>['location_facet', 'format_facet']})
+    #   hash_to_query(:q=>'blah', :fq=>['blah', 'blah'], :facet=>{:field=>['location_facet', 'format_facet']})
     # returns:
     #   ?q=blah&fq=blah&fq=blah&facet.field=location_facet&facet.field=format.facet
     #
     # if a value is empty/nil etc., the key is not added
-    def hash_to_params(params)
-      return unless params.is_a?(Hash)
-      # copy params and convert keys to strings
-      params = params.inject({}){|acc,(k,v)| acc.merge(k.to_s => v) }
-      # get sorted keys
-      params.keys.sort.inject([]) do |acc,k|
-        v = params[k]
-        if v.is_a?(Array)
-          acc << v.reject{|i|i.to_s.empty?}.collect{|vv|build_param(k, vv)}
-        elsif v.is_a?(Hash)
-          # NOT USED
-          # creates dot based params like:
-          # hash_to_params(:facet=>{:field=>['one', 'two']}) == facet.field=one&facet.field=two
-          # TODO: should this go into a non-solr based param builder?
-          #   - dotted syntax is special to solr only
-          #v.each_pair do |field,field_value|
-          #  acc.push(hash_to_params({"#{k}.#{field}"=>field_value}))
-          #end
-        elsif ! v.to_s.empty?
-          acc.push(build_param(k, v))
+    def hash_to_query(params)
+      params.map { |k, v|
+        if v.class == Array
+          hash_to_query(v.map { |x| [k, x] })
+        else
+          build_param k, v
         end
-        acc
-      end.join('&')
+      }.join("&")
     end
     
   end

data/lib/rsolr/message/{builders → adapter}/builder.rb

@@ -1,6 +1,6 @@
 require 'builder'
 
-class RSolr::Message::Builders::Builder
+class RSolr::Message::Adapter::Builder
   
   # shortcut method -> xml = RSolr::Message.xml
   def xml

data/lib/rsolr/message/{builders → adapter}/libxml.rb

@@ -1,6 +1,6 @@
 require 'libxml'
 
-class RSolr::Message::Builders::Libxml
+class RSolr::Message::Adapter::Libxml
   
   def add(documents, attributes = {})
     add_node = new_node('add', attributes)

data/lib/rsolr/message.rb

@@ -1,8 +1,11 @@
 # The Solr::Message class is the XML generation module for sending updates to Solr.
 
-class RSolr::Message
+module RSolr::Message
   
-  autoload :Builders, 'rsolr/message/builders'
+  module Adapter
+    autoload :Builder, 'rsolr/message/adapter/builder'
+    autoload :Libxml, 'rsolr/message/adapter/libxml'
+  end
   
   # A class that represents a "doc" xml element for a solr update
   class Document
@@ -74,11 +77,15 @@ class RSolr::Message
     
   end
   
-  class << self
-    attr_writer :builder
-
-    def builder
-      @builder ||= Builders::Builder.new
+  class Builder
+    
+    attr_writer :adapter
+    
+    # b = Builder.new
+    # b.adapter = RSolr::Message::Adapter::LibXML.new
+    # b.optimize == '<optimize/>'
+    def adapter
+      @adapter ||= RSolr::Message::Adapter::Builder.new
     end
     
     # generates "add" xml for updating solr
@@ -113,34 +120,34 @@ class RSolr::Message
         yield doc if block_given?
         doc
       end
-      builder.add(documents, add_attrs)
+      adapter.add(documents, add_attrs)
     end
     
     # generates a <commit/> message
     def commit(opts={})
-      builder.commit(opts)
+      adapter.commit(opts)
     end
     
     # generates a <optimize/> message
     def optimize(opts={})
-      builder.optimize(opts)
+      adapter.optimize(opts)
     end
     
     # generates a <rollback/> message
     def rollback
-      builder.rollback
+      adapter.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)
-      builder.delete_by_id(ids)
+      adapter.delete_by_id(ids)
     end
     
     # generates a <delete><query>ID</query></delete> message
     # "queries" can be a single value or an array of values
     def delete_by_query(queries)
-      builder.delete_by_query(queries)
+      adapter.delete_by_query(queries)
     end
   end
 end

data/lib/rsolr.rb

@@ -1,36 +1,43 @@
 # add this directory to the load path if it hasn't already been added
 
-$: << File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__))
+require 'rubygems'
 
-unless Array.respond_to?(:extract_options!)
-  class Array
-    def extract_options!
-      last.is_a?(::Hash) ? pop : {}
-    end
-  end
-end
+$: << File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__))
 
 module RSolr
   
-  VERSION = '0.8.8'
+  VERSION = '0.9.5'
   
   autoload :Message, 'rsolr/message'
   autoload :Connection, 'rsolr/connection'
-  autoload :Adapter, 'rsolr/adapter'
   autoload :HTTPClient, 'rsolr/http_client'
   
-  # factory for creating connections
-  # "options" is a hash that gets used by the Connection
-  # object AND the adapter object.
-  def self.connect(options={})
-    adapter_name = options[:adapter] ||= :http
-    types = {
-      :http=>'HTTP',
-      :direct=>'Direct'
-    }
-    adapter_class = RSolr::Adapter.const_get(types[adapter_name])
-    adapter = adapter_class.new(options)
-    RSolr::Connection.new(adapter, options)
+  # Factory for creating connections.
+  # 2 modes of argument operations:
+  #   1. first argument is solr-adapter type, second arg is options hash for solr-adapter instance.
+  #   2. options hash for solr-adapter only (no adapter type as first arg)
+  #
+  # Examples:
+  # # default http connection
+  # RSolr.connect
+  # # http connection with custom url
+  # RSolr.connect :url=>'http://solr.web100.org'
+  # # direct connection
+  # RSolr.connect :direct, :home_dir=>'solr', :dist_dir=>'solr-nightly'
+  def self.connect(*args)
+    type = args.first.is_a?(Symbol) ? args.shift : :http
+    opts = args
+    type_class = case type
+      when :http,nil
+        'HTTP'
+      when :direct
+        'Direct'
+      else
+        raise "Invalid connection type: #{type} - use :http, :direct or leave nil for :http/default"
+      end
+    adapter_class = RSolr::Connection::Adapter.const_get(type_class)
+    adapter = adapter_class.new(*opts)
+    RSolr::Connection::Base.new(adapter)
   end
   
   # A module that contains string related methods
@@ -48,7 +55,7 @@ module RSolr
   # send the escape method into the Connection class ->
   # solr = RSolr.connect
   # solr.escape('asdf')
-  RSolr::Connection.send(:include, Char)
+  RSolr::Connection::Base.send(:include, Char)
   
   # bring escape into this module (RSolr) -> RSolr.escape('asdf')
   extend Char

data/rsolr.gemspec

@@ -1,28 +1,27 @@
 Gem::Specification.new do |s|
+  
   s.name = "rsolr"
-  s.version = "0.9.1"
-  s.date = "2009-07-22"
+  s.version = "0.9.5"
+  s.date = "2009-09-05"
   s.summary = "A Ruby client for Apache Solr"
   s.email = "goodieboy@gmail.com"
   s.homepage = "http://github.com/mwmitchell/rsolr"
   s.description = "RSolr is a Ruby gem for working with Apache Solr!"
   s.has_rdoc = true
   s.authors = ["Matt Mitchell"]
+  
   s.files = [
     "examples/http.rb",
     "examples/direct.rb",
     "lib/rsolr.rb",
-    "lib/rsolr/adapter/direct.rb",
-    "lib/rsolr/adapter/http.rb",
-    "lib/rsolr/adapter.rb",
+    "lib/rsolr/connection/adapter/direct.rb",
+    "lib/rsolr/connection/adapter/http.rb",
     "lib/rsolr/connection.rb",
     "lib/rsolr/http_client/adapter/curb.rb",
     "lib/rsolr/http_client/adapter/net_http.rb",
-    "lib/rsolr/http_client/adapter.rb",
     "lib/rsolr/http_client.rb",
-    "lib/rsolr/message/builders/builder.rb",
-    "lib/rsolr/message/builders/libxml.rb",
-    "lib/rsolr/message/builders.rb",
+    "lib/rsolr/message/adapter/builder.rb",
+    "lib/rsolr/message/adapter/libxml.rb",
     "lib/rsolr/message.rb",
     "LICENSE",
     "Rakefile",

data/test/connection/direct_test.rb

@@ -14,7 +14,7 @@ if defined?(JRUBY_VERSION)
       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(:direct, :home_dir=>@home, :dist_dir=>@dist)
       @solr.delete_by_query('*:*')
       @solr.commit
     end
@@ -26,8 +26,8 @@ if defined?(JRUBY_VERSION)
     def test_new_connection_with_existing_core
       Dir["#{@dist}/dist/*.jar"].each { |p| require p }
       dc = org.apache.solr.servlet.DirectSolrConnection.new(@home, "#{@home}/data", nil)
-      adapter = RSolr::Adapter::Direct.new dc
-      s = RSolr::Connection.new(adapter)
+      adapter = RSolr::Connection::Adapter::Direct.new dc
+      s = RSolr::Connection::Base.new(adapter)
       assert_equal Hash, s.request('/admin/ping').class
       adapter.close
     end

data/test/connection/http_test.rb

@@ -8,7 +8,7 @@ unless defined?(JRUBY_VERSION)
     include ConnectionTestMethods
   
     def setup
-      @solr = RSolr.connect
+      @solr = RSolr.connect(:http)
       @solr.delete_by_query('*:*')
       @solr.commit
     end

data/test/connection/test_methods.rb

@@ -86,7 +86,7 @@ module ConnectionTestMethods
   end
   
   def test_admin_luke_index_info
-    response = @solr.send_request('/admin/luke', :numTerms=>0)
+    response = @solr.request('/admin/luke', :numTerms=>0)
     assert response.is_a?(Hash)
     # make sure the ? methods are true/false
     assert [true, false].include?(response['index']['current'])

data/test/http_client/curb_test.rb

@@ -8,7 +8,7 @@ unless defined?(JRUBY_VERSION)
   class CurbTest < RSolrBaseTest
   
     def setup
-      @c ||= RSolr::HTTPClient::Connector.new(:curb).connect(URL)
+      @c ||= RSolr::HTTPClient::connect(:curb, :url=>URL)
     end
   
     include HTTPClientTestMethods

data/test/http_client/net_http_test.rb

@@ -4,7 +4,7 @@ require 'http_client/test_methods'
 class NetHTTPTest < RSolrBaseTest
   
   def setup
-    @c ||= RSolr::HTTPClient::Connector.new(:net_http).connect(URL)
+    @c ||= RSolr::HTTPClient::connect(:url=>URL)
   end
   
   include HTTPClientTestMethods

data/test/http_client/test_methods.rb

@@ -4,7 +4,7 @@ module HTTPClientTestMethods
   
   def test_raise_unknown_adapter
     assert_raise RSolr::HTTPClient::UnkownAdapterError do
-      c = RSolr::HTTPClient::Connector.new(:blah).connect(URL)
+      c = RSolr::HTTPClient.connect(:blah, URL)
     end
   end
   

data/test/http_client/util_test.rb

@@ -11,11 +11,15 @@ class HTTPUtilTest < RSolrBaseTest
   end
   
   def test_build_url
-    m = @c.method(:build_url)
-    assert_equal '/something', m.call('/something')
-    assert_equal '/something?q=Testing', m.call('/something', :q=>'Testing')
-    assert_equal '/something?array=1&array=2&array=3', m.call('/something', :array=>[1, 2, 3])
-    assert_equal '/something?array=1&array=2&array=3&q=A', m.call('/something', :q=>'A', :array=>[1, 2, 3])
+    assert_equal '/something', @c.build_url('/something')
+    assert_equal '/something?q=Testing', @c.build_url('/something', :q=>'Testing')
+    assert_equal '/something?array=1&array=2&array=3', @c.build_url('/something', :array=>[1, 2, 3])
+    result = @c.build_url('/something', :q=>'A', :array=>[1, 2, 3])
+    assert result=~/^\/something\?/
+    assert result=~/q=A/
+    assert result=~/array=1/
+    assert result=~/array=2/
+    assert result=~/array=3/
   end
   
   def test_escape
@@ -26,15 +30,54 @@ class HTTPUtilTest < RSolrBaseTest
     assert_equal '%3A', @c.escape(':')
   end
   
-  def test_hash_to_params
+  def test_hash_to_query
     my_params = {
-      :z=>'should be last',
+      :z=>'should be whatever',
       :q=>'test',
       :d=>[1, 2, 3, 4],
       :b=>:zxcv,
       :x=>['!', '*', nil]
     }
-    assert_equal 'b=zxcv&d=1&d=2&d=3&d=4&q=test&x=%21&x=%2A&z=should+be+last', @c.hash_to_params(my_params)
+    result = @c.hash_to_query(my_params)
+    assert result=~/z=should\+be\+whatever/
+    assert result=~/q=test/
+    assert result=~/d=1/
+    assert result=~/d=2/
+    assert result=~/d=3/
+    assert result=~/d=4/
+    assert result=~/b=zxcv/
+    assert result=~/x=%21/
+    assert result=~/x=*/
+    assert result=~/x=&?/
+  end
+  
+  def test_ampersand_within_query_value
+    my_params = {
+      "fq" => "building_facet:\"Green (Humanities & Social Sciences)\""
+    }
+    expected = 'fq=building_facet%3A%22Green+%28Humanities+%26+Social+Sciences%29%22'
+    assert_equal expected, @c.hash_to_query(my_params)
+  end
+  
+  def test_brackets
+    assert_equal '%7B', @c.escape('{')
+    assert_equal '%7D', @c.escape('}')
+  end
+  
+  def test_exclamation
+    assert_equal '%21', @c.escape('!')
+  end
+  
+  def test_complex_solr_query1
+    my_params = {'fq' => '{!raw f=field_name}crazy+\"field+value'}
+    expected = 'fq=%7B%21raw+f%3Dfield_name%7Dcrazy%2B%5C%22field%2Bvalue'
+    assert_equal expected, @c.hash_to_query(my_params)
+  end
+  
+  def test_complex_solr_query2
+    my_params = {'q' => '+popularity:[10 TO *] +section:0'}
+    expected = 'q=%2Bpopularity%3A%5B10+TO+%2A%5D+%2Bsection%3A0'
+    assert_equal expected, @c.hash_to_query(my_params)
   end
   
 end