stretchy-model 0.6.5 → 0.6.6

data/lib/stretchy/relations/aggregation_methods/nested.rb

@@ -0,0 +1,40 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Nested
+        # Perform a nested aggregation.
+        #
+        # This method is used to perform a nested aggregation, which allows you to aggregate nested documents as if they were indexed as separate documents. It accepts a name for the aggregation, a hash of options for the aggregation, and an optional array of nested aggregations.
+        #
+        # ### Parameters
+        #
+        # - `name:` The Symbol or String representing the name of the aggregation.
+        # - `options:` The Hash representing the options for the aggregation (default: {}).
+        #     - `:path:` The String representing the path to use for the nested aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified nested aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Nested aggregation
+        #
+        # ```ruby
+        #   Model.nested(:my_agg, {path: 'path_to_field'})
+        #   Model.nested(:my_agg, {path: 'path_to_field'}, aggs: {...})
+        # ```
+        #
+        def nested(name, options = {}, *aggs)
+            options = {nested: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:nested)
+
+      end
+    end
+  end
+end

data/lib/stretchy/relations/aggregation_methods/percentile_ranks.rb

@@ -0,0 +1,45 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module PercentileRanks
+        # Perform a percentile_ranks aggregation.
+        #
+        # This method is used to perform a percentile_ranks aggregation, which allows you to calculate the percentile rank for each value in a set of values. It accepts a name for the aggregation, a hash of options for the aggregation, and an optional array of nested aggregations.
+        #
+        # ### Parameters
+        #
+        # - `name:` The Symbol or String representing the name of the aggregation.
+        # - `options:` The Hash representing the options for the aggregation (default: {}).
+        #     - `:field:` The String representing the field to use for the percentile_ranks aggregation.
+        #     - `:values:` The Array of values to use for the percentile_ranks aggregation.
+        #     - `:keyed:` The Boolean that associates a unique string key with each bucket and returns the ranges as a hash rather than an array. Default is true.
+        #     - `:script:` The Hash representing the script to use for the percentile_ranks aggregation. Example: script: {source: "doc['field_name'].value", lang: "painless"}
+        #     - `:hdr:` The Hash representing the hdr to use for the percentile_ranks aggregation. Example: hdr: {number_of_significant_value_digits: 3}
+        #     - `:missing:` The value to use for the percentile_ranks aggregation when a field is missing in a document. Example: missing: 10
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified percentile_ranks aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Percentile_ranks aggregation
+        #
+        # ```ruby
+        #   Model.percentile_ranks(:my_agg, {field: 'field_name', values: [1, 2, 3]})
+        #   Model.percentile_ranks(:my_agg, {field: 'field_name', values: [1, 2, 3]}, aggs: {...})
+        # ```
+        #
+        def percentile_ranks(name, options = {}, *aggs)
+            options = {percentile_ranks: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:percentile_ranks)
+
+      end
+    end
+  end
+end

data/lib/stretchy/relations/aggregation_methods/percentiles.rb

@@ -0,0 +1,45 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Percentiles
+        # Perform a percentiles aggregation.
+        #
+        # This method is used to perform a percentiles aggregation, which allows you to calculate the percentiles of a set of values. It accepts a name for the aggregation, a hash of options for the aggregation, and an optional array of nested aggregations.
+        #
+        # ### Parameters
+        #
+        # - `name:` The Symbol or String representing the name of the aggregation.
+        # - `options:` The Hash representing the options for the aggregation (default: {}).
+        #     - `:field:` The String representing the field to use for the percentiles aggregation.
+        #     - `:percents:` The Array of Floats representing the percentiles to calculate for the percentiles aggregation. Example: percents: [95, 99, 99.9]
+        #     - `:keyed:` The Boolean that associates a unique string key with each bucket and returns the ranges as a hash rather than an array. Default is true.
+        #     - `:tdigest:` The Hash representing the tdigest to use for the percentiles aggregation. Example: tdigest: {compression: 100, execution_hint: "high_accuracy"}
+        #         - `:compression:` The Float representing the compression factor to use for the t-digest algorithm. A higher compression factor will yield more accurate percentiles, but will require more memory. The default value is 100.
+        #         - `:execution_hint:` The String representing the execution_hint to use for the t-digest algorithm. Example: execution_hint: "auto"
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified percentiles aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Percentiles aggregation
+        #
+        # ```ruby
+        #   Model.percentiles(:my_agg, {field: 'field_name', percents: [1, 2, 3]})
+        #   Model.percentiles(:my_agg, {field: 'field_name', percents: [1, 2, 3]}, aggs: {...})
+        # ```
+        #
+        def percentiles(name, options = {}, *aggs)
+            options = {percentiles: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:percentiles)
+
+      end
+    end
+  end
+end

