solr4r 0.2.0 → 0.3.0

data/lib/solr4r/client/{query.rb → query_mixin.rb}

@@ -5,7 +5,7 @@
 #                                                                             #
 # solr4r -- A Ruby client for Apache Solr                                     #
 #                                                                             #
-# Copyright (C) 2014-2015 Jens Wille                                          #
+# Copyright (C) 2014-2016 Jens Wille                                          #
 #                                                                             #
 # solr4r is free software: you can redistribute it and/or modify it under the #
 # terms of the GNU Affero General Public License as published by the Free     #
@@ -30,6 +30,7 @@ module Solr4R
     MATCH_ALL_QUERY = '*:*'
 
     DEFAULT_SELECT_PATH = 'select'
+    DEFAULT_SPELL_PATH  = 'spell'
     DEFAULT_MLT_PATH    = 'mlt'
 
     MLT_DEFAULT_FL   = '*,score'
@@ -45,7 +46,7 @@ module Solr4R
       minwl
     ], type: :mlt, qf: '$mlt.fl')
 
-    module Query
+    module QueryMixin
 
       def count(
           params = {}, options = {}, path = DEFAULT_SELECT_PATH, &block)
@@ -96,7 +97,7 @@ module Solr4R
 
     end
 
-    include Query
+    include QueryMixin
 
   end
 

data/lib/solr4r/client/{update.rb → update_mixin.rb}

@@ -5,7 +5,7 @@
 #                                                                             #
 # solr4r -- A Ruby client for Apache Solr                                     #
 #                                                                             #
-# Copyright (C) 2014-2015 Jens Wille                                          #
+# Copyright (C) 2014-2016 Jens Wille                                          #
 #                                                                             #
 # solr4r is free software: you can redistribute it and/or modify it under the #
 # terms of the GNU Affero General Public License as published by the Free     #
@@ -33,7 +33,7 @@ module Solr4R
 
     DEFAULT_UPDATE_PATH = 'update'
 
