mwmitchell-rsolr 0.8.0 → 0.8.1

data/CHANGES.txt

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

data/README.rdoc

@@ -2,10 +2,6 @@
 
 A Ruby client for Apache Solr. Has transparent JRuby support by using "org.apache.solr.servlet.DirectSolrConnection" as a connection adapter.
 
-=NOTE
-Please look at the latest code/branch here: http://github.com/mwmitchell/rsolr/tree/no-response-wrap
-The mapping/response helper stuff in master, will be extracted out into a separate Gem.
-
 ==Installation:
   gem sources -a http://gems.github.com
   sudo gem install mwmitchell-rsolr
@@ -53,13 +49,18 @@ Single document
   response = solr.add(:id=>1, :price=>1.00)
 
 Multiple documents
-  response = solr.add([{:id=>1, :price=>1.00}, {:id=>2, :price=>10.50}])
-
-When adding, you can also supply "add" attributes and/or a block for digging into the Solr "add" params:
+  documents = [{:id=>1, :price=>1.00}, {:id=>2, :price=>10.50}]
+  response = solr.add(documents)
 
+When adding, you can also supply "add" xml element attributes and/or a block for manipulating other "add" related elements:
+  
   doc = {:id=>1, :price=>1.00}
-  solr.add(doc, {:allowDups=>false, :commitWithin=>10.0}) do |doc_attrs|
-    doc_attrs[:boost] = 10.0
+  add_attributes = {:allowDups=>false, :commitWithin=>10.0}
+  solr.add(doc, add_attributes) do |doc|
+    # boost each document
+    doc.attrs[:boost] = 1.5
+    # boost the price field:
+    doc.field_by_name(:price).attrs[:boost] = 2.0
   end
 
 Delete by id
@@ -81,6 +82,13 @@ Commit & Optimize
 == Response Formats
 The default response format is Ruby. When the :wt param is set to :ruby, the response is eval'd and wrapped up in a nice Mash (Hash) class. You can get a raw response by setting the :wt to "ruby" - notice, the string -- not a symbol. All other response formats are available as expected, :wt=>'xml' etc..
 
+===XML:
+  solr.select(:wt=>:xml)
+===JSON:
+  solr.select(:wt=>:json)
+===Raw Ruby
+  solr.select(:wt=>'ruby')
+
 You can access the original request context (path, params, url etc.) by using a block:
   solr.select(:q=>'*:*') do |solr_response, adapter_response|
     adapter_response[:status_code]

data/examples/direct.rb

@@ -17,4 +17,6 @@ docs.each do |doc|
   puts doc[:timestamp]
 end
 
-solr.delete_by_query('*:*') and solr.commit
+solr.delete_by_query('*:*') and solr.commit
+
+solr.adapter.close

data/lib/rsolr/http_client.rb

@@ -105,9 +105,9 @@ module RSolr::HTTPClient
     #
     # 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_params(:q=>'blah', 'facet.field'=>['location_facet', 'format_facet'])
+    #   hash_to_params(:q=>'blah', :fq=>['blah', 'blah'], :facet=>{:field=>['location_facet', 'format_facet']})
     # returns:
-    #   ?q=blah&facet.field=location_facet&facet.field=format.facet
+    #   ?q=blah&fq=blah&fq=blah&facet.field=location_facet&facet.field=format.facet
     #
     # if a value is empty/nil etc., the key is not added
     def hash_to_params(params)
@@ -119,6 +119,15 @@ module RSolr::HTTPClient
         v = params[k]
         if v.is_a?(Array)
           acc << v.reject{|i|i.to_s.empty?}.collect{|vv|build_param(k, vv)}
+        elsif v.is_a?(Hash)
+          # NOT USED
+          # creates dot based params like:
+          # hash_to_params(:facet=>{:field=>['one', 'two']}) == facet.field=one&facet.field=two
+          # TODO: should this go into a non-solr based param builder?
+          #   - dotted syntax is special to solr only
+          #v.each_pair do |field,field_value|
+          #  acc.push(hash_to_params({"#{k}.#{field}"=>field_value}))
+          #end
         elsif ! v.to_s.empty?
           acc.push(build_param(k, v))
         end

data/lib/rsolr/message.rb

@@ -6,49 +6,128 @@ require 'builder'
 
 class 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)
+        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
+    
+  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 << self
     
+    # shortcut method -> xml = RSolr::Message.xml
     def xml
       ::Builder::XmlMarkup.new
     end
     
-    # add({})
-    # add([{}, {}])
-    # add(docs) do |doc|
-    #   doc[:boost] = 10.0
+    # 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
-    def add(data, opts={}, &block)
-      data = [data] if data.respond_to?(:each_pair) # if it's a hash, put it in an array
-      xml.add(opts) do |add_xml|
+    #
+    # 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={}, &blk)
+      data = [data] if data.respond_to?(:each_pair)
+      xml.add(add_attrs) do |add_node|
         data.each do |item|
-          add_xml.doc do |doc_xml|
-            # convert keys into strings and perform an alpha sort (easier testing between ruby and jruby)
-            # but probably not great for performance? whatever...
-            #sorted_items = item.inject({}) {|acc,(k,v)| acc.merge({k.to_s=>v})}
-            item.keys.each do |k|
-              doc_attrs = {:name=>k}
-              yield item, doc_attrs if block_given?
-              [item[k]].flatten.each do |v| # multiValued attributes
-                doc_xml.field(v, doc_attrs)
-              end
+          # create doc, passing in fields
+          doc = Document.new(item)
+          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
     
