rsolr 0.13.0.pre → 1.0.0.beta

data/lib/rsolr/xml.rb

@@ -0,0 +1,161 @@
+module RSolr::Xml
+  
+  class 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::Xml::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::Xml::Field.new(options.merge({:name=>name}), value)
+    end
+    
+  end
+  
+  class 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
+  
+  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 = RSolr::Xml::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
+  
+end

data/lib/rsolr.rb

@@ -1,53 +1,32 @@
-
+require 'uri'
+require 'net/http'
+require 'net/https'
 require 'rubygems'
-$:.unshift File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__))
+require 'builder'
+
+$: << "#{File.dirname(__FILE__)}"
 
 module RSolr
   
+  %W(Char Client Error Http Uri Xml).each{|n|autoload n.to_sym, "rsolr/#{n.downcase}"}
+  
   def self.version
-    @version ||= File.read(File.join(File.dirname(__FILE__), '..', 'VERSION'))
+    @version ||= File.read(File.join(File.dirname(__FILE__), '..', 'VERSION')).chomp
   end
   
   VERSION = self.version
   
-  autoload :Message, 'rsolr/message'
-  autoload :Client, 'rsolr/client'
-  autoload :Connection, 'rsolr/connection'
-  
-  module Connectable
-    
-    def connect opts={}
-      Client.new Connection::NetHttp.new(opts)
-    end
-    
+  def self.connect *args
+    opts = parse_options *args
+    Client.new Http.new(opts[0], opts[1])
   end
   
-  extend Connectable
-  
-  # A module that contains string related methods
-  module Char
-    
-    # escape - from the solr-ruby library
-    # RSolr.escape('asdf')
-    # backslash everything that isn't a word character
-    def escape(value)
-      value.gsub(/(\W)/, '\\\\\1')
-    end
-    
+  def self.parse_options *args
+    opts = args[-1].kind_of?(Hash) ? args.pop : {}
+    url = args.empty? ? 'http://127.0.0.1:8983/solr/' : args[0]
+    uri = Uri.create url
+    proxy = Uri.create opts[:proxy] if opts[:proxy]
+    [uri, {:proxy => proxy}]
   end
   
-  # send the escape method into the Connection class ->
-  # solr = RSolr.connect
-  # solr.escape('asdf')
-  RSolr::Client.send(:include, Char)
-  
-  # bring escape into this module (RSolr) -> RSolr.escape('asdf')
-  extend Char
-  
-  # RequestError is a common/generic exception class used by the adapters
-  class RequestError < RuntimeError; end
-  
-  # TODO: The connection drivers need to start raising this...
-  class ConnectionError < RuntimeError; end
-  
 end

