caoutsearch 0.0.1 → 0.0.3

data/lib/caoutsearch/search/search/query_methods.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-module Caoutsearch
-  module Search
-    module Search
-      module QueryMethods
-        delegate :merge, :merge!, :to_h, :to_json, :as_json, :filters,
-          :add_none, :add_filter, :add_sort, :add_aggregation, :add_suggestion,
-          :build_terms, :should_filter_on, :must_filter_on, :must_not_filter_on,
-          :nested_queries, :nested_query,
-          to: :elasticsearch_query
-
-        # Accessors
-        # ------------------------------------------------------------------------
-        def elasticsearch_query
-          @elasticsearch_query ||= Caoutsearch::Search::Query::Base.new
-        end
-
-        # Applying criteria
-        # ------------------------------------------------------------------------
-        def search_by(criteria)
-          case criteria
-          when Array  then criteria.each { |criterion| search_by(criterion) }
-          when Hash   then criteria.each { |key, value| filter_by(key, value) }
-          when String then apply_dsl_match_all(criteria)
-          end
-        end
-
-        def filter_by(key, value)
-          case key
-          when Array
-            items = key.filter_map { |k| config[:filters][k] }
-            apply_dsl_filters(items, value)
-          when Caoutsearch::Search::DSL::Item
-            apply_dsl_filter(key, value)
-          else
-            if config[:filters].key?(key)
-              apply_dsl_filter(config[:filters][key], value)
-            elsif config[:filters].key?(:__undef__)
-              block = config[:filters][:__undef__]
-              instance_exec(key, value, &block)
-            end
-          end
-        end
-
-        # Applying DSL filters items
-        # ------------------------------------------------------------------------
-        def apply_dsl_match_all(value)
-          return unless (block = config[:match_all])
-
-          instance_exec(value, &block)
-        end
-
-        def apply_dsl_filter(item, value)
-          return instance_exec(value, &item.block) if item.has_block?
-
-          terms   = []
-          indexes = item.indexes
-          options = item.options.dup
-          query   = elasticsearch_query
-
-          if options[:nested_query]
-            query = nested_query(options[:nested_query])
-            options[:nested] = nil
-          end
-
-          indexes.each do |index|
-            options_index = options.dup
-            options_index[:type]              = mappings.find_type(index)          unless options_index.key?(:type)
-            options_index[:nested]            = mappings.nested_path(index)        unless options_index.key?(:nested)
-            options_index[:include_in_parent] = mappings.include_in_parent?(index) unless options_index.key?(:include_in_parent) || !options_index[:nested]
-
-            terms += query.build_terms(index, value, **options_index)
-          end
-
-          query.should_filter_on(terms)
-        end
-
-        def apply_dsl_filters(items, value)
-          terms = []
-
-          items.each do |item|
-            terms += isolate_dsl_filter(item, value)
-          end
-
-          should_filter_on(terms)
-        end
-
-        def isolate_dsl_filter(item, value)
-          isolated_instance = clone
-          isolated_instance.apply_dsl_filter(item, value)
-          isolated_instance.elasticsearch_query.dig(:query, :bool, :filter) || []
-        end
-
-        # Applying orders
-        # ------------------------------------------------------------------------
-        def order_by(keys)
-          case keys
-          when Array          then keys.each { |key| order_by(key) }
-          when Hash           then keys.each { |key, direction| sort_by(key, direction) }
-          when String, Symbol then sort_by(keys)
-          end
-        end
-
-        def sort_by(key, direction = nil)
-          if config[:sorts].key?(key)
-            apply_dsl_sort(config[:sorts][key], direction)
-          elsif config[:sorts].key?(:__undef__)
-            block = config[:sorts][:__undef__]
-            instance_exec(key, direction, &block)
-          end
-        end
-
-        def apply_dsl_sort(item, direction)
-          return instance_exec(direction, &item.block) if item.has_block?
-
-          indexes = item.indexes
-          indexes.each do |index|
-            case index
-            when :default, "default"
-              sort_by(:default, direction)
-
-            when Hash
-              index.map do |key, value|
-                key_direction = (value.to_s == direction.to_s ? :asc : :desc)
-                add_sort(key, key_direction)
-              end
-
-            else
-              add_sort(index, direction)
-            end
-          end
-        end
-
-        # Applying aggregations
-        # ------------------------------------------------------------------------
-        def aggregate_with(*args)
-          args.each do |arg|
-            if arg.is_a?(Hash)
-              arg.each do |key, value|
-                next unless (item = config[:aggregations][key])
-
-                apply_dsl_aggregate(item, value)
-              end
-            elsif (item = config[:aggregations][arg])
-              apply_dsl_aggregate(item)
-            end
-          end
-        end
-
-        def apply_dsl_aggregate(item, *args)
-          return instance_exec(*args, &item.block) if item.has_block?
-
-          add_aggregation(item.name, item.options)
-        end
-
-        # Applying Suggests
-        # ------------------------------------------------------------------------
-        def suggest_with(*args)
-          args.each do |(hash, options)|
-            raise ArgumentError unless hash.is_a?(Hash)
-
-            hash.each do |key, value|
-              next unless (item = config[:suggestions][key.to_s])
-
-              options ||= {}
-              apply_dsl_suggest(item, value, **options)
-            end
-          end
-        end
-
-        def apply_dsl_suggest(item, query, **options)
-          return instance_exec(query, **options, &item.block) if item.has_block?
-
-          add_suggestion(item.name, query, **options)
-        end
-      end
-    end
-  end
-end

