rsolr 0.11.0 → 0.12.0

data/CHANGES.txt

@@ -1,3 +1,10 @@
+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

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2008-2009 Matt Mitchell
+Copyright 2008-2010 Matt Mitchell
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/README.rdoc

@@ -13,6 +13,7 @@ A Ruby client for Apache Solr. RSolr has been developed to be simple and extenda
 * {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:
   require 'rubygems'
@@ -27,29 +28,6 @@ A Ruby client for Apache Solr. RSolr has been developed to be simple and extenda
   
   # alternative to above:
   response = rsolr.catalog :q=>'*:*'
-  
-To use a DirectSolrConnection (no http) in JRuby:
-  
-  # "apache-solr" should be a path to a solr build.
-  Dir['apache-solr/dist/*.jar'].each{|jar|require jar}
-  Dir['apache-solr/lib/*.jar'].each{|jar|require jar}
-  
-  opts = {:home_dir=>'/path/to/solr/home'}
-  
-  # note: you'll have to close the direct connection yourself unless using a block.
-  solr = RSolr.direct_connect(opts)
-  solr.select :q=>'*:*'
-  solr.connection.close
-  
-  # OR using a block for automatic connection closing:
-  RSolr.direct_connect opts do |solr|
-    solr.select :q=>'*:*'
-  end
-
-In general, the direct connection is less than ideal in most applications. You'll be missing out on Http caching, and it'll be impossible to do distributed searches. The direct connection could possibly come in handy though, for quickly indexing large numbers of documents.
-
-For more information about DirectSolrConnection, see the {API}[http://lucene.apache.org/solr/api/org/apache/solr/servlet/DirectSolrConnection.html].
-
 
 == Querying
 Use the #select method to send requests to the /select handler:

data/lib/rsolr.rb

@@ -1,38 +1,17 @@
-# add this directory to the load path if it hasn't already been added
 
 require 'rubygems'
-
-$: << File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__))
-
-require 'xout'
+$:.unshift File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__))
 
 module RSolr
   
-  VERSION = '0.11.1'
+  VERSION = '0.12.0'
   
   autoload :Message, 'rsolr/message'
   autoload :Client, 'rsolr/client'
   autoload :Connection, 'rsolr/connection'
   
-  # Http connection. Example:
-  #   RSolr.connect
-  #   RSolr.connect 'http://solr.web100.org'
-  def self.connect *args
-    Client.new(Connection::NetHttp.new(*args))
-  end
-  
-  # DirectSolrConnection (jruby only). Example:
-  #   RSolr.direct_connect 'path/to/solr/distribution'
-  #   RSolr.direct_connect :dist_dir=>'path/to/solr/distribution', :home_dir=>'/path/to/solrhome'
-  #   RSolr.direct_connect opts do |rsolr|
-  #     ###
-  #   end
-  # Note:
-  # if a block is used, the client is yielded and the solr core will be closed for you.
-  # if a block is NOT used, the the client is returned and the core is NOT closed.
-  def self.direct_connect *args, &blk
-    rsolr = Client.new(Connection::Direct.new(*args))
-    block_given? ? (yield rsolr and rsolr.connection.close) : rsolr
+  def self.connect opts={}
+    Client.new Connection::NetHttp.new(opts)
   end
   
   # A module that contains string related methods

data/lib/rsolr/client.rb

@@ -76,9 +76,9 @@ class RSolr::Client
     update message.delete_by_query(query)
   end
   
-  # shortcut to RSolr::Message::Builder
-  def message
-    @message ||= RSolr::Message::Builder.new
+  # shortcut to RSolr::Message::Generator
+  def message *opts
+    @message ||= RSolr::Message::Generator.new
   end
   
   protected
@@ -95,7 +95,7 @@ class RSolr::Client
   #   : body - the raw response body from the solr server
   # This method will evaluate the :body value if the params[:wt] == :ruby
   # otherwise, the body is returned
-  # The return object has a special method attached called #connection_response
+  # The return object has a special method attached called #raw
   # This method gives you access to the original response from the connection,
   # so you can access things like the actual :url sent to solr,
   # the raw :body, original :params and original :data
@@ -105,7 +105,7 @@ class RSolr::Client
     if connection_response[:params][:wt] == :ruby
       data = Kernel.eval(data)
     end
