solrb 0.1.0

data/lib/solr/query/response/facet_value.rb

@@ -0,0 +1,16 @@
+module Solr
+  module Query
+    class Response
+      class FacetValue
+        attr_reader :text, :count, :subfacets
+
+        def initialize(text:, count:, subfacets: [])
+          @text      = text
+          @count     = count
+          @subfacets = subfacets
+          freeze
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/response/field_facets.rb

@@ -0,0 +1,25 @@
+module Solr
+  module Query
+    class Response
+      class FieldFacets
+        include Enumerable
+
+        attr_reader :field, :facet_values, :count, :subfacets
+
+        def initialize(field:, facet_values:, count:, subfacets: [])
+          @field        = field
+          @facet_values = facet_values
+          @count        = count
+          @subfacets    = subfacets
+
+          freeze
+        end
+
+        def each(&b)
+          return enum_for(:each) unless block_given?
+          facet_values.each(&b)
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/response/parser.rb

@@ -0,0 +1,154 @@
+module Solr
+  module Query
+    class Response
+      class Parser
+        SOLR_INFINITY = '*'.freeze # for cases like [100000 TO *]
+
+        include Solr::Support::SchemaHelper
+
+        attr_reader :request, :solr_response
+
+        def initialize(request:, solr_response:)
+          @request = request
+          @solr_response = solr_response
+        end
+
+        def to_response
+          documents = parse_documents
+          total_count = parse_total_count
+          if !request.grouping.empty?
+            group_counts = parse_group_counts
+            document_collection = Solr::GroupedDocumentCollection.new(documents: documents,
+                                                                      total_count: total_count,
+                                                                      group_counts: group_counts)
+          else
+            document_collection = Solr::DocumentCollection.new(documents: documents, total_count: total_count)
+          end
+          Solr::Query::Response.new(
+            documents: document_collection,
+            available_facets: field_facet_collection,
+            spellcheck: spellcheck
+          )
+        end
+
+        private
+
+        def parse_total_count
+          if !request.grouping.empty?
+            parse_grouped_total_count(solr_grouping_field)
+          else
+            parse_regular_total_count
+          end
+        end
+
+        def parse_grouped_total_count(solr_grouping_field)
+          solr_response['grouped'][solr_grouping_field]['groups'].reduce(0) do |acc, group|
+            acc + group['doclist']['numFound'].to_i
+          end
+        end
+
+        def parse_regular_total_count
+          solr_response.dig('response', 'numFound').to_i
+        end
+
+        def parse_group_counts
+          group_counts = {}
+          unless request.grouping.empty?
+            Array(solr_response.dig('grouped', solr_grouping_field, 'groups')).each do |group|
+              group_counts[group['groupValue']] = group['doclist']['numFound']
+            end
+          end
+          group_counts
+        end
+
+        def parse_documents
+          if !request.grouping.empty?
+            parse_grouped_documents(solr_grouping_field)
+          else
+            parse_regular_documents
+          end
+        end
+
+        def parse_regular_documents
+          solr_response['response']['docs'].map do |d|
+            debug_info = solr_response.dig('debug', 'explain', d['id'])
+            Document.new(id: d['id'], score: d['score'], debug_info: debug_info)
+          end
+        end
+
+        def parse_grouped_documents(solr_grouping_field)
+          Array(solr_response.dig('grouped', solr_grouping_field, 'groups')).map do |group|
+            Array(group.dig('doclist', 'docs')).map do |doc|
+              next unless doc
+              debug_info = solr_response.dig('debug', 'explain', doc['id'])
+              group_information = Document::GroupInformation.new(key: solr_grouping_field, value: group['groupValue'])
+              Document.new(id: doc['id'], score: doc['score'],
+                           debug_info: debug_info, group: group_information)
+            end
+          end.flatten.compact
+        end
+
+        def solr_grouping_field
+          grouping_field = request.grouping.field
+          solarize_field(grouping_field)
+        end
+
+        def field_facet_collection
+          return [] unless solr_response_has_facet_data?
+
+          raw_facet_data = solr_response['facets'].except('count')
+
+          parse_facets(raw_facet_data)
+        end
+
+        # Each facet could contain subfacets.
+        # We need to parse them recursively and store in subfacets array.
+        def parse_facets(raw_facet_data)
+          raw_facet_data.map do |field_name, facet_data|
+            # We need to handle use case when facet_data is not a hash
+            # (e.g. query facet request with aggregate function)
+            if facet_data.is_a?(Hash)
+              parse_facet_hash(field_name, facet_data)
+            else
+              parse_facet_count(field_name, facet_data)
+            end
+          end
+        end
+
+        def parse_facet_hash(field_name, facet_data)
+          count  = facet_data.delete('count')
+          facets = facet_data.delete('buckets')
+
+          facet_values =
+            Array(facets).map do |facet|
+              text  = facet.delete('val')
+              count = facet.delete('count')
+
+              Solr::Query::Response::FacetValue.new(text: text, count: count, subfacets: parse_facets(facet))
+            end
+
+          Solr::Query::Response::FieldFacets.new(field: field_name,
+                                                 facet_values: facet_values,
+                                                 count: count.to_i,
+                                                 subfacets: parse_facets(facet_data))
+        end
+
+        def parse_facet_count(field_name, count)
+          Solr::Query::Response::FieldFacets.new(field: field_name,
+                                                 facet_values: [],
+                                                 count: count.to_i,
+                                                 subfacets: [])
+        end
+
+        def solr_response_has_facet_data?
+          solr_response['facets']
+        end
+
+        def spellcheck
+          return Solr::Query::Response::Spellcheck.empty unless solr_response['spellcheck']
+          Solr::Query::Response::Spellcheck.new(solr_response['spellcheck'])
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/response/spellcheck.rb