-    module Update
+    module UpdateMixin
 
       def update(data,
           params = {}, options = {},
@@ -51,18 +51,12 @@ module Solr4R
         update(builder.add(doc, attributes), params, options, &block)
       end
 
-      def add_batch(docs, attributes = {},
-          params = {}, options = {}, batch_size = DEFAULT_BATCH_SIZE, &block)
-
-        failed = []
-
-        docs.each_slice(batch_size) { |batch|
-          add(batch, attributes, params, options, &block).success? ||
-            failed.concat(batch_size == 1 ? batch : add_batch(batch,
-              attributes, params, options, batch_size / 10, &block))
-        }
+      def add_batch(docs, *args, &block)
+        batch(*args, &block).batch(docs).flush
+      end
 
-        failed
+      def batch(*args, &block)
+        Batch.new(self, *args, &block)
       end
 
       # See Builder#commit.
@@ -118,7 +112,7 @@ module Solr4R
 
     end
 
-    include Update
+    include UpdateMixin
 
   end
 

data/lib/solr4r/client.rb

@@ -5,7 +5,7 @@
 #                                                                             #
 # solr4r -- A Ruby client for Apache Solr                                     #
 #                                                                             #
-# Copyright (C) 2014-2015 Jens Wille                                          #
+# Copyright (C) 2014-2016 Jens Wille                                          #
 #                                                                             #
 # solr4r is free software: you can redistribute it and/or modify it under the #
 # terms of the GNU Affero General Public License as published by the Free     #
@@ -44,88 +44,20 @@ module Solr4R
 
     class << self
 
+      extend Forwardable
+
+      def_delegators Query, :escape, :query_string, :local_params_string
+
       def default_uri(options = {})
         DEFAULT_URI % [
           options.fetch(:host, DEFAULT_HOST),
           options.fetch(:port, DEFAULT_PORT),
           options.fetch(:path, DEFAULT_PATH),
-          options.fetch(:core, DEFAULT_CORE)
+          options.fetch(:collection) {
+          options.fetch(:core, DEFAULT_CORE) }
         ]
       end
 
-      def query_string(query, escape = true)
-        case query
-          when nil
-            # ignore
-          when String
-            escape(query, escape) unless query.empty?
-          when Array
-            if query.last.is_a?(Hash)
-              lp, qs = query_from_hash((query = query.dup).pop, escape)
-              query << qs if qs
-            end
-
-            query_with_params(lp, query_string(query.join(' '), escape))
-          when Hash
-            query_with_params(*query_from_hash(query, escape))
-          else
-            type_error(query)
-        end
-      end
-
-      def local_params_string(local_params, hash = {}, escape = true)
-        case local_params = expand_local_params(local_params, hash.dup)
-          when nil
-            # ignore
-          when String
-            escape("{!#{local_params}}", escape) unless local_params.empty?
-          when Array
-            local_params_string(local_params.join(' '), {}, escape)
-          when Hash
-            local_params_string(local_params.map { |key, value|
-              "#{key}=#{value =~ /\s/ ? %Q{"#{value}"} : value}" }, {}, escape)
-          else
-            type_error(local_params)
-        end
-      end
-
-      def escape(string, escape = true)
-        escape ? string.gsub('&', '%26') : string
-      end
-
-      private
-
-      def query_from_hash(query, escape)
-        local_params = query.key?(lp = :_) &&
-          local_params_string((query = query.dup).delete(lp), {}, escape)
-
-        [local_params, query_string(query.flat_map { |key, values|
-          Array(values).map { |value| "#{key}:#{value}" } }, escape)]
-      end
-
-      def query_with_params(local_params, query_string)
-        local_params ? local_params + query_string : query_string
-      end
-
-      def expand_local_params(local_params, hash)
-        case type = hash[:type]
-          when nil
-            local_params
-          when String, Symbol
-            type_error(local_params, Array) unless local_params.is_a?(Array)
-
-            local_params.each { |param| hash[param] = "$#{type}.#{param}" }
-            hash
-          else
-            type_error(type, %w[String Symbol])
-        end
-      end
-
-      def type_error(obj, types = %w[String Array Hash])
-        types = Array(types).join(' or ')
-        raise TypeError, "#{types} expected, got #{obj.class}", caller(1)
-      end
-
     end
 
     def initialize(options = {})
@@ -152,6 +84,8 @@ module Solr4R
 
     def_delegators 'self.class', :query_string, :local_params_string, :escape
 
+    def_delegators :request, :request_line, :execute
+
     def json(path,
         params = {}, options = {}, &block)
 
@@ -181,7 +115,7 @@ module Solr4R
 
     def inspect
       '#<%s:0x%x @default_params=%p %s>' % [
-        self.class, object_id, default_params, request.request_line
+        self.class, object_id, default_params, request_line
       ]
     end
 
@@ -191,23 +125,19 @@ module Solr4R
       self.class.default_uri(options)
     end
 
-    def amend_options_hash(options, key, value)
-      options.merge(key => value.merge(options.fetch(key, {})))
-    end
-
-    def amend_options_array(options, key, *value)
-      options.merge(key => Array(options[key]) + value)
-    end
-
     def send_request(path, options, &block)
-      request.execute(path, amend_options_hash(
+      execute(path, amend_options_hash(
         options, :params, default_params), &block)
     end
 
+    def amend_options_hash(options, key, value)
+      options.merge(key => value.merge(options.fetch(key, {})))
+    end
+
   end
 
 end
 
-require_relative 'client/update'
-require_relative 'client/query'
-require_relative 'client/admin'
+require_relative 'client/update_mixin'
+require_relative 'client/query_mixin'
+require_relative 'client/admin_mixin'

data/lib/solr4r/document.rb

@@ -5,7 +5,7 @@
 #                                                                             #
 # solr4r -- A Ruby client for Apache Solr                                     #
 #                                                                             #
-# Copyright (C) 2014-2015 Jens Wille                                          #
+# Copyright (C) 2014-2016 Jens Wille                                          #
 #                                                                             #
 # solr4r is free software: you can redistribute it and/or modify it under the #
 # terms of the GNU Affero General Public License as published by the Free     #
@@ -33,6 +33,9 @@ module Solr4R
 
     def initialize(result, hash)
       @result, @hash = result, hash
+
+      hash.each { |key, val|
+        define_singleton_method(key) { val } unless respond_to?(key, true) }
     end
 
     attr_reader :result

data/lib/solr4r/endpoints.rb

@@ -5,7 +5,7 @@
 #                                                                             #
 # solr4r -- A Ruby client for Apache Solr                                     #
 #                                                                             #
-# Copyright (C) 2014-2015 Jens Wille                                          #
+# Copyright (C) 2014-2016 Jens Wille                                          #
 #                                                                             #
 # solr4r is free software: you can redistribute it and/or modify it under the #
 # terms of the GNU Affero General Public License as published by the Free     #
@@ -42,6 +42,13 @@ module Solr4R
       case path
         when nil
           # ignore
+        when Symbol
+          register(path.to_s, options)
+        when Array
+          path.each { |args| register(*args) }
+        when Hash
+          path.each { |_path, _options| register(_path,
+            _options.is_a?(Hash) ? _options : { path: _options }) }
         when String
           name, path = File.basename(path), options.fetch(:path, path).to_s
 
@@ -54,15 +61,8 @@ module Solr4R
             client.send(:send_request, path, options.merge(_options.merge(
               params: options.fetch(:params, {}).merge(_params))), &block)
           }
-        when Symbol
-          register(path.to_s, options)
-        when Array
-          path.each { |args| register(*args) }
-        when Hash
-          path.each { |_path, _options| register(_path,
-            _options.is_a?(Hash) ? _options : { path: _options }) }
         else
-          client.class.send(:type_error, path, %w[String Symbol Array Hash])
+          raise TypeError, "unexpected type #{path.class}"
       end
 
       self

data/lib/solr4r/query.rb

@@ -0,0 +1,181 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# solr4r -- A Ruby client for Apache Solr                                     #
+#                                                                             #
+# Copyright (C) 2014-2016 Jens Wille                                          #
+#                                                                             #
+# solr4r is free software: you can redistribute it and/or modify it under the #
+# terms of the GNU Affero General Public License as published by the Free     #
+# Software Foundation, either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# solr4r is distributed in the hope that it will be useful, but WITHOUT ANY   #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with solr4r. If not, see <http://www.gnu.org/licenses/>.              #
+#                                                                             #
+###############################################################################
+#++
+
+require 'time'
+
+module Solr4R
+
+  class Query
+
+    LOCAL_PARAMS_KEY = :_
+
+    class << self
+
+      def query_string(*args)
+        new(*args).to_s
+      end
+
+      def local_params_string(*args)
+        new.local_params_string(*args)
+      end
+
+      def escape(string, escape = true)
+        escape ? string.gsub('&', '%26') : string
+      end
+
+      def quote(string)
+        string =~ /\s/ ? %Q{"#{string}"} : string
+      end
+
+      def convert_value(value, escape = true)
+        case value
+          when DateTime
+            convert_value(value.to_time, escape)
+          when Time
+            value.getutc.xmlschema.tap { |string|
+              string.gsub!(/:/, '\\\\\&') if escape }
+          when Range
+            '[' << [value.begin, value.end].map { |v|
+              convert_value(v, false) }.join(' TO ') << ']'
+          else
+            value.to_s
+        end
+      end
+
+    end
+
+    def initialize(query = '', escape = true)
+      @query, @escape = query, escape
+    end
+
+    attr_reader :query
+
+    attr_writer :escape
+
+    def escape?
+      @escape
+    end
+
+    def escape(string, escape = escape?)
+      self.class.escape(string, escape)
+    end
+
+    def quote(string)
+      self.class.quote(string)
+    end
+
+    def convert_value(*args)
+      self.class.convert_value(*args)
+    end
+
+    def to_s(escape = escape?)
+      query_string(query, escape)
+    end
+
+    def query_string(query = query(), escape = escape?)
+      case query
+        when nil
+          # ignore
+        when String
+          escape(query, escape) unless query.empty?
+        when Array
+          if query.last.is_a?(Hash)
+            query = query.dup
+
+            local_params, query_string = query_from_hash(query.pop, escape)
+            query << query_string if query_string
+          end
+
+          query_with_params(local_params, query_from_array(query, escape))
+        when Hash
+          query_with_params(*query_from_hash(query, escape))
+        else
+          type_error(query)
+      end
+    end
+
+    def local_params_string(local_params, hash = {}, escape = escape?)
+      case local_params = expand_local_params(local_params, hash)
+        when nil
+          # ignore
+        when String
+          escape("{!#{local_params}}", escape) unless local_params.empty?
+        when Array
+          local_params_string(local_params.join(' '), {}, escape)
+        when Hash
+          local_params_string(local_params.map { |key, value|
+            "#{key}=#{quote(value)}" }, {}, escape)
+        else
+          type_error(local_params)
+      end
+    end
+
+    private
+
+    def query_from_array(query, escape)
+      query_string(query.map { |value| convert_value(value) }.join(' '), escape)
+    end
+
+    def query_from_hash(query, escape)
+      if query.key?(LOCAL_PARAMS_KEY)
+        query = query.dup
+
+        local_params = local_params_string(
+          query.delete(LOCAL_PARAMS_KEY), {}, escape)
+      end
+
+      query = query.flat_map { |key, values|
+        block = lambda { |value| "#{key}:#{convert_value(value)}" }
+        values.respond_to?(:to_ary) ? values.map(&block) : block[values] }
+
+      [local_params, query_string(query, escape)]
+    end
+
+    def query_with_params(local_params, query_string)
+      local_params ? local_params + query_string : query_string
+    end
+
+    def expand_local_params(local_params, hash)
+      case type = hash[:type]
+        when nil
+          local_params
+        when String, Symbol
+          type_error(local_params) unless local_params.is_a?(Array)
+
+          hash = hash.dup
+          local_params.each { |param| hash[param] = "$#{type}.#{param}" }
+          hash
+        else
+          type_error(type)
+      end
+    end
+
+    def type_error(obj)
+      raise TypeError, "unexpected type #{obj.class}", caller(1)
+    end
+
+  end
+
+end

data/lib/solr4r/result.rb

@@ -5,7 +5,7 @@
 #                                                                             #
 # solr4r -- A Ruby client for Apache Solr                                     #
 #                                                                             #
-# Copyright (C) 2014-2015 Jens Wille                                          #
+# Copyright (C) 2014-2016 Jens Wille                                          #
 #                                                                             #
 # solr4r is free software: you can redistribute it and/or modify it under the #
 # terms of the GNU Affero General Public License as published by the Free     #
@@ -37,18 +37,22 @@ module Solr4R
 
     extend Forwardable
 
-    def self.types_for(hash, mix = Nuggets::String::CamelscoreMixin)
-      constants.map { |const|
-        if hash.key?(const.to_s.extend(mix).underscore!)
-          mod = const_get(const)
-          mod if mod.is_a?(Module)
-        end
-      }.compact
+    def self.types
+      @types ||= constants.each_with_object({}) { |const, hash|
+        mod, key = const_get(const), const.to_s; next unless mod.is_a?(Module)
+        hash[key.extend(Nuggets::String::CamelscoreMixin).underscore!] = mod
+      }
     end
 
     def initialize(response, hash)
-      types = self.class.types_for(hash); extend(*types) unless types.empty?
       @response, @hash = response, hash.extend(Nuggets::Hash::DeepFetchMixin)
+
+      self.class.types.each { |key, mod|
+        extend(mod) if val = hash.key?(key)
+
+        respond_to?(meth = "#{key}?", true) or
+          define_singleton_method(meth) { val }
+      }
     end
 
     attr_reader :response
@@ -73,10 +77,6 @@ module Solr4R
       to_i.zero?
     end
 
-    def error?
-      is_a?(Error)
-    end
-
     private
 
     def _each
@@ -102,6 +102,18 @@ module Solr4R
 
     end
 
+    module Debug
+
+      def debug
+        fetch(__method__.to_s)
+      end
+
+      def debug_explain
+        debug.fetch('explain')
+      end
+
+    end
+
     module Terms
 
       def to_i
@@ -142,6 +154,30 @@ module Solr4R
 
     end
 
+    module Highlighting
+
+      def highlighting
+        fetch(__method__.to_s)
+      end
+
+    end
+
+    module Spellcheck
+
+      def spellcheck
+        fetch(__method__.to_s)
+      end
+
+      def spellcheck_collations
+        return enum_for(__method__) unless block_given?
+
+        spellcheck.fetch('collations').each_slice(2) { |_, collation|
+          yield collation.values_at('collationQuery', 'hits')
+        }
+      end
+
+    end
+
   end
 
 end

data/lib/solr4r/version.rb

@@ -3,7 +3,7 @@ module Solr4R
   module Version
 
     MAJOR = 0
-    MINOR = 2
+    MINOR = 3
     TINY  = 0
 
     class << self

data/lib/solr4r.rb

@@ -5,7 +5,7 @@
 #                                                                             #
 # solr4r -- A Ruby client for Apache Solr                                     #
 #                                                                             #
-# Copyright (C) 2014-2015 Jens Wille                                          #
+# Copyright (C) 2014-2016 Jens Wille                                          #
 #                                                                             #
 # solr4r is free software: you can redistribute it and/or modify it under the #
 # terms of the GNU Affero General Public License as published by the Free     #
@@ -41,4 +41,6 @@ require_relative 'solr4r/builder'
 require_relative 'solr4r/request'
 require_relative 'solr4r/response'
 require_relative 'solr4r/endpoints'
+require_relative 'solr4r/query'
+require_relative 'solr4r/batch'
 require_relative 'solr4r/client'

data/spec/solr4r/builder_spec.rb

@@ -1,7 +1,5 @@
 describe Solr4R::Builder do
 
-  subject { described_class.new(Solr4R::Client.new) }
-
   describe '#add' do
 
     example do
@@ -100,6 +98,39 @@ describe Solr4R::Builder do
       EOT
     end
 
+    example do
+      expect(subject.add(date: Date.new(1992, 03, 15))).to eq(<<-EOT)
+<?xml version="1.0" encoding="UTF-8"?>
+<add>
+  <doc>
+    <field name="date">1992-03-15T00:00:00Z</field>
+  </doc>
+</add>
+      EOT
+    end
+
+    example do
+      expect(subject.add(time: Time.new(1992, 03, 15, 16, 23, 55, 3600))).to eq(<<-EOT)
+<?xml version="1.0" encoding="UTF-8"?>
+<add>
+  <doc>
+    <field name="time">1992-03-15T15:23:55Z</field>
+  </doc>
+</add>
+      EOT
+    end
+
+    example do
+      expect(subject.add(datetime: DateTime.new(1992, 03, 15, 16, 23, 55, '+1'))).to eq(<<-EOT)
+<?xml version="1.0" encoding="UTF-8"?>
+<add>
+  <doc>
+    <field name="datetime">1992-03-15T15:23:55Z</field>
+  </doc>
+</add>
+      EOT
+    end
+
   end
 
   describe '#commit' do

data/spec/solr4r/client_spec.rb

@@ -46,6 +46,20 @@ describe Solr4R::Client do
       ['title:foo -author%26:bar -author%26:baz', title: 'foo', '-author&' => %w[bar baz]],
       ['title:foo -author&:bar -author&:baz', { title: 'foo', '-author&' => %w[bar baz] }, false],
 
+      ['date:1992-03-15', date: Date.new(1992, 03, 15)],
+      ['time:1992-03-15T15\:23\:55Z', time: Time.new(1992, 03, 15, 16, 23, 55, 3600)],
+      ['datetime:1992-03-15T15\:23\:55Z', datetime: DateTime.new(1992, 03, 15, 16, 23, 55, '+1')],
+
+      ['stringrange:[a TO z]', stringrange: 'a'..'z'],
+      ['integerrange:[15 TO 25]', integerrange: 15..25],
+      ['floatrange:[-1.5 TO 2.5]', floatrange: -1.5..2.5],
+      ['daterange:[1992-03-15 TO 1992-04-25]',
+         daterange: Date.new(1992, 03, 15)..Date.new(1992, 04, 25)],
+      ['timerange:[1992-03-15T15:23:55Z TO 1992-04-25T15:23:55Z]',
+         timerange: Time.new(1992, 03, 15, 16, 23, 55, 3600)..Time.new(1992, 04, 25, 16, 23, 55, 3600)],
+      ['datetimerange:[1992-03-15T15:23:55Z TO 1992-04-25T15:23:55Z]',
+         datetimerange: DateTime.new(1992, 03, 15, 16, 23, 55, '+1')..DateTime.new(1992, 04, 25, 16, 23, 55, '+1')],
+
       ['{!q.op=AND}title:foo', title: 'foo', _: 'q.op=AND'],
       ['{!q.op=AND}title:foo author:bar', ['title:foo', author: 'bar', _: 'q.op=AND']],
       ['{!q.op=AND df=title}foo', ['foo', _: 'q.op=AND df=title']],