data/lib/stretchy/relations/aggregation_methods/range.rb

@@ -0,0 +1,42 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Range
+        # Perform a range aggregation.
+        #
+        # This method is used to perform a range aggregation, which allows you to aggregate data into specified ranges. It accepts a name for the aggregation, a hash of options for the aggregation, and an optional array of nested aggregations.
+        #
+        # ### Parameters
+        #
+        # - `name:` The Symbol or String representing the name of the aggregation.
+        # - `options:` The Hash representing the options for the aggregation (default: {}).
+        #     - `:field:` The String representing the field to use for the range aggregation.
+        #     - `:ranges:` The Array of Hashes representing the ranges to use for the range aggregation. Example: ranges: [{from: 1, to: 2}, {from: 2, to: 3}]
+        #     - `:keyed:` The Boolean that associates a unique string key with each bucket and returns the ranges as a hash rather than an array. Default is true.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified range aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Range aggregation
+        #
+        # ```ruby
+        #   Model.range(:my_agg, {field: 'field_name', ranges: [{from: 1, to: 2}, {from: 2, to: 3}]})
+        #   Model.range(:my_agg, {field: 'field_name', ranges: [{from: 1, to: 2}, {from: 2, to: 3}]}, aggs: {...})
+        # ```
+        #
+        def range(name, options = {}, *aggs)
+            options = {range: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:range)
+
+      end
+    end
+  end
+end

data/lib/stretchy/relations/aggregation_methods/reverse_nested.rb

@@ -0,0 +1,40 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module ReverseNested
+        # Perform a reverse_nested aggregation.
+        #
+        # This method is used to perform a reverse_nested aggregation, which allows you to access data in the parent document from within a nested document. It accepts a name for the aggregation, a hash of options for the aggregation, and an optional array of nested aggregations.
+        #
+        # ### Parameters
+        #
+        # - `name:` The Symbol or String representing the name of the aggregation.
+        # - `options:` The Hash representing the options for the aggregation (default: {}).
+        #     - `:path:` The String representing the path to use for the reverse_nested aggregation (optional).
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified reverse_nested aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Reverse_nested aggregation
+        #
+        # ```ruby
+        #   Model.reverse_nested(:my_agg)
+        #   Model.reverse_nested(:my_agg, {}, aggs: {...})
+        # ```
+        #
+        def reverse_nested(name, options = {}, *aggs)
+            options = {reverse_nested: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:reverse_nested)
+
+      end
+    end
+  end
+end

data/lib/stretchy/relations/aggregation_methods/sampler.rb

@@ -0,0 +1,40 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Sampler
+        # Perform a sampler aggregation.
+        #
+        # This method is used to perform a sampler aggregation, which allows you to create a representative sample of a larger data set. It accepts a name for the aggregation, a hash of options for the aggregation, and an optional array of nested aggregations.
+        #
+        # ### Parameters
+        #
+        # - `name:` The Symbol or String representing the name of the aggregation.
+        # - `options:` The Hash representing the options for the aggregation (default: {}).
+        #     - `:shard_size:` The Integer representing the shard size to use for the sampler aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified sampler aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Sampler aggregation
+        #
+        # ```ruby
+        #   Model.sampler(:my_agg, {shard_size: 100})
+        #   Model.sampler(:my_agg, {shard_size: 100}, aggs: {...})
+        # ```
+        #
+        def sampler(name, options = {}, *aggs)
+            options = {sampler: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:sampler)
+
+      end
+    end
+  end
+end

data/lib/stretchy/relations/aggregation_methods/scripted_metric.rb