@@ -0,0 +1,42 @@
+module Solr
+  module Query
+    class Response
+      class Spellcheck
+        attr_reader :response
+
+        class Collation
+          def initialize(data)
+            @data = data
+          end
+
+          def collation_query
+            @data['collationQuery']
+          end
+
+          def hits
+            @data['hits']
+          end
+
+          def misspellings_and_corrections
+            return {} unless @data['misspellingsAndCorrections']
+            @data['misspellingsAndCorrections'].in_groups_of(2).to_h
+          end
+        end
+
+        def self.empty
+          new({})
+        end
+
+        def initialize(response)
+          @response = response || {}
+        end
+
+        def collations
+          Array(response['collations']).flatten(1).in_groups_of(2).map do |_, collation|
+            Collation.new(collation)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/response.rb

@@ -0,0 +1,48 @@
+require 'solr/query/response/facet_value'
+require 'solr/query/response/field_facets'
+require 'solr/query/response/parser'
+require 'solr/query/response/spellcheck'
+
+module Solr
+  module Query
+    class Response
+      attr_reader :documents, :available_facets, :spellcheck
+
+      class << self
+        def empty
+          new(documents: Solr::DocumentCollection.empty)
+        end
+
+        def empty_grouped
+          new(documents: Solr::GroupedDocumentCollection.empty)
+        end
+
+        def manual_grouped_documents(ids)
+          documents = ids.map { |id| Solr::Document.new(id: id) }
+          group_counts = ids.each_with_object({}) do |id, acc|
+            acc[id] = 1
+          end
+          new(documents: Solr::GroupedDocumentCollection.new(
+            documents: documents,
+            total_count: ids.count,
+            group_counts: group_counts
+          ))
+        end
+      end
+
+      def initialize(documents:, available_facets: [], spellcheck: Solr::Query::Response::Spellcheck.empty)
+        @documents = documents
+        @available_facets = available_facets
+        @spellcheck = spellcheck
+      end
+
+      def total_count
+        @documents.total_count
+      end
+
+      def empty?
+        total_count.zero?
+      end
+    end
+  end
+end

data/lib/solr/response/header.rb

@@ -0,0 +1,25 @@
+module Solr
+  class Response
+    class Header
+      attr_reader :status, :time
+
+      def initialize(status:, time: 0)
+        @status = status
+        @time = time
+        freeze
+      end
+
+      def ok?
+        status.zero?
+      end
+
+      def inspect
+        if ok?
+          'OK'
+        else
+          status.to_s
+        end
+      end
+    end
+  end
+end

data/lib/solr/response/http_status.rb

@@ -0,0 +1,27 @@
+module Solr
+  class Response
+    class HttpStatus
+      class << self
+        def ok
+          new(status: 200, message: 'OK')
+        end
+
+        def not_found
+          new(status: 404, message: 'Not Found')
+        end
+      end
+
+      attr_reader :status, :message
+
+      def initialize(status:, message:)
+        @status = status
+        @message = message
+        freeze
+      end
+
+      def inspect
+        "#{status} (#{message})"
+      end
+    end
+  end
+end

data/lib/solr/response/parser.rb

