rsolr 1.1.2 → 2.0.0.pre1

data/lib/rsolr/xml.rb

@@ -2,100 +2,11 @@ begin; require 'nokogiri'; rescue LoadError; end
 require 'time'
 
 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)
-        wrap(values).each do |v|
-          v = format_value(v)
-          next if v.empty?
-          @fields << RSolr::Xml::Field.new({:name=>field}, v)
-        end
-      end
-      @attrs={}
-    end
+  require 'rsolr/document'
 
-    # 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
-
-    private
-
-    def format_value(v)
-      case v
-      when Time
-        v.getutc.iso8601
-      when DateTime
-        v.to_time.getutc.iso8601
-      when Date
-        Time.utc(v.year, v.mon, v.mday).iso8601
-      else
-        v.to_s
-      end
-    end
+  Document = RSolr::Document
+  Field = RSolr::Field
 
-    def wrap(object)
-      if object.nil?
-        []
-      elsif object.respond_to?(:to_ary)
-        object.to_ary || [object]
-      elsif object.is_a? Enumerable
-        object
-      else
-        [object]
-      end
-    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
     class << self
       attr_accessor :use_nokogiri
@@ -162,13 +73,9 @@ module RSolr::Xml
       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)
+            doc = RSolr::Document.new(doc) if doc.respond_to?(:each_pair)
             yield doc if block_given?
-            doc_node_builder = lambda do |doc_node|
-              doc.fields.each do |field_obj|
-                doc_node.field field_obj.value, field_obj.attrs
-              end
-            end
+            doc_node_builder = to_xml(doc)
             self.class.use_nokogiri ? add_node.doc_(doc.attrs,&doc_node_builder) : add_node.doc(doc.attrs,&doc_node_builder)
           end
         end
@@ -215,5 +122,24 @@ module RSolr::Xml
         end
       end
     end
+
+    private
+
+    def to_xml(doc)
+      lambda do |doc_node|
+        doc.fields.each do |field_obj|
+          value = field_obj.value
+          if field_obj.name.to_s == RSolr::Document::CHILD_DOCUMENT_KEY
+            child_node_builder = to_xml(field_obj.value)
+            self.class.use_nokogiri ? doc_node.doc_(&child_node_builder) : doc_node.doc(&child_node_builder)
+          elsif value.is_a?(Hash) && value.length == 1 && field_obj.attrs[:update].nil?
+            update_attr, real_value = value.first
+            doc_node.field real_value, field_obj.attrs.merge(update: update_attr)
+          else
+            doc_node.field field_obj.value, field_obj.attrs
+          end
+        end
+      end
+    end
   end
 end

data/lib/rsolr.rb

@@ -1,16 +1,15 @@
 module RSolr
-  
   Dir.glob(File.expand_path("../rsolr/*.rb", __FILE__)).each{|rb_file| require(rb_file)}
-  
+
   def self.connect *args
-    driver = Class === args[0] ? args[0] : RSolr::Connection
-    opts = Hash === args[-1] ? args[-1] : {}
-    Client.new driver.new, opts
+    opts = args.pop if args.last.is_a?(::Hash)
+    opts ||= {}
+
+    connection = args.first
+
+    Client.new connection, opts
   end
-  
-  # RSolr.escape, which is deprecated as of 2015-02
-  extend Char
-  
+
   # backslash escape characters that have special meaning to Solr query parser
   # per http://lucene.apache.org/core/4_0_0/queryparser/org/apache/lucene/queryparser/classic/package-summary.html#Escaping_Special_Characters
   #  + - & | ! ( ) { } [ ] ^ " ~ * ? : \ /

data/rsolr.gemspec

@@ -32,6 +32,8 @@ Gem::Specification.new do |s|
   s.required_ruby_version      = '>= 1.9.3'
 
   s.add_dependency 'builder', '>= 2.1.2'
+  s.add_dependency 'faraday'
+
   s.add_development_dependency 'activesupport'
   s.add_development_dependency 'nokogiri', '>= 1.4.0'
   s.add_development_dependency 'rake', '~> 10.0'

data/spec/api/client_spec.rb

@@ -1,20 +1,15 @@
 require 'spec_helper'
-describe "RSolr::Client" do
 