@@ -0,0 +1,43 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module ScriptedMetric
+        # Perform a scripted_metric aggregation.
+        #
+        # This method is used to perform a scripted_metric aggregation, which allows you to define your own aggregations using scripts. It accepts a name for the aggregation, a hash of options for the aggregation, and an optional array of nested aggregations.
+        #
+        # ### Parameters
+        #
+        # - `name:` The Symbol or String representing the name of the aggregation.
+        # - `options:` The Hash representing the options for the aggregation (default: {}).
+        #     - `:init_script:` The String representing the initialization script for the scripted_metric aggregation.
+        #     - `:map_script:` The String representing the map script for the scripted_metric aggregation.
+        #     - `:combine_script:` The String representing the combine script for the scripted_metric aggregation.
+        #     - `:reduce_script:` The String representing the reduce script for the scripted_metric aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified scripted_metric aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Scripted_metric aggregation
+        #
+        # ```ruby
+        #   Model.scripted_metric(:my_agg, {init_script: '...', map_script: '...', combine_script: '...', reduce_script: '...'})
+        #   Model.scripted_metric(:my_agg, {init_script: '...', map_script: '...', combine_script: '...', reduce_script: '...'}, aggs: {...})
+        # ```
+        #
+        def scripted_metric(name, options = {}, *aggs)
+            options = {scripted_metric: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:scripted_metric)
+
+      end
+    end
+  end
+end

data/lib/stretchy/relations/aggregation_methods/significant_terms.rb

@@ -0,0 +1,45 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module SignificantTerms
+        # Perform a significant_terms aggregation.
+        #
+        # This method is used to perform a significant_terms aggregation, which allows you to find the terms that are unusually common in your data set compared to a background data set. It accepts a name for the aggregation, a hash of options for the aggregation, and an optional array of nested aggregations.
+        #
+        # ### Parameters
+        #
+        # - `name:` The Symbol or String representing the name of the aggregation.
+        # - `options:` The Hash representing the options for the aggregation (default: {}).
+        #     - `:field:` The String representing the field to use for the significant_terms aggregation.
+        #     - `:background_filter:` The Hash representing the background filter to use for the significant_terms aggregation.
+        #     - `:mutual_information:` The Hash representing the mutual information to use for the significant_terms aggregation.
+        #     - `:chi_square:` The Hash representing the chi square to use for the significant_terms aggregation.
+        #     - `:gnd:` The Hash representing the gnd to use for the significant_terms aggregation.
+        #     - `:jlh:` The Hash representing the jlh to use for the significant_terms aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified significant_terms aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Significant_terms aggregation
+        #
+        # ```ruby
+        #   Model.significant_terms(:my_agg, {field: 'field_name'})
+        #   Model.significant_terms(:my_agg, {field: 'field_name'}, aggs: {...})
+        # ```
+        # 
+        def significant_terms(name, options = {}, *aggs)
+            options = {significant_terms: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:significant_terms)
+
+      end
+    end
+  end
+end

data/lib/stretchy/relations/aggregation_methods/stats.rb

@@ -0,0 +1,42 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Stats
+        # Perform a stats aggregation.
+        #
+        # This method is used to perform a stats aggregation, which allows you to compute aggregate statistics over your data set, such as count, min, max, sum, and average. It accepts a name for the aggregation, a hash of options for the aggregation, and an optional array of nested aggregations.
+        #
+        # ### Parameters
+        #
+        # - `name:` The Symbol or String representing the name of the aggregation.
+        # - `options:` The Hash representing the options for the aggregation (default: {}).
+        #     - `:field:` The String representing the field to use for the stats aggregation.
+        #     - `:missing:` The value to use for the stats aggregation when a field is missing in a document. Example: missing: 10
+        #     - `:script:` The Hash representing the script to use for the stats aggregation. Example: script: {source: "doc['field_name'].value", lang: "painless"}
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified stats aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Stats aggregation
+        #
+        # ```ruby
+        #   Model.stats(:my_agg, {field: 'field_name'})
+        #   Model.stats(:my_agg, {field: 'field_name'}, aggs: {...})
+        # ```
+        #
+        def stats(name, options = {}, *aggs)
+            options = {stats: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:stats)
+
+      end
+    end
+  end
+end

data/lib/stretchy/relations/aggregation_methods/sum.rb

