backupify-rsolr-nokogiri 0.12.1.1

data/lib/rsolr/message.rb

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

data/lib/rsolr/message/document.rb

@@ -0,0 +1,48 @@
+# A class that represents a "doc" xml element for a solr update
+class RSolr::Message::Document
+  
+  # "attrs" is a hash for setting the "doc" xml attributes
+  # "fields" is an array of Field objects
+  attr_accessor :attrs, :fields
+  
+  # "doc_hash" must be a Hash/Mash object
+  # If a value in the "doc_hash" is an array,
+  # a field object is created for each value...
+  def initialize(doc_hash = {})
+    @fields = []
+    doc_hash.each_pair do |field,values|
+      # create a new field for each value (multi-valued)
+      # put non-array values into an array
+      values = [values] unless values.is_a?(Array)
+      values.each do |v|
+        next if v.to_s.empty?
+        @fields << RSolr::Message::Field.new({:name=>field}, v.to_s)
+      end
+    end
+    @attrs={}
+  end
+  
+  # returns an array of fields that match the "name" arg
+  def fields_by_name(name)
+    @fields.select{|f|f.name==name}
+  end
+  
+  # returns the *first* field that matches the "name" arg
+  def field_by_name(name)
+    @fields.detect{|f|f.name==name}
+  end
+  
+  #
+  # Add a field value to the document. Options map directly to
+  # XML attributes in the Solr <field> node.
+  # See http://wiki.apache.org/solr/UpdateXmlMessages#head-8315b8028923d028950ff750a57ee22cbf7977c6
+  #
+  # === Example:
+  #
+  #   document.add_field('title', 'A Title', :boost => 2.0)
+  #
+  def add_field(name, value, options = {})
+    @fields << RSolr::Message::Field.new(options.merge({:name=>name}), value)
+  end
+  
+end

data/lib/rsolr/message/field.rb

@@ -0,0 +1,20 @@
+# A class that represents a "doc"/"field" xml element for a solr update
+class RSolr::Message::Field
+  
+  # "attrs" is a hash for setting the "doc" xml attributes
+  # "value" is the text value for the node
+  attr_accessor :attrs, :value
+  
+  # "attrs" must be a hash
+  # "value" should be something that responds to #_to_s
+  def initialize(attrs, value)
+    @attrs = attrs
+    @value = value
+  end
+  
+  # the value of the "name" attribute
+  def name
+    @attrs[:name]
+  end
+  
+end

data/lib/rsolr/message/generator.rb

@@ -0,0 +1,91 @@
+class RSolr::Message::Generator
+  
+  def build &block
+    require 'nokogiri'
+    b = Nokogiri::XML::Builder.new(:encoding => 'UTF-8')
+    yield(b) if block_given?
+    b.to_xml(:indent => 0)
+  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 = RSolr::Message::Document.new(doc) if doc.respond_to?(:each_pair)
+          yield doc if block_given?
+          xml.doc_(doc.attrs) {
+            doc.fields.each do |field_obj|
+              xml.field(field_obj.attrs) {
+                text field_obj.value
+              }
+            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

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\"?>\n<add>\n<doc>\n<field name=\"id\">1</field>\n</doc>\n</add>\n"
+      }
+      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\"?>\n<commit/>\n")
+      client.commit
+    end
+    
+    it 'should forward #optimize calls to #update' do
+      client.should_receive(:update).
+        with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<optimize/>\n")
+      client.optimize
+    end
+    
+    it 'should forward #rollback calls to #update' do
+      client.should_receive(:update).
+        with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<rollback/>\n")
+      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\"?>\n<delete>\n<id>1</id>\n</delete>\n")
+      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\"?>\n<delete>\n<query>blah</query>\n</delete>\n")
+      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