redi_search 0.1.0 → 1.0.0

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Search
+    module Clauses
+      class Boolean
+        def initialize(search, term, prior_clause = nil, **term_options)
+          @search = search
+          @prior_clause = prior_clause
+          @not = false
+
+          initialize_term(term, **term_options)
+        end
+
+        def to_s
+          raise ArgumentError, "missing query terms" if term.blank?
+
+          [
+            prior_clause.presence,
+            queryify_term.dup.prepend(not_operator)
+          ].compact.join(operand)
+        end
+
+        delegate :inspect, to: :to_s
+
+        def not(term, **term_options)
+          @not = true
+
+          initialize_term(term, **term_options)
+
+          search
+        end
+
+        private
+
+        attr_reader :prior_clause, :term, :search
+
+        def operand
+          raise NotImplementedError
+        end
+
+        def not_operator
+          return "" unless @not
+
+          "-"
+        end
+
+        def initialize_term(term, **term_options)
+          return if term.blank?
+
+          @term =
+            if term.is_a? RediSearch::Search
+              term
+            else
+              Term.new(term, term_options)
+            end
+        end
+
+        def queryify_term
+          if term.is_a?(RediSearch::Search) &&
+             !term.term_clause.is_a?(RediSearch::Search::Clauses::Where)
+            "(#{term.term_clause})"
+          elsif term.is_a?(RediSearch::Search)
+            term.term_clause
+          else
+            term
+          end.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Search
+    module Clauses
+      class Highlight
+        def initialize(fields: [], opening_tag: "<b>", closing_tag: "</b>")
+          @fields = fields
+          @opening_tag = opening_tag
+          @closing_tag = closing_tag
+        end
+
+        def clause
+          [
+            "HIGHLIGHT",
+            fields_clause,
+            tags_clause,
+          ].compact.flatten(1)
+        end
+
+        private
+
+        attr_reader :fields, :opening_tag, :closing_tag
+
+        def tags_clause
+          return if opening_tag.blank? && closing_tag.blank?
+
+          if opening_tag.present? && closing_tag.present?
+            ["TAGS", opening_tag, closing_tag]
+          else
+            arg_error("Missing opening or closing tag")
+          end
+        end
+
+        def fields_clause
+          return if fields.empty?
+
+          ["FIELDS", fields.size, fields]
+        end
+
+        def arg_error(msg)
+          raise ArgumentError, "Highlight: #{msg}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "redi_search/search/clauses/application_clause"
+
+module RediSearch
+  class Search
+    module Clauses
+      class InOrder < ApplicationClause
+        def clause
+          validate!
+
+          ["INORDER"]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "redi_search/search/clauses/application_clause"
+
+module RediSearch
+  class Search
+    module Clauses
+      class Language < ApplicationClause
+        clause_term :language, presence: true
+
+        def initialize(language:)
+          @language = language
+        end
+
+        def clause
+          validate!
+
+          ["LANGUAGE", language]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "redi_search/search/clauses/application_clause"
+
+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 }
+
+        def initialize(total:, offset: 0)
+          @total = total
+          @offset = offset
+        end
+
+        def clause
+          validate!
+
+          ["LIMIT", [offset, total]]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "redi_search/search/clauses/application_clause"
+
+module RediSearch
+  class Search
+    module Clauses
+      class NoContent < ApplicationClause
+        def clause
+          validate!
+
+          ["NOCONTENT"]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "redi_search/search/clauses/application_clause"
+
+module RediSearch
+  class Search
+    module Clauses
+      class NoStopWords < ApplicationClause
+        def clause
+          validate!
+
+          ["NOSTOPWORDS"]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "redi_search/search/clauses/boolean"
+
+module RediSearch
+  class Search
+    module Clauses
+      class Or < Boolean
+        def where(**condition)
+          @term = search.dup.where(condition)
+
+          search
+        end
+
+        private
+
+        def operand
+          "|"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "redi_search/search/clauses/application_clause"
+
+module RediSearch
+  class Search
+    module Clauses
+      class Return < ApplicationClause
+        clause_term :fields, presence: true
+
+        def initialize(fields:)
+          @fields = fields
+        end
+
+        def clause
+          validate!
+
+          ["RETURN", fields.size, fields]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "redi_search/search/clauses/application_clause"
+
+module RediSearch
+  class Search
+    module Clauses
+      class Slop < ApplicationClause
+        clause_term :slop, numericality: { greater_than_or_equal_to: 0 }
+
+        def initialize(slop:)
+          @slop = slop
+        end
+
+        def clause
+          validate!
+
+          ["SLOP", slop]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "redi_search/search/clauses/application_clause"
+
+module RediSearch
+  class Search
+    module Clauses
+      class SortBy < ApplicationClause
+        clause_term :field, presence: true
+        clause_term :order, presence: true, inclusion: { in: %i(asc desc) }
+
+        def initialize(field:, order: :asc)
+          @field = field
+          @order = order.to_sym
+        end
+
+        def clause
+          validate!
+
+          ["SORTBY", field, order]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "redi_search/search/clauses/application_clause"
+
+module RediSearch
+  class Search
+    module Clauses
+      class Verbatim < ApplicationClause
+        def clause
+          validate!
+
+          ["VERBATIM"]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Search
+    module Clauses
+      class Where
+        def initialize(search, condition, prior_clause = nil)
+          @search = search
+          @prior_clause = prior_clause
+          @not = false
+
+          initialize_term(condition)
+        end
+
+        def to_s
+          [
+            prior_clause.presence,
+            "(#{not_operator}@#{field}:#{queryify_term})"
+          ].compact.join(" ")
+        end
+
+        delegate :inspect, to: :to_s
+
+        def not(condition)
+          @not = true
+
+          initialize_term(condition)
+
+          search
+        end
+
+        private
+
+        attr_reader :prior_clause, :term, :field, :search
+
+        def queryify_term
+          if term.is_a? RediSearch::Search
+            "(#{term.term_clause})"
+          else
+            term.to_s
+          end
+        end
+
+        def not_operator
+          return "" unless @not
+
+          "-"
+        end
+
+        def initialize_term(condition)
+          return if condition.blank?
+
+          condition, *options = condition.to_a
+
+          @field = condition[0]
+          @term =
+            if condition[1].is_a? RediSearch::Search
+              condition[1]
+            else
+              Term.new(condition[1], **options.to_h)
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "redi_search/search/clauses/application_clause"
+
+module RediSearch
+  class Search
+    module Clauses
+      class WithScores < ApplicationClause
+        def clause
+          validate!
+
+          ["WITHSCORES"]
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/search/result.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Search
+    class Result < Array
+      def initialize(index, used_clauses, count, documents)
+        @count = count
+        @used_clauses = used_clauses
+
+        super(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)
+        end)
+      end
+
+      def count
+        @count || super
+      end
+
+      def size
+        @count || super
+      end
+
+      private
+
+      def response_slice
+        slice_length = 2
+        slice_length -= 1 if no_content?
+        slice_length += 1 if with_scores?
+
+        slice_length
+      end
+
+      def with_scores?
+        @used_clauses.include? "with_scores"
+      end
+
+      def no_content?
+        @used_clauses.include? "no_content"
+      end
+    end
+  end
+end