@@ -0,0 +1,47 @@
+module Solr
+  class Response
+    class Parser
+      def initialize(raw_response)
+        @raw_response = raw_response
+      end
+
+      def parse
+        # 404 is a special case, it didn't hit Solr (more likely than not)
+        return not_found_response if @raw_response.status == 404
+        parsed_body = JSON.parse(@raw_response.body).freeze
+        http_status = parse_http_status
+        header = parse_header(parsed_body)
+        solr_error = parse_solr_error(parsed_body)
+        Solr::Response.new(header: header, http_status: http_status, solr_error: solr_error, body: parsed_body)
+      end
+
+      private
+
+      def not_found_response
+        Solr::Response.new(
+          header: Solr::Response::Header.new(status: 404),
+          http_status: Solr::Response::HttpStatus.not_found,
+          solr_error: nil
+        )
+      end
+
+      def parse_header(parsed_body)
+        parsed_header = parsed_body['responseHeader']
+        status = parsed_header['status'].to_i
+        time = parsed_header['QTime'].to_i
+        Solr::Response::Header.new(status: status, time: time)
+      end
+
+      def parse_http_status
+        HttpStatus.new(status: @raw_response.status, message: @raw_response.reason_phrase)
+      end
+
+      def parse_solr_error(parsed_body)
+        return Solr::Response::SolrError.none unless parsed_body['error']
+        code = parsed_body['error']['code'].to_i
+        message = parsed_body['error']['msg']
+        Solr::Response::SolrError.new(code: code, message: message)
+      end
+    end
+  end
+end

data/lib/solr/response/solr_error.rb

@@ -0,0 +1,31 @@
+module Solr
+  class Response
+    class SolrError
+      class None < SolrError
+        def initialize
+          super(code: nil, message: nil)
+          freeze
+        end
+
+        def inspect
+          'SolrError: None'
+        end
+      end
+
+      def self.none
+        None.new
+      end
+
+      attr_reader :code, :message
+      def initialize(code:, message:)
+        @code = code
+        @message = message
+        freeze
+      end
+
+      def inspect
+        "#{message} (#{code})"
+      end
+    end
+  end
+end

data/lib/solr/response.rb

@@ -0,0 +1,52 @@
+require 'solr/response/header'
+require 'solr/response/http_status'
+require 'solr/response/solr_error'
+require 'solr/response/parser'
+
+module Solr
+  class Response
+    OK = 'OK'.freeze
+
+    def self.from_raw_response(response)
+      Solr::Response::Parser.new(response).parse
+    end
+
+    attr_reader :header, :http_status, :solr_error, :body
+
+    def initialize(header:, http_status: HttpStatus.ok, solr_error: SolrError.none, body: {})
+      @header = header
+      @http_status = http_status
+      @solr_error = solr_error
+      @body = body
+      freeze
+    end
+
+    def ok?
+      header.ok?
+    end
+
+    def error?
+      !ok?
+    end
+
+    def status
+      if header.status.zero?
+        OK
+      else
+        header.status
+      end
+    end
+
+    def error_message
+      return if ok?
+      solr_error ? solr_error.message : http_status.inspect
+    end
+
+    def inspect
+      return OK if ok?
+      str = "Error: #{http_status.inspect}"
+      str << "\n#{solr_error.inspect}" if solr_error
+      str
+    end
+  end
+end

data/lib/solr/support/connection_helper.rb

@@ -0,0 +1,12 @@
+module Solr
+  module Support
+    module ConnectionHelper
+      def connection(path, commit: false)
+        url_params = {}
+        url_params[:commit] = true if commit
+        url = Solr::Support::UrlHelper.solr_url(path, url_params: url_params)
+        Solr::Connection.new(url)
+      end
+    end
+  end
+end

data/lib/solr/support/hash_extensions.rb

@@ -0,0 +1,29 @@
+module Solr
+  module Support
+    module HashExtensions
+      extend self
+
+      def symbolize_recursive(hash)
+        {}.tap do |h|
+          hash.each { |key, value| h[key.to_sym] = transform(value) }
+        end
+      end
+
+      private
+
+      def transform(thing)
+        case thing
+        when Hash then symbolize_recursive(thing)
+        when Array then thing.map { |v| transform(v) }
+        else; thing
+        end
+      end
+
+      refine Hash do
+        def deep_symbolize_keys
+          HashExtensions.symbolize_recursive(self)
+        end
+      end
+    end
+  end
+end

data/lib/solr/support/schema_helper.rb

@@ -0,0 +1,11 @@
+module Solr
+  module Support
+    module SchemaHelper
+      def solarize_field(field)
+        core = Solr.current_core_config
+        field_config = core.field_by_name(field.to_sym) if core
+        field_config ? field_config.solr_field_name : field.to_s
+      end
+    end
+  end
+end