@@ -0,0 +1,42 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Sum
+        # Perform a sum aggregation.
+        #
+        # This method is used to perform a sum aggregation, which allows you to compute the sum of a numeric field. It accepts a name for the aggregation, a hash of options for the aggregation, and an optional array of nested aggregations.
+        #
+        # ### Parameters
+        #
+        # - `name:` The Symbol or String representing the name of the aggregation.
+        # - `options:` The Hash representing the options for the aggregation (default: {}).
+        #     - `:field:` The String representing the field to use for the sum aggregation.
+        #     - `:missing:` The value to use for the sum aggregation when a field is missing in a document. Example: missing: 10
+        #     - `:script:` The Hash representing the script to use for the sum aggregation. Example: script: {source: "doc['field_name'].value", lang: "painless"}
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified sum aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Sum aggregation
+        #
+        # ```ruby
+        #   Model.sum(:my_agg, {field: 'field_name'})
+        #   Model.sum(:my_agg, {field: 'field_name'}, aggs: {...})
+        # ```
+        #
+        def sum(name, options = {}, *aggs)
+            options = {sum: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:sum)
+
+      end
+    end
+  end
+end

data/lib/stretchy/relations/aggregation_methods/terms.rb

@@ -0,0 +1,46 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Terms
+        # Perform a terms aggregation.
+        #
+        # This method is used to perform a terms aggregation, which allows you to compute the frequency of different terms within a field. It accepts a name for the aggregation, a hash of options for the aggregation, and an optional array of nested aggregations.
+        #
+        # ### Parameters
+        #
+        # - `name:` The Symbol or String representing the name of the aggregation.
+        # - `options:` The Hash representing the options for the aggregation (default: {}).
+        #     - `:field:` The String representing the field to use for the terms aggregation.
+        #     - `:size:` The Integer representing the size for the terms aggregation (optional).
+        #     - `:min_doc_count:` The Integer representing the minimum document count for the terms aggregation (optional).
+        #     - `:shard_min_doc_count:` The Integer representing the shard minimum document count for the terms aggregation (optional).
+        #     - `:show_term_doc_count_error:` The Boolean representing the show_term_doc_count_error for the terms aggregation (optional). Default is false.
+        #     - `:shard_size:` The Integer representing the shard size for the terms aggregation (optional).
+        #     - `:order:` The Hash representing the order for the terms aggregation (optional).
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified terms aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Terms aggregation
+        #
+        # ```ruby
+        #   Model.terms(:my_agg, {field: 'field_name', size: 10, min_doc_count: 1, shard_size: 100})
+        #   Model.terms(:my_agg, {field: 'field_name', size: 10, min_doc_count: 1, shard_size: 100}, aggs: {...})
+        # ```
+        #
+        def terms(name, options = {}, *aggs)
+            options = {terms: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:terms)
+
+      end
+    end
+  end
+end

data/lib/stretchy/relations/aggregation_methods/top_hits.rb

@@ -0,0 +1,42 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module TopHits
+        # Perform a top_hits aggregation.
+        #
+        # This method is used to perform a top_hits aggregation, which allows you to return the top matching hits for each bucket of a parent aggregation. It accepts a name for the aggregation, a hash of options for the aggregation, and an optional array of nested aggregations.
+        #
+        # ### Parameters
+        #
+        # - `name:` The Symbol or String representing the name of the aggregation.
+        # - `options:` The Hash representing the options for the aggregation (default: {}).
+        #     - `:size:` The Integer representing the size for the top_hits aggregation.
+        #     - `:from:` The Integer representing the from for the top_hits aggregation.
+        #     - `:sort:` The Hash or Array representing the sort for the top_hits aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified top_hits aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Top_hits aggregation
+        #
+        # ```ruby
+        #   Model.top_hits(:my_agg, {size: 10, sort: {...}})
+        #   Model.top_hits(:my_agg, {size: 10, sort: {...}}, aggs: {...})
+        # ```
+        #
+        def top_hits(name, options = {}, *aggs)
+            options = {top_hits: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:top_hits)
+
+      end
+    end
+  end
+end

data/lib/stretchy/relations/aggregation_methods/top_metrics.rb

