solrb 0.1.0

data/lib/solr/core_configuration/core_config.rb

@@ -0,0 +1,44 @@
+module Solr
+  module CoreConfiguration
+    class CoreConfig
+      attr_reader :name, :fields
+
+      def initialize(name:, fields:, default:)
+        @name = name
+        @fields = fields
+        @default = default
+      end
+
+      def field_by_name(field_name)
+        fields[field_name.to_sym]
+      end
+
+      def default?
+        @default
+      end
+
+      def url
+        @url ||= File.join(Solr.configuration.url || ENV['SOLR_URL'], name.to_s).chomp('/')
+      end
+
+      def uri
+        @uri ||= Addressable::URI.parse(url)
+      end
+    end
+
+    class EnvUrlCoreConfig < CoreConfig
+      attr_reader :name, :fields
+
+      def initialize(name: nil, fields: {})
+        @name = name
+        @fields = fields
+        @default = false
+      end
+
+      def url
+        raise ArgumentError, "Solr's URL can't be nil" if ENV['SOLR_URL'].nil?
+        ENV['SOLR_URL']
+      end
+    end
+  end
+end

data/lib/solr/core_configuration/core_config_builder.rb

@@ -0,0 +1,51 @@
+module Solr
+  module CoreConfiguration
+    class CoreConfigBuilder
+      attr_reader :name, :dynamic_fields, :fields_params, :default
+
+      def initialize(name: nil, default:)
+        @name = name
+        @default = default
+        @dynamic_fields = {}
+        @fields_params = {}
+      end
+
+      def dynamic_field(field_name, solr_name:)
+        dynamic_fields[field_name] = Solr::CoreConfiguration::DynamicField.new(name: field_name, solr_name: solr_name)
+      end
+
+      def field(field_name, params = {})
+        fields_params[field_name] = params
+      end
+
+      def build
+        Solr::CoreConfiguration::CoreConfig.new(
+          name: name,
+          fields: build_fields,
+          default: default
+        )
+      end
+
+      def get_dynamic_field(field_name, dynamic_field_name)
+        dynamic_field = dynamic_fields[dynamic_field_name]
+
+        if dynamic_field_name && !dynamic_field
+          raise "Field '#{field_name}' is mapped to an undefined dynamic field '#{dynamic_field_name}'"
+        end
+
+        dynamic_field
+      end
+
+      private
+
+      def build_fields
+        fields_params.each_with_object({}) do |(name, params), fields|
+          fields[name] =
+            Solr::CoreConfiguration::Field.new(name: name,
+                                                solr_name: params[:solr_name],
+                                                dynamic_field: get_dynamic_field(name, params[:dynamic_field]))
+        end
+      end
+    end
+  end
+end

data/lib/solr/core_configuration/dynamic_field.rb

@@ -0,0 +1,17 @@
+module Solr
+  module CoreConfiguration
+    class DynamicField
+      attr_reader :name, :solr_name
+
+      def initialize(name:, solr_name:)
+        @name = name
+        @solr_name = solr_name
+        freeze
+      end
+
+      def build(name)
+        solr_name.gsub('*', name.to_s)
+      end
+    end
+  end
+end

data/lib/solr/core_configuration/field.rb

@@ -0,0 +1,20 @@
+module Solr
+  module CoreConfiguration
+    class Field
+      attr_reader :name, :dynamic_field, :solr_name
+
+      def initialize(name:, dynamic_field: nil, solr_name: nil)
+        @name = name
+        @dynamic_field = dynamic_field
+        @solr_name = solr_name
+        freeze
+      end
+
+      def solr_field_name
+        return solr_name.to_s if solr_name
+        return dynamic_field.build(name) if dynamic_field
+        name.to_s
+      end
+    end
+  end
+end

data/lib/solr/delete/request.rb

@@ -0,0 +1,34 @@
+module Solr
+  module Delete
+    class Request
+      include Solr::Support::ConnectionHelper
+      using Solr::Support::HashExtensions
+
+      PATH = '/update'.freeze
+
+      attr_reader :delete_command
+
+      def initialize(options = {})
+        options = validate_delete_options!(options)
+        @delete_command = { delete: options }
+      end
+
+      def run(commit: false)
+        # need to think how to move out commit data from the connection, it doesn't belong there
+        raw_response = connection(PATH, commit: commit).post_as_json(delete_command)
+        Solr::Response.from_raw_response(raw_response)
+      end
+
+      private
+
+      def validate_delete_options!(options)
+        options = options.deep_symbolize_keys
+        id, query = options.values_at(:id, :query)
+        error_message = 'options must contain either id or query, but not both'
+        raise ArgumentError, error_message if id.nil? && query.nil?
+        raise ArgumentError, error_message if id && query
+        options
+      end
+    end
+  end
+end