data/lib/solr/support/string_extensions.rb

@@ -0,0 +1,12 @@
+module Solr
+  module Support
+    module StringExtensions
+      refine String do
+        # REVIEW: this escape
+        def solr_escape
+          gsub(%r(([+\-&|!\(\)\{\}\[\]\^"~\*\?:\\/])), '\\\\\1')
+        end
+      end
+    end
+  end
+end

data/lib/solr/support/url_helper.rb

@@ -0,0 +1,12 @@
+module Solr
+  module Support
+    module UrlHelper
+      def self.solr_url(path, url_params: {})
+        full_url = File.join(Solr.current_core_config.uri, path)
+        full_uri = Addressable::URI.parse(full_url)
+        full_uri.query_values = url_params if url_params.any?
+        full_uri
+      end
+    end
+  end
+end

data/lib/solr/support.rb

@@ -0,0 +1,5 @@
+require 'solr/support/hash_extensions'
+require 'solr/support/string_extensions'
+require 'solr/support/url_helper'
+require 'solr/support/connection_helper'
+require 'solr/support/schema_helper'

data/lib/solr/testing.rb

@@ -0,0 +1,19 @@
+module Solr
+  module Testing
+    class << self
+      attr_reader :last_solr_request_params, :last_solr_response
+
+      def subscribe_to_events
+        if defined? ActiveSupport::Notifications
+          ActiveSupport::Notifications.subscribe('solrb.request_response_cycle') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            @last_solr_request_params = event.payload[:request][:params]
+            @last_solr_response = event.payload[:response]
+          end
+        end
+      end
+    end
+  end
+end
+
+Solr::Testing.subscribe_to_events

data/lib/solr/version.rb

@@ -0,0 +1,3 @@
+module Solr
+  VERSION = '0.1.0'.freeze
+end

data/lib/solr.rb

@@ -0,0 +1,65 @@
+require 'json'
+require 'faraday'
+require 'addressable/uri'
+require 'solr/support'
+require 'solr/configuration'
+require 'solr/version'
+require 'solr/connection'
+require 'solr/document'
+require 'solr/document_collection'
+require 'solr/grouped_document_collection'
+require 'solr/response'
+require 'solr/query/request'
+require 'solr/indexing/document'
+require 'solr/indexing/request'
+require 'solr/delete/request'
+require 'solr/commit/request'
+
+module Solr
+  class << self
+    CURRENT_CORE_CONFIG_VARIABLE_NAME = :solrb_current_core_config
+
+    attr_accessor :configuration
+
+    Solr.configuration = Configuration.new
+
+    def configure
+      yield configuration
+    end
+
+    def current_core_config
+      Thread.current[CURRENT_CORE_CONFIG_VARIABLE_NAME] || Solr.configuration.default_core_config
+    end
+
+    def commit
+      Solr::Commit::Request.new.run
+    end
+
+    def delete_by_id(id, commit: false)
+      Solr::Delete::Request.new(id: id).run(commit: commit)
+    end
+
+    def delete_by_query(query, commit: false)
+      Solr::Delete::Request.new(query: query).run(commit: commit)
+    end
+
+    def with_core(core)
+      core_config = Solr.configuration.core_config_by_name(core)
+      old_core_config = Thread.current[CURRENT_CORE_CONFIG_VARIABLE_NAME]
+      Thread.current[CURRENT_CORE_CONFIG_VARIABLE_NAME] = core_config
+      yield
+    ensure
+      Thread.current[CURRENT_CORE_CONFIG_VARIABLE_NAME] = old_core_config
+    end
+
+    def instrument(name:, data: {})
+      if defined? ActiveSupport::Notifications
+        ActiveSupport::Notifications.instrument(name, data) do
+          yield if block_given?
+        end
+      else
+        yield if block_given?
+      end
+    end
+  end
+end

data/solrb.gemspec

@@ -0,0 +1,36 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'solr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'solrb'
+  spec.version       = Solr::VERSION
+  spec.authors       = ['Adriano Luz', 'Valentin Vasilyev']
+  spec.email         = ['adriano.luz@machinio.com', 'valentin@machinio.com']
+
+  spec.summary       = 'Solr Ruby client with a nice object-oriented API'
+  spec.homepage      = 'https://github.com/machinio/solrb'
+  spec.license       = 'MIT'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'addressable'
+  spec.add_runtime_dependency 'faraday'
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rspec_junit_formatter'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'simplecov'
+end