solr4r 0.0.5 → 0.0.6

data/lib/solr4r/client.rb

@@ -7,7 +7,7 @@
 #                                                                             #
 # Copyright (C) 2014-2015 Jens Wille                                          #
 #                                                                             #
-# Mir is free software: you can redistribute it and/or modify it under the    #
+# 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.                                                          #
@@ -30,178 +30,143 @@ module Solr4R
     include Logging
 
     DEFAULT_HOST = 'localhost'
-    DEFAULT_PATH = 'solr'
     DEFAULT_PORT = 8983
+    DEFAULT_PATH = 'solr'
+    DEFAULT_CORE = 'collection1'
 
-    DEFAULT_PARAMS = {
-      wt: :json
-    }
-
-    DEFAULT_BATCH_SIZE = 1000
-
-    DEFAULT_ENDPOINTS = %w[select query spell suggest terms] <<
-      ['ping', path: 'admin/ping', method: :head] <<
-      ['dump', path: 'debug/dump']
-
-    DEFAULT_SELECT_PATH = 'select'
-
-    DEFAULT_UPDATE_PATH = 'update'
-
-    DEFAULT_MLT_PATH = 'mlt'
-
-    SYSTEM_INFO_PATH = 'admin/info/system'
-
-    MATCH_ALL_QUERY = '*:*'
-
-    def initialize(options = {})
-      uri, options = options, {} unless options.is_a?(Hash)
-
-      self.options = options
-
-      uri ||= options.fetch(:uri, default_uri)
-
-      self.logger = options.fetch(:logger, default_logger)
+    DEFAULT_PARAMS = { wt: :json }
 
-      self.builder = options.fetch(:builder) {
-        forward_logger(Builder.new) }
+    class << self
 
-      self.request = options.fetch(:request) {
-        forward_logger(Request.new(self, uri)) }
+      def default_uri(options = {})
+        'http://%s:%d/%s/%s' % [
+          options.fetch(:host, DEFAULT_HOST),
+          options.fetch(:port, DEFAULT_PORT),
+          options.fetch(:path, DEFAULT_PATH),
+          options.fetch(:core, DEFAULT_CORE)
+        ]
+      end
 
-      self.default_params = options.fetch(:default_params, DEFAULT_PARAMS)
+      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
 
-      register_endpoints(options.fetch(:endpoints, DEFAULT_ENDPOINTS))
-    end
+      def local_params_string(local_params, hash = {}, escape = true)
+        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}=#{value =~ /\s/ ? %Q{"#{value}"} : value}" }, {}, escape)
+          else
+            type_error(local_params)
+        end
+      end
 
-    attr_accessor :options, :builder, :request, :default_params
+      def escape(string, escape = true)
+        escape ? string.gsub('&', '%26') : string
+      end
 
-    def register_endpoints(endpoints)
-      endpoints.each { |args| register_endpoint(*args) } if endpoints
-      self
-    end
+      private
 
-    def register_endpoint(path, options = {})
-      name, path = path, options.fetch(:path, path)
+      def query_from_hash(query, escape)
+        local_params = query.key?(lp = :_) &&
+          local_params_string((query = query.dup).delete(lp), {}, escape)
 
-      if error = invalid_endpoint?(name.to_s)
-        raise ArgumentError, "invalid endpoint: #{name} (#{error})"
-      else
-        define_singleton_method(name) { |_params = {}, _options = {}, &block|
-          send_request(path, options.merge(_options.merge(
-            params: options.fetch(:params, {}).merge(_params))), &block)
-        }
+        [local_params, query_string(query.flat_map { |key, values|
+          Array(values).map { |value| "#{key}:#{value}" } }, escape)]
       end
 
-      self
-    end
-
-    def json(path, params = {}, options = {}, &block)
-      get(path, params.merge(wt: :json), options, &block).result
-    end
-
-    def get(path, params = {}, options = {}, &block)
-      send_request(path, options.merge(method: :get, params: params), &block)
-    end
+      def query_with_params(local_params, query_string)
+        local_params ? local_params + query_string : query_string
+      end
 
-    def post(path, data = nil, options = {}, &block)
-      send_request(path, options.merge(method: :post, data: data), &block)
-    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 head(path, params = {}, options = {}, &block)
-      send_request(path, options.merge(method: :head, params: params), &block)
-    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
 
-    def update(data, options = {}, path = DEFAULT_UPDATE_PATH, &block)
-      options = amend_options(options, :headers, 'Content-Type' => 'text/xml')
-      post(path, data, options, &block)
     end
 
-    # See Builder#add.
-    def add(doc, attributes = {}, options = {}, &block)
-      update(builder.add(doc, attributes), options, &block)
-    end
+    def initialize(options = {})
+      uri, options = options, {} unless options.is_a?(Hash)
 
