redi_search 1.0.3 → 2.0.2

data/lib/redi_search/search/clauses/boolean.rb

@@ -4,26 +4,28 @@ module RediSearch
   class Search
     module Clauses
       class Boolean
+        extend Forwardable
+
         def initialize(search, term, prior_clause = nil, **term_options)
           @search = search
           @prior_clause = prior_clause
           @not = false
 
-          initialize_term(term, **term_options) if term.present?
+          initialize_term(term, **term_options) if term
         end
 
         def to_s
-          raise ArgumentError, "missing query terms" if term.blank?
+          raise ArgumentError, "missing query terms" unless term
 
-          [prior_clause.presence, queryify_term].compact.join(operand)
+          [prior_clause, queryify_term].compact.join(operand)
         end
 
-        delegate :inspect, to: :to_s
+        def_delegator :to_s, :inspect
 
         def not(term, **term_options)
           @not = true
 
-          initialize_term(term, **term_options) if term.present?
+          initialize_term(term, **term_options) if term
 
           search
         end
@@ -33,7 +35,7 @@ module RediSearch
         attr_reader :prior_clause, :term, :search
 
         def operand
-          raise NotImplementedError
+          raise NotImplementedError, "#{__method__} needs to be defined"
         end
 
         def not_operator

data/lib/redi_search/search/clauses/highlight.rb

@@ -23,9 +23,9 @@ module RediSearch
         attr_reader :fields, :opening_tag, :closing_tag
 
         def tags_clause
-          return if opening_tag.blank? && closing_tag.blank?
+          return if !opening_tag? && !closing_tag?
 
-          if opening_tag.present? && closing_tag.present?
+          if opening_tag? && closing_tag?
             ["TAGS", opening_tag, closing_tag]
           else
             arg_error("Missing opening or closing tag")
@@ -41,6 +41,22 @@ module RediSearch
         def arg_error(msg)
           raise ArgumentError, "Highlight: #{msg}"
         end
+
+        def opening_tag?
+          if opening_tag.respond_to? :empty?
+            !opening_tag.empty?
+          else
+            opening_tag
+          end
+        end
+
+        def closing_tag?
+          if closing_tag.respond_to? :empty?
+            !closing_tag.empty?
+          else
+            closing_tag
+          end
+        end
       end
     end
   end

data/lib/redi_search/search/clauses/limit.rb

@@ -6,10 +6,12 @@ module RediSearch
   class Search
     module Clauses
       class Limit < ApplicationClause
-        clause_term :total, presence: true,
-                            numericality: { greater_than_or_equal_to: 0 }
-        clause_term :offset, presence: true,
-                             numericality: { greater_than_or_equal_to: 0 }
+        clause_term :total, presence: true, numericality: {
+          within: 0..Float::INFINITY, only_integer: true
+        }
+        clause_term :offset, presence: true, numericality: {
+          within: 0..Float::INFINITY, only_integer: true
+        }
 
         def initialize(total:, offset: 0)
           @total = total
@@ -19,7 +21,7 @@ module RediSearch
         def clause
           validate!
 
-          ["LIMIT", [offset, total]]
+          ["LIMIT", offset, total]
         end
       end
     end

data/lib/redi_search/search/clauses/return.rb

@@ -15,7 +15,7 @@ module RediSearch
         def clause
           validate!
 
-          ["RETURN", fields.size, fields]
+          ["RETURN", fields.size, *fields]
         end
       end
     end

data/lib/redi_search/search/clauses/slop.rb

@@ -6,7 +6,7 @@ module RediSearch
   class Search
     module Clauses
       class Slop < ApplicationClause
-        clause_term :slop, numericality: { greater_than_or_equal_to: 0 }
+        clause_term :slop, numericality: { within: 0..Float::INFINITY }
 
         def initialize(slop:)
           @slop = slop

data/lib/redi_search/search/clauses/sort_by.rb

@@ -7,7 +7,7 @@ module RediSearch
     module Clauses
       class SortBy < ApplicationClause
         clause_term :field, presence: true