-    # attach a method called #connection_response that returns the original connection response value
+    # attach a method called #raw that returns the original connection response value
     def data.raw; @raw end
     data.send(:instance_variable_set, '@raw', connection_response)
     data

data/lib/rsolr/connection.rb

@@ -1,72 +1,9 @@
+require 'uri'
+
 module RSolr::Connection
   
-  autoload :Direct, 'rsolr/connection/direct'
   autoload :NetHttp, 'rsolr/connection/net_http'
-  
-  # Helpful utility methods for building queries to a Solr server
-  module Utils
-
-    # Performs URI escaping so that you can construct proper
-    # query strings faster.  Use this rather than the cgi.rb
-    # version since it's faster.  (Stolen from Rack).
-    def escape(s)
-      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
-        #'%'+$1.unpack('H2'*$1.size).join('%').upcase
-        '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
-      }.tr(' ', '+')
-    end
-    
-    # Return the bytesize of String; uses String#length under Ruby 1.8 and
-    # String#bytesize under 1.9.
-    if ''.respond_to?(:bytesize)
-      def bytesize(string)
-        string.bytesize
-      end
-    else
-      def bytesize(string)
-        string.size
-      end
-    end
-    
-    # creates and returns a url as a string
-    # "url" is the base url
-    # "params" is an optional hash of GET style query params
-    # "string_query" is an extra query string that will be appended to the 
-    # result of "url" and "params".
-    def build_url url='', params={}, string_query=''
-      queries = [string_query, hash_to_query(params)]
-      queries.delete_if{|i| i.to_s.empty?}
-      url += "?#{queries.join('&')}" unless queries.empty?
-      url
-    end
-
-    # converts a key value pair to an escaped string:
-    # Example:
-    # build_param(:id, 1) == "id=1"
-    def build_param(k,v)
-      "#{escape(k)}=#{escape(v)}"
-    end
-
-    #
-    # converts hash into URL query string, keys get an alpha sort
-    # if a value is an array, the array values get mapped to the same key:
-    #   hash_to_query(:q=>'blah', :fq=>['blah', 'blah'], :facet=>{:field=>['location_facet', 'format_facet']})
-    # returns:
-    #   ?q=blah&fq=blah&fq=blah&facet.field=location_facet&facet.field=format.facet
-    #
-    # if a value is empty/nil etc., it is not added
-    def hash_to_query(params)
-      mapped = params.map do |k, v|
-        next if v.to_s.empty?
-        if v.class == Array
-          hash_to_query(v.map { |x| [k, x] })
-        else
-          build_param k, v
-        end
-      end
-      mapped.compact.join("&")
-    end
-
-  end
+  autoload :Utils, 'rsolr/connection/utils'
+  autoload :Requestable, 'rsolr/connection/requestable'
   
 end

data/lib/rsolr/connection/net_http.rb

@@ -5,40 +5,7 @@ require 'net/http'
 #
 class RSolr::Connection::NetHttp
   
-  include RSolr::Connection::Utils
-  
-  attr_reader :opts, :uri
-  
-  # opts can have:
-  #   :url => 'http://localhost:8080/solr'
-  def initialize opts={}
-    opts[:url] ||= 'http://127.0.0.1:8983/solr'
-    @opts = opts
-    @uri = URI.parse opts[:url]
-  end
-  
-  # send a request to the connection
-  # request '/update', :wt=>:xml, '</commit>'
-  def request path, params={}, *extra
-    opts = extra[-1].kind_of?(Hash) ? extra.pop : {}
-    data = extra[0]
-    # force a POST, use the query string as the POST body
-    if opts[:method] == :post and data.to_s.empty?
-      http_context = self.post(path, hash_to_query(params), {}, {'Content-Type' => 'application/x-www-form-urlencoded'})
-    else
-      if data
-        # standard POST, using "data" as the POST body
-        http_context = self.post(path, data, params, {"Content-Type" => 'text/xml; charset=utf-8'})
-      else
-        # standard GET
-        http_context = self.get(path, params)
-      end
-    end
-    raise RSolr::RequestError.new("Solr Response: #{http_context[:message]}") unless http_context[:status_code] == 200
-    http_context
-  end
-  
-  protected
+  include RSolr::Connection::Requestable
   
   def connection
     @connection ||= Net::HTTP.new(@uri.host, @uri.port)
