caoutsearch 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bca0632fb965301b9c35bcd47ea7c8346cae1b49a22f41f6ccebd5fdd3181495
+  data.tar.gz: af08a8b38223708009694fa0025c6e83986b12db7e564009416a2cf8c2e303c8
+SHA512:
+  metadata.gz: aef96ca4c7b5dfb867dcaf962eb619deb6091eb47dcbc4946ca3e940d6496af9c8e92d0bff3138039e920f27eaf447e735ec008c79b30e6a4eceadb9d66b13ce
+  data.tar.gz: 0fbc8e5451179f8066a7af0ac228d33639fe81e8e4f157edcf36923e89d73a778116717cc50e06f5d614844249da2993baabac0b99236978ff7373917e0f5735

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2022 Mon Territoire
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# Caoutsearch [\ˈkawt͡ˈsɝtʃ\\](http://ipa-reader.xyz/?text=ˈkawt͡ˈsɝtʃ)
+
+### Installation
+
+```bash
+bundle add caoutsearch
+```
+
+### Configuration
+
+<!-- TODO -->
+
+### Usage
+
+<!-- TODO -->
+
+## Contributing
+
+1. Don't hesitate to submit your feature/idea/fix in [issues](https://github.com/mon-territoire/caoutsearch)
+2. Fork the [repository](https://github.com/mon-territoire/caoutsearch)
+3. Create your feature branch
+4. Ensure RSpec & Rubocop are passing
+4. Create a pull request
+
+### Tests & lint
+
+```bash
+bundle exec rspec
+bundle exec rubocop
+```
+
+Both can be run with:
+
+```bash
+bundle exec rake
+```
+
+## License & credits
+
+Please see [LICENSE](https://github.com/mon-territoire/caoutsearch/blob/main/LICENSE) for further details.
+
+Contributors: [./graphs/contributors](https://github.com/mon-territoire/caoutsearch/graphs/contributors)
+

data/lib/caoutsearch/config/client.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Config
+    module Client
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :client, default: Caoutsearch.client
+      end
+    end
+  end
+end

data/lib/caoutsearch/config/mappings.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Config
+    module Mappings
+      extend ActiveSupport::Concern
+
+      included do
+        delegate :mappings, to: :class
+      end
+
+      class_methods do
+        def mappings
+          @mappings ||= Caoutsearch::Mappings.new(default_mappings)
+        end
+
+        def mappings=(mappings)
+          @mappings = Caoutsearch::Mappings.new(mappings)
+        end
+
+        def remote_mappings
+          @remote_mappings ||= Caoutsearch::Mappings.new(get_remote_mappings)
+        end
+
+        protected
+
+        def default_mappings
+          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)
+        end
+
+        def get_remote_mappings
+          client.indices.get_mapping(index: index_name).values[0]["mappings"]
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/config/settings.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Config
+    module Settings
+      extend ActiveSupport::Concern
+
+      included do
+        delegate :mappings, to: :class
+      end
+
+      class_methods do
+        def settings
+          @settings ||= Caoutsearch::Settings.new(default_settings)
+        end
+
+        def settings=(settings)
+          @settings = Caoutsearch::Settings.new(settings)
+        end
+
+        protected
+
+        def default_settings
+          Caoutsearch.settings.to_hash.dup
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/filter/base.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Filter
+    class Base
+      attr_reader :key, :original_value, :type, :options
+
+      def initialize(key, original_value, type, options = {})
+        @key            = key
+        @original_value = original_value
+        @type           = type
+        @options        = options
+      end
+
+      def value
+        @value = cast_value(original_value) unless defined?(@value)
+        @value
+      end
+
+      def as_json
+        filter = self.filter
+        filter = group_filters(filter) if filter.is_a?(Array)
+
+        if filter.present? && nested_query?
+          filter = {
+            nested: {
+              path: nested_path,
+              query: { bool: { filter: Array.wrap(filter) } }
+            }
+          }
+        end
+
+        filter
+      end
+
+      def filter
+        raise NotImplementedError
+      end
+
+      protected
+
+      def default_cast_type
+        type
+      end
+
+      def cast_value(value, type = default_cast_type)
+        Caoutsearch::Search::Value.new(
+          value,
+          type,
+          **options.slice(:null_values, :transform)
+        ).value
+      end
+
+      def original_values
+        case original_value
+        when String then original_value.split(",")
+        when Array  then original_value
+        else Array.wrap(original_value)
+        end
+      end
+
+      def group_filters(terms)
+        groups = terms.select { |term| term.is_a?(Hash) && (term.key?(:term) || term.key?(:terms)) }
+        groups = groups.group_by { |term| (term[:term] || term[:terms]).keys[0] }
+
+        groups.each do |key, grouped_terms|
+          next if grouped_terms.size < 2
+
+          values = grouped_terms.flat_map { |term| (term[:term] || term[:terms])[key] }
+          values = values.uniq
+
+          grouped_terms.each { |term| terms.delete(term) }
+
+          terms << if values.size == 1
+            { term: { key => values[0] } }
+          else
+            { terms: { key => values } }
+          end
+        end
+
+        terms
+      end
+
+      def nested_query?
+        nested_path? && !include_in_parent?
+      end
+
+      def nested_path?
+        options[:nested] && key.to_s.include?(".")
+      end
+
+      def include_in_parent?
+        options[:include_in_parent]
+      end
+
+      def nested_path
+        options[:nested].is_a?(String) ? options[:nested] : key.to_s.split(".")[0].to_sym
+      end
+    end
+  end
+end

data/lib/caoutsearch/filter/boolean.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Filter
+    class Boolean < Base
+      def filter
+        return {} if value.nil?
+
+        { term: { key => value } }
+      end
+
+      protected
+
+      def default_cast_type
+        "boolean"
+      end
+    end
+  end
+end

data/lib/caoutsearch/filter/date.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Filter
+    class Date < Base
+      def filter
+        original_values.map do |value|
+          case value
+          when true
+            { 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] } } }
+            else
+              raise ArgumentError, "unknown operator #{operator.inspect} in #{value.inspect}"
+            end
+          end
+        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
+          else
+            raise ArgumentError, "unknown unit #{unit.inspect} in #{value.inspect}"
+          end
+        elsif value.is_a?(ActiveSupport::Duration)
+          value = value.ago
+        end
+
+        cast_value(value, :date)
+      end
+    end
+  end
+end

