arelastic 3.4.0 → 3.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8edfdb17e46c6148893fd8ae238a07c4743359a9c5e4955b424649727196ff8
-  data.tar.gz: 3c5c40a1d08cbf850a096b0d72b675c4d63e692d9b55d0b123792e68904a1aa9
+  metadata.gz: 36e11d1e2ddab3f9a341f595e3283d942b1ab84ce56f668edf2fd73f219696e3
+  data.tar.gz: 1bd43e54049ea28f58edba742ac2fffbd0d1d0eb80a350fa3b7d58ccca734307
 SHA512:
-  metadata.gz: eb01a6abd4f16c130a8759a53d40582698221b11e58178ec49297be9cacf03e87bc2cd666a1076480b65a264968b1ef539d9888aaa3416ad4474617f98de5613
-  data.tar.gz: 20ae0b0240d1b2d439b08d6dbb38576687f7a5d3c2c5bc4bafb018625f5f35b6662e0fd9f62e45b9264ace1c8164ab4e71f68e696100509ccbff83b14af79e26
+  metadata.gz: 5b49b306de42d3b05b0dc06d7a9fbd838aaab75d6b082001bce3650104839c632ecd3cde9e4ffaadf00dbb2f22b1cd4f21ea423f664374cf6736bcfee950bc3f
+  data.tar.gz: bf5f7f70d412eeb798df3809de62249ad801a6e614d68913663cc208e3483937c4a6086946f10eef3615e5aacb761ead34eaaf5626a535d4e0417775516e9d84

data/lib/arelastic/aggregations/max.rb

@@ -0,0 +1,9 @@
+module Arelastic
+  module Aggregations
+    class Max < Arelastic::Aggregations::Aggregation
+      def as_elastic_aggregation
+        {'max' => options}
+      end
+    end
+  end
+end

data/lib/arelastic/aggregations.rb

@@ -10,6 +10,7 @@ require 'arelastic/aggregations/date_histogram'
 require 'arelastic/aggregations/filter'
 require 'arelastic/aggregations/filters'
 require 'arelastic/aggregations/histogram'
+require 'arelastic/aggregations/max'
 require 'arelastic/aggregations/min'
 require 'arelastic/aggregations/missing'
 require 'arelastic/aggregations/nested'

data/lib/arelastic/builders/aggregations.rb

@@ -3,16 +3,20 @@ module Arelastic
     class Aggregations
       class << self
         MACROS_TO_ARELASTIC = {
-          cardinality:   Arelastic::Aggregations::Cardinality,
+          cardinality:    Arelastic::Aggregations::Cardinality,
           date_histogram: Arelastic::Aggregations::DateHistogram,
           filter:         Arelastic::Aggregations::Filter,
           filters:        Arelastic::Aggregations::Filters,
           histogram:      Arelastic::Aggregations::Histogram,
+          max:            Arelastic::Aggregations::Max,
+          min:            Arelastic::Aggregations::Min,
           missing:        Arelastic::Aggregations::Missing,
           nested:         Arelastic::Aggregations::Nested,
+          parent:         Arelastic::Aggregations::Parent,
           range:          Arelastic::Aggregations::Range,
           reverse_nested: Arelastic::Aggregations::ReverseNested,
           sampler:        Arelastic::Aggregations::Sampler,
+          sum:            Arelastic::Aggregations::Sum,
           terms:          Arelastic::Aggregations::Terms,
           value_count:    Arelastic::Aggregations::ValueCount
         }

data/lib/arelastic/builders/queries.rb

@@ -13,6 +13,7 @@ module Arelastic
         geo_bounding_box:    Arelastic::Queries::GeoBoundingBox,
         geo_distance:        Arelastic::Queries::GeoDistance,
         geo_polygon:         Arelastic::Queries::GeoPolygon,
+        geo_shape_polygon:   Arelastic::Queries::GeoShape::Polygon,
         has_child:           Arelastic::Queries::HasChild,
         has_parent:          Arelastic::Queries::HasParent,
         ids:                 Arelastic::Queries::Ids,

data/lib/arelastic/nodes/node.rb

@@ -7,7 +7,7 @@ module Arelastic
 
       def convert_to_elastic(expr)
         if expr.is_a?(Array)
