gsolr 0.12.2

data/lib/gsolr/message/generator.rb

@@ -0,0 +1,94 @@
+module GSolr
+  module Message
+    class Generator
+
+      def build(&block)
+        require 'builder'
+        b = ::Builder::XmlMarkup.new(:indent=>0, :margin=>0, :encoding => 'UTF-8')
+        b.instruct!
+        block_given? ? yield(b) : b
+      end
+
+      # generates "add" xml for updating solr
+      # "data" can be a hash or an array of hashes.
+      # - each hash should be a simple key=>value pair representing a solr doc.
+      # If a value is an array, multiple fields will be created.
+      #
+      # "add_attrs" can be a hash for setting the add xml element attributes.
+      # 
+      # This method can also accept a block.
+      # The value yielded to the block is a Message::Document; for each solr doc in "data".
+      # You can set xml element attributes for each "doc" element or individual "field" elements.
+      #
+      # For example:
+      #
+      # solr.add({:id=>1, :nickname=>'Tim'}, {:boost=>5.0, :commitWithin=>1.0}) do |doc_msg|
+      #   doc_msg.attrs[:boost] = 10.00 # boost the document
+      #   nickname = doc_msg.field_by_name(:nickname)
+      #   nickname.attrs[:boost] = 20 if nickname.value=='Tim' # boost a field
+      # end
+      #
+      # would result in an add element having the attributes boost="10.0"
+      # and a commitWithin="1.0".
+      # Each doc element would have a boost="10.0".
+      # The "nickname" field would have a boost="20.0"
+      # if the doc had a "nickname" field with the value of "Tim".
+      #
+      def add(data, add_attrs={}, &block)
+        data = [data] unless data.is_a?(Array)
+
+        build do |xml|
+          xml.add(add_attrs) do |add_node|
+            data.each do |doc|
+              doc = GSolr::Message::Document.new(doc) if doc.respond_to?(:each_pair)
+              yield doc if block_given?
+              add_node.doc(doc.attrs) do |doc_node|
+                doc.fields.each do |field_obj|
+                  doc_node.field field_obj.value, field_obj.attrs
+                end
+              end
+            end
+          end
+        end
+      end
+
+      # generates a <commit/> message
+      def commit(opts={})
+        build {|xml| xml.commit opts}
+      end
+
+      # generates a <optimize/> message
+      def optimize(opts={})
+        build {|xml| xml.optimize opts}
+      end
+
+      # generates a <rollback/> message
+      def rollback opts={}
+        build {|xml| xml.rollback opts}
+      end
+
+      # generates a <delete><id>ID</id></delete> message
+      # "ids" can be a single value or array of values
+      def delete_by_id(ids)
+        ids = [ids] unless ids.is_a?(Array)
+        build do |xml|
+          xml.delete do |delete_node|
+            ids.each { |id| delete_node.id(id) }
+          end
+        end
+      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)
+        queries = [queries] unless queries.is_a?(Array)
+        build do |xml|
+          xml.delete do |delete_node|
+            queries.each { |query| delete_node.query query }
+          end
+        end
+      end
+
+    end # class Generator
+  end # module Message
+end # module GSolr

data/lib/gsolr/message.rb

@@ -0,0 +1,8 @@
+# The Solr::Message::Generator class is the XML generation module for sending updates to Solr.
+module GSolr
+  module Message
+    autoload :Document,   'gsolr/message/document'
+    autoload :Field,      'gsolr/message/field'
+    autoload :Generator,  'gsolr/message/generator'
+  end
+end

data/lib/gsolr/version.rb

@@ -0,0 +1,3 @@
+module Gsolr
+  VERSION = "0.12.2"
+end

data/lib/gsolr.rb

@@ -0,0 +1,39 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'json'
+
+module GSolr
+  autoload :Message,    'gsolr/message'
+  autoload :Client,     'gsolr/client'
+  autoload :Connection, 'gsolr/connection'
+
+  module Connectable
+    def connect(opts={})
+      Client.new Connection::NetHttp.new(opts)
+    end
+  end
+  extend Connectable
+
+  # A module that contains string related methods
+  module Char
+    # escape - from the solr-ruby library
+    # GSolr.escape('asdf')
+    # backslash everything that isn't a word character
+    def escape(value)
+      value.gsub(/(\W)/, '\\\\\1')
+    end
+  end
+
+  # send the escape method into the Connection class ->
+  # solr = GSolr.connect
+  # solr.escape('asdf')
+  GSolr::Client.send(:include, Char)
+
+  # bring escape into this module (GSolr) -> GSolr.escape('asdf')
+  extend Char
+
+  # RequestError is a common/generic exception class used by the adapters
+  class RequestError < RuntimeError
+  end
+end

data/spec/api/client_spec.rb

@@ -0,0 +1,97 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe GSolr::Client do
+
+  let(:client) {
+    GSolr::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=>:json}, "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=>:json).
+          # 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 GSolr::Connection::NetHttp do
+  
+  # calls #let to set "net_http" as method accessor
+  module NetHttpHelper
+    def self.included base
+      base.let(:net_http){ GSolr::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 GSolr::Connection::Requestable do
+  
+  # calls #let to set "net_http" as method accessor
+  class R
+    include GSolr::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 GSolr::Connection::Utils do
+  
+  # calls #let to set "utils" as a method accessor
+  module UtilsHelper
+    def self.included base
+      base.let(:utils){ nil.extend GSolr::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/gsolr_spec.rb

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