@@ -72,13 +39,6 @@ class RSolr::Connection::NetHttp
     }
   end
   
-  # encodes the string as utf-8 in Ruby 1.9
-  # returns the unaltered string in Ruby 1.8
-  def encode_utf8 string
-    (string.respond_to?(:force_encoding) and string.respond_to?(:encoding)) ?
-      string.force_encoding(Encoding::UTF_8) : string
-  end
-  
   # accepts a path/string and optional hash of query params
   def build_url path, params={}
     full_path = @uri.path + path

data/lib/rsolr/connection/requestable.rb

@@ -0,0 +1,43 @@
+# A module that defines the interface and top-level logic for http based connection classes.
+module RSolr::Connection::Requestable
+  
+  include RSolr::Connection::Utils
+  
+  attr_reader :opts, :uri
+  
+  # opts can have:
+  #   :url => 'http://localhost:8080/solr'
+  def initialize opts={}
+    opts[:url] ||= 'http://127.0.0.1:8983/solr'
+    @opts = opts
+    @uri = URI.parse opts[:url]
+  end
+  
+  # send a request to the connection
+  # request '/select', :q=>'*:*'
+  #
+  # request '/update', {:wt=>:xml}, '</commit>'
+  # 
+  # force a post where the post body is the param query
+  # request '/update', "<optimize/>", :method=>:post
+  #
+  def request path, params={}, *extra
+    opts = extra[-1].kind_of?(Hash) ? extra.pop : {}
+    data = extra[0]
+    # force a POST, use the query string as the POST body
+    if opts[:method] == :post and data.to_s.empty?
+      http_context = self.post(path, hash_to_query(params), {}, {'Content-Type' => 'application/x-www-form-urlencoded'})
+    else
+      if data
+        # standard POST, using "data" as the POST body
+        http_context = self.post(path, data, params, {"Content-Type" => 'text/xml; charset=utf-8'})
+      else
+        # standard GET
+        http_context = self.get(path, params)
+      end
+    end
+    raise RSolr::RequestError.new("Solr Response: #{http_context[:message]}") unless http_context[:status_code] == 200
+    http_context
+  end
+  
+end

data/lib/rsolr/connection/utils.rb

@@ -0,0 +1,73 @@
+# Helpful utility methods for building queries to a Solr server
+# This includes helpers that the Direct connection can use.
+module RSolr::Connection::Utils
+  
+  # Performs URI escaping so that you can construct proper
+  # query strings faster.  Use this rather than the cgi.rb
+  # version since it's faster.  (Stolen from Rack).
+  def escape(s)
+    s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
+      #'%'+$1.unpack('H2'*$1.size).join('%').upcase
+      '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
+    }.tr(' ', '+')
+  end
+  
+  # encodes the string as utf-8 in Ruby 1.9
+  # returns the unaltered string in Ruby 1.8
+  def encode_utf8 string
+    (string.respond_to?(:force_encoding) and string.respond_to?(:encoding)) ?
+      string.force_encoding(Encoding::UTF_8) : string
+  end
+  
+  # Return the bytesize of String; uses String#length under Ruby 1.8 and
+  # String#bytesize under 1.9.
+  if ''.respond_to?(:bytesize)
+    def bytesize(string)
+      string.bytesize
+    end
+  else
+    def bytesize(string)
+      string.size
+    end
+  end
+  
+  # creates and returns a url as a string
+  # "url" is the base url
+  # "params" is an optional hash of GET style query params
+  # "string_query" is an extra query string that will be appended to the 
+  # result of "url" and "params".
+  def build_url url='', params={}, string_query=''
+    queries = [string_query, hash_to_query(params)]
+    queries.delete_if{|i| i.to_s.empty?}
+    url += "?#{queries.join('&')}" unless queries.empty?
+    url
+  end
+
+  # converts a key value pair to an escaped string:
+  # Example:
+  # build_param(:id, 1) == "id=1"
+  def build_param(k,v)
+    "#{escape(k)}=#{escape(v)}"
+  end
+
+  #
+  # converts hash into URL query string, keys get an alpha sort
+  # if a value is an array, the array values get mapped to the same key:
+  #   hash_to_query(:q=>'blah', :fq=>['blah', 'blah'], :facet=>{:field=>['location_facet', 'format_facet']})
+  # returns:
+  #   ?q=blah&fq=blah&fq=blah&facet.field=location_facet&facet.field=format.facet
+  #
+  # if a value is empty/nil etc., it is not added
+  def hash_to_query(params)
+    mapped = params.map do |k, v|
+      next if v.to_s.empty?
+      if v.class == Array
+        hash_to_query(v.map { |x| [k, x] })
+      else
+        build_param k, v
+      end
+    end
+    mapped.compact.join("&")
+  end
+
+end