data/lib/solr/document.rb

@@ -0,0 +1,26 @@
+module Solr
+  class Document
+    class GroupInformation
+      attr_reader :key, :value
+      def initialize(key:, value:)
+        @key = key
+        @value = value
+      end
+
+      def self.empty
+        new(key: nil, value: nil)
+      end
+    end
+
+    attr_reader :id, :model_name, :score, :debug_info, :group
+
+    # TODO: model_name is specific for machinio
+    def initialize(id:, model_name: nil, score: nil, debug_info: nil, group: GroupInformation.empty)
+      @id = id
+      @model_name = model_name
+      @score = score
+      @debug_info = debug_info
+      @group = group
+    end
+  end
+end

data/lib/solr/document_collection.rb

@@ -0,0 +1,55 @@
+module Solr
+  class DocumentCollection
+    include Enumerable
+    attr_reader :documents, :total_count
+
+    def self.from_ids(ids, model_name:)
+      documents = ids.map { |id| Solr::Document.new(id: id, model_name: model_name) }
+      new(documents: documents, total_count: documents.count)
+    end
+
+    def self.empty
+      new(documents: [], total_count: 0)
+    end
+
+    def initialize(documents:, total_count:)
+      @documents = documents
+      @total_count = total_count
+    end
+
+    def each(&b)
+      return enum_for(:each) unless block_given?
+      documents.each(&b)
+    end
+
+    def first(n)
+      new_documents = documents.first(n)
+      self.class.new(documents: new_documents, total_count: new_documents.count)
+    end
+
+    def slice(range)
+      new_documents = documents[range]
+      if new_documents
+        self.class.new(documents: new_documents, total_count: new_documents.count)
+      else
+        self.class.empty
+      end
+    end
+
+    def +(other)
+      self.class.new(
+        documents: documents + other.documents,
+        total_count: total_count + other.total_count
+      )
+    end
+
+    def unshift(document)
+      @documents.unshift(document)
+      @total_count += 1
+    end
+
+    def find(id)
+      documents.find { |doc| doc.id == id }
+    end
+  end
+end

data/lib/solr/errors/ambiguous_core_error.rb

@@ -0,0 +1,9 @@
+module Errors
+  class AmbiguousCoreError < StandardError
+    ERROR_MESSAGE = 'Multiple cores defined: default core can\'t be found'.freeze
+
+    def initialize
+      super(ERROR_MESSAGE)
+    end
+  end
+end

data/lib/solr/errors/solr_query_error.rb

@@ -0,0 +1,4 @@
+module Errors
+  class SolrQueryError < StandardError
+  end
+end

data/lib/solr/errors/solr_url_not_defined_error.rb

@@ -0,0 +1,16 @@
+module Errors
+  class SolrUrlNotDefinedError < StandardError
+    SOLR_URL_NOT_DEFINED_MESSAGE = '
+      Solrb gem requires you to set the URL of your Solr instance
+      either through SOLR_URL environmental variable or explicitly inside the configure block:
+
+      Solr.configure do |config|
+        config.url = "http://localhost:8983/solr/core"
+      end
+    '.freeze
+
+    def initialize
+      super(SOLR_URL_NOT_DEFINED_MESSAGE)
+    end
+  end
+end

data/lib/solr/grouped_document_collection.rb

@@ -0,0 +1,38 @@
+module Solr
+  class GroupedDocumentCollection < DocumentCollection
+    attr_reader :group_counts
+
+    def self.empty
+      new(documents: [], total_count: 0, group_counts: {})
+    end
+
+    def initialize(documents:, total_count:, group_counts:)
+      super(documents: documents, total_count: total_count)
+      @group_counts = group_counts
+    end
+
+    def first(n)
+      new_documents = documents.first(n)
+      self.class.new(documents: new_documents,
+                     total_count: new_documents.count, group_counts: group_counts)
+    end
+
+    def slice(range)
+      new_documents = documents[range]
+      if new_documents
+        self.class.new(documents: new_documents, total_count: new_documents.count, group_counts: group_counts)
+      else
+        self.class.empty
+      end
+    end
+
+    def +(other)
+      other_group_counts = other.is_a?(Solr::GroupedDocumentCollection) ? other.group_counts : {}
+      self.class.new(
+        documents: documents + other.documents,
+        total_count: total_count + other.total_count,
+        group_counts: group_counts.merge(other_group_counts)
+      )
+    end
+  end
+end

data/lib/solr/indexing/document.rb

