elasticfusion 1.0.0

data/lib/elasticfusion/model/settings.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+module Elasticfusion
+  module Model
+    class Settings
+      delegate :[], :values_at, to: :@settings
+
+      def initialize(model, &block)
+        @model = model
+
+        @settings = DSL.build_settings(&block) if block_given?
+        @settings ||= {}
+
+        @settings[:searchable_mapping] = searchable_mapping
+        @settings[:searchable_fields] ||= @settings[:searchable_mapping].keys
+      end
+
+      def searchable_mapping
+        mapping = @model.__elasticsearch__.mapping.to_hash[
+          @model.__elasticsearch__.document_type.to_sym][:properties]
+
+        if @settings[:searchable_fields]
+          mapping.select { |field, _| @settings[:searchable_fields].include? field }
+        else
+          mapping
+        end
+      end
+
+      class DSL
+        def self.build_settings(&block)
+          new.tap { |dsl| dsl.instance_eval(&block) }.settings
+        end
+
+        def settings
+          @settings ||= {}
+        end
+
+        def scopes
+          settings[:scopes] = yield
+        end
+
+        def keyword_field(field)
+          settings[:keyword_field] = field
+        end
+
+        def searchable_fields(ary)
+          settings[:searchable_fields] = ary
+        end
+
+        def default_query(query)
+          settings[:default_query] = query
+        end
+
+        def default_sort(sort)
+          settings[:default_sort] = sort
+        end
+
+        def reindex_when_updated(attributes)
+          settings[:reindex_when_updated] = attributes
+        end
+      end
+    end
+  end
+end

data/lib/elasticfusion/search/builder.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+module Elasticfusion
+  module Search
+    class Builder
+      def initialize(settings)
+        @scopes        = settings[:scopes]        || {}
+        @default_query = settings[:default_query] || { match_all: {} }
+        @default_sort  = settings[:default_sort]  || {}
+
+        @queries = []
+        @filters = []
+        @sorts   = []
+      end
+
+      # Attribute writers
+
+      def query(q)
+        @queries << q
+      end
+
+      def filter(f)
+        @filters << f
+      end
+
+      def scope(scope, *args)
+        scope = @scopes[scope]
+        raise ArgumentError, "Unknown scope #{scope}" if scope.nil?
+
+        @filters << scope.call(*args)
+      end
+
+      def sort_by(field, direction)
+        raise Search::InvalidSortOrderError if %w(desc asc).exclude? direction.to_s
+        @sorts << { field => direction }
+      end
+
+      # An explicit setter for sort order tiebreaker.
+      # Makes the purpose of the code that uses it more clear, otherwise is identical to +sort_by+.
+      def ensure_deterministic_order_with_unique_field(field)
+        @sorts << { field => :desc }
+      end
+
+      # Attribute readers
+
+      def queries
+        return @queries if @queries.any?
+        @default_query
+      end
+
+      def filters
+        @filters
+      end
+
+      def sorts
+        return @sorts if @sorts.any?
+        @default_sort
+      end
+    end
+  end
+end

data/lib/elasticfusion/search/errors.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Elasticfusion
+  module Search
+    class SearchError < StandardError
+    end
+
+    class ImbalancedParenthesesError < SearchError
+      def message
+        'Imbalanced parentheses.'
+      end
+    end
+
+    class InvalidFieldValueError < SearchError
+      attr_reader :field, :value
+
+      def initialize(field, value)
+        @field = field
+        @value = value
+      end
+
+      def message
+        "\"#{value}\" is not a valid value for \"#{field}\"."
+      end
+    end
+
+    class InvalidSortOrderError < SearchError
+      def message
+        'Invalid sort order. Accepted values: "desc" and "asc".'
+      end
+    end
+  end
+end