-  module ClientHelper
-    def client
-      @client ||= (
-        connection = RSolr::Connection.new
-        RSolr::Client.new connection, :url => "http://localhost:9999/solr", :read_timeout => 42, :open_timeout=>43
-      )
-    end
+RSpec.describe RSolr::Client do
+  let(:connection) { nil }
+  let(:connection_options) { { url: "http://localhost:9999/solr", read_timeout: 42, open_timeout: 43, update_format: :xml } }
 
-    def client_with_proxy
-      @client_with_proxy ||= (
-        connection = RSolr::Connection.new
-        RSolr::Client.new connection, :url => "http://localhost:9999/solr", :proxy => 'http://localhost:8080', :read_timeout => 42, :open_timeout=>43
-      )
-    end
+  let(:client) do
+    RSolr::Client.new connection, connection_options
+  end
+
+  let(:client_with_proxy) do
+    RSolr::Client.new connection, connection_options.merge(proxy: 'http://localhost:8080')
   end
 
   context "initialize" do
@@ -49,61 +44,20 @@ describe "RSolr::Client" do
   end
 
   context "send_and_receive" do
-    include ClientHelper
     it "should forward these method calls the #connection object" do
       [:get, :post, :head].each do |meth|
-        expect(client.connection).to receive(:execute).
+        expect(client).to receive(:execute).
           and_return({:status => 200, :body => "{}", :headers => {}})
         client.send_and_receive '', :method => meth, :params => {}, :data => nil, :headers => {}
       end
     end
-
-    it "should be timeout aware" do
-      [:get, :post, :head].each do |meth|
-        expect(client.connection).to receive(:execute).with(client, hash_including(:read_timeout => 42, :open_timeout=>43))
-        client.send_and_receive '', :method => meth, :params => {}, :data => nil, :headers => {}
-      end
-    end
-  end
-
-  context "execute" do
-    include ClientHelper
-    let :request_context do
-      {
-        :method => :post,
-        :params => {},
-        :data => nil,
-        :headers => {},
-        :path => '',
-        :uri => client.base_uri,
-        :retry_503 => 1
-      }
-    end
-    it "should retry 503s if requested" do
-      expect(client.connection).to receive(:execute).exactly(2).times.and_return(
-        {:status => 503, :body => "{}", :headers => {'Retry-After' => 0}},
-        {:status => 200, :body => "{}", :headers => {}}
-      )
-      client.execute request_context
-    end
-    it "should not retry a 503 if the retry-after is too large" do
-      expect(client.connection).to receive(:execute).exactly(1).times.and_return(
-        {:status => 503, :body => "{}", :headers => {'Retry-After' => 10}}
-      )
-      expect {
-        Timeout.timeout(0.5) do
-          client.execute({:retry_after_limit => 0}.merge(request_context))
-        end
-      }.to raise_error(RSolr::Error::Http)
-    end
   end
 
   context "post" do
-    include ClientHelper
     it "should pass the expected params to the connection's #execute method" do
       request_opts = {:data => "the data", :method=>:post, :headers => {"Content-Type" => "text/plain"}}
