elastic_record 4.1.8 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: def9a67ba563b5ae2dfc9928f1bf6f9167763c7d
-  data.tar.gz: 345857b95dea56d079fd7e431d07659af21cda94
+SHA256:
+  metadata.gz: bb2dad78eb2851499ca2b7099f7774d79c375b5a180001bd612113353dfba33c
+  data.tar.gz: ff1262c6527d45f1e9b0e8eb46e24dc881cdb10b5cb51b93e40f72f5a2f366dc
 SHA512:
-  metadata.gz: 40c79f1e780cc01977532cec6c5feb3950f464b9afa38615661f6aa978f8ffb1d5e4763cdf4ca9028b0433048820b2acee24f9ed0eb6cb472e35c018b2d843bf
-  data.tar.gz: 634ce4d865cef8c57fa3ce1b9556cba7d4a0b53618eb96f3d3489389387b5d9b0d48a8250a499d21e772520b7055e88330244d321e06cc7efb1b85e60342e5ff
+  metadata.gz: b1c4fab2b261935713156c78ebf2fd675a7a7b107ac5a415a25dd20c8364690492f566d82b4685e9c223818abafbaf21ef2083d89ad3ad1e2a60bb93ed150685
+  data.tar.gz: 8f9d7ad4d081fe9096c65872c8b0e4fd0c2d4a3fa2df79bd7a8a8a3975fd7a7055c48b664a5f47beb2b7fcea07020e542f64b4f64e188c125e66c27ee11ad70f

data/.travis.yml

@@ -2,17 +2,24 @@ rvm: 2.4.1
 cache: bundler
 sudo: false
 dist: trusty
-addons:
-  apt:
-    sources:
-    - elasticsearch-5.x
-    packages:
-    - elasticsearch
+
+before_install:
+- wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-${ES_VERSION}.tar.gz
+- tar -xzf elasticsearch-${ES_VERSION}.tar.gz
+- ./elasticsearch-${ES_VERSION}/bin/elasticsearch -d
+
 before_script:
 - cp test/dummy/.env.example test/dummy/.env
-- curl localhost:9200
+- wget --quiet --waitretry=1 --retry-connrefused --timeout=20 -O - http://127.0.0.1:9200
 - bundle exec rake app:db:setup
 - bundle exec rake app:index:reset
+
+env:
+  global:
+  - ES_VERSION=6.2.3
+
 services:
-- elasticsearch
 - postgresql
+
+addons:
+  postgresql: 9.6

data/Gemfile

@@ -4,7 +4,7 @@ gemspec
 
 gem 'dotenv-rails'
 gem 'oj'
-gem 'pg'
+gem 'pg', '~> 0.21'
 gem 'rails'
 gem 'rake', '~> 10.5.0'
 gem 'webmock', require: false

data/README.md