-          expr.map { |e| convert_to_elastic(e) }
+          expr.uniq.map { |e| convert_to_elastic(e) }
         elsif expr.is_a?(Hash)
           expr.transform_values { |e| convert_to_elastic(e) }
         else
@@ -22,6 +22,12 @@ module Arelastic
       def ==(other)
         other.is_a?(Arelastic::Nodes::Node) && as_elastic == other.as_elastic
       end
+
+      def hash
+        as_elastic.hash
+      end
+
+      alias eql? ==
     end
   end
 end

data/lib/arelastic/queries/bool.rb

@@ -19,11 +19,30 @@ module Arelastic
           'should'   => should,
           'must_not' => must_not
         }.each do |k, v|
+          if v.is_a?(Array)
+            v = merge_expression(k, v, klass: Queries::HasParent, merge_test_method: :parent_type)
+            v = merge_expression(k, v, klass: Queries::HasChild, merge_test_method: :type)
+            v = merge_expression(k, v, klass: Queries::Nested, merge_test_method: :path_and_options)
+          end
+
           searches[k] = convert_to_elastic(v) if v
         end
 
         { 'bool' => searches.update(options) }
       end
+
+      def merge_expression(clause, expr, klass:, merge_test_method:)
+        mergeable, other = expr.partition { |el| el.is_a?(klass) }
+        merged = mergeable.group_by(&merge_test_method).flat_map do |_, group|
+          if group.size > 1
+            group.first.instance_variable_set("@query", self.class.new(clause => group.map(&:query)))
+            group.first
+          else
+            group
+          end
+        end
+        merged + other
+      end
     end
   end
 end

data/lib/arelastic/queries/geo_polygon.rb

@@ -2,16 +2,19 @@ module Arelastic
   module Queries
     class GeoPolygon < Arelastic::Queries::Query
       attr_accessor :field, :points, :options
+
       def initialize(field, points, options = {})
+        warn 'Arelastic::Queries::GeoPolygon is deprecated in Elastic Search 7.12;'
+        + 'Use Arelastic::Queries::GeoShape instead.'
         @field   = field
         @points  = points
         @options = options
       end
 
       def as_elastic
-        params = {field => {"points" => points}}.update(options)
+        params = { field => { 'points' => points } }.update(options)
 
-        { "geo_polygon" => params }
+        { 'geo_polygon' => params }
       end
     end
   end

data/lib/arelastic/queries/geo_shape/polygon.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Arelastic
+  module Queries
+    module GeoShape
+      class Polygon < Arelastic::Queries::Query
+        attr_accessor :field, :points, :options
+
+        def initialize(field, points, options = {})
+          @field   = field
+          @points  = points
+          @options = options
+        end
+
+        def as_elastic
+          params = {
+            'shape' => { 'type' => 'polygon', 'coordinates' => [points] },
+            'relation' => 'within'
+          }.update(options)
+
+          { 'geo_shape' => { field => params } }
+        end
+      end
+    end
+  end
+end

data/lib/arelastic/queries/geo_shape.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'arelastic/queries/geo_shape/polygon'

data/lib/arelastic/queries/nested.rb

@@ -17,6 +17,10 @@ module Arelastic
 
         { 'nested' => params }
       end
+
+      def path_and_options
+        [path, options]
+      end
     end
   end
 end

data/lib/arelastic/queries.rb

@@ -11,6 +11,7 @@ require 'arelastic/queries/fuzzy'
 require 'arelastic/queries/geo_bounding_box'
 require 'arelastic/queries/geo_distance'
 require 'arelastic/queries/geo_polygon'
+require 'arelastic/queries/geo_shape'
 require 'arelastic/queries/has_child'
 require 'arelastic/queries/has_parent'
 require 'arelastic/queries/ids'
@@ -23,7 +24,6 @@ require 'arelastic/queries/multi_match'
 require 'arelastic/queries/nested'
 require 'arelastic/queries/percolate'
 require 'arelastic/queries/prefix'
-require 'arelastic/queries/query'
 require 'arelastic/queries/query_string'
 require 'arelastic/queries/range'
 require 'arelastic/queries/regexp'

data/lib/arelastic/searches/runtime_mappings.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Searches
+    class RuntimeMappings < Arelastic::Searches::Search
+      unary 'runtime_mappings'
+    end
+  end
+end

data/lib/arelastic/searches.rb