data/lib/caoutsearch/filter/default.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Filter
+    class Default < Base
+      def filter
+        if value.nil? && %w[text keyword].include?(type)
+          {
+            bool: {
+              should: [
+                { bool: { must_not: { exists: { field: key } } } },
+                { term: { key => "" } }
+              ]
+            }
+          }
+
+        elsif value.nil?
+          { bool: { must_not: { exists: { field: key } } } }
+
+        elsif value.is_a?(Array) && value.any?(&:nil?)
+          terms = []
+          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] } }
+          elsif terms_values.size > 1
+            terms << { terms: { key => terms_values } }
+          end
+
+          if terms.size == 1
+            terms[0]
+          else
+            { bool: { should: terms } }
+          end
+
+        elsif value.is_a?(Array) && value.size == 1
+          { term: { key => value[0] } }
+
+        elsif value.is_a?(Array)
+          { terms: { key => value } }
+
+        else
+          { term: { key => value } }
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/filter/geo_point.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Filter
+    class GeoPoint < Base
+      def filter
+        { geo_distance: { :distance => "1mm", key => value } }
+      end
+    end
+  end
+end

data/lib/caoutsearch/filter/match.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Filter
+    class Match < Base
+      def filter
+        if use_query_string?
+          {
+            query_string: {
+              query:            sanitized_for_query_string,
+              default_field:    key,
+              default_operator: "and",
+              analyze_wildcard: true
+            }
+          }
+        elsif multiple_words?
+          { match: { key => { query: value, operator: "and" } } }
+        else
+          { match: { key => value } }
+        end
+      end
+
+      def nested_query?
+        nested_path? && (multiple_words? || !include_in_parent?)
+      end
+
+      def multiple_words?
+        value.is_a?(String) && value.squish.include?(" ")
+      end
+
+      # https://rubular.com/r/KEA7poAaIeNrZe
+      QUERY_STRING_REGEXP = %r{
+        (?:[*?][^\s*?]|[^\s*?][*?]|(?:^|\s)(?:AND|OR|NOT)(?:$|\s)|^\*$)
+      }x
+
+      # https://rubular.com/r/tVMSviF0a74e1s
+      STRIPPED_OPERATOR_REGEXP = %r{
+        (?:^\s*(?:AND|OR)\*$|^\s*(?:AND|OR)\s+|\s+(?:AND|OR)\s*$)
+      }x
+
+      def use_query_string?
+        QUERY_STRING_REGEXP.match?(value)
+      end
+
+      def sanitized_for_query_string
+        # Do not allow setting fields in query string
+        clean_value = Caoutsearch::Search::Sanitizer.sanitize(value, ":")
+
+        # Delete leading and trailing operators
+        # Example : " OR ANGE"  => "ANGE"
+        # Example : "MASSE OR " => "MASSE"
+
+        clean_value.gsub(STRIPPED_OPERATOR_REGEXP, "")
+      end
+    end
+  end
+end

