caoutsearch 0.0.1 → 0.0.4

data/lib/caoutsearch/search/sanitizer.rb

@@ -3,7 +3,7 @@
 module Caoutsearch
   module Search
     module Sanitizer
-      ESCAPED_CHARACTERS        = "\+-&|!(){}[]^~*?:"
+      ESCAPED_CHARACTERS = "+-&|!(){}[]^~*?:"
       ESCAPED_CHARACTERS_REGEXP = /([+\-&|!(){}\[\]\^~*?:])/
 
       class << self
@@ -14,7 +14,7 @@ module Caoutsearch
           when Hash
             value.each { |k, v| value[k] = sanitize(v) }
           when String
-            regexp   = ESCAPED_CHARACTERS_REGEXP if characters == ESCAPED_CHARACTERS
+            regexp = ESCAPED_CHARACTERS_REGEXP if characters == ESCAPED_CHARACTERS
             regexp ||= Regexp.new("([#{Regexp.escape(characters)}])")
 
             value.gsub(regexp, '\\\\\1')

data/lib/caoutsearch/search/search_methods.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module SearchMethods
+      extend ActiveSupport::Concern
+
+      attr_reader :current_context, :current_order, :current_aggregations,
+        :current_suggestions, :current_fields, :current_source
+
+      # Public API
+      # ------------------------------------------------------------------------
+      class_methods do
+        delegate :search, :order, :page, :limit, :offset, :aggregate,
+          :suggest, :fields, :source, :without_sources, :without_hits,
+          :track_total_hits, :prepend, :append,
+          to: :new
+      end
+
+      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.filter_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
+
+      # rubocop:disable Layout/HashAlignment
+      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
+      # rubocop:enable Layout/HashAlignment
+
+      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

data/lib/caoutsearch/search/type_cast.rb

@@ -15,7 +15,7 @@ module Caoutsearch
           when "geo_point"
             cast_as_geo_point(value)
           when "date"
-            value.to_date.as_json
+            cast_as_date(value)
           else
             value
           end
@@ -23,17 +23,17 @@ module Caoutsearch
 
         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
+          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 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
@@ -70,6 +70,14 @@ module Caoutsearch
 
           value.map(&:to_f).reverse
         end
+
+        def cast_as_date(value)
+          return value if value.is_a?(String) && value.match?(/\Anow[+-]{0,1}\d*[yMwdhHms]{0,1}(\/d){0,1}\Z/)
+
+          json_value = value.as_json if value.respond_to?(:as_json)
+          json_value ||= MultiJson.dump(value)
+          json_value if Time.parse(json_value)
+        end
       end
     end
   end

data/lib/caoutsearch/search/value.rb

@@ -6,12 +6,12 @@ module Caoutsearch
       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)
+        @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
@@ -50,7 +50,7 @@ module Caoutsearch
 
           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
+            raise Caoutsearch::Search::ValueOverflow.new(:upper, value, range.last) if range && value > range.last
           end
 
           value
@@ -63,10 +63,10 @@ module Caoutsearch
       end
 
       INTEGER_TYPE_LIMITS = {
-        "long"    => bytes_size_to_integer_range(64),
+        "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)
+        "short" => bytes_size_to_integer_range(16),
+        "byte" => bytes_size_to_integer_range(8)
       }.freeze
 
       def transform_value(value)

data/lib/caoutsearch/search/value_overflow.rb

@@ -6,7 +6,7 @@ module Caoutsearch
       attr_reader :value, :limit, :type
 
       def initialize(type, value, limit)
-        @type  = type
+        @type = type
         @value = value
         @limit = limit
 

data/lib/caoutsearch/settings.rb

@@ -16,7 +16,7 @@ module Caoutsearch
     alias_method :as_json, :to_hash
 
     def to_json(*)
-      as_json.to_json
+      MultiJson.dump(as_json)
     end
   end
 end

data/lib/caoutsearch/testing/mock_requests.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "webmock"
+require "uri"
+
+module Caoutsearch
+  module Testing
+    module MockRequests
+      def stub_elasticsearch_request(verb, pattern)
+        transport = Caoutsearch.client.transport
+        host = transport.__full_url(transport.hosts[0])
+
+        # Elasticsearch::Client is verify the connection
+        #
+        unless @subbed_verify
+          root_url = URI.join(host, "/").to_s
+          body = +MultiJson.dump({version: {number: "8.4.1"}})
+          @subbed_verify = stub_request(:get, root_url).to_return(
+            headers: {"Content-Type" => "application/json", "X-Elastic-Product" => "Elasticsearch"},
+            status: 200,
+            body: body
+          )
+        end
+
+        case pattern
+        when String
+          pattern = URI.join(host, pattern).to_s
+        when Regexp
+          pattern = URI.join(host, pattern.source).to_s
+          pattern = Regexp.new(pattern)
+        else
+          raise TypeError, "wrong type received for URL pattern"
+        end
+
+        stub_request(verb, pattern)
+      end
+
+      def stub_elasticsearch_search_request(index_name, hits, sources: true, total: nil)
+        hits = hits.map.each_with_index do |item, index|
+          hit = {}
+          hit = item if item.is_a?(Hash)
+          hit = yield(item) if block_given?
+          hit["_index"] ||= index_name
+          hit["_id"] ||= item.respond_to?(:id) ? item.id.to_s : (index + 1).to_s
+          hit["_score"] ||= 1
+          hit["_source"] ||= (sources && item.respond_to?(:as_indexed_json)) ? item.as_indexed_json : {}
+          hit
+        end
+
+        total ||= hits.size
+        total = {"value" => total} if total.is_a?(Numeric)
+
+        stub_elasticsearch_request(:post, "#{index_name}/_search").to_return_json(body: {
+          "took" => 10,
+          "hits" => {
+            "total" => total,
+            "max_score" => hits.max { |hit| hit["_score"] },
+            "hits" => hits
+          }
+        })
+      end
+
+      def stub_elasticsearch_reindex_request(index_name)
+        stub_elasticsearch_request(:post, "#{index_name}/_bulk").to_return_json(body: {
+          "took" => 100,
+          "items" => [],
+          "errors" => false
+        })
+
+        stub_elasticsearch_request(:post, "#{index_name}/_refresh").to_return_json(body: {
+          "_shards" => {
+            "total" => 1,
+            "failed" => 0,
+            "successful" => 1
+          }
+        })
+      end
+
+      def stub_elasticsearch_batching_requests(index_name, hits = [], keep_alive: "1m", batch_size: 1000)
+        pid_id = SecureRandom.base64
+
+        stub_elasticsearch_request(:post, "#{index_name}/_pit?keep_alive=#{keep_alive}")
+          .to_return_json(body: {id: pid_id})
+
+        stub_elasticsearch_request(:delete, "_pit")
+          .with(body: {id: pid_id})
+          .to_return_json(body: {succeed: true})
+
+        search_request = stub_elasticsearch_request(:post, "_search")
+          .with { |request| request.body.include?(pid_id) }
+
+        hits.each_slice(batch_size).each_with_index do |slice, index|
+          total = index.zero? ? {value: hits.size} : {value: slice.size, relation: "gte"}
+
+          search_request.to_return_json(body: {
+            hits: {total: total, hits: slice},
+            pit_id: pid_id
+          })
+        end
+
+        search_request
+      end
+    end
+  end
+end

data/lib/caoutsearch/testing.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "testing/mock_requests"

data/lib/caoutsearch/version.rb

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

data/lib/caoutsearch.rb

@@ -1,12 +1,17 @@
 # frozen_string_literal: true
 
+require "active_support"
+require "active_support/core_ext"
+require "elasticsearch"
+require "hashie"
 require "zeitwerk"
+
 loader = Zeitwerk::Loader.for_gem
-loader.inflector.inflect(
-  "dsl" => "DSL",
-  "internal_dsl" => "InternalDSL",
-  "none" => "NONE"
-)
+loader.ignore("#{__dir__}/caoutsearch/testing.rb")
+loader.ignore("#{__dir__}/caoutsearch/testing")
+loader.inflector.inflect("dsl" => "DSL")
+loader.inflector.inflect("internal_dsl" => "InternalDSL")
+loader.inflector.inflect("none" => "NONE")
 loader.setup
 
 module Caoutsearch