@@ -3,5 +3,6 @@ require 'arelastic/searches/search'
 require 'arelastic/searches/aggregations'
 require 'arelastic/searches/from'
 require 'arelastic/searches/query'
+require 'arelastic/searches/runtime_mappings'
 require 'arelastic/searches/size'
 require 'arelastic/searches/sort'

data/test/arelastic/aggregations/max_test.rb

@@ -0,0 +1,16 @@
+require 'helper'
+
+class Arelastic::Aggregations::MaxTest < Minitest::Test
+  def test_as_elastic
+    aggregation = Arelastic::Aggregations::Max.new('max_segment_id', 'field' => 'segment_id')
+
+    expected = {
+      "max_segment_id" => {
+        "max" => {
+          "field" => "segment_id"
+        }
+      }
+    }
+    assert_equal expected, aggregation.as_elastic
+  end
+end

data/test/arelastic/arities/polyadic_test.rb

@@ -8,6 +8,6 @@ class Arelastic::Arities::PolyadicTest < Minitest::Test
     end
 
     expected = {'xor' => [{'a' => 'b'}, {'x' => 'y'}]}
-    assert_equal expected, node.new([expr.new('a' => 'b'), expr.new('x' => 'y')]).as_elastic
+    assert_equal expected, node.new([expr.new({ 'a' => 'b' }), expr.new({'x' => 'y' })]).as_elastic
   end
 end

data/test/arelastic/builders/sort_test.rb

@@ -1,5 +1,17 @@
 require 'helper'
 
 class Arelastic::Builders::SortTest < Minitest::Test
-  
-end
+  def test_asc
+    query = Arelastic::Builders::Sort['field'].asc
+    expected = { 'field' => 'asc' }
+
+    assert_equal expected, query.as_elastic
+  end
+
+  def test_desc
+    query = Arelastic::Builders::Sort['field'].desc
+    expected = { 'field' => 'desc' }
+
+    assert_equal expected, query.as_elastic
+  end
+end

data/test/arelastic/queries/bool_test.rb

@@ -13,7 +13,7 @@ class Arelastic::Queries::BoolTest < Minitest::Test
   #
   # def test_as_elastic_with_query_node
   #   filtered = Arelastic::Queries::Filtered.new(query: Arelastic::Queries::QueryString.new("bar"))
-  #   expected = {"filtered" => {"query" => {"query_string" => {"query"=>"bar"}}}}
+  #   expected = {"filtered" => {"query" => {"query_string" => {"query" => "bar"}}}}
   #
   #   assert_equal expected, filtered.as_elastic
   # end
@@ -55,4 +55,67 @@ class Arelastic::Queries::BoolTest < Minitest::Test
 
     assert_equal expected, bool.as_elastic
   end
+
+  def test_merging_terms
+
+    expected = {
+      "bool" => {
+        "must"=> [
+          {
+            "nested" => {
+              "path" => "friends",
+              "query"=> { "match" => { "friends.age" => { "query" => "101" } } },
+              "inner_hits" => {}
+            }
+          },
+          {
+            "nested" => {
+              "path" => "friends",
+              "query" => {
+                "bool" => {
+                  "must"=> [
+                    { "match" => { "friends.first_name" => { "query" => "Thomas" } } },
+                    { "match" => { "friends.last_name" => { "query" => "Jefferson" } } }
+                  ]
+                }
+              }
+            }
+          }
+        ],
+        "should" => [
+          {
+            "has_parent" => {
+              "parent_type" => "user",
+              "query" => {
+                "bool" => {
+                  "should" => [
+                    { "query_string1" => "Texas" },
+                    { "query_string2" => "Delaware" }
+                  ]
+                }
+              }
+            }
+          },
+          {
+            "has_parent" => {
+              "parent_type" => "president",
+              "query" => { "query_string3" => "Washington" }
+            }
+          }
+        ]
+      }
+    }
+
+    should = [
+      Arelastic::Queries::HasParent.new("user",      { "query_string1" => "Texas"      }),
+      Arelastic::Queries::HasParent.new("user",      { "query_string2" => "Delaware"   }),
+      Arelastic::Queries::HasParent.new("president", { "query_string3" => "Washington" })
+    ]
+    must = [
+      Arelastic::Queries::Nested.new("friends", {"match" => { "friends.age"        => { "query" => "101"       }}}, 'inner_hits' => {}),
+      Arelastic::Queries::Nested.new("friends", {"match" => { "friends.first_name" => { "query" => "Thomas"    }}}),
+      Arelastic::Queries::Nested.new("friends", {"match" => { "friends.last_name"  => { "query" => "Jefferson" }}})
+    ]
+    assert_equal expected, Arelastic::Queries::Bool.new(should: should, must: must).as_elastic
+  end
 end