data/lib/rsolr/message.rb

@@ -1,154 +1,8 @@
-# The Solr::Message class is the XML generation module for sending updates to Solr.
-
+# The Solr::Message::Generator class is the XML generation module for sending updates to Solr.
 module RSolr::Message
   
-  # A class that represents a "doc" xml element for a solr update
-  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 << 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 << Field.new(options.merge({:name=>name}), value)
-    end
-    
-  end
-  
-  # A class that represents a "doc"/"field" xml element for a solr update
-  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 Builder
-    
-    # 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={})
-      data = [data] unless data.is_a?(Array)
-      add = Xout.new :add, add_attrs
-      data.each do |doc|
-        doc = Document.new(doc) if doc.respond_to?(:each_pair)
-        yield doc if block_given?
-        add.child :doc, doc.attrs do |doc_node|
-          doc.fields.each do |field_obj|
-            doc_node.child :field, field_obj.value, field_obj.attrs
-          end
-        end
-      end
-      add.to_xml
-    end
-    
-    # generates a <commit/> message
-    def commit(opts={})
-      Xout.new(:commit, opts).to_xml
-    end
-    
-    # generates a <optimize/> message
-    def optimize(opts={})
-      Xout.new(:optimize, opts).to_xml
-    end
-    
-    # generates a <rollback/> message
-    def rollback
-      Xout.new(:rollback).to_xml
-    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)
-      delete_node = Xout.new(:delete) do |xml|
-        ids.each { |id| xml.child :id, id }
-      end
-      delete_node.to_xml
-    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)
-      delete_node = Xout.new(:delete) do |xml|
-        queries.each { |query| xml.child :query, query }
-      end
-      delete_node.to_xml
-    end
-    
-  end
+  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,89 @@
+class RSolr::Message::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::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

data/rsolr.gemspec

@@ -1,8 +1,8 @@
 Gem::Specification.new do |s|
   
   s.name = "rsolr"