data/lib/caoutsearch/filter/none.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Filter
+    NONE = { term: { 0 => 1 } }.freeze
+  end
+end

data/lib/caoutsearch/filter/range.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Filter
+    class Range < Base
+      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) } }
+          end
+        end
+      end
+
+      def cast_value_with_overflow(value, type)
+        cast_value(value)
+      rescue Caoutsearch::Search::ValueOverflow => e
+        raise(e) unless type == e.type
+
+        e.limit
+      end
+    end
+  end
+end

data/lib/caoutsearch/filter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Filter
+    class << self
+      def filters
+        @filters ||= {}
+      end
+
+      def [](key)
+        @filters[key.to_s]
+      end
+
+      def register(filter_class, as: nil)
+        as ||= filter_class.name.demodulize.underscore
+
+        @filters ||= {}
+        @filters[as] = filter_class
+      end
+    end
+  end
+end
+
+Caoutsearch::Filter.register(Caoutsearch::Filter::Boolean)
+Caoutsearch::Filter.register(Caoutsearch::Filter::Date)
+Caoutsearch::Filter.register(Caoutsearch::Filter::Default)
+Caoutsearch::Filter.register(Caoutsearch::Filter::GeoPoint)
+Caoutsearch::Filter.register(Caoutsearch::Filter::Match)
+Caoutsearch::Filter.register(Caoutsearch::Filter::Range)

data/lib/caoutsearch/index/base.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Index
+    class Base
+      include Caoutsearch::Config::Client
+      include Caoutsearch::Config::Mappings
+      include Caoutsearch::Config::Settings
+
+      include Caoutsearch::Index::Document
+      include Caoutsearch::Index::Indice
+      include Caoutsearch::Index::IndiceVersions
+      include Caoutsearch::Index::Instrumentation
+      include Caoutsearch::Index::InternalDSL
+      include Caoutsearch::Index::Naming
+      include Caoutsearch::Index::Reindex
+      include Caoutsearch::Index::Scoping
+      include Caoutsearch::Index::Serialization
+
+      attr_reader :record
+
+      delegate_missing_to :record
+
+      def initialize(record)
+        @record = record
+      end
+
+      class << self
+        def wrap(*records)
+          Array.wrap(*records).map { |record| new(record) }
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/index/document.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Index
+    module Document
+      extend ActiveSupport::Concern
+
+      # Return the indexed document
+      #
+      #     record = Article.find(1)
+      #     ArticleIndex.new(record).indexed_document
+      #
+      def indexed_document
+        request_payload = {
+          index: index_name,
+          id:    record.id
+        }
+
+        response = instrument(:get) do |event_payload|
+          event_payload[:request]  = request_payload
+          event_payload[:response] = client.get(request_payload)
+        end
+
+        response.body
+      end
+
+      # Overwrite or partially update a document
+      #
+      #     record = Article.find(1)
+      #     ArticleIndex.new(record).update_document
+      #     ArticleIndex.new(record).update_document(:title, :content)
+      #
+      def update_document(*keys, index: index_name, refresh: false)
+        request_payload = {
+          index: index,
+          id:    id
+        }
+
+        if keys.empty?
+          request_payload[:body] = as_json
+
+          instrument(:index) do |event_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[:response] = client.bulk(request_payload)
+          end
+        end
+
+        refresh_indice(index: index) if refresh
+      end
+
+      # Delete the document
+      #
+      #     record = Article.find(1)
+      #     ArticleIndex.new(record).delete_document
+      #
+      def delete_document(index: index_name, refresh: false)
+        self.class.delete_document(record.id, index: index, refresh: refresh)
+      end
+
+      class_methods do
+        # Delete one document
+        #
+        #     ArticleIndex.delete_document(1)
+        #
+        def delete_document(id, index: index_name, refresh: false)
+          request_payload = {
+            index:  index,
+            id:     id,
+            ignore: 404
+          }
+
+          instrument(:delete) do |event_payload|
+            event_payload[:request]  = request_payload
+            event_payload[:response] = client.delete(request_payload)
+          end
+
+          refresh_indice(index: index) if refresh
+        end
+
+        # Delete many documents, using bulk API
+        #
+        #     ArticleIndex.delete_documents([1, 2, 3])
+        #
+        def delete_documents(ids, index: index_name, refresh: false)
+          request_payload = {
+            index:  index,
+            body:   ids.map { |id| { delete: { _id: id } } }
+          }
+
+          instrument(:bulk, method: :delete) do |event_payload|
+            event_payload[:request]  = request_payload
+            event_payload[:response] = client.bulk(request_payload)
+          end
+
+          refresh_indice(index: index) if refresh
+        end
+      end
+    end
+  end
+end