solrb 0.1.0

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

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

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

@@ -0,0 +1,46 @@
+require 'solr/query/request/boosting/scale_function_boost'
+require 'solr/query/request/boosting/geodist_function'
+require 'solr/query/request/boosting/recent_field_value_boost_function'
+require 'solr/query/request/boosting/ranking_field_boost_function'
+require 'solr/query/request/boosting/field_value_match_boost_function'
+require 'solr/query/request/boosting/numeric_field_value_match_boost_function'
+require 'solr/query/request/boosting/textual_field_value_match_boost_function'
+require 'solr/query/request/boosting/dictionary_boost_function'
+require 'solr/query/request/boosting/exists_boost_function'
+require 'solr/query/request/boosting/field_value_less_than_boost_function'
+require 'solr/query/request/boosting/ln_function_boost'
+require 'solr/query/request/boosting/phrase_proximity_boost'
+
+module Solr
+  module Query
+    class Request
+      class Boosting
+        class << self
+          def empty
+            @empty ||= new
+          end
+        end
+
+        attr_reader :additive_boost_functions, :multiplicative_boost_functions, :phrase_boosts, :spatial_boost
+
+        def initialize(additive_boost_functions: [], multiplicative_boost_functions: [], phrase_boosts: [])
+          @additive_boost_functions = additive_boost_functions
+          @multiplicative_boost_functions = multiplicative_boost_functions
+          @phrase_boosts = phrase_boosts
+          @spatial_boost = find_spatial_boost
+          freeze
+        end
+
+        def empty?
+          [multiplicative_boost_functions, additive_boost_functions, phrase_boosts].all(&:empty?)
+        end
+
+        private
+
+        def find_spatial_boost
+          multiplicative_boost_functions.find { |mbf| mbf.is_a? ::Solr::Query::Request::Boosting::GeodistFunction }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+module Solr
+  module Query
+    class Request
+      class EdismaxAdapter
+        SOLR_INFINITY = '*'.freeze # for cases like [100000 TO *]
+        include Solr::Support::SchemaHelper
+
+        EDISMAX_QUERY_FIELDS = :qf
+        EDISMAX_FILTER_QUERY = :fq
+        EDISMAX_ADDITIVE_BOOST_FUNCTION = :bf
+        EDISMAX_MULTIPLICATIVE_BOOST_FUNCTION = :boost
+        EDISMAX_PHRASE_BOOST = :pf
+        EDISMAX_PHRASE_SLOP = :ps
+        RESPONSE_FIELDS = :fl
+        RERANK_QUERY = :rq
+        QUERY_OPERATOR = :'q.op'
+
+        attr_reader :request
+
+        def initialize(request)
+          @request = request
+        end
+
+        def to_h
+          solr_params = { q: request.search_term, defType: :edismax }
+          solr_params = add_query_fields(solr_params)
+          solr_params = add_response_fields(solr_params)
+          solr_params = add_filters(solr_params)
+          solr_params = add_facets(solr_params)
+          solr_params = add_boosting(solr_params)
+          solr_params = add_grouping(solr_params)
+          solr_params = add_sorting(solr_params)
+          solr_params = add_debug(solr_params)
+          solr_params = add_spellcheck(solr_params)
+          solr_params = add_rerank_query(solr_params)
+          solr_params = add_phrase_slop(solr_params)
+          solr_params = add_query_operator(solr_params)
+          solr_params
+        end
+
+        private
+
+        def add_query_fields(solr_params)
+          fields = request.fields.map(&:to_solr_s)
+          solr_params.merge(EDISMAX_QUERY_FIELDS => fields)
+        end
+
+        def add_filters(solr_params)
+          filters = request.filters.map(&:to_solr_s)
+          solr_params.merge(EDISMAX_FILTER_QUERY => filters)
+        end
+
+        def add_facets(solr_params)
+          return solr_params if Array(request.facets).empty?
+
+          solr_params['json.facet'] = request.facets.map(&:to_solr_h).reduce(&:merge).to_json
+
+          solr_params
+        end
+
+        def add_boosting(solr_params)
+          return solr_params unless request.boosting
+          solr_params = add_additive_boost_functions(solr_params)
+          solr_params = add_multiplicative_boost_functions(solr_params)
+          add_phrase_boosts(solr_params)
+        end
+
+        def add_additive_boost_functions(solr_params)
+          additive_boosts = request.boosting.additive_boost_functions.map(&:to_solr_s)
+          if additive_boosts.any?
+            solr_params.merge(EDISMAX_ADDITIVE_BOOST_FUNCTION => additive_boosts)
+          else
+            solr_params
+          end
+        end
+
+        def add_multiplicative_boost_functions(solr_params)
+          multiplicative_boosts = request.boosting.multiplicative_boost_functions.map(&:to_solr_s)
+          if multiplicative_boosts.any?
+            solr_params = solr_params.merge(EDISMAX_MULTIPLICATIVE_BOOST_FUNCTION => multiplicative_boosts)
+            # https://stackoverflow.com/questions/47025453/
+            maybe_add_spatial_fields(solr_params, request.boosting.spatial_boost)
+          else
+            solr_params
+          end
+        end
+
+        def add_phrase_boosts(solr_params)
+          solr_phrase_boosts = request.boosting.phrase_boosts.map(&:to_solr_s)
+          if solr_phrase_boosts.any?
+            solr_params.merge(EDISMAX_PHRASE_BOOST => solr_phrase_boosts)
+          else
+            solr_params
+          end
+        end
+
+        def maybe_add_spatial_fields(solr_params, geodist_function)
+          if geodist_function
+            solr_params.merge(pt: geodist_function.latlng, sfield: geodist_function.sfield)
+          else
+            solr_params
+          end
+        end
+
+        def add_grouping(solr_params)
+          return solr_params if request.grouping.empty?
+          group_info = {
+            'group' => true,
+            'group.format' => 'grouped',
+            'group.limit' => request.grouping.limit,
+            'group.field' => solarize_field(request.grouping.field)
+          }
+          solr_params.merge(group_info)
+        end
+
+        def add_sorting(solr_params)
+          return solr_params if request.sorting.empty?
+          # sorting nulls last, not-nulls first
+          solr_sorting = request.sorting.fields.map do |sort_field|
+            solr_field = solarize_field(sort_field.name)
+            "exists(#{solr_field}) desc, #{solr_field} #{sort_field.direction}"
+          end
+          solr_params.merge(sort: solr_sorting)
+        end
+
+        def add_response_fields(solr_params)
+          response_fields = 'id'
+          response_fields += ',score' if debug_mode?
+          response_fields += request.response_fields if request.response_fields
+          solr_params.merge(RESPONSE_FIELDS => response_fields)
+        end
+
+        def add_debug(solr_params)
+          solr_params.merge(debug: debug_mode?)
+        end
+
+        def debug_mode?
+          request.debug_mode
+        end
+
+        def add_spellcheck(solr_params)
+          solr_params.merge(request.spellcheck.to_h)
+        end
+
+        def add_rerank_query(solr_params)
+          return solr_params unless request.limit_docs_by_field
+          rerank_query = request.limit_docs_by_field.to_solr_s
+          solr_params.merge(RERANK_QUERY => rerank_query)
+        end
+
+        def add_phrase_slop(solr_params)
+          return solr_params unless request.phrase_slop
+          solr_params.merge(EDISMAX_PHRASE_SLOP => request.phrase_slop)
+        end
+
+        def add_query_operator(solr_params)
+          return solr_params unless request.query_operator
+          solr_params.merge(QUERY_OPERATOR => request.query_operator)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Solr
+  module Query
+    class Request
+      class Facet
+        include Solr::Support::SchemaHelper
+
+        TERMS_TYPE = :terms
+        QUERY_TYPE = :query
+        RANGE_TYPE = :range
+
+        attr_reader :field,
+                    :type,
+                    :name,
+                    :value,
+                    :limit,
+                    :filters,
+                    :subfacets,
+                    :gap,
+                    :lower_bound,
+                    :upper_bound
+
+        def initialize(field:, type:, name: nil, value: nil, filters: [], subfacets: [], options: {})
+          if options[:limit].nil? && type == TERMS_TYPE
+            raise ArgumentError, "Need to specify :limit option value for 'terms' facet type"
+          end
+
+          if options.values_at(:gap, :lower_bound, :upper_bound).any?(&:nil?) && type == RANGE_TYPE
+            raise ArgumentError, "Need to specify :lower_bound, :upper_bound, :gap option values for 'range' facet type"
+          end
+
+          @field       = field
+          @name        = name || field
+          @type        = type
+          @value       = value
+          @filters     = filters
+          @subfacets   = subfacets
+          @limit       = options[:limit].to_i
+          @gap         = options[:gap]
+          @lower_bound = options[:lower_bound]
+          @upper_bound = options[:upper_bound]
+        end
+
+        def to_solr_h
+          return { name.to_s => value } if type == QUERY_TYPE && value
+
+          default_solr_h
+        end
+
+        protected
+
+        def default_solr_h
+          {
+            "#{name}": {
+              type: type,
+              field: solarize_field(field),
+              limit: limit,
+              q: filters.any? ? filters.map(&:to_solr_s).join(' AND ') : nil,
+              facet: subfacets.map(&:to_solr_h).reduce(&:merge),
+              gap: gap,
+              start: lower_bound,
+              end: upper_bound
+            }.compact
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Solr
+  module Query
+    class Request
+      class FieldWithBoost
+        attr_reader :field, :boost_magnitude
+
+        def initialize(field:, boost_magnitude: Solr::Query::Request::BoostMagnitude::DEFAULT)
+          @field = field
+          @boost_magnitude = boost_magnitude
+        end
+
+        def to_solr_s
+          "#{field}^#{boost_magnitude}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'date'
+
+module Solr
+  module Query
+    class Request
+      class Filter
+        include Solr::Support::SchemaHelper
+        using Solr::Support::StringExtensions
+
+        EQUAL_TYPE = :equal
+        NOT_EQUAL_TYPE = :not_equal
+        attr_reader :type, :field, :value
+
+        def initialize(type:, field:, value:)
+          @type = type
+          @field = field
+          @value = value
+        end
+
+        def to_solr_s
+          "#{solr_prefix}#{solr_field}:(#{solr_value})"
+        end
+
+        def solr_field
+          solarize_field(@field)
+        end
+
+        def solr_value
+          if value.is_a?(::Array)
+            value.map { |v| to_primitive_solr_value(v) }.join(' OR ')
+          elsif value.is_a?(::Range)
+            to_interval_solr_value(value)
+          else
+            to_primitive_solr_value(value)
+          end
+        end
+
+        private
+
+        def solr_prefix
+          '-' if NOT_EQUAL_TYPE == @type
+        end
+
+        def to_interval_solr_value(range)
+          solr_min = to_primitive_solr_value(range.min)
+          solr_max = if date_infinity?(range.max) || range.max.to_f.infinite?
+                       '*'
+                     else
+                       to_primitive_solr_value(range.max)
+                     end
+          "[#{solr_min} TO #{solr_max}]"
+        end
+
+        def to_primitive_solr_value(value)
+          if date_or_time?(value)
+            value.strftime('%Y-%m-%dT%H:%M:%SZ')
+          else
+            %("#{value.to_s.solr_escape}")
+          end
+        end
+
+        def date_infinity?(value)
+          value.is_a?(DateTime::Infinity)
+        end
+
+        def date_or_time?(value)
+          return false unless value
+          value.is_a?(::Date) || value.is_a?(::Time)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Solr
+  module Query
+    class Request
+      class GeoFilter
+        SPATIAL_RADIUS = 161 # roughly 100mi
+
+        include Solr::Support::SchemaHelper
+
+        attr_reader :field, :latitude, :longitude, :spatial_radius
+
+        def initialize(field:, latitude:, longitude:, spatial_radius: SPATIAL_RADIUS)
+          @field = field
+          @latitude = latitude
+          @longitude = longitude
+          @spatial_radius = spatial_radius
+          freeze
+        end
+
+        def to_solr_s
+          solr_field = solarize_field(@field)
+          "{!geofilt sfield=#{solr_field} pt=#{@latitude},#{@longitude} d=#{spatial_radius}}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Solr
+  module Query
+    class Request
+      class Grouping
+        class None
+          def initialize
+            freeze
+          end
+
+          def empty?
+            true
+          end
+
+          def inspect
+            'No Grouping'
+          end
+        end
+
+        attr_reader :field, :limit
+
+        def self.none
+          None.new
+        end
+
+        def initialize(field:, limit:)
+          @field = field
+          @limit = limit
+          freeze
+        end
+
+        def empty?
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Solr
+  module Query
+    class Request
+      class OrFilter
+        def initialize(*filters)
+          @filters = filters
+        end
+
+        def to_solr_s
+          subexpressions = @filters.map { |f| "#{f.solr_field}:(#{f.solr_value})" }
+          "(#{subexpressions.join(' OR ')})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Solr
+  module Query
+    class Request
+      class Runner
+        PATH = '/select'.freeze
+
+        include Solr::Support::ConnectionHelper
+
+        attr_reader :page, :page_size, :solr_params
+
+        class << self
+          def run(opts)
+            new(opts).run
+          end
+        end
+
+        def initialize(page:, page_size:, solr_params: {})
+          @page = page
+          @page_size = page_size
+          @solr_params = solr_params
+        end
+
+        def run
+          raw_response = connection(PATH).post_as_json(request_params)
+          response = Solr::Response.from_raw_response(raw_response)
+          Solr.instrument(name: 'solrb.request_response_cycle',
+                          data: { request: request_params, response: raw_response })
+          response
+        end
+
+        private
+
+        def start
+          start_page = @page.to_i - 1
+          start_page = start_page < 1 ? 0 : start_page
+          start_page * page_size
+        end
+
+        def request_params
+          # https://lucene.apache.org/solr/guide/7_1/json-request-api.html#passing-parameters-via-json
+          @request_params ||= { params: solr_params.merge(wt: :json, rows: page_size.to_i, start: start) }
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/request/sorting/field.rb

@@ -0,0 +1,16 @@
+module Solr
+  module Query
+    class Request
+      class Sorting
+        class Field
+          attr_reader :name, :direction
+          def initialize(name:, direction:)
+            @name = name
+            @direction = direction
+            freeze
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Solr
+  module Query
+    class Request
+      class Sorting
+        ASC = :asc
+        DESC = :desc
+        class None
+          def initialize
+            freeze
+          end
+
+          def empty?
+            true
+          end
+        end
+
+        attr_reader :fields
+
+        def self.none
+          None.new
+        end
+
+        def initialize(fields: [])
+          @fields = fields
+          freeze
+        end
+
+        def empty?
+          fields.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Solr
+  module Query
+    class Request
+      class Spellcheck
+        class Disabled
+          attr_reader :previous_search_term, :collated_search_term
+
+          def initialize(previous_search_term: nil, collated_search_term: nil)
+            @previous_search_term = previous_search_term
+            @collated_search_term = collated_search_term
+          end
+
+          def to_h
+            {}
+          end
+
+          def collated?
+            collated_search_term.present?
+          end
+
+          def disabled?
+            true
+          end
+
+          def inspect
+            'Disabled'
+          end
+        end
+
+        class Default
+          def to_h
+            {
+              spellcheck: true,
+              'spellcheck.dictionary': 'spellcheck',
+              'spellcheck.count': 1,
+              'spellcheck.collate': true,
+              'spellcheck.maxCollations': 1,
+              'spellcheck.collateExtendedResults': true,
+              'spellcheck.maxCollationTries': 1,
+              'spellcheck.onlyMorePopular': true
+            }
+          end
+
+          def previous_search_term; end
+
+          def collated_search_term; end
+
+          def collated?
+            false
+          end
+
+          def disabled?
+            false
+          end
+        end
+
+        def self.collated(previous:, collated:)
+          Disabled.new(
+            previous_search_term: previous,
+            collated_search_term: collated
+          )
+        end
+
+        def self.disabled
+          Disabled.new
+        end
+
+        def self.default
+          Default.new
+        end
+      end
+    end
+  end
+end

data/lib/solr/query/request.rb

@@ -0,0 +1,49 @@
+require 'solr/query/request/facet'
+require 'solr/query/request/filter'
+require 'solr/query/request/boost_magnitude'
+require 'solr/query/request/geo_filter'
+require 'solr/query/request/sorting'
+require 'solr/query/request/edismax_adapter'
+require 'solr/query/request/grouping'
+require 'solr/query/request/boosting'
+require 'solr/query/request/spellcheck'
+require 'solr/query/request/sorting/field'
+require 'solr/query/request/field_with_boost'
+require 'solr/query/request/or_filter'
+require 'solr/query/request/runner'
+require 'solr/query/response'
+require 'solr/errors/solr_query_error'
+
+module Solr
+  module Query
+    class Request
+      attr_reader :search_term
+      attr_accessor :filters, :fields, :facets, :boosting, :debug_mode, :spellcheck,
+                    :limit_docs_by_field, :phrase_slop, :response_fields, :query_operator
+      attr_writer :grouping, :sorting
+
+      def initialize(search_term:, fields: [], filters: [])
+        @search_term = search_term
+        @fields = fields
+        @filters = filters
+      end
+
+      # Runs this Solr::Request against Solr and
+      # returns [Solr::Response]
+      def run(page: 1, page_size: 10)
+        solr_params = Solr::Query::Request::EdismaxAdapter.new(self).to_h
+        solr_response = Solr::Query::Request::Runner.run(page: page, page_size: page_size, solr_params: solr_params)
+        raise Errors::SolrQueryError, solr_response.error_message unless solr_response.ok?
+        Solr::Query::Response::Parser.new(request: self, solr_response: solr_response.body).to_response
+      end
+
+      def grouping
+        @grouping ||= Solr::Query::Request::Grouping.none
+      end
+
+      def sorting
+        @sorting ||= Solr::Query::Request::Sorting.none
+      end
+    end
+  end
+end