-        clause_term :order, presence: true, inclusion: { in: %i(asc desc) }
+        clause_term :order, presence: true, inclusion: { within: %i(asc desc) }
 
         def initialize(field:, order: :asc)
           @field = field

data/lib/redi_search/search/clauses/where.rb

@@ -4,6 +4,8 @@ module RediSearch
   class Search
     module Clauses
       class Where
+        extend Forwardable
+
         def initialize(search, condition, prior_clause = nil)
           @search = search
           @prior_clause = prior_clause
@@ -14,12 +16,12 @@ module RediSearch
 
         def to_s
           [
-            prior_clause.presence,
+            prior_clause,
             "(#{not_operator}@#{field}:#{queryify_term})"
           ].compact.join(" ")
         end
 
-        delegate :inspect, to: :to_s
+        def_delegator :to_s, :inspect
 
         def not(condition)
           @not = true
@@ -48,7 +50,7 @@ module RediSearch
         end
 
         def initialize_term(condition)
-          return if condition.blank?
+          return if condition?(condition)
 
           condition, *options = condition.to_a
 
@@ -63,6 +65,14 @@ module RediSearch
             Term.new(condition[1], **options.to_h)
           end
         end
+
+        def condition?(condition)
+          if condition.respond_to?(:empty?)
+            condition.empty?
+          else
+            !condition
+          end
+        end
       end
     end
   end

data/lib/redi_search/search/result.rb

@@ -2,24 +2,40 @@
 
 module RediSearch
   class Search
-    class Result < Array
-      def initialize(index, used_clauses, count, documents)
-        @count = count
-        @used_clauses = used_clauses
+    class Result
+      extend Forwardable
+      include Enumerable
 
-        super(parse_results(index, documents))
+      def initialize(search, count, documents)
+        @count = count
+        @search = search
+        @results = parse_results(documents)
       end
 
       def count
-        @count || super
+        @count || results.count
       end
 
       def size
-        @count || super
+        @count || results.size
+      end
+
+      def_delegators :results, :each, :empty?, :[], :last
+
+      def inspect
+        results
+      end
+
+      #:nocov:
+      def pretty_print(printer)
+        printer.pp(results)
       end
+      #:nocov:
 
       private
 
+      attr_reader :results, :search
+
       def response_slice
         slice_length = 2
         slice_length -= 1 if no_content?
@@ -29,20 +45,20 @@ module RediSearch
       end
 
       def with_scores?
-        @used_clauses.include? "with_scores"
+        search.used_clauses.include? Search::Clauses::WithScores
       end
 
       def no_content?
-        @used_clauses.include? "no_content"
+        search.used_clauses.include? Search::Clauses::NoContent
       end
 
-      def parse_results(index, documents)
+      def parse_results(documents)
         documents.each_slice(response_slice).map do |slice|
           document_id = slice[0]
           fields = slice.last unless no_content?
           score = slice[1].to_f if with_scores?
 
-          Document.new(index, document_id, Hash[*fields.to_a], score)
+          Document.new(search.index, document_id, Hash[*fields.to_a], score)
         end
       end
     end

data/lib/redi_search/search/term.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
+require "redi_search/validatable"
+
 module RediSearch
   class Search
     class Term
-      include ActiveModel::Validations
+      include Validatable
 
-      validates :fuzziness, numericality: {
-        only_integer: true, less_than: 4, greater_than: 0, allow_blank: true
-      }
-      validates :option, inclusion: { in: %i(fuzziness optional prefix) },
-                         allow_nil: true
+      validates_numericality_of :fuzziness, within: 1..3, only_integer: true,
+                                            allow_nil: true
+      validates_inclusion_of :option, within: %i(fuzziness optional prefix),
+                                      allow_nil: true
 
       def initialize(term, **options)
         @term = term

data/lib/redi_search/spellcheck.rb

@@ -2,15 +2,14 @@
 
 require "redi_search/lazily_load"
 require "redi_search/spellcheck/result"
+require "redi_search/validatable"
 
 module RediSearch
   class Spellcheck
     include LazilyLoad