@@ -0,0 +1,25 @@
+module Solr
+  module Indexing
+    class Document
+      include Solr::Support::SchemaHelper
+      attr_reader :fields
+
+      def initialize(fields = {})
+        @fields = fields
+      end
+
+      def add_field(name, value)
+        @fields[name] = value
+      end
+
+      # TODO: refactor & optimize this
+      def to_json(_json_context)
+        solr_fields = fields.map do |k, v|
+          solr_field_name = solarize_field(k)
+          [solr_field_name, v]
+        end.to_h
+        JSON.generate(solr_fields)
+      end
+    end
+  end
+end

data/lib/solr/indexing/request.rb

@@ -0,0 +1,22 @@
+module Solr
+  module Indexing
+    class Request
+      include Solr::Support::ConnectionHelper
+
+      # TODO: potentially make handlers configurable and have them handle the path
+      PATH = '/update'.freeze
+
+      attr_reader :documents
+
+      def initialize(documents = [])
+        @documents = documents
+      end
+
+      def run(commit: false)
+        # need to think how to move out commit data from the connection, it doesn't belong there
+        raw_response = connection(PATH, commit: commit).post_as_json(documents)
+        Solr::Response.from_raw_response(raw_response)
+      end
+    end
+  end
+end

data/lib/solr/query/request/boost_magnitude.rb

@@ -0,0 +1,9 @@
+module Solr
+  module Query
+    class Request
+      module BoostMagnitude
+        DEFAULT = 1
+      end
+    end
+  end
+end

data/lib/solr/query/request/boosting/dictionary_boost_function.rb

@@ -0,0 +1,36 @@
+module Solr
+  module Query
+    class Request
+      class Boosting
+        class DictionaryBoostFunction
+          include Solr::Support::SchemaHelper
+          using Solr::Support::StringExtensions
+          attr_reader :field, :dictionary
+
+          def initialize(field:, dictionary:)
+            raise 'dictionary must be a non-empty Hash' if Hash(dictionary).empty?
+            @field = field
+            @dictionary = dictionary
+          end
+
+          # example: given a hash (dictionary)
+          # {3025 => 2.0, 3024 => 1.5, 3023 => 1.2}
+          # and a field of category_id
+          # the resulting boosting function will be:
+          # if(eq(category_id_it, 3025), 2.0, if(eq(category_id_it, 3024), 1.5, if(eq(category_id_it, 3023), 1.2, 1)))
+          # note that I added spaces for readability, real Solr query functions must always be w/out spaces
+          def to_solr_s
+            sf = solarize_field(field)
+            dictionary.to_a.reverse.reduce(1) do |acc, (field_value, boost)|
+              if field_value.is_a?(String) || field_value.is_a?(Symbol)
+                "if(termfreq(#{sf},\"#{field_value.to_s.solr_escape}\"),#{boost},#{acc})"
+              else
+                "if(eq(#{sf},#{field_value}),#{boost},#{acc})"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/request/boosting/exists_boost_function.rb

@@ -0,0 +1,27 @@
+module Solr
+  module Query
+    class Request
+      class Boosting
+        class ExistsBoostFunction
+          include Solr::Support::SchemaHelper
+
+          attr_reader :field, :boost_magnitude
+
+          def initialize(field:, boost_magnitude:)
+            @field = field
+            @boost_magnitude = boost_magnitude
+            freeze
+          end
+
+          def to_solr_s
+            "if(exists(#{solr_field}),#{boost_magnitude},1)"
+          end
+
+          def solr_field
+            solarize_field(field)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/request/boosting/field_value_less_than_boost_function.rb

@@ -0,0 +1,25 @@
+module Solr
+  module Query
+    class Request
+      class Boosting
+        class FieldValueLessThanBoostFunction
+          include Solr::Support::SchemaHelper
+
+          attr_reader :field, :max, :boost_magnitude
+
+          def initialize(field:, max:, boost_magnitude:)
+            @field = field
+            @max = max
+            @boost_magnitude = boost_magnitude
+            freeze
+          end
+
+          def to_solr_s
+            solr_field = solarize_field(field)
+            "if(sub(#{max},max(#{solr_field},#{max})),1,#{boost_magnitude})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/request/boosting/field_value_match_boost_function.rb

@@ -0,0 +1,24 @@
+module Solr
+  module Query
+    class Request
+      class Boosting
+        class FieldValueMatchBoostFunction
+          include Solr::Support::SchemaHelper
+
+          attr_reader :field, :value, :boost_magnitude
+
+          def initialize(field:, value:, boost_magnitude:)
+            @field = field
+            @value = value
+            @boost_magnitude = boost_magnitude
+            freeze
+          end
+
+          def solr_field
+            solarize_field(field)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/request/boosting/geodist_function.rb