@@ -2,7 +2,7 @@
 [![Build Status](https://secure.travis-ci.org/data-axle/elastic_record.png?rvm=2.0.0)](http://travis-ci.org/data-axle/elastic_record)
 [![Code Climate](https://codeclimate.com/github/data-axle/elastic_record.png)](https://codeclimate.com/github/data-axle/elastic_record)
 
-ElasticRecord is an Elasticsearch 2.x ORM.
+ElasticRecord is an Elasticsearch 6.x ORM.
 
 ## Setup ##
 
@@ -68,9 +68,6 @@ search.filter(Product.arelastic[:name].prefix("Sca").negate)
 
 # Size is greater than 5
 search.filter(Product.arelastic[:size].gt(5))
-
-# Name is 'hola' or name is missing
-search.filter(Product.arelastic[:name].eq("hola").or(Product.arelastic[:name].missing))
 ```
 
 Helpful Arel builders can be found at https://github.com/matthuhiggins/arelastic/blob/master/lib/arelastic/builders/filter.rb.
@@ -113,12 +110,11 @@ Aggregations are added with the aggregate method:
 search.aggregate('popular_colors' => {'terms' => {'field' => 'color'}})
 ```
 
-It is important to note that adding aggregations to a query is different than retrieving the results of the query:
+Results are retrieved at query time within `aggregations`:
 
 ```ruby
 search = search.aggregate('popular_colors' => {'terms' => {'field' => 'color'}})
-search.aggregations
-#=> {"popular_colors" => {"buckets" => ...}}
+search.aggregations['popular_colors'].buckets
 ```
 
 ### Getting Results ###
@@ -180,12 +176,14 @@ Use the `percolate` method to find records with queries that match.
 
 ## Index Configuration
 
-To avoid elasticsearch dynamically mapping fields, you can directly configure Product.doctype.mapping
-and Product.elastic_index.settings:
+To avoid elasticsearch dynamically mapping fields, you can directly configure `elastic_index.mapping`
+and `elastic_index.settings`:
 
 ```ruby
 class Product
-  doctype.mapping = {
+  include ElasticRecord::Model
+
+  elastic_index.mapping = {
     properties: {
       name: {type: "text"},
       status: {type: "keyword"}
@@ -194,6 +192,27 @@ class Product
 end
 ```
 
+Mapping types will be removed in ElasticSearch 7.x.  To rename the default mapping type (`_doc`), use `elastic_index.mapping_type`:
+
+```ruby
+class Product
+  include ElasticRecord::Model
+
+  elastic_index.mapping_type = 'product'
+end
+```
+
+### Inheritance
+
+When one model inherits from another, ElasticRecord makes some assumptions about how the child index should be configured.  By default:
+
+* `alias_name` - Same as parent
+* `mapping` - Same as parent
+* `mapping_type` - Same as parent
+* `settings` (including analysis configuration) - Same as parent
+
+These can all be overridden.  For instance, it might be desirable for the child documents to be in a separate index.
+
 ### Load Documents from Source
 
 To fetch documents without an additional request to a backing ActiveRecord database you can load the documents from `_source`.
@@ -242,14 +261,3 @@ Product.elastic_index.reset              # Delete related indexes and deploy a n
 Product.elastic_index.refresh            # Call the refresh API
 Product.elastic_index.get_mapping        # Get the index mapping defined by elastic search
 ```
-
-## JSON Adapter ##
-
-By default, ElasticRecord uses ActiveSupport::JSON to serialize Elasticsearch payloads. There
-is optional support for using the Oj gem. To use Oj, ensure that oj is required and set:
-
-```ruby
-  ElasticRecord::JSON.parser = :oj
-```
-
-To return to the default parser, set the variable to :active_support.

data/elastic_record.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = 'elastic_record'
-  s.version = '4.1.8'
+  s.version = '5.1.0'
   s.summary = 'An Elasticsearch querying ORM'
   s.description = 'Find your records with Elasticsearch'
 

data/lib/elastic_record.rb

@@ -3,19 +3,31 @@ require 'active_support/concern'
 require 'active_model'
 
 module ElasticRecord
-  autoload :AsDocument, 'elastic_record/as_document'
-  autoload :Callbacks, 'elastic_record/callbacks'
-  autoload :Config, 'elastic_record/config'
-  autoload :Connection, 'elastic_record/connection'
-  autoload :Doctype, 'elastic_record/doctype'
-  autoload :Index, 'elastic_record/index'
-  autoload :JSON, 'elastic_record/json'
-  autoload :Lucene, 'elastic_record/lucene'
-  autoload :Model, 'elastic_record/model'
-  autoload :NameCache, 'elastic_record/name_cache'
-  autoload :PercolatorModel, 'elastic_record/percolator_model'
-  autoload :Relation, 'elastic_record/relation'
-  autoload :Searching, 'elastic_record/searching'
+  extend ActiveSupport::Autoload
+  autoload :AsDocument
+  autoload :Callbacks
+  autoload :Config
+  autoload :Connection
+  autoload :Doctype
+  autoload :Index
+  autoload :Lucene
+  autoload :Model
+  autoload :PercolatorModel
+  autoload :Relation
+  autoload :Searching
+
+  module AggregationResponse
+    extend ActiveSupport::Autoload
+
+    autoload :Aggregation
+    autoload :Bucket
+    autoload :Builder
+    autoload :HasAggregations
+    autoload :MultiBucketAggregation
+    autoload :MultiValueAggregation
+    autoload :SingleBucketAggregation
+    autoload :SingleValueAggregation
+  end
 
   class << self
     def configure

data/lib/elastic_record/aggregation_response/aggregation.rb

@@ -0,0 +1,19 @@
+module ElasticRecord
+  module AggregationResponse
+    class Aggregation
+      attr_accessor :name, :results, :meta
+      def initialize(name, results)
+        @name     = name
+        @results  = results
+
+        @results.each do |key, value|
+          send("#{key}=", value) if respond_to?("#{key}=")
+        end
+      end
+
+      def inspect
+        "#<#{self.class} #{results}>"
+      end
+    end
+  end
+end

data/lib/elastic_record/aggregation_response/bucket.rb

@@ -0,0 +1,24 @@
+module ElasticRecord
+  module AggregationResponse
+    class Bucket
+      include HasAggregations
+
+      attr_accessor :results
+      def initialize(results)
+        @results = results
+      end
+
+      def key
+        results['key']
+      end
+
+      def doc_count
+        results['doc_count']
+      end
+
+      def inspect
+        "#<#{self.class} #{results}>"
+      end
+    end
+  end
+end

data/lib/elastic_record/aggregation_response/builder.rb

@@ -0,0 +1,55 @@
+module ElasticRecord
+  module AggregationResponse
+    class Builder
+      AGGREGATION_KLASSES = {
+        SingleBucketAggregation => %w(
+          children
+          sampler
+          filter
+          missing
+          nested
+          reverse_nested
+          global
+        ),
+        MultiBucketAggregation => %w(
+          composite
+          date_histogram
+          filters
+          geohash_grid
+          histogram
+          range
+          dterms
+          lterms
+          sterms
+        ),
+        SingleValueAggregation => %w(
+          avg
+          cardinality
+          max
+          min
+          value_count
+        ),
+        MultiValueAggregation => %w(
+          stats
+          dpercentiles
+          lpercentiles
+          spercentiles
+        )
+      }
+
+      AGGREGATIONS_BY_TYPE = AGGREGATION_KLASSES.each_with_object({}) do |(klass, types), hash|
+        types.each { |type| hash[type] = klass }
+      end
+
+      def self.extract(hash)
+        hash.each_with_object({}) do |(key, results), aggs|
+          next unless key.include?('#')
+
+          type, name = key.split('#')
+          klass = AGGREGATIONS_BY_TYPE.fetch(type)
+          aggs[name] = klass.new(name, results)
+        end
+      end
+    end
+  end
+end

data/lib/elastic_record/aggregation_response/has_aggregations.rb

@@ -0,0 +1,9 @@
+module ElasticRecord
+  module AggregationResponse
+    module HasAggregations
+      def aggregations
+        @aggregations ||= Builder.extract(results)
+      end
+    end
+  end
+end

data/lib/elastic_record/aggregation_response/multi_bucket_aggregation.rb

@@ -0,0 +1,9 @@
+module ElasticRecord
+  module AggregationResponse
+    class MultiBucketAggregation < Aggregation
+      def buckets
+        @buckets ||= results['buckets'].map { |bucket| ElasticRecord::AggregationResponse::Bucket.new(bucket) }
+      end
+    end
+  end
+end

data/lib/elastic_record/aggregation_response/multi_value_aggregation.rb

@@ -0,0 +1,6 @@
+module ElasticRecord
+  module AggregationResponse
+    class MultiValueAggregation < Aggregation
+    end
+  end
+end

data/lib/elastic_record/aggregation_response/single_bucket_aggregation.rb

@@ -0,0 +1,8 @@
+module ElasticRecord
+  module AggregationResponse
+    class SingleBucketAggregation < Aggregation
+      include HasAggregations
+      attr_accessor :doc_count
+    end
+  end
+end

data/lib/elastic_record/aggregation_response/single_value_aggregation.rb

@@ -0,0 +1,7 @@
+module ElasticRecord
+  module AggregationResponse
+    class SingleValueAggregation < Aggregation
+      attr_accessor :value, :value_as_string
+    end
+  end
+end

data/lib/elastic_record/as_document.rb

@@ -1,8 +1,8 @@
 module ElasticRecord
   module AsDocument
-    def as_search_document
-      doctype.mapping[:properties].each_with_object({}) do |(field, mapping), result|
-        value = elastic_search_value field, mapping
+    def as_search_document(mapping_properties = elastic_index.mapping[:properties])
+      mapping_properties.each_with_object({}) do |(field, mapping), result|
+        value = value_for_elastic_search field, mapping, mapping_properties
 
         unless value.nil?
           result[field] = value
@@ -11,31 +11,48 @@ module ElasticRecord
     end
 
     def as_partial_update_document
-      mappings = doctype.mapping[:properties]
+      mapping_properties = elastic_index.mapping[:properties]
+      changed_fields = respond_to?(:saved_changes) ? saved_changes.keys : changed
 
-      changed.each_with_object({}) do |field, result|
-        if field_mapping = mappings[field]
-          result[field] = elastic_search_value field, field_mapping
+      changed_fields.each_with_object({}) do |field, result|
+        if field_mapping = mapping_properties[field]
+          result[field] = value_for_elastic_search field, field_mapping, mapping_properties
         end
       end
     end
 
-    def elastic_search_value(field, mapping)
+    def value_for_elastic_search(field, mapping, mapping_properties)
       value = try field
       return if value.nil?
 
-      value = case mapping[:type]
-              when :object
-                value.as_search_document
-              when :nested
-                value.map(&:as_search_document)
-              else
-                value
-              end
+      value =
+        case mapping[:type]&.to_sym
+        when :object
+          object_mapping_properties = mapping_properties.dig(field, :properties)
+          value_for_elastic_search_object(value, object_mapping_properties)
+        when :nested
+          object_mapping_properties = mapping_properties.dig(field, :properties)
+          value.map { |entry| value_for_elastic_search_object(entry, object_mapping_properties) }
+        when :integer_range, :float_range, :long_range, :double_range, :date_range
+          value_for_elastic_search_range(value)
+        else
+          value
+        end
 
       if value.present? || value == false
         value
       end
     end
+
+    def value_for_elastic_search_object(object, nested_mapping)
+      object.respond_to?(:as_search_document) ? object.as_search_document(nested_mapping) : object
+    end
+
+    def value_for_elastic_search_range(range)
+      gte = range.begin unless range.begin == -Float::INFINITY
+      lte = range.end unless range.end == Float::INFINITY
+
+      {'gte' => gte, 'lte' => lte}
+    end
   end
 end

data/lib/elastic_record/callbacks.rb

@@ -5,7 +5,7 @@ module ElasticRecord
 
       base.class_eval do
         after_create :create_index_document
-        after_update :update_index_document, if: :changed?
+        after_update :update_index_document, if: -> { respond_to?(:saved_changes?) ? saved_changes? : changed? }
         after_destroy :delete_index_document
       end
     end

data/lib/elastic_record/config.rb

@@ -5,6 +5,9 @@ module ElasticRecord
     class_attribute :connection_options
     self.connection_options = {}
 
+    class_attribute :default_index_settings
+    self.default_index_settings = {}
+
     class_attribute :model_names
     self.model_names = []