data/lib/caoutsearch/search/search/resettable.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Caoutsearch
-  module Search
-    module Search
-      module Resettable
-        def spawn
-          clone
-        end
-
-        def clone
-          super.reset
-        end
-
-        def dup
-          super.reset
-        end
-
-        def reset
-          reset_variable(:@elasticsearch_query)
-          reset_variable(:@nested_queries)
-          reset_variable(:@response)
-          reset_variable(:@total_count)
-          self
-        end
-
-        private
-
-        def reset_variable(key)
-          remove_instance_variable(key) if instance_variable_defined?(key)
-        end
-      end
-    end
-  end
-end

data/lib/caoutsearch/search/search/response.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-module Caoutsearch
-  module Search
-    module Search
-      module Response
-        delegate :empty?, :size, :slice, :[], :to_a, :to_ary, to: :hits
-        delegate_missing_to :each
-
-        def response
-          load unless @response
-          @response
-        end
-
-        def took
-          response["took"]
-        end
-
-        def timed_out
-          response["timed_out"]
-        end
-
-        def shards
-          response["_shards"]
-        end
-
-        def hits
-          response.dig("hits", "hits")
-        end
-
-        def max_score
-          response.dig("hits", "max_score")
-        end
-
-        def total_count
-          if response.dig("hits", "total", "relation") == "gte" && !@track_total_hits
-            @total_count ||= spawn.track_total_hits(true).total_count
-          else
-            response.dig("hits", "total", "value")
-          end
-        end
-
-        def total_pages
-          (total_count.to_f / current_limit).ceil
-        end
-
-        def ids
-          hits.pluck("_id")
-        end
-
-        def aggregations
-          # TODO
-        end
-
-        def suggestions
-          # TODO
-        end
-
-        def records
-          model.where(model.primary_key => ids)
-        end
-
-        def each(&block)
-          return to_enum(:each) { hits.size } unless block
-
-          hits.each(&block)
-        end
-
-        def load
-          @response = perform_search_query(build.to_h)
-          self
-        end
-
-        def perform_search_query(query)
-          request_payload = {
-            index:  index_name,
-            body:   query
-          }
-
-          instrument(:search) do |event_payload|
-            event_payload[:request]  = request_payload
-            event_payload[:response] = client.search(request_payload)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/caoutsearch/search/search/scroll_methods.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-module Caoutsearch
-  module Search
-    module Search
-      module ScrollMethods
-        def scroll(scroll: "1h", &block)
-          return to_enum(scroll, scroll: scroll) unless block
-
-          request_payload = {
-            index:  index_name,
-            scroll: scroll,
-            body:   build.to_h
-          }
-
-          total              = 0
-          progress           = 0
-          requested_at       = nil
-          last_response_time = nil
-
-          results = instrument(:scroll_search) do |event_payload|
-            response           = client.search(request_payload)
-            last_response_time = Time.current
-
-            total     = response["hits"]["total"]["value"]
-            progress += response["hits"]["hits"].size
-
-            event_payload[:request]  = request_payload
-            event_payload[:response] = response
-            event_payload[:total]    = total
-            event_payload[:progress] = progress
-
-            response
-          end
-
-          scroll_id = results["_scroll_id"]
-          hits      = results["hits"]["hits"]
-
-          yield hits, { progress: progress, total: total, scroll_id: scroll_id }
-
-          while progress < total
-            request_payload = {
-              scroll_id: scroll_id,
-              scroll:    scroll
-            }
-
-            requested_at = Time.current
-
-            results = instrument(:scroll, scroll: scroll_id) do |event_payload|
-              response           = client.scroll(request_payload)
-              last_response_time = Time.current
-
-              total     = response["hits"]["total"]["value"]
-              progress += response["hits"]["hits"].size
-
-              event_payload[:request]  = request_payload
-              event_payload[:response] = response
-              event_payload[:total]    = total
-              event_payload[:progress] = progress
-
-              response
-            rescue Elastic::Transport::Transport::Errors::NotFound => e
-              raise_enhance_message_when_scroll_failed(e, scroll, requested_at, last_response_time)
-            end
-
-            hits       = results["hits"]["hits"]
-            progress  += hits.size
-
-            break if hits.empty?
-
-            yield hits, { progress: progress, total: total, scroll_id: scroll_id }
-          end
-
-          total
-        ensure
-          clear_scroll(scroll_id) if scroll_id
-        end
-
-        def clear_scroll(scroll_id)
-          client.clear_scroll(scroll_id: scroll_id)
-        rescue ::Elastic::Transport::Transport::Errors::NotFound
-          # We dont care if the scroll ID is already expired
-        end
-
-        def scroll_records_in_batches(**options)
-          return to_enum(:scroll_records_in_batches, **options) unless block_given?
-
-          scroll(**options) do |hits|
-            ids = hits.map { |doc| doc["_id"] }
-            yield model.where(id: ids)
-            model.connection.clear_query_cache
-          end
-        end
-
-        def scroll_records(**options, &block)
-          return to_enum(:scroll_records, **options) unless block
-
-          scroll_records_in_batches(**options) do |relation|
-            relation.each(&block)
-          end
-        end
-
-        private
-
-        def raise_enhance_message_when_scroll_failed(error, scroll, requested_at, last_response_time)
-          elapsed = (requested_at - last_response_time).round(1).seconds
-
-          raise error.exception("Scroll registered for #{scroll}, #{elapsed.inspect} elapsed between. #{error.message}")
-        end
-      end
-    end
-  end
-end