data/spec/api/rsolr_client_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+describe "RSolr::Client" do
+  
+  module ClientHelper
+    def client
+      @client ||= (
+        connection = RSolr::Http.new URI.parse("http://localhost:9999/solr")
+        RSolr::Client.new(connection)
+      )
+    end
+  end
+  
+  context "initialize" do
+    it "should accept whatevs and set it as the @connection" do
+      RSolr::Client.new(:whatevs).connection.should == :whatevs
+    end
+  end
+  
+  context "adapt_response" do
+    
+    include ClientHelper
+    
+    it 'should not try to evaluate ruby when the :qt is not :ruby' do
+      body = '{:time=>"NOW"}'
+      result = client.send(:adapt_response, {:params=>{}}, {:body => body})
+      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, {:params=>{:wt=>:ruby}}, {:body=>body})
+      result.should be_a(Hash)
+      result.should == {:time=>"NOW"}
+    end
+    
+    ["nil", :ruby].each do |wt|
+      it "should return an object that responds to :request and :response when :wt == #{wt}" do
+        req = {:params=>{:wt=>wt}}
+        res = {:body=>""}
+        result = client.send(:adapt_response, req, res)
+        result.request.should == req
+        result.response.should == res
+      end
+    end
+    
+    it "ought raise a RSolr::Error::InvalidRubyResponse when the ruby is indeed frugged" do
+      lambda {
+        client.send(:adapt_response, {:params=>{:wt => :ruby}}, {:body => "<woops/>"})
+      }.should raise_error RSolr::Error::InvalidRubyResponse
+    end
+    
+  end
+  
+  context "build_request" do
+    include ClientHelper
+    it 'should return a request context array' do
+      result = client.build_request 'select', {:q=>'test', :fq=>[0,1]}, "data", headers = {}
+      ["select?fq=0&fq=1&q=test", "select?q=test&fq=0&fq=1"].should include(result[0].to_s)
+      result[1].should == "data"
+      result[2].should == headers
+    end
+    it "should set the Content-Type header to application/x-www-form-urlencoded if a hash is passed in to the data arg" do
+      result = client.build_request 'select', nil, {:q=>'test', :fq=>[0,1]}, headers = {}
+      result[0].to_s.should == "select"
+      ["fq=0&fq=1&q=test", "q=test&fq=0&fq=1"].should include(result[1])
+      result[2].should == headers
+    end
+  end
+  
+  context "map_params" do
+    include ClientHelper
+    it "should return a hash if nil is passed in" do
+      client.map_params(nil).should == {:wt => :ruby}
+    end
+    it "should set the :wt to ruby if blank" do
+      r = client.map_params({:q=>"q"})
+      r[:q].should == "q"
+      r[:wt].should == :ruby
+    end
+    it "should not override the :wt to ruby if set" do
+      r = client.map_params({:q=>"q", :wt => :json})
+      r[:q].should == "q"
+      r[:wt].should == :json
+    end
+  end
+  
+  context "send_request" do
+    include ClientHelper
+    it "should forward these method calls the #connection object" do
+      [:get, :post, :head].each do |meth|
+        client.connection.should_receive(meth).
+            and_return({:status => 200})
+        client.send_request meth, '', {}, nil, {}
+      end
+    end
+    it "should extend any exception raised by the #connection object with a RSolr::Error::SolrContext" do
+      client.connection.should_receive(:get).
+          and_raise(RuntimeError)
+      lambda {
+        client.send_request :get, '', {}, nil, {}
+      }.should raise_error(RuntimeError){|error|
+        error.should be_a(RSolr::Error::SolrContext)
+        error.should respond_to(:request)
+        error.request.keys.should include(:connection, :method, :uri, :data, :headers, :params)
+      }
+    end
+    it "should raise an Http error if the response status code aint right" do
+      client.connection.should_receive(:get).
+        and_return({:status_code => 404})
+      lambda{
+        client.send_request :get, '', {}, nil, {}
+      }.should raise_error(RSolr::Error::Http) {|error|
+        error.should be_a(RSolr::Error::Http)
+        error.should respond_to(:request)
+        error.should respond_to(:response)
+      }
+    end
+  end
+  
+  context "post" do
+    include ClientHelper
+    it "should pass the expected params to the connection's #post method" do
+      client.connection.should_receive(:post).
+        with("update?wt=ruby", "the data", {"Content-Type" => "text/plain"}).
+          and_return(:status => 200)
+      client.post "update", "the data", nil, {"Content-Type" => "text/plain"}
+    end
+  end
+  
+  context "xml" do
+    include ClientHelper
+    it "should return an instance of RSolr::Xml::Generator" do
+      client.xml.should be_a RSolr::Xml::Generator
+    end
+  end
+  
+  context "add" do
+    include ClientHelper
+    it "should send xml to the connection's #post method" do
+      client.connection.should_receive(:post).
+        with("update?wt=ruby", "<xml/>", {"Content-Type"=>"text/xml"}).
+          and_return(:status => 200)
+      # the :xml attr is lazy loaded... so load it up first
+      client.xml
+      client.xml.should_receive(:add).
+        with({:id=>1}, :commitWith=>1.0).
+          and_return("<xml/>")
+      client.add({:id=>1}, {:commitWith=>1.0})
+    end
+  end
+  
+  context "update" do
+    include ClientHelper
+    it "should send data to the connection's #post method" do
+      client.connection.should_receive(:post).
+        with("update?wt=xml", instance_of(String), {"Content-Type"=>"text/xml"}).
+          and_return(:status => 200)
+      client.update("<optimize/>", {:wt=>:xml})
+    end
+  end
+  
+  context "post based helper methods:" do
+    include ClientHelper
+    [:commit, :optimize, :rollback].each do |meth|
+      it "should send a #{meth} message to the connection's #post method" do
+        client.connection.should_receive(:post).
+          with("update?wt=ruby", "<?xml version=\"1.0\" encoding=\"UTF-8\"?><#{meth}/>", {"Content-Type"=>"text/xml"}).
+            and_return(:status => 200)
+        client.send meth
+      end
+    end
+  end
+  
+  context "delete_by_id" do
+    include ClientHelper
+    it "should send data to the connection's #post method" do
+      client.connection.should_receive(:post).
+        with("update?wt=ruby", instance_of(String), {"Content-Type"=>"text/xml"}).
+          and_return(:status => 200)
+      client.delete_by_id 1
+    end
+  end
+  
+  context "delete_by_query" do
+    include ClientHelper
+    it "should send data to the connection's #post method" do
+      client.connection.should_receive(:post).
+        with("update?wt=ruby", instance_of(String), {"Content-Type"=>"text/xml"}).
+          and_return(:status => 200)
+      client.delete_by_query :fq => "category:\"trash\""
+    end
+  end
+  
+end