@@ -0,0 +1,37 @@
+# Spatial search:
+# https://cwiki.apache.org/confluence/display/solr/Spatial+Search
+
+module Solr
+  module Query
+    class Request
+      class Boosting
+        class GeodistFunction
+          include Solr::Support::SchemaHelper
+
+          attr_reader :field, :latitude, :longitude
+
+          def initialize(field:, latitude:, longitude:)
+            @field = field
+            @latitude = latitude
+            @longitude = longitude
+            freeze
+          end
+
+          def to_solr_s
+            # this constants are magical, but they influence the slope of geo proximity decay function
+            'recip(geodist(),3,17000,3000)'
+          end
+
+          # TODO: Check this dead code and the initialize arguments
+          def latlng
+            "#{latitude},#{longitude}"
+          end
+
+          def sfield
+            solarize_field(field)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/request/boosting/ln_function_boost.rb

@@ -0,0 +1,28 @@
+module Solr
+  module Query
+    class Request
+      class Boosting
+        class LnFunctionBoost
+          include Solr::Support::SchemaHelper
+
+          attr_reader :field, :min, :boost_magnitude
+
+          def initialize(field:, min: 0.69, boost_magnitude: 1)
+            @field = field
+            @min = min
+            @boost_magnitude = boost_magnitude
+            freeze
+          end
+
+          def to_solr_s
+            "mul(if(gt(#{solr_field},1),ln(#{solr_field}),#{min}),#{boost_magnitude})"
+          end
+
+          def solr_field
+            solarize_field(field)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/request/boosting/numeric_field_value_match_boost_function.rb

@@ -0,0 +1,13 @@
+module Solr
+  module Query
+    class Request
+      class Boosting
+        class NumericFieldValueMatchBoostFunction < FieldValueMatchBoostFunction
+          def to_solr_s
+            "if(sub(def(#{solr_field},-1),#{value}),1,#{boost_magnitude})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/request/boosting/phrase_proximity_boost.rb

@@ -0,0 +1,27 @@
+module Solr
+  module Query
+    class Request
+      class Boosting
+        # https://wiki.apache.org/solr/ExtendedDisMax#pf_.28Phrase_Fields.29
+        # solr in action chapter 16.3.5
+        # we only need to do the phrase proximity boosting if we have a phrase, i.e. more than 1 word
+        class PhraseProximityBoost
+          include Solr::Support::SchemaHelper
+
+          attr_reader :field, :boost_magnitude
+
+          def initialize(field:, boost_magnitude:)
+            @field = field
+            @boost_magnitude = boost_magnitude
+            freeze
+          end
+
+          def to_solr_s
+            solr_field = solarize_field(field)
+            "#{solr_field}^#{boost_magnitude}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/request/boosting/ranking_field_boost_function.rb

@@ -0,0 +1,20 @@
+module Solr
+  module Query
+    class Request
+      class Boosting
+        class RankingFieldBoostFunction
+          include Solr::Support::SchemaHelper
+          attr_reader :field
+
+          def initialize(field:)
+            @field = field
+          end
+
+          def to_solr_s
+            solarize_field(field).to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/request/boosting/recent_field_value_boost_function.rb

@@ -0,0 +1,26 @@
+module Solr
+  module Query
+    class Request
+      class Boosting
+        class RecentFieldValueBoostFunction
+          include Solr::Support::SchemaHelper
+
+          attr_reader :field, :boost_magnitude, :max_age_days
+
+          def initialize(field:, boost_magnitude:, max_age_days:)
+            @field = field
+            @boost_magnitude = boost_magnitude
+            @max_age_days = max_age_days
+            freeze
+          end
+
+          def to_solr_s
+            solr_field = solarize_field(field)
+            recip_max_age_days_ms = 1.0 / (max_age_days * 24 * 3600 * 1000)
+            "mul(#{boost_magnitude},recip(ms(NOW,#{solr_field}),#{recip_max_age_days_ms},0.5,0.1))"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/request/boosting/scale_function_boost.rb

@@ -0,0 +1,28 @@
+module Solr
+  module Query
+    class Request
+      class Boosting
+        class ScaleFunctionBoost
+          include Solr::Support::SchemaHelper
+
+          attr_reader :field, :min, :max
+
+          def initialize(field:, min:, max:)
+            @field = field
+            @min = min
+            @max = max
+            freeze
+          end
+
+          def to_solr_s
+            "scale(#{solr_field},#{min},#{max})"
+          end
+
+          def solr_field
+            solarize_field(field)
+          end
+        end
+      end
+    end
+  end
+end