data/lib/caoutsearch/search/search/search_methods.rb

@@ -1,230 +0,0 @@
-# frozen_string_literal: true
-
-module Caoutsearch
-  module Search
-    module Search
-      module SearchMethods
-        attr_reader :current_context, :current_order, :current_aggregations,
-          :current_suggestions, :current_fields, :current_source
-
-        # Public API
-        # ------------------------------------------------------------------------
-        def search(...)
-          spawn.search!(...)
-        end
-
-        def context(...)
-          spawn.context!(...)
-        end
-
-        def order(...)
-          spawn.order!(...)
-        end
-
-        def page(...)
-          spawn.page!(...)
-        end
-
-        def limit(...)
-          spawn.limit!(...)
-        end
-        alias_method :per, :limit
-
-        def offset(...)
-          spawn.offset!(...)
-        end
-
-        def aggregate(...)
-          spawn.aggregate!(...)
-        end
-
-        def suggest(...)
-          spawn.suggest!(...)
-        end
-
-        def fields(...)
-          spawn.fields!(...)
-        end
-        alias_method :returns, :fields
-
-        def source(...)
-          spawn.source!(...)
-        end
-        alias_method :with_sources, :source
-
-        def without_sources
-          spawn.source!(false)
-        end
-
-        def without_hits
-          spawn.source!(false).limit!(0)
-        end
-
-        def track_total_hits(...)
-          spawn.track_total_hits!(...)
-        end
-
-        def prepend(...)
-          spawn.prepend!(...)
-        end
-
-        def append(...)
-          spawn.append!(...)
-        end
-
-        def unscope(...)
-          spawn.unscope!(...)
-        end
-
-        # Setters
-        # ------------------------------------------------------------------------
-        def search!(*values)
-          values = values.flatten.map do |value|
-            value = value.stringify_keys if value.is_a?(Hash)
-            value
-          end
-
-          @search_criteria ||= []
-          @search_criteria += values
-          self
-        end
-
-        def context!(value)
-          @current_context = value
-          self
-        end
-
-        def order!(value)
-          @current_order = value
-          self
-        end
-
-        def page!(value)
-          @current_page = value
-          self
-        end
-
-        def limit!(value)
-          @current_limit = value
-          self
-        end
-
-        def offset!(value)
-          @current_offset = value
-          self
-        end
-
-        def aggregate!(*values)
-          @current_aggregations ||= []
-          @current_aggregations += values.flatten
-          self
-        end
-
-        def suggest!(values, **options)
-          raise ArgumentError unless values.is_a?(Hash)
-
-          @current_suggestions ||= []
-          @current_suggestions << [values, options]
-          self
-        end
-
-        def fields!(*values)
-          @current_fields ||= []
-          @current_fields += values.flatten
-          self
-        end
-
-        def source!(*values)
-          @current_source ||= []
-          @current_source += values.flatten
-          self
-        end
-
-        def track_total_hits!(value = true)
-          @track_total_hits = value
-          self
-        end
-
-        def prepend!(hash)
-          @prepend_hash = hash
-          self
-        end
-
-        def append!(hash)
-          @append_hash = hash
-          self
-        end
-
-        UNSCOPE_KEYS = {
-          "search"          => :@search_criteria,
-          "search_criteria" => :@search_criteria,
-          "limit"           => :@current_limit,
-          "per"             => :@current_limit,
-          "aggregate"       => :@current_aggregations,
-          "aggregations"    => :@current_aggregations,
-          "suggest"         => :@current_suggestions,
-          "suggestions"     => :@current_suggestions,
-          "context"         => :@current_context,
-          "order"           => :@current_order,
-          "page"            => :@current_page,
-          "offset"          => :@current_offset,
-          "fields"          => :@current_fields,
-          "source"          => :@current_source
-        }.freeze
-
-        def unscope!(key)
-          raise ArgumentError unless (variable = UNSCOPE_KEYS[key.to_s])
-
-          reset_variable(variable)
-          self
-        end
-
-        # Getters
-        # ------------------------------------------------------------------------
-        def search_criteria
-          @search_criteria ||= []
-        end
-
-        def current_page
-          @current_page&.to_i || 1
-        end
-
-        def current_limit
-          @current_limit&.to_i || 10
-        end
-
-        def current_offset
-          if @current_offset
-            @current_offset.to_i
-          elsif @current_page
-            (current_limit * (current_page - 1))
-          else
-            0
-          end
-        end
-
-        # Criteria handlers
-        # ------------------------------------------------------------------------
-        def find_criterion(key)
-          key = key.to_s
-          search_criteria.find do |value|
-            return value[key] if value.is_a?(Hash) && value.key?(key)
-          end
-        end
-
-        def has_criterion?(key)
-          key = key.to_s
-          search_criteria.any? do |value|
-            return true if value.is_a?(Hash) && value.key?(key)
-          end
-        end
-
-        def search_criteria_keys
-          search_criteria.each_with_object([]) do |criterion, keys|
-            keys.concat(criterion.keys) if criterion.is_a?(Hash)
-          end
-        end
-      end
-    end
-  end
-end