data/lib/elasticfusion/search/peeker.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Elasticfusion
+  module Search
+    # An instance of +Peeker+ can return consecutive (previous and next)
+    # records for a given record and an instance of +Search::Wrapper+.
+    #
+    # Under the hood, it uses search_after parameters (see
+    # https://www.elastic.co/guide/en/elasticsearch/reference/5.2/search-request-search-after.html).
+    class Peeker
+      def initialize(wrapper)
+        @wrapper = wrapper
+      end
+
+      def next_record(current_record)
+        request = @wrapper.elasticsearch_request
+
+        first_record_after(current_record, request)
+      end
+
+      def previous_record(current_record)
+        request = @wrapper.elasticsearch_request
+        request[:sort] = reverse_sort request[:sort]
+
+        first_record_after(current_record, request)
+      end
+
+      private
+
+      def first_record_after(record, request)
+        indexed = record.as_indexed_json
+
+        request[:size] = 1
+        request[:search_after] = request[:sort].map do |sort_hash|
+          field, _direction = sort_hash.first
+
+          if indexed[field].is_a? Time
+            ms_since_epoch = (indexed[field].to_f * 1000).to_i
+            ms_since_epoch
+          else
+            indexed[field]
+          end
+        end
+
+        @wrapper.perform(request).records.first
+      end
+
+      def reverse_sort(sort)
+        sort.map do |sort_hash|
+          field, direction = sort_hash.first
+
+          inverse_direction = if direction.to_sym == :asc
+            :desc
+          else
+            :asc
+          end
+
+          { field => inverse_direction }
+        end
+      end
+    end
+  end
+end

data/lib/elasticfusion/search/query/ast.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module Elasticfusion
+  module Search
+    module Query
+      Expression = Struct.new(:op, :left, :right)
+
+      # See visitors/polyadic_tree_visitor.rb
+      PolyadicExpression = Struct.new(:op, :children)
+
+      NegatedClause = Struct.new(:body)
+
+      FieldTerm = Struct.new(:field, :qualifier, :value)
+
+      Term = Struct.new(:body)
+    end
+  end
+end