@@ -0,0 +1,44 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module TopMetrics
+        # Perform a top_metrics aggregation.
+        #
+        # This method is used to perform a top_metrics aggregation, which allows you to return the top metrics for each bucket of a parent aggregation. It accepts a name for the aggregation, a hash of options for the aggregation, and an optional array of nested aggregations.
+        #
+        # ### Parameters
+        #
+        # - `name:` The Symbol or String representing the name of the aggregation.
+        # - `options:` The Hash representing the options for the aggregation (default: {}).
+        #     - `:metrics:` The Array of Hashes representing the metrics to use for the top_metrics aggregation. Example: metrics: [{field: 'field_name', type: 'max'}, {field: 'field_name', type: 'min'}]
+        #     - `:field:` The String representing the field to use for the top_metrics aggregation (optional).
+        #     - `:size:` The Integer representing the size for the top_metrics aggregation (optional).
+        #     - `:sort:` The Hash or Array representing the sort for the top_metrics aggregation (optional).
+        #     - `:missing:` The value to use for the top_metrics aggregation when a field is missing in a document (optional).
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified top_metrics aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Top_metrics aggregation
+        #
+        # ```ruby
+        #   Model.top_metrics(:my_agg, {metrics: [{field: 'field_name', type: 'max'}, {field: 'field_name', type: 'min'}]})
+        #   Model.top_metrics(:my_agg, {metrics: [{field: 'field_name', type: 'max'}, {field: 'field_name', type: 'min'}]}, aggs: {...})
+        # ```
+        #
+        def top_metrics(name, options = {}, *aggs)
+            options = {top_metrics: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:top_metrics)
+
+      end
+    end
+  end
+end

data/lib/stretchy/relations/aggregation_methods/value_count.rb

@@ -0,0 +1,41 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module ValueCount
+        # Perform a value_count aggregation.
+        #
+        # This method is used to perform a value_count aggregation, which allows you to compute the count of values for a specific field. It accepts a name for the aggregation, a hash of options for the aggregation, and an optional array of nested aggregations.
+        #
+        # ### Parameters
+        #
+        # - `name:` The Symbol or String representing the name of the aggregation.
+        # - `options:` The Hash representing the options for the aggregation (default: {}).
+        #     - `:field:` The String representing the field to use for the value_count aggregation.
+        #     - `:script:` The Hash representing the script to use for the value_count aggregation. Example: script: {source: "doc['field_name'].value", lang: "painless"}
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified value_count aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Value_count aggregation
+        #
+        # ```ruby
+        #   Model.value_count(:my_agg, {field: 'field_name'})
+        #   Model.value_count(:my_agg, {field: 'field_name'}, aggs: {...})
+        # ```
+        #
+        def value_count(name, options = {}, *aggs)
+            options = {value_count: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:value_count)
+
+      end
+    end
+  end
+end

data/lib/stretchy/relations/aggregation_methods/weighted_avg.rb

@@ -0,0 +1,42 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module WeightedAvg
+        # Perform a weighted_avg aggregation.
+        #
+        # This method is used to perform a weighted_avg aggregation, which allows you to compute a weighted average of a specified field. It accepts a name for the aggregation, a hash of options for the aggregation, and an optional array of nested aggregations.
+        #
+        # ### Parameters
+        #
+        # - `name:` The Symbol or String representing the name of the aggregation.
+        # - `options:` The Hash representing the options for the aggregation (default: {}).
+        #     - `:value:` The Hash representing the value field to use for the weighted_avg aggregation. Example: value: { field: 'price', missing: 0}
+        #     - `:weight:` The Hash representing the weight field to use for the weighted_avg aggregation. Example: weight: { field: 'weight', missing: 0}
+        #     - `:format:` The String representing the format for the weighted_avg aggregation (optional).
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified weighted_avg aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Weighted_avg aggregation
+        #
+        # ```ruby
+        #   Model.weighted_avg(:my_agg, {value: {field: 'value_field_name'}, weight: {field: 'weight_field_name'}})
+        #   Model.weighted_avg(:my_agg, {value: {field: 'value_field_name'}, weight: {field: 'weight_field_name'}}, aggs: {...})
+        # ```
+        #
+        def weighted_avg(name, options = {}, *aggs)
+            options = {weighted_avg: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:weighted_avg)
+
+      end
+    end
+  end
+end