-    def add_batch(docs, attributes = {}, options = {}, batch_size = DEFAULT_BATCH_SIZE, &block)
-      failed = []
+      self.options, self.default_params =
+        options, options.fetch(:default_params, DEFAULT_PARAMS)
 
-      docs.each_slice(batch_size) { |batch|
-        unless add(batch, attributes, options, &block).success?
-          failed.concat(batch_size == 1 ? batch : add_batch(
-            batch, attributes, options, batch_size / 10, &block))
-        end
-      }
+      self.logger  = options.fetch(:logger)  { default_logger }
 
-      failed
-    end
+      self.builder = options.fetch(:builder) { forward_logger(Builder.new) }
 
-    # See Builder#commit.
-    def commit(attributes = {}, options = {}, &block)
-      update(builder.commit(attributes), options, &block)
-    end
+      self.request = options.fetch(:request) { forward_logger(Request.new(
+        self, uri || options.fetch(:uri) { default_uri })) }
 
-    # See Builder#optimize.
-    def optimize(attributes = {}, options = {}, &block)
-      update(builder.optimize(attributes), options, &block)
+      self.endpoints = forward_logger(Endpoints.new(self))
     end
 
-    # See Builder#rollback.
-    def rollback(options = {}, &block)
-      update(builder.rollback, options, &block)
-    end
+    attr_accessor :options, :builder, :request, :default_params, :endpoints
 
-    # See Builder#delete.
-    def delete(hash, options = {}, &block)
-      update(builder.delete(hash), options, &block)
-    end
+    alias_method :ep, :endpoints
 
-    # See #delete.
-    def delete_by_id(id, options = {}, &block)
-      delete({ id: id }, options, &block)
-    end
+    def json(path,
+        params = {}, options = {}, &block)
 
-    # See #delete.
-    def delete_by_query(query, options = {}, &block)
-      delete({ query: query }, options, &block)
+      get(path, params.merge(wt: :json), options, &block).result
     end
 
-    # See #delete_by_query.
-    def delete_all!(options = {}, &block)
-      delete_by_query(MATCH_ALL_QUERY, options, &block)
-    end
+    def get(path,
+        params = {}, options = {}, &block)
 
-    def count(params = {}, options = {}, path = DEFAULT_SELECT_PATH, &block)
-      params = params.merge(rows: 0)
-      params[:q] ||= MATCH_ALL_QUERY
-      get(path, params, options, &block)
+      send_request(path, options.merge(
+        method: :get, params: params), &block)
     end
 
-    def json_query(params = {}, options = {}, path = DEFAULT_SELECT_PATH, &block)
-      json(path, params.merge(q: query_string(params[:q])), options, &block)
-    end
+    def post(path, data = nil,
+        params = {}, options = {}, &block)
 
-    def more_like_this(params = {}, options = {}, path = DEFAULT_MLT_PATH, &block)
-      json_query(params, options, path, &block)
+      send_request(path, options.merge(
+        method: :post, params: params, data: data), &block)
     end
 
-    def query_string(query)
-      case query
-        when nil
-          # ignore
-        when String
-          query.gsub('&', '%26')
-        when Array, Hash
-          query.flat_map { |key, values|
-            Array(values).map { |value|
-              query_string("#{key}:#{value}")
-            }
-          }.join(' ')
-        else
-          query_string(query.to_s)
-      end
-    end
+    def head(path,
+        params = {}, options = {}, &block)
 
-    def solr_version(type = :spec)
-      json(SYSTEM_INFO_PATH) % "lucene/solr-#{type}-version"
+      send_request(path, options.merge(
+        method: :head, params: params), &block)
     end
 
     def inspect
@@ -213,27 +178,26 @@ module Solr4R
     private
 
     def default_uri
-      'http://%s:%d/%s' % [
-        options.fetch(:host, DEFAULT_HOST),
-        options.fetch(:port, DEFAULT_PORT),
-        options.fetch(:path, DEFAULT_PATH)
-      ]
+      self.class.default_uri(options)
     end
 
-    def amend_options(options, key, value)
+    def amend_options_hash(options, key, value)
       options.merge(key => value.merge(options.fetch(key, {})))
     end
 
-    def send_request(path, options, &block)
-      request.execute(path,
-        amend_options(options, :params, default_params), &block)
+    def amend_options_array(options, key, *value)
+      options.merge(key => Array(options[key]).dup.concat(value))
     end
 
-    def invalid_endpoint?(name)
-      'method already defined' if respond_to?(name) || (
-        respond_to?(name, true) && !DEFAULT_ENDPOINTS.flatten.include?(name))
+    def send_request(path, options, &block)
+      request.execute(path, amend_options_hash(
+        options, :params, default_params), &block)
     end
 
   end
 
 end
+
+require_relative 'client/update'
+require_relative 'client/query'
+require_relative 'client/admin'