data/test/arelastic/queries/geo_shape/polygon_test.rb

@@ -0,0 +1,24 @@
+require 'helper'
+
+class Arelastic::Queries::GeoShape::PolygonTest < Minitest::Test
+  def test_as_elastic
+    points = [
+      [-124.33, 47.15],
+      [-124.42, 46.63],
+      [-123.84, 46.15]
+    ]
+    expected = {
+      'geo_shape' => {
+        'person.location' => {
+          'shape' => {
+            'type' => 'polygon',
+            'coordinates' => [points]
+          },
+          'relation' => 'within'
+        }
+      }
+    }
+
+    assert_equal expected, Arelastic::Queries::GeoShape::Polygon.new('person.location', points).as_elastic
+  end
+end

data/test/arelastic/queries/match_all_test.rb

@@ -7,4 +7,15 @@ class Arelastic::Queries::MatchAllTest < Minitest::Test
 
     assert_equal expected, match_all.as_elastic
   end
-end
+
+  def test_merging_match_all_terms
+    expected = { "bool" => { "should" => [{
+      "match_all" => {}
+    }]}}
+
+    term1 = Arelastic::Queries::MatchAll.new
+    term2 = Arelastic::Queries::MatchAll.new
+    assert_equal expected, Arelastic::Queries::Bool.new(should: [term1, term2]).as_elastic
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arelastic
 version: !ruby/object:Gem::Version
-  version: 3.4.0
+  version: 3.4.1
 platform: ruby
 authors:
 - Matthew Higgins
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-07 00:00:00.000000000 Z
+date: 2023-03-23 00:00:00.000000000 Z
 dependencies: []
 description: Build Elastic Search queries with objects
 email: developer@matthewhiggins.com
@@ -30,6 +30,7 @@ files:
 - lib/arelastic/aggregations/filter.rb
 - lib/arelastic/aggregations/filters.rb
 - lib/arelastic/aggregations/histogram.rb
+- lib/arelastic/aggregations/max.rb
 - lib/arelastic/aggregations/min.rb
 - lib/arelastic/aggregations/missing.rb
 - lib/arelastic/aggregations/nested.rb
@@ -74,6 +75,8 @@ files:
 - lib/arelastic/queries/geo_bounding_box.rb
 - lib/arelastic/queries/geo_distance.rb
 - lib/arelastic/queries/geo_polygon.rb
+- lib/arelastic/queries/geo_shape.rb
+- lib/arelastic/queries/geo_shape/polygon.rb
 - lib/arelastic/queries/has_child.rb
 - lib/arelastic/queries/has_parent.rb
 - lib/arelastic/queries/ids.rb
@@ -99,6 +102,7 @@ files:
 - lib/arelastic/searches/aggregations.rb
 - lib/arelastic/searches/from.rb
 - lib/arelastic/searches/query.rb
+- lib/arelastic/searches/runtime_mappings.rb
 - lib/arelastic/searches/search.rb
 - lib/arelastic/searches/size.rb
 - lib/arelastic/searches/sort.rb
@@ -115,6 +119,7 @@ files:
 - test/arelastic/aggregations/date_histogram_test.rb
 - test/arelastic/aggregations/filter_test.rb
 - test/arelastic/aggregations/filters_test.rb
+- test/arelastic/aggregations/max_test.rb
 - test/arelastic/aggregations/missing_test.rb
 - test/arelastic/aggregations/nested_test.rb
 - test/arelastic/aggregations/range_test.rb
@@ -141,6 +146,7 @@ files:
 - test/arelastic/queries/geo_bounding_box_test.rb
 - test/arelastic/queries/geo_distance_test.rb
 - test/arelastic/queries/geo_polygon_test.rb
+- test/arelastic/queries/geo_shape/polygon_test.rb
 - test/arelastic/queries/has_child_test.rb
 - test/arelastic/queries/has_parent_test.rb
 - test/arelastic/queries/ids_test.rb