-    include ActiveModel::Validations
+    include Validatable
 
-    validates :distance, numericality: {
-      greater_than: 0, less_than: 5
-    }
+    validates_numericality_of :distance, within: 1..4, only_integer: true
 
     def initialize(index, terms, distance: 1)
       @index = index

data/lib/redi_search/spellcheck/result.rb

@@ -14,7 +14,6 @@ module RediSearch
         end
       end
 
-      #:nocov:
       def inspect
         inspection = %w(term suggestions).map do |field_name|
           "#{field_name}: #{public_send(field_name)}"
@@ -23,6 +22,7 @@ module RediSearch
         "#<#{self.class} #{inspection}>"
       end
 
+      #:nocov:
       def pretty_print(printer) # rubocop:disable Metrics/MethodLength
         printer.object_address_group(self) do
           printer.seplist(

data/lib/redi_search/validatable.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "redi_search/validations/inclusion"
+require "redi_search/validations/presence"
+require "redi_search/validations/numericality"
+
+module RediSearch
+  class ValidationError < StandardError
+  end
+
+  module Validatable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      attr_accessor :validations
+
+      def validates_inclusion_of(field, within:, **options)
+        self.validations = [
+          *validations.to_a,
+          Validations::Inclusion.new(field: field, within: within, **options)
+        ]
+      end
+
+      def validates_presence_of(field)
+        self.validations = [
+          *validations.to_a,
+          Validations::Presence.new(field: field)
+        ]
+      end
+
+      def validates_numericality_of(field, within:, **options)
+        self.validations = [
+          *validations.to_a,
+          Validations::Numericality.new(
+            field: field, within: within, **options
+          )
+        ]
+      end
+    end
+
+    def validate!
+      self.class.validations.to_a.each do |validator|
+        validator.validate!(self)
+      end
+    end
+  end
+end

data/lib/redi_search/validations/inclusion.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RediSearch
+  module Validations
+    class Inclusion
+      def initialize(field:, within:, allow_nil: false)
+        @field = field
+        @within = within
+        @allow_nil = allow_nil
+      end
+
+      def validate!(object)
+        value = object.send(field)
+
+        return true if within.include?(value) || (allow_nil? && value.nil?)
+
+        raise ValidationError, "#{value.inspect} not included in #{within}"
+      end
+
+      private
+
+      attr_reader :field, :within, :allow_nil
+      alias allow_nil? allow_nil
+    end
+  end
+end

data/lib/redi_search/validations/numericality.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "redi_search/validations/inclusion"
+
+module RediSearch
+  module Validations
+    class Numericality
+      def initialize(field:, within:, only_integer: false, allow_nil: false)
+        @field = field
+        @within = within
+        @only_integer = only_integer
+        @allow_nil = allow_nil
+      end
+
+      def validate!(object)
+        value = object.send(field)
+
+        return true if value.nil? && allow_nil?
+
+        validate_numberness!(value)
+        validate_inclusion!(object)
+      end
+
+      private
+
+      attr_reader :field, :within, :only_integer, :allow_nil
+      alias only_integer? only_integer
+      alias allow_nil? allow_nil
+
+      def validate_numberness!(value)
+        raise(ValidationError, "#{field} must be a number") unless
+          value.is_a?(Numeric)
+
+        raise(ValidationError, "#{field} must be an Integer") if
+          only_integer? && !value.is_a?(Integer)
+
+        true
+      end
+
+      def validate_inclusion!(object)
+        Inclusion.new(field: field, within: within).validate!(object)
+      end
+    end
+  end
+end

data/lib/redi_search/validations/presence.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RediSearch
+  module Validations
+    class Presence
+      def initialize(field:)
+        @field = field
+      end
+
+      def validate!(object)
+        return true if value_present?(object.send(field))
+
+        raise RediSearch::ValidationError, "#{field} can't be blank"
+      end
+
+      private
+
+      attr_reader :field
+
+      def value_present?(value)
+        if value.respond_to?(:empty?)
+          !value.empty?
+        else
+          value
+        end
+      end
+    end
+  end
+end