data/spec/api/rsolr_error_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+describe "RSolr::Error" do
+  # add some shiz here...
+end

data/spec/api/rsolr_http_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+describe "RSolr::Http" do
+  # add some shiz here...
+end

data/spec/api/rsolr_spec.rb

@@ -1,29 +1,17 @@
-describe RSolr do
+require 'spec_helper'
+describe "RSolr class methods" 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
-    
+  it "should parse these here options" do
+    result = RSolr.parse_options "http://localhost:8983/solr/blah", :proxy => "http://qtpaglzvm.com"
+    result[0].should be_a(URI)
+    result[1].should be_a(Hash)
+    result[1][:proxy].should be_a(URI)
   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
+  it "should not create a URI instance for :proxy => nil" do
+    result = RSolr.parse_options "http://localhost:8983/solr/blah"
+    result[0].should be_a(URI)
+    result[1].should == {:proxy => nil}
   end
   
 end

data/spec/api/rsolr_uri_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+describe "RSolr::Uri" do
+  
+  context "class-level methods" do
+    
+    let(:uri){ RSolr::Uri }
+    
+    it "should return a URI object with a trailing slash" do
+      u = uri.create 'http://apache.org'
+      u.path[0].should == ?/
+    end
+  
+    it "should return the bytesize of a string" do
+      uri.bytesize("test").should == 4
+    end
+  
+    it "should convert a solr query string from a hash w/o a starting ?" do
+      hash = {:q => "gold", :fq => ["mode:one", "level:2"]}
+      query = uri.params_to_solr hash
+      query[0].should_not == ??
+      [/q=gold/, /fq=mode%3Aone/, /fq=level%3A2/].each do |p|
+        query.should match p
+      end
+      query.split('&').size.should == 3
+    end
+    
+    context "escape_query_value" do
+      
+      it 'should escape &' do
+        uri.params_to_solr(:fq => "&").should == 'fq=%26'
+      end
+
+      it 'should convert spaces to +' do
+        uri.params_to_solr(: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'
+        uri.params_to_solr(my_params).should == expected
+      end
+
+      it 'should escape complex queries, part 2' do
+        my_params = {'q' => '+popularity:[10 TO *] +section:0'}
+        expected = 'q=%2Bpopularity%3A%5B10+TO+%2A%5D+%2Bsection%3A0'
+        uri.params_to_solr(my_params).should == expected
+      end
+      
+      it 'should escape properly' do
+        uri.escape_query_value('+').should == '%2B'
+        uri.escape_query_value('This is a test').should == 'This+is+a+test'
+        uri.escape_query_value('<>/\\').should == '%3C%3E%2F%5C'
+        uri.escape_query_value('"').should == '%22'
+        uri.escape_query_value(':').should == '%3A'
+      end
+
+      it 'should escape brackets' do
+        uri.escape_query_value('{').should == '%7B'
+        uri.escape_query_value('}').should == '%7D'
+      end
+
+      it 'should escape exclamation marks!' do
+        uri.escape_query_value('!').should == '%21'
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/api/{message_spec.rb → rsolr_xml_spec.rb}

@@ -1,6 +1,7 @@
-describe RSolr::Message do
+require 'spec_helper'
+describe "RSolr::Xml" do
   
-  let(:generator){ RSolr::Message::Generator.new }
+  let(:generator){ RSolr::Xml::Generator.new }
   
   # call all of the simple methods...
   # make sure the xml string is valid
@@ -70,7 +71,7 @@ describe RSolr::Message do
     end
 
     it 'should create an add from a single Message::Document' do
-      document = RSolr::Message::Document.new
+      document = RSolr::Xml::Document.new
       document.add_field('id', 1)
       document.add_field('name', 'matt', :boost => 2.0)
       result = generator.add(document)
@@ -83,7 +84,7 @@ describe RSolr::Message do
     
     it 'should create adds from multiple Message::Documents' do
       documents = (1..2).map do |i|
-        doc = RSolr::Message::Document.new
+        doc = RSolr::Xml::Document.new
         doc.add_field('id', i)
         doc.add_field('name', "matt#{i}")
         doc

metadata

@@ -3,11 +3,11 @@ name: rsolr
 version: !ruby/object:Gem::Version 
   prerelease: true
   segments: 
+  - 1
   - 0
-  - 13
   - 0
-  - pre
-  version: 0.13.0.pre
+  - beta
+  version: 1.0.0.beta
 platform: ruby
 authors: 
 - Matt Mitchell
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-04 00:00:00 -04:00
+date: 2010-06-29 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -46,15 +46,12 @@ files:
 - README.rdoc
 - VERSION
 - lib/rsolr.rb
+- lib/rsolr/char.rb
 - lib/rsolr/client.rb
-- lib/rsolr/connection.rb
-- lib/rsolr/connection/httpable.rb
-- lib/rsolr/connection/net_http.rb
-- lib/rsolr/connection/utils.rb
-- lib/rsolr/message.rb
-- lib/rsolr/message/document.rb
-- lib/rsolr/message/field.rb
-- lib/rsolr/message/generator.rb
+- lib/rsolr/error.rb
+- lib/rsolr/http.rb
+- lib/rsolr/uri.rb
+- lib/rsolr/xml.rb
 has_rdoc: true
 homepage: http://github.com/mwmitchell/rsolr
 licenses: []
@@ -88,13 +85,12 @@ signing_key:
 specification_version: 3
 summary: A Ruby client for Apache Solr
 test_files: 
-- spec/api/client_spec.rb
-- spec/api/connection/httpable_spec.rb
-- spec/api/connection/net_http_spec.rb
-- spec/api/connection/utils_spec.rb
-- spec/api/message_spec.rb
+- spec/api/rsolr_client_spec.rb
+- spec/api/rsolr_error_spec.rb
+- spec/api/rsolr_http_spec.rb
 - spec/api/rsolr_spec.rb
-- spec/integration/http_errors_spec.rb
+- spec/api/rsolr_uri_spec.rb
+- spec/api/rsolr_xml_spec.rb
 - spec/spec_helper.rb
 - Rakefile
 - tasks/spec.rake