data/lib/solr4r/document.rb

@@ -7,7 +7,7 @@
 #                                                                             #
 # Copyright (C) 2014-2015 Jens Wille                                          #
 #                                                                             #
-# Mir is free software: you can redistribute it and/or modify it under the    #
+# 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.                                                          #
@@ -31,12 +31,6 @@ module Solr4R
 
     extend Forwardable
 
-    UNIQUE_KEY = 'id'
-
-    MLT_DEFAULT_FL = '*,score'
-
-    MLT_DEFAULT_ROWS = 5
-
     def initialize(result, hash)
       @result, @hash = result, hash
     end
@@ -45,20 +39,26 @@ module Solr4R
 
     def_delegators :result, :client
 
-    def_delegators :to_hash, :[], :each, :to_json
+    def_delegators :to_hash, :[], :each, :fetch, :to_json
 
     def to_hash
       @hash
     end
 
-    def more_like_this(fl = nil, params = {}, *args, &block)
-      client.more_like_this(params.merge(
-        q:    { id: self[UNIQUE_KEY] },
-        fl:   params.fetch(:fl,   MLT_DEFAULT_FL),
-        rows: params.fetch(:rows, MLT_DEFAULT_ROWS),
-        'mlt.fl' => Array(fl).join(',')), *args, &block)
+    def id
+      fetch('id')
+    end
+
+    def more_like_this_h(*args, &block)
+      client.more_like_this_h(id, *args, &block)
+    end
+
+    def more_like_this_q(*args, &block)
+      client.more_like_this_q(id, *args, &block)
     end
 
+    alias_method :more_like_this, :more_like_this_q
+
   end
 
 end

data/lib/solr4r/endpoints.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# solr4r -- A Ruby client for Apache Solr                                     #
+#                                                                             #
+# Copyright (C) 2014-2015 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/>.              #
+#                                                                             #
+###############################################################################
+#++
+
+module Solr4R
+
+  class Endpoints
+
+    include Logging
+
+    DEFAULT_ENDPOINTS = %w[select query export spell suggest terms debug/dump]
+
+    def initialize(client)
+      @client, @endpoints = client, []
+      register(client.options.fetch(:endpoints, DEFAULT_ENDPOINTS))
+    end
+
+    attr_reader :client
+
+    def register(path, options = {})
+      case path
+        when nil
+          # ignore
+        when String
+          name, path = File.basename(path), options.fetch(:path, path).to_s
+
+          error = invalid_endpoint?(name) and
+            raise ArgumentError, "invalid endpoint: #{name} (#{error})"
+
+          @endpoints << [name, path]
+
+          define_singleton_method(name) { |_params = {}, _options = {}, &block|
+            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 { |name, opts| register(name,
+            opts.is_a?(Hash) ? opts : { path: opts }) }
+        else
+          Client.send(:type_error, path, %w[String Symbol Array Hash])
+      end
+
+      self
+    end
+
+    def inspect
+      '#<%s:0x%x [%s]>' % [self.class, object_id, @endpoints.map { |name, path|
+        name == path ? name : "#{name}=#{path}" }.join(', ')]
+    end
+
+    private
+
+    def invalid_endpoint?(name)
+      'method already defined' if respond_to?(name) || (
+        respond_to?(name, true) &&
+          DEFAULT_ENDPOINTS.all? { |ep,| ep.to_s != name })
+    end
+
+  end
+
+end

data/lib/solr4r/logging.rb

@@ -5,9 +5,9 @@
 #                                                                             #
 # solr4r -- A Ruby client for Apache Solr                                     #
 #                                                                             #
-# Copyright (C) 2014 Jens Wille                                               #
+# Copyright (C) 2014-2015 Jens Wille                                          #
 #                                                                             #
-# Mir is free software: you can redistribute it and/or modify it under the    #
+# 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.                                                          #
@@ -24,12 +24,14 @@
 #++
 
 require 'logger'
-require 'nuggets/module/lazy_attr'
+require 'nuggets/module/lazy_attr_mixin'
 
 module Solr4R
 
   module Logging
 
+    extend Nuggets::Module::LazyAttrMixin
+
     DEFAULT_LOG_DEVICE = $stderr
     DEFAULT_LOG_LEVEL  = Logger::WARN
     DEFAULT_LOG_NAME   = "Solr4R/#{VERSION}"

data/lib/solr4r/request.rb

@@ -7,7 +7,7 @@
 #                                                                             #
 # Copyright (C) 2014-2015 Jens Wille                                          #
 #                                                                             #
-# Mir is free software: you can redistribute it and/or modify it under the    #
+# 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.                                                          #
@@ -25,7 +25,6 @@
 
 require 'net/https'
 
-require_relative 'request_extension'
 require_relative 'uri_extension'
 
 module Solr4R
@@ -45,6 +44,8 @@ module Solr4R
 
     attr_reader :client
 
+    attr_accessor :base_uri, :http_options, :http, :last_response
+
     def start
       self.http = Net::HTTP.start(base_uri.hostname, base_uri.port,
         { use_ssl: base_uri.scheme == 'https' }.merge(http_options))
@@ -69,18 +70,7 @@ module Solr4R
       req = prepare_request(path, options, &block)
       res = http.request(req)
 
-      self.last_response = Response.new(self,
-        request_body:     req.body,
-        request_headers:  req.to_hash,
-        request_method:   req.method.downcase.to_sym,
-        request_params:   req.params,
-        request_url:      req.uri.to_s,
-
-        response_body:    res.body,
-        response_charset: res.type_params['charset'],
-        response_code:    res.code.to_i,
-        response_headers: res.to_hash
-      )
+      self.last_response = Response.new(self, req, res)
     end
 
     def request_line
@@ -93,15 +83,11 @@ module Solr4R
 
     private
 
-    attr_accessor :base_uri, :http_options, :http, :last_response
-
     def prepare_request(path, options)
       uri = make_uri(path, options.fetch(:params, {}))
+      req = make_request(uri, options.fetch(:method, DEFAULT_METHOD))
 
-      req = make_request(uri,
-        options.fetch(:method, DEFAULT_METHOD),
-        options.fetch(:data, {}))
-
+      set_data(req, options.fetch(:data, {})) if req.request_body_permitted?
       set_headers(req, options.fetch(:headers, {}))
 
       yield req if block_given?
@@ -113,31 +99,17 @@ module Solr4R
       base_uri.merge(path).extend(RequestUriExtension).with_params(params)
     end
 
-    def make_request(uri, method, data)
-      case method
-        when :get, :head
-          req = request_for(method, uri)
-        when :post
-          req = request_for(method, uri)
-          set_data(req, data)
-        else
-          raise ArgumentError, "method not supported: #{method}"
-      end
-
+    def make_request(uri, method)
+      req = Net::HTTP.const_get(method.to_s.capitalize).new(uri)
+      req.uri.extend(RequestUriExtension).params = uri.params
       req
     end
 
-    def request_for(method, uri)
-      Net::HTTP.const_get(method.to_s.capitalize)
-        .extend(HTTPRequestExtension).from_uri(uri)
-    end
-
     def set_headers(req, headers)
       req['User-Agent'] = DEFAULT_USER_AGENT
 
       headers.each { |key, value|
-        Array(value).each { |val| req.add_field(key, val) }
-      }
+        Array(value).each { |val| req.add_field(key, val) } }
     end
 
     def set_data(req, data)