+    # generates a <commit/> message
     def commit(opts={})
       xml.commit(opts)
     end
     
+    # generates a <optimize/> message
     def optimize(opts={})
       xml.optimize(opts)
     end
     
+    # generates a <rollback/> message
     def rollback
       xml.rollback
     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)
       xml.delete do |xml|
@@ -58,6 +137,8 @@ class RSolr::Message
       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)
       xml.delete do |xml|

data/lib/rsolr.rb

@@ -7,7 +7,7 @@ proc {|base, files|
 
 module RSolr
   
-  VERSION = '0.8.0'
+  VERSION = '0.8.1'
   
   autoload :Message, 'rsolr/message'
   autoload :Connection, 'rsolr/connection'
@@ -29,6 +29,25 @@ module RSolr
     RSolr::Connection.new(adapter, connection_opts)
   end
   
+  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
+    
+  end
+  
+  # send the escape method into the Connection class ->
+  # solr = RSolr.connect
+  # solr.escape('asdf')
+  RSolr::Connection.send(:include, Char)
+  
+  # bring escape into this module (RSolr) -> RSolr.escape('asdf')
+  extend Char
+  
   class RequestError < RuntimeError; end
   
 end

data/test/connection/test_methods.rb

@@ -6,11 +6,11 @@
 module ConnectionTestMethods
   
   
-  #def teardown
-  #  @solr.delete_by_query('id:[* TO *]')
-  #  @solr.commit
-  #  assert_equal 0, @solr.select(:q=>'*:*').docs.size
-  #end
+  def teardown
+    @solr.delete_by_query('id:[* TO *]')
+    @solr.commit
+    assert_equal 0, @solr.select(:q=>'*:*')[:response][:docs].size
+  end
   
   # If :wt is NOT :ruby, the format doesn't get converted into a Mash (special Hash; see lib/mash.rb)
   # Raw ruby can be returned by using :wt=>'ruby', not :ruby
@@ -56,7 +56,7 @@ module ConnectionTestMethods
   
   def test_add
     assert_equal 0, @solr.select(:q=>'*:*')[:response][:numFound]
-    update_response = @solr.add(:id=>100)
+    update_response = @solr.add({:id=>100})
     assert update_response.is_a?(Mash)
     #
     @solr.commit
@@ -79,7 +79,7 @@ module ConnectionTestMethods
     @solr.add(:id=>1, :name=>'BLAH BLAH BLAH')
     @solr.commit
     assert_equal 1, @solr.select(:q=>'*:*')[:response][:numFound]
-    response = @solr.delete_by_query('name:BLAH BLAH BLAH')
+    response = @solr.delete_by_query('name:"BLAH BLAH BLAH"')
     @solr.commit
     assert response.is_a?(Mash)
     assert_equal 0, @solr.select(:q=>'*:*')[:response][:numFound]

data/test/message_test.rb

@@ -14,13 +14,27 @@ class MessageTest < RSolrBaseTest
     end
   end
   
-  def test_add_yields_field_attrs_if_block_given
-    result = RSolr::Message.add({:id=>1}, :boost=>200.00) do |hash_doc, doc_xml_attrs|
-      doc_xml_attrs[:boost] = 10
+  def test_add_yields_doc_objects_if_block_given
+    documents = [{:id=>1, :name=>'sam', :cat=>['cat 1', 'cat 2']}]
+    add_attrs = {:boost=>200.00}
+    result = RSolr::Message.add(documents, add_attrs) do |doc|
+      doc.field_by_name(:name).attrs[:boost] = 10
+      assert_equal 4, doc.fields.size
+      assert_equal 2, doc.fields_by_name(:cat).size
     end
-    assert result =~ /add boost="200.0"/
-    assert result =~ /boost="10"/
-    #assert_equal '<add boost="200.0"><doc><field name="id" boost="10">1</field></doc></add>', result
+    #<add boost="200.0">
+      #<doc>
+        #<field name="cat">cat 1</field>
+        #<field name="cat">cat 2</field>
+        #<field name="name" boost="10">sam</field>
+        #<field name="id">1</field>
+      #</doc>
+    #</add>
+    assert result =~ %r(name="cat">cat 1</field>)
+    assert result =~ %r(name="cat">cat 2</field>)
+    assert result =~ %r(<add boost="200.0">)
+    assert result =~ %r(boost="10")
+    assert result =~ %r(<field name="id">1</field>)
   end
   
   def test_delete_by_id
@@ -83,8 +97,11 @@ class MessageTest < RSolrBaseTest
       :id   => 1,
       :name => ['matt1', 'matt2']
     }
-    assert RSolr::Message.add(data).to_s =~ /<field name="name">matt1<\/field>/
-    assert RSolr::Message.add(data).to_s =~ /<field name="name">matt2<\/field>/
+    
+    result = RSolr::Message.add(data)
+    
+    assert result.to_s =~ /<field name="name">matt1<\/field>/
+    assert result.to_s =~ /<field name="name">matt2<\/field>/
   end
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mwmitchell-rsolr
 version: !ruby/object:Gem::Version 
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors: 
 - Matt Mitchell
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-11 00:00:00 -07:00
+date: 2009-03-12 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency