caoutsearch 0.0.1 → 0.0.3

data/lib/caoutsearch/config/mappings.rb

@@ -28,7 +28,7 @@ module Caoutsearch
           path = ::Rails.root.join("config/elasticsearch/#{index_name}.json")
           raise ArgumentError, "No mappings file found for #{index_name} at #{path}" unless path.exist?
 
-          JSON.parse(path.read)
+          MultiJson.load(path.read)
         end
 
         def get_remote_mappings

data/lib/caoutsearch/filter/base.rb

@@ -5,11 +5,15 @@ module Caoutsearch
     class Base
       attr_reader :key, :original_value, :type, :options
 
+      def self.call(...)
+        new(...).as_json
+      end
+
       def initialize(key, original_value, type, options = {})
-        @key            = key
+        @key = key
         @original_value = original_value
-        @type           = type
-        @options        = options
+        @type = type
+        @options = options
       end
 
       def value
@@ -25,7 +29,7 @@ module Caoutsearch
           filter = {
             nested: {
               path: nested_path,
-              query: { bool: { filter: Array.wrap(filter) } }
+              query: {bool: {filter: Array.wrap(filter)}}
             }
           }
         end
@@ -54,7 +58,7 @@ module Caoutsearch
       def original_values
         case original_value
         when String then original_value.split(",")
-        when Array  then original_value
+        when Array then original_value
         else Array.wrap(original_value)
         end
       end
@@ -72,9 +76,9 @@ module Caoutsearch
           grouped_terms.each { |term| terms.delete(term) }
 
           terms << if values.size == 1
-            { term: { key => values[0] } }
+            {term: {key => values[0]}}
           else
-            { terms: { key => values } }
+            {terms: {key => values}}
           end
         end
 

data/lib/caoutsearch/filter/boolean.rb

@@ -6,7 +6,7 @@ module Caoutsearch
       def filter
         return {} if value.nil?
 
-        { term: { key => value } }
+        {term: {key => value}}
       end
 
       protected

data/lib/caoutsearch/filter/date.rb

@@ -4,45 +4,116 @@ module Caoutsearch
   module Filter
     class Date < Base
       def filter
-        original_values.map do |value|
-          case value
+        original_values.map do |input|
+          case input
           when true
-            { exists: { field: key } }
+            {exists: {field: key}}
           when false
-            { bool: { must_not: { exists: { field: key } } } }
-          when Hash
-            operator, value, unit = value.stringify_keys.values_at("operator", "value", "unit")
-
-            case operator
-            when "less_than"
-              { range: { key => { gte: cast_date(value, unit) } } }
-            when "greater_than"
-              { range: { key => { lt:  cast_date(value, unit) } } }
-            when "between"
-              dates = value.map { |v| cast_date(v, unit) }.sort
-              { range: { key => { gte: dates[0], lt: dates[1] } } }
+            {bool: {must_not: {exists: {field: key}}}}
+          when ::Date
+            {range: {key => {gte: input.as_json, lte: input.as_json}}}
+          when ::String
+            case input
+            when /\A\.\.(.+)\Z/
+              build_range_query(..$1)
+            when /\A(.+)\.\.\Z/
+              build_range_query($1..)
+            when /\A(.+)\.\.(.+)\Z/
+              build_range_query($1..$2)
             else
-              raise ArgumentError, "unknown operator #{operator.inspect} in #{value.inspect}"
+              {range: {key => {gte: input, lte: input}}}
             end
+          when ::Range, ::Array
+            build_range_query(input)
+          when ::Hash
+            case input
+            in { operator:, value:, **other}
+              build_legacy_range_query_from_hash(input)
+            in { between: dates }
+              build_range_query(dates)
+            else
+              parameters = input.to_h do |operator, value|
+                [cast_operator(operator), cast_value(value)]
+              end
+
+              {range: {key => parameters}}
+            end
+          end
+        end
+      end
+
+      def build_range_query(input)
+        lower_bound = input.is_a?(::Range) ? input.begin : input.first
+        upper_bound = input.is_a?(::Range) ? input.end : input.last
+        return unless upper_bound || lower_bound
+
+        query = {range: {key => {}}}
+        query[:range][key][:gte] = cast_value(lower_bound) if lower_bound
+
+        if upper_bound
+          if input.is_a?(::Range) && input.exclude_end?
+            query[:range][key][:lt] = cast_value(upper_bound)
+          else
+            query[:range][key][:lte] = cast_value(upper_bound)
           end
         end
+
+        query
+      end
+
+      def build_legacy_range_query_from_hash(input)
+        ActiveSupport::Deprecation.warn("This form of hash to search for dates will be removed")
+        operator, value, unit = input.values_at(:operator, :value, :unit)
+
+        case operator
+        when "less_than"
+          {range: {key => {gte: cast_date(value, unit)}}}
+        when "greater_than"
+          {range: {key => {lt: cast_date(value, unit)}}}
+        when "between"
+          dates = value.map { |v| cast_date(v, unit) }.sort
+          {range: {key => {gte: dates[0], lt: dates[1]}}}
+        else
+          raise ArgumentError, "unknown operator #{operator.inspect} in #{value.inspect}"
+        end
+      end
+
+      RANGE_OPERATORS = {
+        "less_than" => "lt",
+        "less_than_or_equal" => "lte",
+        "greater_than" => "gt",
+        "greater_than_or_equal" => "gte"
+      }.freeze
+
+      def cast_operator(original_operator)
+        operator = original_operator.to_s
+        return original_operator if RANGE_OPERATORS.value?(operator)
+
+        operator = RANGE_OPERATORS[operator]
+        if operator.nil?
+          raise ArgumentError, "unknown operator #{original_operator.inspect}"
+        elsif original_operator.is_a?(Symbol)
+          operator.to_sym
+        else
+          operator
+        end
       end
 
       def cast_date(value, unit)
         if value.is_a?(Numeric) && unit
           case unit
-          when "day"        then value = value.days.ago
-          when "week"       then value = value.weeks.ago
-          when "month"      then value = value.months.ago
-          when "year", nil  then value = value.years.ago
+          when "day" then value = value.days.ago.to_date
+          when "week" then value = value.weeks.ago.to_date
+          when "month" then value = value.months.ago.to_date
+          when "year", nil then value = value.years.ago.to_date
           else
             raise ArgumentError, "unknown unit #{unit.inspect} in #{value.inspect}"
           end
         elsif value.is_a?(ActiveSupport::Duration)
-          value = value.ago
+          value = value.ago.to_date
         end
 
-        cast_value(value, :date)
+        cast_value(value)
       end
     end
   end

data/lib/caoutsearch/filter/default.rb

@@ -8,42 +8,42 @@ module Caoutsearch
           {
             bool: {
               should: [
-                { bool: { must_not: { exists: { field: key } } } },
-                { term: { key => "" } }
+                {bool: {must_not: {exists: {field: key}}}},
+                {term: {key => ""}}
               ]
             }
           }
 
         elsif value.nil?
-          { bool: { must_not: { exists: { field: key } } } }
+          {bool: {must_not: {exists: {field: key}}}}
 
         elsif value.is_a?(Array) && value.any?(&:nil?)
           terms = []
-          terms << { bool: { must_not: { exists: { field: key } } } }
+          terms << {bool: {must_not: {exists: {field: key}}}}
 
           terms_values = value.compact
           terms_values += [""] if %w[text keyword].include?(type)
 
           if terms_values.size == 1
-            terms << { term: { key => terms_values[0] } }
+            terms << {term: {key => terms_values[0]}}
           elsif terms_values.size > 1
-            terms << { terms: { key => terms_values } }
+            terms << {terms: {key => terms_values}}
           end
 
           if terms.size == 1
             terms[0]
           else
-            { bool: { should: terms } }
+            {bool: {should: terms}}
           end
 
         elsif value.is_a?(Array) && value.size == 1
-          { term: { key => value[0] } }
+          {term: {key => value[0]}}
 
         elsif value.is_a?(Array)
-          { terms: { key => value } }
+          {terms: {key => value}}
 
         else
-          { term: { key => value } }
+          {term: {key => value}}
         end
       end
     end

data/lib/caoutsearch/filter/geo_point.rb

@@ -4,7 +4,7 @@ module Caoutsearch
   module Filter
     class GeoPoint < Base
       def filter
-        { geo_distance: { :distance => "1mm", key => value } }
+        {geo_distance: {:distance => "1mm", key => value}}
       end
     end
   end

data/lib/caoutsearch/filter/match.rb

@@ -6,17 +6,17 @@ module Caoutsearch
       def filter
         if use_query_string?
           {
-            query_string: {
-              query:            sanitized_for_query_string,
-              default_field:    key,
+            simple_query_string: {
+              fields: [key],
+              query: sanitized_for_query_string,
               default_operator: "and",
               analyze_wildcard: true
             }
           }
         elsif multiple_words?
-          { match: { key => { query: value, operator: "and" } } }
+          {match: {key => {query: value, operator: "and"}}}
         else
-          { match: { key => value } }
+          {match: {key => value}}
         end
       end
 

data/lib/caoutsearch/filter/none.rb

@@ -2,6 +2,6 @@
 
 module Caoutsearch
   module Filter
-    NONE = { term: { 0 => 1 } }.freeze
+    NONE = {term: {0 => 1}}.freeze
   end
 end

data/lib/caoutsearch/filter/range.rb

@@ -6,12 +6,12 @@ module Caoutsearch
       def filter
         original_values.map do |value|
           case value
-          when />(.+)/      then { range: { key => { gt:  cast_value_with_overflow($1, :lower) } } }
-          when /<(.+)/      then { range: { key => { lt:  cast_value_with_overflow($1, :upper) } } }
-          when /≥(.+)/      then { range: { key => { gte: cast_value_with_overflow($1, :lower) } } }
-          when /≤(.+)/      then { range: { key => { lte: cast_value_with_overflow($1, :upper) } } }
-          when /(.+)-(.+)/  then { range: { key => { gte: cast_value_with_overflow($1, :lower), lte: cast_value_with_overflow($2, :upper) } } }
-          else                   { term:  { key => cast_value(value) } }
+          when />(.+)/ then {range: {key => {gt: cast_value_with_overflow($1, :lower)}}}
+          when /<(.+)/ then {range: {key => {lt: cast_value_with_overflow($1, :upper)}}}
+          when /≥(.+)/ then {range: {key => {gte: cast_value_with_overflow($1, :lower)}}}
+          when /≤(.+)/ then {range: {key => {lte: cast_value_with_overflow($1, :upper)}}}
+          when /(.+)-(.+)/ then {range: {key => {gte: cast_value_with_overflow($1, :lower), lte: cast_value_with_overflow($2, :upper)}}}
+          else {term: {key => cast_value(value)}}
           end
         end
       end

data/lib/caoutsearch/index/document.rb

@@ -13,11 +13,11 @@ module Caoutsearch
       def indexed_document
         request_payload = {
           index: index_name,
-          id:    record.id
+          id: record.id
         }
 
         response = instrument(:get) do |event_payload|
-          event_payload[:request]  = request_payload
+          event_payload[:request] = request_payload
           event_payload[:response] = client.get(request_payload)
         end
 
@@ -33,21 +33,21 @@ module Caoutsearch
       def update_document(*keys, index: index_name, refresh: false)
         request_payload = {
           index: index,
-          id:    id
+          id: id
         }
 
         if keys.empty?
           request_payload[:body] = as_json
 
           instrument(:index) do |event_payload|
-            event_payload[:request]  = request_payload
+            event_payload[:request] = request_payload
             event_payload[:response] = client.index(request_payload)
           end
         else
           request_payload[:body] = bulkify(:update, keys)
 
           instrument(:bulk, method: :update) do |event_payload|
-            event_payload[:request]  = request_payload
+            event_payload[:request] = request_payload
             event_payload[:response] = client.bulk(request_payload)
           end
         end
@@ -71,13 +71,13 @@ module Caoutsearch
         #
         def delete_document(id, index: index_name, refresh: false)
           request_payload = {
-            index:  index,
-            id:     id,
+            index: index,
+            id: id,
             ignore: 404
           }
 
           instrument(:delete) do |event_payload|
-            event_payload[:request]  = request_payload
+            event_payload[:request] = request_payload
             event_payload[:response] = client.delete(request_payload)
           end
 
@@ -90,12 +90,12 @@ module Caoutsearch
         #
         def delete_documents(ids, index: index_name, refresh: false)
           request_payload = {
-            index:  index,
-            body:   ids.map { |id| { delete: { _id: id } } }
+            index: index,
+            body: ids.map { |id| {delete: {_id: id}} }
           }
 
           instrument(:bulk, method: :delete) do |event_payload|
-            event_payload[:request]  = request_payload
+            event_payload[:request] = request_payload
             event_payload[:response] = client.bulk(request_payload)
           end
 

data/lib/caoutsearch/index/indice_versions.rb

@@ -83,14 +83,14 @@ module Caoutsearch
           version_name = last_indice_version if version_name == :__last__
 
           actions = []
-          actions << { add: { index: version_name, alias: index_name } }
+          actions << {add: {index: version_name, alias: index_name}}
 
           aliased_indice_versions.each do |alias_name|
             return false if alias_name == version_name
-            actions << { remove: { index: alias_name, alias: index_name } }
+            actions << {remove: {index: alias_name, alias: index_name}}
           end
 
-          client.indices.update_aliases(body: { actions: actions })
+          client.indices.update_aliases(body: {actions: actions})
           refresh_indice
           version_name
         end

data/lib/caoutsearch/index/internal_dsl.rb

@@ -9,7 +9,7 @@ module Caoutsearch
         # Be careful with these class attributes
         # Always use `+=` or `.dup.merge` to assign a new copy
         #
-        class_attribute :properties,            instance_writer: false, default: []
+        class_attribute :properties, instance_writer: false, default: []
         class_attribute :partial_reindexations, instance_writer: false, default: {}
       end
 
@@ -54,13 +54,13 @@ module Caoutsearch
           raise ArgumentError, "The allow_partial_reindex body needs to be callable." if body && !body.respond_to?(:call)
 
           name = name.to_s
-          self.partial_reindexations = partial_reindexations.dup.merge(name => { properties: properties })
+          self.partial_reindexations = partial_reindexations.dup.merge(name => {properties: properties})
 
           if body
             define_method(name, &body)
           else
             define_method(name) do
-              body = { doc: properties.index_with { |key| send(key) } }
+              body = {doc: properties.index_with { |key| send(key) }}
               body[:doc_as_upsert] = true if upsert
               body
             end

data/lib/caoutsearch/index/reindex.rb

@@ -32,17 +32,17 @@ module Caoutsearch
           records = apply_scopes(records, keys)
           records = records.strict_loading
 
-          index            = options.fetch(:index, index_name)
-          refresh          = options.fetch(:refresh, false)
-          method           = options.fetch(:method) { keys.present? ? :update : :index }
-          batch_size       = options[:batch_size] || 100
-          total            = options[:total] || records.count(:all)
-          progress         = options[:progress]
+          index = options.fetch(:index, index_name)
+          refresh = options.fetch(:refresh, false)
+          method = options.fetch(:method) { keys.present? ? :update : :index }
+          batch_size = options[:batch_size] || 100
+          total = options[:total] || records.count(:all)
+          progress = options[:progress]
           current_progress = 0
 
           return if total.zero?
 
-          progress&.total    = total
+          progress&.total = total
           progress&.progress = current_progress
 
           finder = if total <= batch_size
@@ -53,13 +53,13 @@ module Caoutsearch
 
           finder.each do |batch|
             current_progress += batch.size
-            request_payload   = {
-              index:  index,
-              body:   bulkify(batch, method, keys)
+            request_payload = {
+              index: index,
+              body: bulkify(batch, method, keys)
             }
 
             instrument(:reindex, total: total, progress: current_progress, records: batch) do |event_payload|
-              event_payload[:request]  = request_payload
+              event_payload[:request] = request_payload
               event_payload[:response] = client.bulk(request_payload)
             end
 

data/lib/caoutsearch/index/scoping.rb

@@ -6,7 +6,7 @@ module Caoutsearch
       extend ActiveSupport::Concern
 
       included do
-        class_attribute :scopes,   instance_accessor: false, default: {}
+        class_attribute :scopes, instance_accessor: false, default: {}
         class_attribute :preloads, instance_accessor: false, default: {}
       end
 
@@ -38,11 +38,11 @@ module Caoutsearch
 
           names.each do |name|
             if scopes.include?(name)
-              scope   = scopes[name]
+              scope = scopes[name]
               records = scope.call(records)
             elsif partial_reindexations.include?(name)
               properties = partial_reindexations.dig(name, :properties)
-              records    = apply_scopes(records, properties) if properties&.any?
+              records = apply_scopes(records, properties) if properties&.any?
             end
           end
 

data/lib/caoutsearch/index/serialization.rb

@@ -5,10 +5,6 @@ module Caoutsearch
     module Serialization
       extend ActiveSupport::Concern
 
-      included do
-        delegate :to_json, to: :as_json
-      end
-
       class_methods do
         # Transform record or array of records to JSON:
         #
@@ -60,6 +56,10 @@ module Caoutsearch
         simplify(json)
       end
 
+      def to_json(*)
+        MultiJson.dump(as_json)
+      end
+
       # Recursive objects simplication:
       #
       #   [nil, 'A', 'A', 'B']          => ['A', 'B']
@@ -90,30 +90,30 @@ module Caoutsearch
       def bulkify(method, keys)
         raise ArgumentError, "unknown method #{method}" unless %i[index update delete].include?(method)
 
-        keys                        = keys.map(&:to_s)
-        payload                     = []
+        keys = keys.map(&:to_s)
+        payload = []
         property_keys, partial_keys = analyze_keys(keys)
 
         case method
         when :index
           raise SerializationError, format("cannot serialize the following keys: %{keys}", keys: partial_keys.to_sentence) if partial_keys.any?
 
-          payload << { index: { _id: record.id } }
+          payload << {index: {_id: record.id}}
           payload << as_json(*keys)
 
         when :update
           if property_keys.any?
-            payload << { update: { _id: record.id } }
-            payload << { doc: as_json(*property_keys) }
+            payload << {update: {_id: record.id}}
+            payload << {doc: as_json(*property_keys)}
           end
 
           partial_keys.each do |key|
-            payload << { update: { _id: record.id } }
+            payload << {update: {_id: record.id}}
             payload << as_json(*key)
           end
 
         when :delete
-          payload << { update: { _id: record.id } }
+          payload << {update: {_id: record.id}}
         end
 
         payload
@@ -122,9 +122,9 @@ module Caoutsearch
       private
 
       def analyze_keys(keys)
-        partial_keys  = partial_reindexations.keys & keys
+        partial_keys = partial_reindexations.keys & keys
         property_keys = properties & keys
-        unknown_keys  = keys - property_keys - partial_keys
+        unknown_keys = keys - property_keys - partial_keys
 
         raise ArgumentError, format("unknown keys: %{keys}", keys: unknown_keys.to_sentence) if unknown_keys.any?
 

data/lib/caoutsearch/instrumentation/base.rb

@@ -8,11 +8,11 @@ module Caoutsearch
       def log_request(subject, event, format: nil)
         return unless format
 
-        payload  = event.payload
-        request  = payload[:request]
+        payload = event.payload
+        request = payload[:request]
 
         debug do
-          title        = color("#{payload[:klass]} #{subject}", GREEN, true)
+          title = color("#{payload[:klass]} #{subject}", GREEN, true)
           request_body = format_request_body(request, format: format)
 
           message = "  #{title} #{request_body}"
@@ -22,20 +22,20 @@ module Caoutsearch
       end
 
       def log_response(subject, event, warn_errors: false)
-        payload  = event.payload
+        payload = event.payload
         response = payload[:response]
         return unless response
 
         debug do
-          title     = color("#{payload[:klass]} #{subject}", GREEN, true)
+          title = color("#{payload[:klass]} #{subject}", GREEN, true)
 
-          duration  = "#{event.duration.round(1)}ms"
+          duration = "#{event.duration.round(1)}ms"
           duration += " / took #{response["took"]}ms" if response.key?("took")
-          duration  = color("(#{duration})", GREEN, true)
+          duration = color("(#{duration})", GREEN, true)
 
-          message  = "  #{title} #{duration}"
+          message = "  #{title} #{duration}"
           message += " got errors" if response["errors"]
-          message  = yield(message, payload) if block_given?
+          message = yield(message, payload) if block_given?
 
           message
         end
@@ -53,16 +53,16 @@ module Caoutsearch
         when "amazing_print", "awesome_print"
           body.ai(limit: true, index: false)
         when "full"
-          json = JSON.dump(body)
+          json = MultiJson.dump(body)
           color(json, BLUE, true)
         when "truncated"
-          json = JSON.dump(body).truncate(200, omission: "…}")
+          json = MultiJson.dump(body).truncate(200, omission: "…}")
           color(json, BLUE, true)
         end
       end
 
       def inspect_json_size(json)
-        ApplicationController.helpers.number_to_human_size(JSON.dump(json).bytesize)
+        ApplicationController.helpers.number_to_human_size(MultiJson.dump(json).bytesize)
       end
     end
   end