data/lib/elasticfusion/search/query/lexer.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+require 'strscan'
+
+module Elasticfusion
+  module Search
+    module Query
+      class Lexer
+        TOKENS = {
+          whitespace: /\s+/,
+          and: /AND|,/,
+          or: /OR|\|/,
+          not: /NOT|-/,
+          field_query_delimiter: /:/,
+          field_qualifier: /less than|more than|earlier than|later than/,
+
+          safe_string_until: /(\s*)(AND|OR|,|\||"|\(|\))/,
+          quoted_string: /"(?:[^\\]|\\.)*?"/,
+          string_with_balanced_parentheses_until: /AND|OR|,|\|/
+        }.freeze
+
+        def initialize(string, searchable_fields)
+          @scanner = StringScanner.new(string)
+          @field_regex = /(#{searchable_fields.join('|')}):/ if searchable_fields.any?
+        end
+
+        def match(token)
+          @scanner.scan TOKENS[token]
+        end
+
+        def skip(token)
+          @scanner.skip TOKENS[token]
+        end
+
+        def match_field
+          return unless @field_regex
+          field = @scanner.scan @field_regex
+          if field
+            field[0..-2] # remove field query delimiter (":")
+          end
+        end
+
+        def left_parentheses
+          @scanner.skip /\(/
+        end
+
+        def right_parentheses(expected_count)
+          @scanner.skip /\){,#{expected_count}}/
+        end
+
+        # May contain words, numbers, spaces, dashes, and underscores.
+        def safe_string
+          match_until TOKENS[:safe_string_until]
+        end
+
+        # May contain any characters except for quotes (the latter are allowed when escaped).
+        def quoted_string
+          string = match(:quoted_string)
+
+          if string
+            string[1..-2] # ignore quotes
+              .gsub(/\\"/, '"')
+              .gsub(/\\\\/, '\\')
+          end
+        end
+
+        def string_with_balanced_parentheses
+          string = match_until TOKENS[:string_with_balanced_parentheses_until]
+
+          if string
+            opening_parens = string.count('(')
+
+            balanced = string.split(')')[0..opening_parens].join(')')
+            balanced += ')' if opening_parens > 0 && string.ends_with?(')')
+
+            cutoff = string.length - balanced.length
+            @scanner.pos -= cutoff
+
+            balanced.strip
+          end
+        end
+
+        # StringScanner#scan_until returns everything up to and including the regex.
+        # To avoid including the pattern, we use a lookahead.
+        def match_until(regex)
+          @scanner.scan /.+?(?=#{regex.source}|\z)/
+        end
+      end
+    end
+  end
+end

data/lib/elasticfusion/search/query/parser.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+require 'elasticfusion/search/query/lexer'
+require 'elasticfusion/search/query/ast'
+
+module Elasticfusion
+  module Search
+    module Query
+      class Parser
+        def initialize(query, searchable_fields = [])
+          @lexer = Lexer.new(query, searchable_fields)
+        end
+
+        delegate :match, :skip,
+                 :match_field, :left_parentheses, :right_parentheses,
+                 :safe_string, :quoted_string, :string_with_balanced_parentheses, to: :@lexer
+
+        # query                    = disjunction
+        #                          ;
+        # disjunction              = conjunction , [ ( "OR" | "|" ) , disjunction ]
+        #                          ;
+        # conjunction              = boolean clause , [ ( "AND" | "," ) , conjunction ]
+        #                          ;
+        # boolean clause           = ( "NOT" | "-" ) , boolean clause
+        #                          | clause
+        #                          ;
+        # clause                   = parenthesized expression
+        #                          | field term
+        #                          | term
+        #                          ;
+        # parenthesized expression = "(" , disjunction , ")"
+        #                          ;
+        # field term               = field , ":" , [ field qualifier ] , safe string
+        #                          ;
+        # term                     = quoted string
+        #                          | string with balanced parentheses
+        #                          ;
+
+        def ast
+          disjunction
+        end
+
+        def disjunction
+          skip :whitespace
+          left = conjunction
+
+          skip :whitespace
+          connective = match :or
+
+          skip :whitespace
+          right = disjunction if connective
+
+          if right
+            Expression.new :or, left, right
+          else
+            left
+          end
+        end
+
+        def conjunction
+          skip :whitespace
+          left = boolean_clause
+
+          skip :whitespace
+          connective = match :and
+
+          skip :whitespace
+          right = conjunction if connective
+
+          if right
+            Expression.new :and, left, right
+          else
+            left
+          end
+        end
+
+        def boolean_clause
+          negation = match :not
+          skip :whitespace
+
+          if negation
+            body = boolean_clause
+            redundant_negation = body.is_a?(NegatedClause)
+
+            if redundant_negation
+              body.body
+            else
+              NegatedClause.new body
+            end
+          else
+            clause
+          end
+        end
+
+        def clause
+          parenthesized_expression || field_term || term
+        end
+
+        def parenthesized_expression
+          opening_parens = left_parentheses
+
+          if opening_parens
+            body = disjunction
+            closing_parens = right_parentheses(opening_parens)
+
+            if opening_parens == closing_parens
+              body
+            else
+              raise ImbalancedParenthesesError
+            end
+          end
+        end
+
+        def field_term
+          field = match_field
+
+          if field
+            qualifier = field_qualifier
+
+            skip :whitespace if qualifier
+
+            field_query = safe_string
+
+            FieldTerm.new field, qualifier, field_query
+          end
+        end
+
+        def term
+          string = quoted_string || string_with_balanced_parentheses
+
+          Term.new string.downcase
+        end
+
+        FIELD_QUALIFIERS = { 'less than' => :lt,
+                             'more than' => :gt,
+                             'earlier than' => :lt,
+                             'later than' => :gt }.freeze
+
+        def field_qualifier
+          skip :whitespace
+
+          qualifier = match :field_qualifier
+          FIELD_QUALIFIERS[qualifier]
+        end
+      end
+    end
+  end
+end