-      expect(client.connection).to receive(:execute).
-        with(client, hash_including(request_opts)).
+      expect(client).to receive(:execute).
+        with(hash_including(request_opts)).
         and_return(
           :body => "",
           :status => 200,
@@ -114,18 +68,22 @@ describe "RSolr::Client" do
   end
 
   context "xml" do
-    include ClientHelper
     it "should return an instance of RSolr::Xml::Generator" do
       expect(client.xml).to be_a RSolr::Xml::Generator
     end
   end
 
+  context "json" do
+    it "should return an instance of RSolr::JSON::Generator" do
+      expect(client.json).to be_a RSolr::JSON::Generator
+    end
+  end
+
   context "add" do
-    include ClientHelper
     it "should send xml to the connection's #post method" do
-      expect(client.connection).to receive(:execute).
+      expect(client).to receive(:execute).
         with(
-          client, hash_including({
+          hash_including({
             :path => "update",
             :headers => {"Content-Type"=>"text/xml"},
             :method => :post,
@@ -142,14 +100,54 @@ describe "RSolr::Client" do
         and_return("<xml/>")
       client.add({:id=>1}, :add_attributes => {:commitWith=>10})
     end
+
+    context 'when the client is configured for json updates' do
+      let(:client) do
+        RSolr::Client.new nil, :url => "http://localhost:9999/solr", :read_timeout => 42, :open_timeout=>43, :update_format => :json
+      end
+      it "should send json to the connection's #post method" do
+        expect(client).to receive(:execute).
+          with(hash_including({
+              :path => 'update',
+              :headers => {"Content-Type" => 'application/json'},
+              :method => :post,
+              :data => '{"hello":"this is json"}'
+            })
+          ).
+            and_return(
+              :body => "",
+              :status => 200,
+              :headers => {"Content-Type"=>"text/xml"}
+            )
+        expect(client.json).to receive(:add).
+          with({:id => 1}, {:commitWith=>10}).
+            and_return('{"hello":"this is json"}')
+        client.add({:id=>1}, :add_attributes => {:commitWith=>10})
+      end
+
+      it "should send json to the connection's #post method" do
+        expect(client).to receive(:execute).
+          with(hash_including({
+              :path => 'update',
+              :headers => {'Content-Type'=>'application/json'},
+              :method => :post,
+              :data => '{"optimise" : {}}'
+            })
+          ).
+            and_return(
+              :body => "",
+              :status => 200,
+              :headers => {"Content-Type"=>"text/xml"}
+          )
+        client.update(:data => '{"optimise" : {}}')
+      end
+    end
   end
 
   context "update" do
-    include ClientHelper
     it "should send data to the connection's #post method" do
-      expect(client.connection).to receive(:execute).
-        with(
-          client, hash_including({
+      expect(client).to receive(:execute).
+        with(hash_including({
             :path => "update",
             :headers => {"Content-Type"=>"text/xml"},
             :method => :post,
@@ -178,12 +176,10 @@ describe "RSolr::Client" do
   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
-        expect(client.connection).to receive(:execute).
-          with(
-            client, hash_including({
+        expect(client).to receive(:execute).
+          with(hash_including({
               :path => "update",
               :headers => {"Content-Type"=>"text/xml"},
               :method => :post,
@@ -201,11 +197,10 @@ describe "RSolr::Client" do
   end
 
   context "delete_by_id" do
-    include ClientHelper
     it "should send data to the connection's #post method" do
-      expect(client.connection).to receive(:execute).
+      expect(client).to receive(:execute).
         with(
-          client, hash_including({
+          hash_including({
             :path => "update",
             :headers => {"Content-Type"=>"text/xml"},
             :method => :post,
@@ -222,11 +217,10 @@ describe "RSolr::Client" do
   end
 
   context "delete_by_query" do
-    include ClientHelper
     it "should send data to the connection's #post method" do
-      expect(client.connection).to receive(:execute).
+      expect(client).to receive(:execute).
         with(
-          client, hash_including({
+          hash_including({
             :path => "update",
             :headers => {"Content-Type"=>"text/xml"},
             :method => :post,
@@ -243,7 +237,6 @@ describe "RSolr::Client" do
   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.adapt_response({:params=>{}}, {:status => 200, :body => body, :headers => {}})
@@ -281,9 +274,9 @@ describe "RSolr::Client" do
   end
 
   context "indifferent access" do
-    include ClientHelper
     it "should raise a RuntimeError if the #with_indifferent_access extension isn't loaded" do
-      hide_const("HashWithIndifferentAccess")
+      hide_const("::RSolr::HashWithIndifferentAccessWithResponse")
+      hide_const("ActiveSupport::HashWithIndifferentAccess")
       body = "{'foo'=>'bar'}"
       result = client.adapt_response({:params=>{:wt=>:ruby}}, {:status => 200, :body => body, :headers => {}})
       expect { result.with_indifferent_access }.to raise_error RuntimeError
@@ -306,7 +299,6 @@ describe "RSolr::Client" do
   end
 
   context "build_request" do
-    include ClientHelper
     let(:data) { 'data' }
     let(:params) { { q: 'test', fq: [0,1] } }
     let(:options) { { method: :post, params: params, data: data, headers: {} } }
@@ -314,7 +306,7 @@ describe "RSolr::Client" do
 
     context "when params are symbols" do
       it 'should return a request context array' do
-        [/fq=0/, /fq=1/, /q=test/, /wt=ruby/].each do |pattern|
+        [/fq=0/, /fq=1/, /q=test/, /wt=json/].each do |pattern|
           expect(subject[:query]).to match pattern
         end
         expect(subject[:data]).to eq("data")
@@ -336,11 +328,11 @@ describe "RSolr::Client" do
       let(:options) { { method: :post, data: data, headers: {} } }
 
       it "sets the Content-Type header to application/x-www-form-urlencoded; charset=UTF-8" do
-        expect(subject[:query]).to eq("wt=ruby")
+        expect(subject[:query]).to eq("wt=json")
         [/fq=0/, /fq=1/, /q=test/].each do |pattern|
           expect(subject[:data]).to match pattern
         end
-        expect(subject[:data]).not_to match /wt=ruby/
+        expect(subject[:data]).not_to match(/wt=json/)
         expect(subject[:headers]).to eq({"Content-Type" => "application/x-www-form-urlencoded; charset=UTF-8"})
       end
     end
@@ -351,7 +343,7 @@ describe "RSolr::Client" do
         :data => {:q=>'test', :fq=>[0,1]},
         :headers => {}
       )
-      expect(result[:uri].to_s).to match /^http:\/\/localhost:9999\/solr\//
-    end 
+      expect(result[:uri].to_s).to match %r{^http://localhost:9999/solr/}
+    end
   end
 end

data/spec/api/document_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+RSpec.describe RSolr::Document do
+  describe RSolr::Field do
+    describe ".instance" do
+      subject { RSolr::Field }
+
+      it "uses the class name of the field value" do
+        expect(subject.instance({}, Time.new)).to be_a_kind_of(RSolr::TimeField)
+      end
+
+      it "uses the provided type option when it is a class" do
+        expect(subject.instance({:type => RSolr::TimeField}, nil)).to be_a_kind_of(RSolr::TimeField)
+      end
+
+      it "uses the provided type option when it is a string" do
+        expect(subject.instance({:type => 'Time'}, nil)).to be_a_kind_of(RSolr::TimeField)
+      end
+
+      it "falls back to the base Field class" do
+        expect(subject.instance({:type => 'UndefinedType'}, nil)).to be_a_kind_of(RSolr::Field)
+      end
+
+      it "defaults to the base Field class" do
+        expect(subject.instance({}, nil)).to be_a_kind_of(RSolr::Field)
+      end
+    end
+  end
+
+  describe RSolr::TimeField do
+    it "convert value to string" do
+      time_value = Time.utc(2013, 9, 11, 18, 10, 0)
+      expect(RSolr::Field.instance({}, time_value).value).to eq '2013-09-11T18:10:00Z'
+    end
+
+    it "convert time to UTC" do
+      time_value = Time.new(2013, 9, 11, 18, 10, 0, '+02:00')
+      expect(RSolr::Field.instance({}, time_value).value).to eq '2013-09-11T16:10:00Z'
+    end
+  end
+
+  describe RSolr::DateField do
+    it "convert value to string" do
+      date_value = Date.new(2013, 9, 11)
+      expect(RSolr::Field.instance({}, date_value).value).to eq '2013-09-11T00:00:00Z'
+    end
+  end
+end

data/spec/api/error_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
-describe "RSolr::Error" do
+
+RSpec.describe RSolr::Error do
   def generate_error_with_backtrace(request, response)
     raise RSolr::Error::Http.new request, response
   rescue RSolr::Error::Http => exception

data/spec/api/json_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+RSpec.describe RSolr::JSON do
+
+  let(:generator){ RSolr::JSON::Generator.new }
+
+  context :add do
+    # add a single hash ("doc")
+    it 'should create an add from a hash' do
+      data = {
+        :id=>"1",
+        :name=>'matt'
+      }
+      message = JSON.parse(generator.add(data), symbolize_names: true)
+      expect(message.length).to eq 1
+      expect(message.first).to eq data
+    end
+
+    # add an array of hashes
+    it 'should create many adds from an array of hashes' do
+      data = [
+        {
+          :id=>"1",
+          :name=>'matt'
+        },
+        {
+          :id=>"2",
+          :name=>'sam'
+        }
+      ]
+      message = JSON.parse(generator.add(data), symbolize_names: true)
+      expect(message).to eq data
+    end
+
+    it 'should yield a Document object when #add is called with a block' do
+      documents = [{:id=>1, :name=>'sam', :cat=>['cat 1', 'cat 2']}]
+      result = generator.add(documents) do |doc|
+        doc.field_by_name(:name).attrs[:boost] = 10
+      end
+
+      message = JSON.parse(result, symbolize_names: true)
+
+      expect(message.length).to eq 1
+      expect(message.first).to include name: { boost: 10, value: 'sam' }
+    end
+
+    context 'with add_attr' do
+      it 'should create an add command with the attributes from a hash' do
+        data = {
+          :id=>"1",
+          :name=>'matt'
+        }
+        message = JSON.parse(generator.add(data, boost: 1), symbolize_names: true)
+        expect(message).to include :add
+        expect(message[:add][:doc]).to eq data
+        expect(message[:add][:boost]).to eq 1
+      end
+
+      it 'should create multiple add command with the attributes from a hash' do
+        data = [
+          {
+            :id=>"1",
+            :name=>'matt'
+          },
+          {
+            :id=>"2",
+            :name=>'sam'
+          },
+        ]
+
+        # custom JSON object class to handle Solr's non-standard JSON command format
+        tmp = Class.new do
+          def initialize
+            @source ||= {}
+          end
+
+          def []=(k, v)
+            if k == :add
+              @source[k] ||= []
+              @source[k] << v.to_h
+            elsif v.class == self.class
+              @source[k] = v.to_h
+            else
+              @source[k] = v
+            end
+          end
+
+          def to_h
+            @source
+          end
+        end
+
+        request = generator.add(data, boost: 1)
+        message = JSON.parse(request, object_class: tmp, symbolize_names: true).to_h
+        expect(message[:add].length).to eq 2
+        expect(message[:add].map { |x| x[:doc] }).to eq data
+      end
+    end
+
+    it 'allows for atomic updates' do
+      data = {
+        foo: { set: 'Bar' }
+      }
+
+      message = JSON.parse(generator.add(data), symbolize_names: true)
+      expect(message.length).to eq 1
+      expect(message.first).to eq data
+    end
+
+    it 'supports nested child documents' do
+      data = {
+        _childDocuments_: [
+          {
+            id: 1
+          },
+          {
+            id: 2
+          }
+        ]
+      }
+
+      message = JSON.parse(generator.add(data), symbolize_names: true)
+      expect(message.length).to eq 1
+      expect(message.first).to eq data
+    end
+  end
+
+  it 'should create multiple fields from array values' do
+    data = {
+      :id   => "1",
+      :name => ['matt1', 'matt2']
+    }
+    message = JSON.parse(generator.add(data), symbolize_names: true)
+    expect(message.length).to eq 1
+    expect(message.first).to eq data
+  end
+
+  describe '#commit' do
+    it 'generates a commit command' do
+      expect(JSON.parse(generator.commit, symbolize_names: true)).to eq(commit: {})
+    end
+  end
+
+  describe '#optimize' do
+    it 'generates a optimize command' do
+      expect(JSON.parse(generator.optimize, symbolize_names: true)).to eq(optimize: {})
+    end
+  end
+
+  describe '#rollback' do
+    it 'generates a rollback command' do
+      expect(JSON.parse(generator.rollback, symbolize_names: true)).to eq(rollback: {})
+    end
+  end
+
+  describe '#delete_by_id' do
+    it 'generates a delete_by_id command for single documents' do
+      expect(JSON.parse(generator.delete_by_id('x'), symbolize_names: true)).to eq(delete: 'x')
+    end
+
+    it 'generates a delete_by_id command for an array of documents' do
+      expect(JSON.parse(generator.delete_by_id(%w(a b c)), symbolize_names: true)).to eq(delete: %w(a b c))
+    end
+  end
+
+  describe '#delete_by_query' do
+    it 'generates a delete_by_id command for single documents' do
+      expect(JSON.parse(generator.delete_by_query('id:x'), symbolize_names: true)).to eq(delete: { query: 'id:x'})
+    end
+
+    it 'generates a delete_by_id command for an array of documents' do
+      expect(JSON.parse(generator.delete_by_id(%w(a b c)), symbolize_names: true)).to eq(delete: %w(a b c))
+    end
+  end
+end