rsolr 0.12.0 → 0.12.1

data/README.rdoc

@@ -1,21 +1,12 @@
 =RSolr
 
-A Ruby client for Apache Solr. RSolr has been developed to be simple and extendable. It features transparent JRuby DirectSolrConnection support and a simple Hash-in, Hash-out architecture.
+A simple, extensible Ruby client for Apache Solr.
 
 == Installation:
   gem sources -a http://gemcutter.org
   sudo gem install rsolr
 
-==Related Resources & Projects
-* {Solr}[http://lucene.apache.org/solr/]
-* {RSolr Google Group}[http://groups.google.com/group/rsolr]
-* {RSolr::Ext}[http://github.com/mwmitchell/rsolr-ext] -- an extension kit for RSolr
-* {Sunspot}[http://github.com/outoftime/sunspot] -- an awesome Solr DSL, built with RSolr
-* {Blacklight}[http://blacklightopac.org] -- a next generation Library OPAC, built with RSolr
-* {solr-ruby}[http://wiki.apache.org/solr/solr-ruby] -- the original Solr Ruby Gem
-* {java_bin}[http://github.com/kennyj/java_bin] -- Provides javabin/binary parsing for Ruby
-
-== Simple usage:
+== Example:
   require 'rubygems'
   require 'rsolr'
   solr = RSolr.connect :url=>'http://solrserver.com'
@@ -37,7 +28,7 @@ Use the #select method to send requests to the /select handler:
     :rows=>10
   })
 
-The params sent into the method are sent to Solr as-is. The one exception is if a value is an array. When an array is used, multiple parameters are generated for the Solr query. Example:
+The params sent into the method are sent to Solr as-is. The one exception is if a value is an array. When an array is used, multiple parameters *with the same name* are generated for the Solr query. Example:
   
   solr.select :q=>'roses', :fq=>['red', 'violet']
 
@@ -48,12 +39,12 @@ The above statement generates this Solr query:
 Use the #request method for a custom request handler path:
   response = solr.request '/documents', :q=>'test'
 
-A shortcut for the above example:
+A shortcut for the above example use a method call instead:
   response = solr.documents :q=>'test'
 
 
 == Updating Solr
-Updating can be done using native Ruby structures. Hashes are used for single documents and arrays are used for a collection of documents (hashes). These structures get turned into simple XML "messages". Raw XML strings can also be used.
+Updating uses native Ruby structures. Hashes are used for single documents and arrays are used for a collection of documents (hashes). These structures get turned into simple XML "messages". Raw XML strings can also be used.
 
 Raw XML via  #update
   solr.update '</commit>'
@@ -110,4 +101,29 @@ You can access the original request context (path, params, url etc.) by calling
   response.raw[:body]
   response.raw[:url]
 
-The raw is a hash that contains the generated params, url, path, post data, headers etc., very useful for debugging and testing.
+The raw is a hash that contains the generated params, url, path, post data, headers etc., very useful for debugging and testing.
+
+==Related Resources & Projects
+* {RSolr Google Group}[http://groups.google.com/group/rsolr] -- The RSolr discussion group
+* {rsolr-ext}[http://github.com/mwmitchell/rsolr-ext] -- An extension kit for RSolr
+* {rsolr-direct}[http://github.com/mwmitchell/rsolr-direct] -- JRuby direct connection for RSolr
+* {SunSpot}[http://github.com/outoftime/sunspot] -- An awesome Solr DSL, built with RSolr
+* {Blacklight}[http://blacklightopac.org] -- A "next generation" Library OPAC, built with RSolr
+* {java_bin}[http://github.com/kennyj/java_bin] -- Provides javabin/binary parsing for RSolr
+* {Solr}[http://lucene.apache.org/solr/] -- The Apache Solr project
+* {solr-ruby}[http://wiki.apache.org/solr/solr-ruby] -- The original Solr Ruby Gem!
+
+== Note on Patches/Pull Requests
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+==Contributors
+* mperham
+* Mat Brown
+* shairontoledo
+* Matthew Rudy
+* Fouad Mardini

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+ENV['RUBYOPT'] = '-W1'
+ 
+task :environment do
+  require File.dirname(__FILE__) + '/lib/rsolr'
+end
+ 
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+task :default => ['spec:api']

data/VERSION

@@ -0,0 +1 @@
+0.12.1

data/lib/rsolr.rb

@@ -4,16 +4,26 @@ $:.unshift File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__))
 
 module RSolr
   
-  VERSION = '0.12.0'
+  def self.version
+    @version ||= File.read(File.join(File.dirname(__FILE__), '..', 'VERSION'))
+  end
+  
+  VERSION = self.version
   
   autoload :Message, 'rsolr/message'
   autoload :Client, 'rsolr/client'
   autoload :Connection, 'rsolr/connection'
   
-  def self.connect opts={}
-    Client.new Connection::NetHttp.new(opts)
+  module Connectable
+    
+    def connect opts={}
+      Client.new Connection::NetHttp.new(opts)
+    end
+    
   end
   
+  extend Connectable
+  
   # A module that contains string related methods
   module Char
     

data/spec/api/client_spec.rb

@@ -0,0 +1,93 @@
+describe RSolr::Client do
+  
+  let(:client){ RSolr::Client.new('') }
+  
+  context :method_missing do
+    
+    it 'a non-existent method should be forwarded to #method_missing and then to #request' do
+      client.should_receive(:request).
+        with('/music', :q=>'Coltrane')
+      client.music :q=>'Coltrane'
+    end
+    
+  end
+  
+  context :update do
+    
+    it 'should forward /update to #request("/update")' do
+      client.should_receive(:request)#.
+      #  with('/update', {:wt=>:ruby}, "my xml message")
+      client.update "my xml message"
+    end
+    
+    it 'should forward #add calls to #update' do
+      client.should_receive(:update) {|value,params|
+        value.should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?><add><doc><field name=\"id\">1</field></doc></add>"
+      }
+      client.add(:id=>1)
+    end
+    
+    it 'should forward #commit calls to #update' do
+      client.should_receive(:update).
+        with("<?xml version=\"1.0\" encoding=\"UTF-8\"?><commit/>")
+      client.commit
+    end
+    
+    it 'should forward #optimize calls to #update' do
+      client.should_receive(:update).
+        with("<?xml version=\"1.0\" encoding=\"UTF-8\"?><optimize/>")
+      client.optimize
+    end
+    
+    it 'should forward #rollback calls to #update' do
+      client.should_receive(:update).
+        with("<?xml version=\"1.0\" encoding=\"UTF-8\"?><rollback/>")
+      client.rollback
+    end
+    
+    it 'should forward #delete_by_id calls to #update' do
+      client.should_receive(:update).
+        with("<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><id>1</id></delete>")
+      client.delete_by_id 1
+    end
+    
+    it 'should forward #delete_by_query calls to #update' do
+      client.should_receive(:update).
+        with("<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><query>blah</query></delete>")
+      client.delete_by_query 'blah'
+    end
+    
+  end
+  
+  context :request do
+    
+    it 'should forward #request calls to the connection' do
+      client.connection.should_receive(:request).
+        with('/music', :q=>'Coltrane', :wt=>:ruby).
+          # empty params so that Client doesn't try to evalulate to Ruby;
+          #   -- this happens if the :wt equal :ruby
+          and_return(:params=>{})
+      client.request '/music', :q=>'Coltrane'
+    end
+    
+  end
+  
+  context :adapt_response do
+    
+    it 'should not try to evaluate ruby when the :qt is not :ruby' do
+      body = '{:time=>"NOW"}'
+      result = client.send(:adapt_response, {:body=>body, :params=>{}})
+      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.send(:adapt_response, {:body=>body, :params=>{:wt=>:ruby}})
+      result.should be_a(Hash)
+      result.should == {:time=>"NOW"}
+    end
+    
+  end
+  
+end

data/spec/api/connection/net_http_spec.rb

@@ -0,0 +1,148 @@
+describe RSolr::Connection::NetHttp do
+  
+  # calls #let to set "net_http" as method accessor
+  module NetHttpHelper
+    def self.included base
+      base.let(:net_http){ RSolr::Connection::NetHttp.new }
+    end
+  end
+  
+  context '#request' do
+    
+    include NetHttpHelper
+    
+    it 'should forward simple, non-data calls to #get' do
+      net_http.should_receive(:get).
+        with('/select', :q=>'a').
+          and_return({:status_code=>200})
+      net_http.request('/select', :q=>'a') 
+    end
+    
+    it 'should forward :method=>:post calls to #post with a special header' do
+      net_http.should_receive(:post).
+        with('/select', 'q=a', {}, {"Content-Type"=>"application/x-www-form-urlencoded"}).
+          and_return({:status_code=>200})
+      net_http.request('/select', {:q=>'a'}, :method=>:post)
+    end
+    
+    it 'should forward data calls to #post' do
+      net_http.should_receive(:post).
+        with("/update", "<optimize/>", {}, {"Content-Type"=>"text/xml; charset=utf-8"}).
+          and_return({:status_code=>200})
+      net_http.request('/update', {}, '<optimize/>')
+    end
+    
+  end
+  
+  context 'connection' do
+    
+    include NetHttpHelper
+    
+    it 'will create an instance of Net::HTTP' do
+      net_http.send(:connection).should be_a(Net::HTTP)
+    end
+    
+  end
+  
+  context 'get/post' do
+    
+    include NetHttpHelper
+    
+    it 'should make a GET request as expected' do
+      net_http_response = mock('net_http_response')
+      net_http_response.should_receive(:code).
+        and_return(200)
+      net_http_response.should_receive(:body).
+        and_return('The Response')
+      net_http_response.should_receive(:message).
+        and_return('OK')
+      c = net_http.send(:connection)
+      c.should_receive(:get).
+        with('/solr/select?q=1').
+          and_return(net_http_response)
+      
+      context = net_http.send(:get, '/select', :q=>1)
+      context.should be_a(Hash)
+      
+      keys = [:data, :body, :status_code, :path, :url, :headers, :params, :message]
+      context.keys.size.should == keys.size
+      context.keys.all?{|key| keys.include?(key) }.should == true
+      
+      context[:data].should == nil
+      context[:body].should == 'The Response'
+      context[:status_code].should == 200
+      context[:path].should == '/select'
+      context[:url].should == 'http://127.0.0.1:8983/solr/select?q=1'
+      context[:headers].should == {}
+      context[:params].should == {:q=>1}
+      context[:message].should == 'OK'
+    end
+    
+    it 'should make a POST request as expected' do
+      net_http_response = mock('net_http_response')
+      net_http_response.should_receive(:code).
+        and_return(200)
+      net_http_response.should_receive(:body).
+        and_return('The Response')
+      net_http_response.should_receive(:message).
+        and_return('OK')
+      c = net_http.send(:connection)
+      c.should_receive(:post).
+        with('/solr/update', '<rollback/>', {}).
+          and_return(net_http_response)
+      context = net_http.send(:post, '/update', '<rollback/>')
+      context.should be_a(Hash)
+      
+      keys = [:data, :body, :status_code, :path, :url, :headers, :params, :message]
+      context.keys.size.should == keys.size
+      context.keys.all?{|key| keys.include?(key) }.should == true
+      
+      context[:data].should == '<rollback/>'
+      context[:body].should == 'The Response'
+      context[:status_code].should == 200
+      context[:path].should == '/update'
+      context[:url].should == 'http://127.0.0.1:8983/solr/update'
+      context[:headers].should == {}
+      context[:params].should == {}
+      context[:message].should == 'OK'
+    end
+    
+  end
+  
+  context 'build_url' do
+    
+    include NetHttpHelper
+    
+    it 'should incude the base path to solr' do
+      result = net_http.send(:build_url, '/select', :q=>'*:*', :check=>'{!}')
+      # this is a non-ordered hash work around,
+      #   -- the order of the parameters in the resulting url will be different depending on the ruby distribution/platform
+      # yuk.
+      begin
+        result.should == '/solr/select?check=%7B%21%7D&q=%2A%3A%2A'
+      rescue
+        result.should == '/solr/select?q=%2A%3A%2A&check=%7B%21%7D'
+      end
+    end
+    
+  end
+  
+  context 'encode_utf8' do
+    
+    include NetHttpHelper
+    
+    it 'should encode response body as utf-8' do
+      string = 'testing'
+      if RUBY_VERSION =~ /1\.9/
+        string.encoding.should == Encoding::US_ASCII
+        encoded_string = net_http.send(:encode_utf8, string)
+        string.encoding.should == Encoding::UTF_8
+      else
+        encoded_string = net_http.send(:encode_utf8, string)
+        encoded_string.should == string
+      end
+    end
+    
+  end
+  
+end

data/spec/api/connection/requestable_spec.rb

@@ -0,0 +1,92 @@
+describe RSolr::Connection::Requestable do
+  
+  # calls #let to set "net_http" as method accessor
+  class R
+    include RSolr::Connection::Requestable
+  end
+  
+  module RequestableHelper
+    def self.included base
+      base.let(:requestable){R.new}
+    end
+  end
+  
+  context 'new' do
+    
+    include RequestableHelper
+    
+    it 'should define an intialize method that accepts a hash argument' do
+      lambda{R.new({})}.should_not raise_error 
+    end
+  
+    it 'should have an #opts attribute after creation' do
+      requestable.should respond_to(:opts)
+    end
+  
+    it 'should have an #uri attribute after creation' do
+      requestable.should respond_to(:uri)
+    end
+    
+  end
+  
+  context 'opts and uri' do
+    
+    it 'should allow setting the opts' do
+      opts = {:url=>'blah'}
+      r = R.new(opts)
+      r.opts.should == opts
+    end
+    
+    it 'should parser the url option into a URI object' do
+      opts = {:url => 'http://xyz:1010/solr'}
+      r = R.new(opts)
+      r.uri.should be_a(URI)
+      r.uri.host.should == 'xyz'
+    end
+    
+  end
+  
+  context :request do
+    
+    include RequestableHelper
+    
+    it 'should send a get to itself' do
+      expected_response = {:status_code => 200}
+      requestable.should_receive(:get).
+        with('/blah', {:id=>1}).
+        and_return(expected_response)
+      requestable.request('/blah', :id=>1).should == expected_response
+    end
+    
+    it 'should raise an error if the status_code is not 200' do
+      expected_response = {:status_code => 503}
+      requestable.should_receive(:get).
+        with('/blah', {:id=>1}).
+        and_return(expected_response)
+      lambda{
+        requestable.request('/blah', :id=>1)
+      }.should raise_error
+    end
+    
+    it 'should send a post to itself if data is supplied' do
+      expected_response = {:status_code => 200}
+      my_data = "<commit/>"
+      post_headers = {"Content-Type"=>"text/xml; charset=utf-8"}
+      requestable.should_receive(:post).
+        with('/blah', my_data, {:id=>1}, post_headers).
+        and_return(expected_response)
+      requestable.request('/blah', {:id=>1}, my_data).should == expected_response
+    end
+    
+    it 'should send a post to itself when :method=>:post is set even if no POST data is supplied' do
+      expected_response = {:status_code => 200}
+      post_headers = {"Content-Type"=>"application/x-www-form-urlencoded"}
+      requestable.should_receive(:post).
+        with('/blah', "", {}, post_headers).
+        and_return(expected_response)
+      requestable.request('/blah', {}, :method => :post).should == expected_response
+    end
+    
+  end
+  
+end

data/spec/api/connection/utils_spec.rb

@@ -0,0 +1,84 @@
+describe RSolr::Connection::Utils do
+  
+  # calls #let to set "utils" as a method accessor
+  module UtilsHelper
+    def self.included base
+      base.let(:utils){ nil.extend RSolr::Connection::Utils }
+    end
+  end
+  
+  context 'hash_to_query method' do
+    
+    include UtilsHelper
+    
+    it "should build a query string from a hash, converting arrays to multi-params and removing nils/emptys" do
+      test_params = {
+        :z=>'should be whatever',
+        :q=>'test',
+        :item => [1, 2, 3, nil],
+        :nil=>nil
+      }
+      result = utils.hash_to_query(test_params)
+      [/z=should\+be\+whatever/, /q=test/, /item=1/, /item=2/, /item=3/].each do |regexp|
+        result.should match(regexp)
+      end
+      result.split('&').size.should == 5
+    end
+    
+    it 'should escape &' do
+      utils.hash_to_query(:fq => "&").should == 'fq=%26'
+    end
+    
+    it 'should convert spaces to +' do
+      utils.hash_to_query(:fq => "me and you").should == 'fq=me+and+you'
+    end
+    
+    it 'should escape comlex queries, part 1' do
+      my_params = {'fq' => '{!raw f=field_name}crazy+\"field+value'}
+      expected = 'fq=%7B%21raw+f%3Dfield_name%7Dcrazy%2B%5C%22field%2Bvalue'
+      utils.hash_to_query(my_params).should == expected
+    end
+    
+    it 'should escape comlex queries, part 2' do
+      my_params = {'q' => '+popularity:[10 TO *] +section:0'}
+      expected = 'q=%2Bpopularity%3A%5B10+TO+%2A%5D+%2Bsection%3A0'
+      utils.hash_to_query(my_params).should == expected
+    end
+    
+  end
+  
+  context 'escape method' do
+    
+    include UtilsHelper
+    
+    it 'should escape properly' do
+      utils.escape('+').should == '%2B'
+      utils.escape('This is a test').should == 'This+is+a+test'
+      utils.escape('<>/\\').should == '%3C%3E%2F%5C'
+      utils.escape('"').should == '%22'
+      utils.escape(':').should == '%3A'
+    end
+    
+    it 'should escape brackets' do
+      utils.escape('{').should == '%7B'
+      utils.escape('}').should == '%7D'
+    end
+    
+    it 'should escape exclamation marks!' do
+      utils.escape('!').should == '%21'
+    end
+    
+  end
+  
+  context 'build_url method' do
+    
+    include UtilsHelper
+    
+    it 'should build correctly' do
+      url = utils.build_url '/solr/select', {:q=>'test'}, 'blah=blah'
+      url.should == '/solr/select?blah=blah&q=test'
+    end
+    
+  end
+  
+end

data/spec/api/message_spec.rb

@@ -0,0 +1,120 @@
+describe RSolr::Message do
+  
+  let(:generator){ RSolr::Message::Generator.new }
+  
+  # call all of the simple methods...
+  # make sure the xml string is valid
+  # ensure the class is actually Solr::XML
+  [:optimize, :rollback, :commit].each do |meth|
+    it "#{meth} should generator xml" do
+      result = generator.send(meth)
+      result.should match(Regexp.escape("<#{meth}/>"))
+    end
+  end
+  
+  context :add do
+    
+    it 'should yield a Message::Document object when #add is called with a block' do
+      documents = [{:id=>1, :name=>'sam', :cat=>['cat 1', 'cat 2']}]
+      add_attrs = {:boost=>200.00}
+      result = generator.add(documents, add_attrs) do |doc|
+        doc.field_by_name(:name).attrs[:boost] = 10
+        doc.fields.size.should == 4
+        doc.fields_by_name(:cat).size.should == 2
+      end
+      result.should match(%r(name="cat">cat 1</field>))
+      result.should match(%r(name="cat">cat 2</field>))
+      result.should match(%r(<add boost="200.0">))
+      result.should match(%r(boost="10"))
+      result.should match(%r(<field name="id">1</field>))
+    end
+    
+    # add a single hash ("doc")
+    it 'should create an add from a hash' do
+      data = {
+        :id=>1,
+        :name=>'matt'
+      }
+      result = generator.add(data)
+      result.should match(/<field name="name">matt<\/field>/)
+      result.should match(/<field name="id">1<\/field>/)
+    end
+
+    # add an array of hashes
+    it 'should create many adds from an array of hashes' do
+      data = [
+        {
+          :id=>1,
+          :name=>'matt'
+        },
+        {
+          :id=>2,
+          :name=>'sam'
+        }
+      ]
+      message = generator.add(data)
+      expected = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><add><doc><field name=\"id\">1</field><field name=\"name\">matt</field></doc><doc><field name=\"id\">2</field><field name=\"name\">sam</field></doc></add>"
+      message.should match(/<field name="name">matt<\/field>/)
+      message.should match(/<field name="name">sam<\/field>/)
+    end
+
+    # multiValue field support test, thanks to Fouad Mardini!
+    it 'should create multiple fields from array values' do
+      data = {
+        :id   => 1,
+        :name => ['matt1', 'matt2']
+      }
+      result = generator.add(data)
+      result.should match(/<field name="name">matt1<\/field>/)
+      result.should match(/<field name="name">matt2<\/field>/)
+    end
+
+    it 'should create an add from a single Message::Document' do
+      document = RSolr::Message::Document.new
+      document.add_field('id', 1)
+      document.add_field('name', 'matt', :boost => 2.0)
+      result = generator.add(document)
+      result.should match(Regexp.escape('<?xml version="1.0" encoding="UTF-8"?>'))
+      result.should match(/<field name="id">1<\/field>/)
+      result.should match Regexp.escape('boost="2.0"')
+      result.should match Regexp.escape('name="name"')
+      result.should match Regexp.escape('matt</field>')
+    end
+    
+    it 'should create adds from multiple Message::Documents' do
+      documents = (1..2).map do |i|
+        doc = RSolr::Message::Document.new
+        doc.add_field('id', i)
+        doc.add_field('name', "matt#{i}")
+        doc
+      end
+      result = generator.add(documents)
+      result.should match(/<field name="name">matt1<\/field>/)
+      result.should match(/<field name="name">matt2<\/field>/)
+    end
+    
+  end
+  
+  context :delete_by_id do
+    
+    it 'should create a doc id delete' do
+      generator.delete_by_id(10).should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><id>10</id></delete>"
+    end
+    
+    it 'should create many doc id deletes' do
+      generator.delete_by_id([1, 2, 3]).should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><id>1</id><id>2</id><id>3</id></delete>"
+    end
+    
+  end
+  
+  context :delete_by_query do
+    it 'should create a query delete' do
+      generator.delete_by_query('status:"LOST"').should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><query>status:\"LOST\"</query></delete>"
+    end
+    
+    it 'should create many query deletes' do
+      generator.delete_by_query(['status:"LOST"', 'quantity:0']).should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><query>status:\"LOST\"</query><query>quantity:0</query></delete>"
+    end
+  end
+  
+end

data/spec/api/rsolr_spec.rb

@@ -0,0 +1,29 @@
+describe RSolr do
+  
+  context :connect do
+    
+    it 'does not care about valid/live URLs yet' do
+      lambda{RSolr.connect :url=>'http://blah.blah.blah:666/solr'}.should_not raise_error
+    end
+    
+    it 'should create an instance of RSolr::Connection::NetHttp as the #connection' do
+      expected_class = RSolr::Connection::NetHttp
+      RSolr.connect.connection.should be_a(expected_class)
+      RSolr.connect(:url=>'blah').connection.should be_a(expected_class)
+    end
+    
+  end
+  
+  context :escape do
+  
+    it "should escape properly" do
+      RSolr.escape('Trying & % different "characters" here!').should == "Trying\\ \\&\\ \\%\\ different\\ \\\"characters\\\"\\ here\\!"
+    end
+  
+    it 'should escape' do
+      expected = "http\\:\\/\\/lucene\\.apache\\.org\\/solr"
+      RSolr.escape("http://lucene.apache.org/solr").should == expected
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'rsolr')

data/tasks/rdoc.rake

@@ -0,0 +1,9 @@
+# Rdoc
+desc 'Generate documentation for the rsolr gem.'
+Rake::RDocTask.new(:doc) do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = 'RSolr'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/tasks/spec.rake

@@ -0,0 +1,42 @@
+gem 'rspec'
+
+# $stderr.puts `gem list`
+
+require 'spec'
+require 'spec/rake/spectask'
+
+namespace :spec do
+  
+  namespace :ruby do
+    desc 'run api specs through the Ruby implementations'
+    task :api do
+      puts "Ruby 1.8.7"
+      puts `rake spec:api`
+      puts "Ruby 1.9"
+      puts `rake1.9 spec:api`
+      puts "JRuby"
+      puts `jruby -S rake spec:api`
+    end
+  end
+  
+  desc 'run api specs (mock out Solr dependency)'
+  Spec::Rake::SpecTask.new(:api) do |t|
+    
+    t.spec_files = [File.join('spec', 'spec_helper.rb')]
+    t.spec_files += FileList[File.join('spec', 'api', '**', '*_spec.rb')]
+    
+    t.verbose = true
+    t.spec_opts = ['--color']
+  end
+  
+  desc 'run integration specs'
+  Spec::Rake::SpecTask.new(:integration) do |t|
+    
+    t.spec_files = [File.join('spec', 'spec_helper.rb')]
+    t.spec_files += FileList[File.join('spec', 'integration', '**', '*_spec.rb')]
+    
+    t.verbose = true
+    t.spec_opts = ['--color']
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rsolr
 version: !ruby/object:Gem::Version 
-  version: 0.12.0
+  version: 0.12.1
 platform: ruby
 authors: 
 - Matt Mitchell
@@ -9,11 +9,20 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-03 00:00:00 -05:00
+date: 2010-02-04 00:00:00 -05:00
 default_executable: 
-dependencies: []
-
-description: RSolr is a Ruby gem for working with Apache Solr!
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.1.2
+    version: 
+description: RSolr aims to provide a simple and extensible library for working with Solr
 email: goodieboy@gmail.com
 executables: []
 
@@ -22,29 +31,27 @@ extensions: []
 extra_rdoc_files: 
 - LICENSE
 - README.rdoc
-- CHANGES.txt
 files: 
-- CHANGES.txt
+- LICENSE
+- README.rdoc
+- VERSION
+- lib/rsolr.rb
 - lib/rsolr/client.rb
+- lib/rsolr/connection.rb
 - lib/rsolr/connection/net_http.rb
 - lib/rsolr/connection/requestable.rb
 - lib/rsolr/connection/utils.rb
-- lib/rsolr/connection.rb
+- lib/rsolr/message.rb
 - lib/rsolr/message/document.rb
 - lib/rsolr/message/field.rb
 - lib/rsolr/message/generator.rb
-- lib/rsolr/message.rb
-- lib/rsolr.rb
-- LICENSE
-- README.rdoc
-- rsolr.gemspec
 has_rdoc: true
 homepage: http://github.com/mwmitchell/rsolr
 licenses: []
 
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -66,5 +73,14 @@ rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: A Ruby client for Apache Solr
-test_files: []
-
+test_files: 
+- spec/api/client_spec.rb
+- spec/api/connection/net_http_spec.rb
+- spec/api/connection/requestable_spec.rb
+- spec/api/connection/utils_spec.rb
+- spec/api/message_spec.rb
+- spec/api/rsolr_spec.rb
+- spec/spec_helper.rb
+- Rakefile
+- tasks/spec.rake
+- tasks/rdoc.rake

data/CHANGES.txt

@@ -1,282 +0,0 @@
-0.12.0 - February 3, 2010
-  Removed adapters for xml and connections (these will be provided via separate gems)
-    - default xml generator is Builder
-    - default http connection is Net::Http
-  Removed JRuby/Direct connection stuff (this will be in a new library)
-  Updated specs
-
-0.11.0 - November 17, 2009
-  Removed pagination feature yet again... keeping it in RSolr::Ext until a better API can be thought up.
-  Updated Xout with fixed version - thanks to Mat Brown
-    - bug in escaping consecutive special characters
-    - moved regexp patterns out of loop, into "static" variables instead
-
-0.10.1 - November 13, 2009
-  Same changes as 0.10.0 -- but fixing version number problems
-
-0.10.0 - November 13, 2009
-  Changed RSolr.connect to return Http connection only:
-    RSolr.connect :url=>'xxx'
-  Added RSolr.direct_connect to handle the creation of SolrDirectConnections
-    rsolr = RSolr.direct_connect :home_dir=>''
-    
-    # can also use a block so the connection will get closed automatically:
-    RSolr.direct_connect :home_dir=>'' do |rsolr|
-      # query...
-    end
-  Added paginate method to RSolr::Client
-    - This method requires 2 new arguments: current page and per page:
-        solr.paginate 1, 10, :q=>''
-    - handler paths can be set:
-        solr.paginate 1, 10, '/music', :q=>''
-    - handler paths can also be set by method names:
-        solr.paginate_music 1, 10
-  Removed :dist_dir option from Direct connection options -- you gotta load your own java libs. See examples/direct.rb
-  Updated specs
-
-0.9.7.2 - November 6, 2009
-  fixed gem spec, added client.rb
-
-0.9.7.1 - November 5, 2009
-  added support for multibyte url characters in RSolr::Connection::Utils
-    - this is because Ruby 1.9's String size method is different than 1.8
-
-0.9.7 - October 23, 2009
-  Removed XML message builders - using pure Ruby generator instead
-    - benchmarks show generation speed is a little faster than libxml
-    - minimal xml escaping so binary posting to Solr should no longer be a problem.
-  Changed response.adapter_resonse to response.raw
-  Removed HTTP adapters - sticking with NetHTTP
-  Removed builder dependency in gemspec
-  Removed Adapter and HTTPClient modules
-  Moved HTTPCLient::Util to Connection::Utils
-  Updated all tests
-
-0.9.6 - September 9, 2009
-  Added ability to create direct connections from existing Java::OrgApacheSolrCore::SolrCore
-  Added ability to send queries using POST
-  - solr.request '/select', :q=>'*:*', :method=>:post
-
-0.9.5 - September 4, 2009
-  Removed Array #extract_options!
-  Removed the Connection #send_request method (now #request)
-  Removed the Connection #select method -- still works, but this now ends up calling Connection #method_missing
-  Removed HTTPClient::Connector
-    - HTTPClient now uses a method called #connect (like RSolr.connect)
-    - This method accepts 1 or 2 args, see the #connect method comments
-  Changed the way the HTTP client adapter is set. Now just pass in when connecting:
-    - RSolr.connect(:http, :adapter=>curb, :url=>'http://solr.com')
-  Moved Message::Builders to Message::Adapter
-  Made Connection a module and moved class methods to "Base" class
-  Made HTTPClient a module and moved class methods to "Base" class
-  Removed the "adapter.rb" files -- Adapter modules are defined in the parent module file.
-  Moved Message module/singleton functionality to Message::Builder class
-  XML message adapter API change: no longer a singleton, must instantiate Message::Builder
-  Made RSolr::Connection #message public -- can change the adapter as needed; connection.message.adapter = RSolr::Message::Adapter::LibXML.new
-  More tests for HTTPClient::Util
-  Simplified url/query building in HTTPClient::Util
-  Updated tests accordingly
-
-0.9.1 - July 22, 2009
-  Added LibXml builder support (Thanks to Mat Brown - github.com/outoftime)
-
-0.9.0 - July 17, 2009
-  Added ability to use DirectSolrConnection instance when connecting
-  Loading Java classes using full package name
-
-0.8.9 - June 30, 2009
-  Deprecated hash syntax fix from outoftime/rsolr (Mat Brown)
-
-0.8.8 - May 6, 2009
-  Added method :request to RSolr::Connection
-    - this method is an alias for send_request
-
-0.8.7 - May 6, 2009
-  Added method_missing to RSolr::Connection, which sets the request handler path,
-  based on the method name:
-	# this sends a request like: /music_library?q=>coltrane
-	solr.music_library :q=>'coltrane'
-  Removed the core_ext file, put the Array extension code directly into rsolr.rb
-
-0.8.6 - April 25, 2009
-  Removed the Mash stuff -- which means the response keys from solr are only accessable using String based keys.
-  Use RSolr::Ext if you want more magic.
-
-0.8.5 - April 7, 2009
-  The RSolr::Message #add method now accepts a single Message::Document or an array of Message::Document objects
-  The Message::Document class has a new method: #add_field
-  Tests added for both changes
-  Permissions of files changed to non-executable
-  -- the above changes were made by Mat Brown, thank you Mat!
-  Added CannedSolrResponse module for mocks in the specs... not used yet
-
-0.8.4 - April 3, 2009
-  New test suite using RSpec and mocks coming. Run "rake spec"
-    - added specs for RSolr and RSolr::Connection
-
-0.8.3 - April 3, 2009
-  RSolr::Connection
-    - removed the block functionality of send_request and related methods
-      - this was used to gain access to the raw adapter response
-    - added #adapter_response method to all response objects
-      - this is used to get access to the original adapter response:
-        response = rsolr.select(:q=>'test')
-        response.adapter_response[:status_code]
-
-0.8.2 - March 24, 2009
-  Changed RSolr.connect method to accept one options hash argument
-    - This hash gets passed to the Connection object and the adapter
-  Updated tests, examples and README.rdoc to reflect this change
-  Bumped the version up in gemspec and the RSolr module
-
-0.8.1 - March 12, 2009
-  Added RSolr.escape and RSolr::Connection.new.escape
-    - tests in rsolr_test
-  Added ability to set doc and field attributes when adding documents via Message.add
-
-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
-  Modified Test::Unit::TestCase in test/test_helpers.rb
-
-0.7.0 - February 20, 2009
-  Removed all param mapping behavior, code and tests
-   - this stuff just gunks up rsolr and should be in an extension of some sort
-  Can now specify the request handler in all RSolr::Connection::Base methods as the first argument:
-    - solr.query 'select', :q=>'ipod'
-    - solr.query 'catalog', :q=>'humphry'
-    - solr.query :q=>'big' # defaults to the /select handler
-
-0.6.9 - January 29, 2009
-	Simplified facet response methods
-	Main facet method is called #facets
-	  - returns an array of Response::Facet instances
-	  - each Facet instance has field and values attributes
-	  -- the values attribute is an array with FacetValue instances which have @value and @hits
-	Added ability to set Connection::Base @param_adapters using :dismax or :standard
-	  instead of full class constant
-	  updated comments for #search method
-	Updated tests
-	Bumped up version
-
-0.6.8 - January 28, 2009
-	New method added to RSolr::Connection::Base - #find_values_for_facet
-	This method searches for facet values only, and sets the :rows param to 0
-	- returns an RSolr::Response::Query::Base instance
-	Example:
-		search_params[:facets][:offset]=0
-		search_params[:facets][:limit]=5
-		response = solr.search_facet_by_name(:language_facet, search_params)
-
-0.6.7 - January 27, 2009
-	The Symbol extension in core_ext.rb was cause for some REALLY painful debuging - so I removed it :(
-	This means no more :q.alt or :facet.field until RSolr gets a really nice query-builder module happening.
-
-0.6.6 - January 26, 2009
-	Added #get method helper to RSolr::Response::Query::DocExt
-	# doc.get(key, opts)
-	# key is the name of the field
-	# opts is a hash with the following valid keys:
-	#  - :sep - a string used for joining multivalued field values
-	#  - :default - a value to return when the key doesn't exist
-	# if :sep is nil and the field is a multivalued field, the array is returned
-
-0.6.5 - January 26, 2009
-	Removed to_mash everywhere, except for usage in RSolr::Response
-	Added a #close method to the Direct adapter
-		- this closes the connection and sets the @connection variable to nil
-	Removed to_mash in RSolr::Connection::Base
-	Changed RSolr::Response::Query::Doc to DocExt
-		- this no longer extends Mash
-		- each doc in the response now uses the #extend method to mixin the new DocExt module
-	Added #teardown method in direct connection test, this method closes the connection
-	Updated the connection test methods a bit
-
-0.6.4 - January 26, 2009
-	Updated the mapping output for the :filters and :phrase_filters (when using the #search method)
-		- now sending multiple fq's instead of one
-	Updated mapping tests
-
-0.6.3 - January 21, 2009
-	Added a new param mapping module: RSolr::Connection::ParamMapping
-	Mapping only for fields that need conversion/escaping or nested (facet.*) etc.
-	This new module can be activated by using the #search method
-	New tests for ParamMapping
-
-0.6.2 - January 14, 2009
-	Removed mapping and indexer modules -- seems to me that a general purpose mapping library
-	would be more valuable than an embedded module in RSolr ( RMapper ?)
-	This helps lighten RSolr a bit too
-	
-0.6.1 - January 13, 2009
-	Removed SearchExt and mapping until this library gets some real use
-	The only param mapping now is for :page and :per_page via the #search method
-	The Connection::Base #query method does NO mapping now
-	
-0.6.0 - January 9, 2009
-	Removed first argument from RSolr.connect, the "adapter_name"
-		The adapter is now set using the :adapter key when passing in options to RSolr.connect:
-		s = RSolr.connect(:adapter=>:direct)
-	
-0.5.9 - January 7, 2009
-	Finally brought in the ExtLib Mash classes for incoming params and response hashes from solr
-	  - this gives the ability to access/set values for hashes using strings OR symbols (HashWithIndifferentAccess)
-	Organized response tests
-	Added more response tests
-	Simplified the RSolr::Response::Base class by supporting only raw/string ruby input
-	Added method to Response::IndexInfo for grabbing a Solr field list
-	
-0.5.7 - January 5, 2009
-	Changed name from Solr to RSolr, changed all references to Solr to RSolr
-	Added new tests for RSolr::Mapper and RSolr::Message
-	
-0.5.6 - December 30, 2008
-	solr.gemspec cleanedup thanks to shairontoledo on github! :)
-	Added Solr::Response::Query::Facet module with helpers from the delsolr project
-		Also added test stub in test/connection/search_ext_test_methods.rb
-	Fixed pagination math errors
-	Added new SearchExt helper field: :phrase_filters
-		This will add quoted values to the :filters (fq solr param) hash for doing easier facet requests
-	
-	Be sure to check out the new demo app: http://github.com/mwmitchell/consuminator/tree/master
-	
-0.5.5 - December 29, 2008
-	Fixed bug where accessing a field by method name failed:
-		docs.each do |doc|
-			doc.timestamp
-		end
-	Fixed bug where using the #has? method on a doc failed:
-		docs.each do |doc|
-			doc.has?('timestamp')
-		end
-	Removed invalid autoload in Solr module
-	Fixed spelling error in Solr::Connection::SearchExt (thanks to matthewrudy)
-	
-0.5.4 - December 29, 2008
-	Re-organized the main Solr adapters, they're now in Solr::Connection::Adapter instead of Solr::Adapter
-	All responses from HTTPClient and Connection::Adapter::Direct return a hash with the following keys:
-		:status_code
-		:body
-		:params
-		:url
-		:path
-		:headers
-		:data
-	This hash is now available in the solr response objects as #source - this will be useful in testing and debugging by allowing you to see the generated params and queries... example:
-		response = Solr.query(:q=>'*:*')
-		response.source[:params]
-		response.source[:body]
-		response.source[:url]
-	Added MultiValue field support in Solr::Message, thanks to Fouad Mardini
-	Bug in Solr::Connection::SearchExt where the :q params was not getting generated - fixed by Fouad Mardini
-	Organized tests a bit, moved connection tests into test/connection
-	Fixed a bug in Solr::Connection::Adapter::HTTP where invalid HTTP POST headers were being generated

data/rsolr.gemspec

@@ -1,32 +0,0 @@
-Gem::Specification.new do |s|
-  
-  s.name = "rsolr"
-  s.version = "0.12.0"
-  s.date = "2010-02-03"
-  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 = [
-    "CHANGES.txt",
-    "lib/rsolr/client.rb",
-    "lib/rsolr/connection/net_http.rb",
-    "lib/rsolr/connection/requestable.rb",
-    "lib/rsolr/connection/utils.rb",
-    "lib/rsolr/connection.rb",
-    "lib/rsolr/message/document.rb",
-    "lib/rsolr/message/field.rb",
-    "lib/rsolr/message/generator.rb",
-    "lib/rsolr/message.rb",
-    "lib/rsolr.rb",
-    "LICENSE",
-    "README.rdoc",
-    "rsolr.gemspec"
-  ]
-  
-  #s.rdoc_options = ["--main", "README.rdoc"]
-  s.extra_rdoc_files = %w(LICENSE README.rdoc CHANGES.txt)
-end