caoutsearch 0.0.0

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

@@ -0,0 +1,230 @@
+# 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

data/lib/caoutsearch/search/type_cast.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module TypeCast
+      class << self
+        def cast(type, value)
+          case type.to_s
+          when "integer", "long", "short", "byte"
+            cast_as_integer(value)
+          when "double", "float", "half_float", "scaled_float"
+            cast_as_float(value)
+          when "boolean"
+            cast_as_boolean(value)
+          when "geo_point"
+            cast_as_geo_point(value)
+          when "date"
+            value.to_date.as_json
+          else
+            value
+          end
+        end
+
+        def cast_as_integer(value)
+          case value
+          when nil      then nil
+          when Array    then value.map { |v| cast_as_integer(v) }
+          when String   then value.delete(" ").to_i
+          else value.to_i
+          end
+        end
+
+        def cast_as_float(value)
+          case value
+          when nil    then nil
+          when Array  then value.map { |v| cast_as_float(v) }
+          when String then value.to_s.delete(" ").tr(",", ".").to_f
+          else value.to_f
+          end
+        end
+
+        # rubocop:disable Lint/BooleanSymbol
+        BOOLEAN_FALSE_VALUES = [
+          false, 0,
+          "0", :"0",
+          "f", :f,
+          "F", :F,
+          "false", :false,
+          "FALSE", :FALSE,
+          "off", :off,
+          "OFF", :OFF
+        ].to_set.freeze
+        # rubocop:enable Lint/BooleanSymbol
+
+        def cast_as_boolean(value)
+          if value == ""
+            nil
+          else
+            BOOLEAN_FALSE_VALUES.exclude?(value)
+          end
+        end
+
+        def cast_as_geo_point(value)
+          if value.is_a? Hash
+            value = value.stringify_keys
+            value = [value["lat"], value["lon"] || value["lng"]]
+          end
+
+          raise ArgumentError, "invalid geo point: #{value.inspect}" unless value.is_a?(Array) && value.length == 2
+
+          value.map(&:to_f).reverse
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/value.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    class Value
+      attr_reader :original_value, :type, :null_values, :transform_proc, :overflow_strategy
+
+      def initialize(original_value, type, null_values: nil, transform: nil, sanitize: false)
+        @original_value    = original_value
+        @type              = type
+        @null_values       = Array.wrap(null_values)
+        @sanitize_value    = sanitize
+        @transform_proc    = transform
+        @transform_proc    = transform.to_proc if transform.is_a?(Symbol)
+      end
+
+      def value
+        unless defined?(@value)
+          @value = transform_value(original_value)
+          @value = cast_value(@value)
+          @value = check_value_overflow(@value)
+          @value = strip_value(@value)
+          @value = sanitize_value(@value) if sanitize_value?
+          @value = replace_null_values(@value)
+          @value = reduce_value(@value)
+        end
+
+        @value
+      end
+
+      def cast_value(value)
+        Caoutsearch::Search::TypeCast.cast(type, value)
+      end
+
+      def sanitize_value(value)
+        Caoutsearch::Search::Sanitizer.sanitize(value)
+      end
+
+      def sanitize_value?
+        !!@sanitize_value
+      end
+
+      def check_value_overflow(value)
+        if value.is_a?(Array)
+          value.map { |v| check_value_overflow(v) }
+        elsif value.nil?
+          value
+        else
+          range = INTEGER_TYPE_LIMITS[type.to_s]
+
+          if range
+            raise Caoutsearch::Search::ValueOverflow.new(:lower, value, range.first) if value < range.first
+            raise Caoutsearch::Search::ValueOverflow.new(:upper, value, range.last)  if range && value > range.last
+          end
+
+          value
+        end
+      end
+
+      def self.bytes_size_to_integer_range(bytes_size)
+        limit = 2**(bytes_size - 1)
+        -limit..(limit - 1)
+      end
+
+      INTEGER_TYPE_LIMITS = {
+        "long"    => bytes_size_to_integer_range(64),
+        "integer" => bytes_size_to_integer_range(32),
+        "short"   => bytes_size_to_integer_range(16),
+        "byte"    => bytes_size_to_integer_range(8)
+      }.freeze
+
+      def transform_value(value)
+        if value.is_a?(Array)
+          value.flat_map { |v| transform_value(v) }
+
+        elsif transform_proc.respond_to?(:call)
+          transform_proc.call(value)
+
+        else
+          value
+        end
+      end
+
+      def strip_value(value)
+        value = value.strip if value.is_a?(String)
+        value
+      end
+
+      def replace_null_values(value)
+        if value.is_a?(Array)
+          value.map { |v| replace_null_values(v) }
+
+        elsif null_values.include?(value)
+          nil
+
+        else
+          value
+        end
+      end
+
+      def reduce_value(value)
+        if value.is_a?(Array) && value.size == 1
+          value[0]
+
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/value_overflow.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    class ValueOverflow < StandardError
+      attr_reader :value, :limit, :type
+
+      def initialize(type, value, limit)
+        @type  = type
+        @value = value
+        @limit = limit
+
+        super("the value #{value.inspect} exceeds the #{type} limit (#{limit})")
+      end
+    end
+  end
+end

data/lib/caoutsearch/search.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+  end
+end

data/lib/caoutsearch/settings.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  class Settings
+    # Build an index mapping
+    #
+    #   Caoutsearch::Settings.new(number_of_replicas: 2)
+    #
+    def initialize(settings = {})
+      @settings = settings.deep_symbolize_keys
+    end
+
+    def to_hash
+      @settings
+    end
+    alias_method :as_json, :to_hash
+
+    def to_json(*)
+      as_json.to_json
+    end
+  end
+end

data/lib/caoutsearch/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  VERSION = "0.0.0"
+end

data/lib/caoutsearch.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  "dsl" => "DSL",
+  "internal_dsl" => "InternalDSL",
+  "none" => "NONE"
+)
+loader.setup
+
+module Caoutsearch
+  class << self
+    attr_writer :client
+
+    def client
+      @client ||= Elasticsearch::Client.new
+    end
+
+    def settings
+      @settings ||= Caoutsearch::Settings.new({})
+    end
+
+    def settings=(settings)
+      @settings = Caoutsearch::Settings.new(settings)
+    end
+
+    def instrument!(**options)
+      @instrumentation_options = options
+      Caoutsearch::Instrumentation::Index.attach_to :caoutsearch_index if options[:index]
+      Caoutsearch::Instrumentation::Search.attach_to :caoutsearch_search if options[:search]
+    end
+
+    def instrumentation_options
+      @instrumentation_options ||= {}
+    end
+  end
+end