data/lib/solr4r/response.rb

@@ -7,7 +7,7 @@
 #                                                                             #
 # Copyright (C) 2014-2015 Jens Wille                                          #
 #                                                                             #
-# Mir is free software: you can redistribute it and/or modify it under the    #
+# 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.                                                          #
@@ -34,18 +34,29 @@ module Solr4R
 
     DEFAULT_CHARSET = 'UTF-8'
 
-    EVALUATE_METHODS = [:get, :post]
+    def initialize(request, req = nil, res = nil)
+      @request, @evaluate = request, req.response_body_permitted?
 
-    def initialize(request, options)
-      @request = request
-      options.each { |key, value| send("#{key}=", value) }
-      @evaluate = EVALUATE_METHODS.include?(request_method)
+      if req
+        self.request_body    = req.body
+        self.request_headers = req.to_hash
+        self.request_method  = req.method.downcase.to_sym
+        self.request_params  = req.uri.params
+        self.request_url     = req.uri.to_s
+      end
+
+      if res
+        self.response_body    = res.body
+        self.response_headers = res.to_hash
+        self.response_charset = res.type_params['charset']
+        self.response_code    = res.code.to_i
+      end
     end
 
     attr_reader :request
 
-    attr_accessor :response_body, :response_charset, :response_code, :response_headers,
-      :request_body, :request_method, :request_params, :request_url, :request_headers
+    attr_accessor :response_body, :response_headers, :response_charset, :response_code,
+      :request_body, :request_headers, :request_method, :request_params, :request_url
 
     def_delegators :request, :client
 

data/lib/solr4r/result.rb

@@ -7,7 +7,7 @@
 #                                                                             #
 # Copyright (C) 2014-2015 Jens Wille                                          #
 #                                                                             #
-# Mir is free software: you can redistribute it and/or modify it under the    #
+# 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.                                                          #
@@ -55,7 +55,7 @@ module Solr4R
 
     def_delegators :response, :client
 
-    def_delegators :to_hash, :fetch, :deep_fetch, :%
+    def_delegators :to_hash, :%, :deep_fetch, :fetch
 
     def to_hash
       @hash