-  s.version = "0.11.0"
-  s.date = "2009-11-17"
+  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"
@@ -13,12 +13,15 @@ Gem::Specification.new do |s|
   s.files = [
     "CHANGES.txt",
     "lib/rsolr/client.rb",
-    "lib/rsolr/connection/direct.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",
-    "lib/xout.rb",
     "LICENSE",
     "README.rdoc",
     "rsolr.gemspec"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rsolr
 version: !ruby/object:Gem::Version 
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors: 
 - Matt Mitchell
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-17 00:00:00 -05:00
+date: 2010-02-03 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -26,12 +26,15 @@ extra_rdoc_files:
 files: 
 - CHANGES.txt
 - lib/rsolr/client.rb
-- lib/rsolr/connection/direct.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
-- lib/xout.rb
 - LICENSE
 - README.rdoc
 - rsolr.gemspec

data/lib/rsolr/connection/direct.rb

@@ -1,69 +0,0 @@
-raise "JRuby Required" unless defined?(JRUBY_VERSION)
-
-require 'java'
-
-#
-# Connection for JRuby + DirectSolrConnection
-#
-class RSolr::Connection::Direct
-  
-  include RSolr::Connection::Utils
-  
-  attr_accessor :opts
-  
-  # opts can be an instance of org.apache.solr.servlet.DirectSolrConnection
-  # if opts is NOT an instance of org.apache.solr.servlet.DirectSolrConnection
-  # then...
-  # required: opts[:home_dir] is absolute path to solr home (the directory with "data", "config" etc.)
-  # 
-  # You can load your own solr java libs by setting :autoload_jars to false.
-  # When set to true (default), RSolr loads its own set of solr java libs.
-  def initialize(opts, &block)
-    if defined?(Java::OrgApacheSolrCore::SolrCore) and opts.is_a?(Java::OrgApacheSolrCore::SolrCore)
-      @connection = org.apache.solr.servlet.DirectSolrConnection.new(opts)
-    elsif defined?(Java::OrgApacheSolrServlet::DirectSolrConnection) and opts.is_a?(Java::OrgApacheSolrServlet::DirectSolrConnection)
-      @connection = opts
-    else
-      opts[:data_dir] ||= File.join(opts[:home_dir].to_s, 'data')
-      @opts = opts
-    end
-  end
-  
-  # sets the @connection instance variable if it has not yet been set
-  def connection
-    @connection ||= (
-      org.apache.solr.servlet.DirectSolrConnection.new(opts[:home_dir], @opts[:data_dir], nil)
-    )
-  end
-  
-  def close
-    if @connection
-      @connection.close
-      @connection=nil
-    end
-  end
-  
-  # send a request to the connection
-  # request '/select', :q=>'something'
-  # request '/update', :wt=>:xml, '</commit>'
-  def request(path, params={}, data=nil, opts={})
-    data = data.to_xml if data.respond_to?(:to_xml)
-    url = build_url(path, params)
-    begin
-      body = connection.request(url, data)
-    rescue
-      raise RSolr::RequestError.new($!.message)
-    end
-    {
-      :status_code => 200,
-      :url=>url,
-      :body=>body,
-      :path=>path,
-      :params=>params,
-      :data=>data,
-      :headers => {},
-      :message => ''
-    }
-  end
-  
-end

data/lib/xout.rb

@@ -1,87 +0,0 @@
-class Xout
-  
-  VERSION = '0.1.0'
-  
-  attr_reader :name, :text, :attrs, :children
-  
-  def initialize node_name, *args, &block
-    @children = []
-    attrs = args.last.is_a?(Hash) ? args.pop : {}
-    text = args.empty? ? '' : args.pop.to_s
-    @name, @text, @attrs = node_name, text, attrs
-    yield self if block_given?
-  end
-  
-  def child name, *args, &block
-    add_child self.class.new(name, *args, &block)
-  end
-  
-  def add_child node
-    children << node
-  end
-  
-  def to_xml
-    xml = ["<#{name}#{create_attrs(attrs)}"]
-    if not text.empty? or not children.empty?
-      xml << ">#{escape_text text.to_s}"
-      xml += children.map{|child|child.to_xml}
-      xml << "</#{name}>"
-    else
-      xml << '/>'
-    end
-    xml.join
-  end
-  
-  alias :to_s :to_xml
-  
-  def to_xml_doc
-    '<?xml version="1.0" encoding="UTF-8"?>' + to_xml
-  end
-  
-  # builds an XML attribute string.
-  # escapes each attribute value by running it through #escape_attr
-  def create_attrs hash
-    r = hash.map { |k,v| "#{k}=\"#{escape_attr v.to_s}\"" }.join(' ')
-    " #{r}" unless r.empty?
-  end
-  
-  module Escapable
-    
-    def text_mapping
-      @text_mapping ||= {'&'=>'&amp;', '<'=>'&lt;', '>'=>'&gt;'}
-    end
-
-    def text_regexp
-      @text_regexp ||= /[#{text_mapping.keys.join}]/
-    end
-
-    def attr_mapping
-      @attr_mapping ||= {'&'=>'&amp;', '<'=>'&lt;', '>'=>'&gt;', "'"=>'&apos;', '"'=>'&quote;'}
-    end
-
-    def attr_regexp
-      @attr_regexp ||= /[#{attr_mapping.keys.join}]/
-    end
-    
-    # minimal escaping for attribute values
-    def escape_attr input
-      escape input, attr_regexp, attr_mapping
-    end
-
-    # minimal escaping for text
-    def escape_text input
-      escape input, text_regexp, text_mapping
-    end
-
-    # accepts a string input and a hash mapping of characters => replacement values:
-    # Example:
-    #   escape 'My <string>cat</strong>', '<'=>'&gt;', '>'=>'&lt;'
-    def escape input, regexp, map
-      input.gsub(regexp) { | char | map[char] || char }
-    end
-    
-  end
-  
-  include Escapable
-  
-end