stretchy-model 0.6.5 → 0.6.6

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

@@ -0,0 +1,47 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Children
+        # Perform a children aggregation.
+        #
+        # This method is used to aggregate on child documents of the parent documents that match the query. 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: {}).
+        #     - `:type:` The String representing the type of children to aggregate.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified children aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Children aggregation
+        #
+        # ```ruby
+        #   Model.children(:my_agg, {type: 'my_type'})
+        #   Model.children(:my_agg, {type: 'my_type'}, aggs: {...})
+        # ```
+        #
+        # Aggregation results are available in the `aggregations` method of the results under the name provided in the aggregation.
+        #
+        # ```ruby
+        #   results = Model.where(color: :blue).children(:my_agg, {type: 'my_type'})
+        #   results.aggregations.my_agg
+        # ```
+        #
+        def children(name, options = {}, *aggs)
+            options = {children: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:children)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Composite
+        # Perform a composite aggregation.
+        #
+        # This method is used to perform a composite aggregation, which allows you to collect terms or histogram aggregations on high cardinality fields. 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: {}).
+        #     - `:sources:` The Array representing the sources to use for the composite aggregation.
+        #     - `:size:` The Integer representing the size of the composite aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified composite aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Composite aggregation
+        #
+        # ```ruby
+        #   Model.composite(:my_agg, {sources: [...], size: 100})
+        #   Model.composite(:my_agg, {sources: [...], size: 100}, aggs: {...})
+        # ```
+        #
+        def composite(name, options = {}, *aggs)
+            options = {composite: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:composite)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module DateHistogram
+        # Perform a date_histogram aggregation.
+        #
+        # This method is used to perform a date_histogram aggregation, which allows you to aggregate time-based data by a certain interval. 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 date_histogram aggregation.
+        #     - `:interval:` The String representing the interval for the date_histogram aggregation.
+        #     - `:calendar_interval:` The Symbol representing the calendar interval for the date_histogram aggregation.
+        #     - `:format:` The String representing the format for the date_histogram aggregation.
+        #     - `:time_zone:` The String representing the time zone for the date_histogram aggregation.
+        #     - `:min_doc_count:` The Integer representing the minimum document count for the date_histogram aggregation.
+        #     - `:extended_bounds:` The Hash representing the extended bounds for the date_histogram aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified date_histogram aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Date_histogram aggregation
+        #
+        # ```ruby
+        #   Model.date_histogram(:my_agg, {field: 'date', interval: 'month', format: 'MM-yyyy', time_zone: 'UTC'})
+        #   Model.date_histogram(:my_agg, {field: 'date', calendar_interval: :month, format: 'MM-yyyy', time_zone: 'UTC'}, aggs: {...})
+        # ```
+        #
+        # Aggregation results are available in the `aggregations` method of the results under the name provided in the aggregation.
+        #
+        # ```ruby
+        #   results = Model.where(color: :blue).date_histogram(:my_agg, {field: 'date', interval: 'month', format: 'MM-yyyy', time_zone: 'UTC'})
+        #   results.aggregations.my_agg
+        # ```
+        #
+        def date_histogram(name, options = {}, *aggs)
+            options = {date_histogram: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:date_histogram)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module DateRange
+        # Perform a date_histogram aggregation.
+        #
+        # This method is used to perform a date_histogram aggregation, which allows you to aggregate time-based data by a certain interval. 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 date_histogram aggregation.
+        #     - `:interval:` The String representing the interval for the date_histogram aggregation.
+        #     - `:calendar_interval:` The Symbol representing the calendar interval for the date_histogram aggregation.
+        #     - `:format:` The String representing the format for the date_histogram aggregation.
+        #     - `:time_zone:` The String representing the time zone for the date_histogram aggregation.
+        #     - `:min_doc_count:` The Integer representing the minimum document count for the date_histogram aggregation.
+        #     - `:extended_bounds:` The Hash representing the extended bounds for the date_histogram aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified date_histogram aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Date_histogram aggregation
+        #
+        # ```ruby
+        #   Model.date_histogram(:my_agg, {field: 'date', interval: 'month', format: 'MM-yyyy', time_zone: 'UTC'})
+        #   Model.date_histogram(:my_agg, {field: 'date', calendar_interval: :month, format: 'MM-yyyy', time_zone: 'UTC'}, aggs: {...})
+        # ```
+        #
+        # Aggregation results are available in the `aggregations` method of the results under the name provided in the aggregation.
+        #
+        # ```ruby
+        #   results = Model.where(color: :blue).date_histogram(:my_agg, {field: 'date', interval: 'month', format: 'MM-yyyy', time_zone: 'UTC'})
+        #   results.aggregations.my_agg
+        # ```
+        #
+        def date_range(name, options = {}, *aggs)
+            options = {date_range: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:date_range)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module ExtendedStats
+        # Perform an extended_stats aggregation.
+        #
+        # This method is used to perform an extended_stats aggregation, which allows you to compute several statistical measures from your data. 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 extended_stats aggregation.
+        #     - `:sigma:` The Float representing the sigma for the extended_stats aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified extended_stats aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Extended_stats aggregation
+        #
+        # ```ruby
+        #   Model.extended_stats(:my_agg, {field: 'field_name', sigma: 1.0})
+        #   Model.extended_stats(:my_agg, {field: 'field_name', sigma: 1.0}, aggs: {...})
+        # ```
+        #
+        # Aggregation results are available in the `aggregations` method of the results under the name provided in the aggregation.
+        #
+        # ```ruby
+        #   results = Model.where(color: :blue).extended_stats(:my_agg, {field: 'field_name', sigma: 1.0})
+        #   results.aggregations.my_agg
+        # ```
+        #
+        def extended_stats(name, options = {}, *aggs)
+            options = {extended_stats: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:extended_stats)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Filter
+        # Perform a filter aggregation.
+        #
+        # This method is used to perform a filter_agg aggregation, which allows you to filter the data that an aggregation operates on. 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: {}).
+        #     - `:filter:` The Hash representing the filter to use for the filter_agg aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified filter_agg aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Filter_agg aggregation
+        #
+        # ```ruby
+        #   Model.filter(:my_agg, {filter: {...}})
+        #   Model.filter(:my_agg, {filter: {...}}, aggs: {...})
+        # ```
+        #
+        # Aggregation results are available in the `aggregations` method of the results under the name provided in the aggregation.
+        #
+        # ```ruby
+        #   results = Model.where(color: :blue).filter(:my_agg, {filter: {...}})
+        #   results.aggregations.my_agg
+        # ```
+        #
+        def filter(name, options = {}, *aggs)
+            options = {filter: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:filter)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Filters
+        # Perform a filters aggregation.
+        #
+        # This method is used to perform a filters aggregation, which allows you to apply several filters and return the document count for each filter. 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: {}).
+        #     - `:filters:` The Hash representing the filters to use for the filters aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified filters aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Filters aggregation
+        #
+        # ```ruby
+        #   Model.filters(:my_agg, {filters: {...}})
+        #   Model.filters(:my_agg, {filters: {...}}, aggs: {...})
+        # ```
+        #
+        # Aggregation results are available in the `aggregations` method of the results under the name provided in the aggregation.
+        #
+        # ```ruby
+        #   results = Model.where(color: :blue).filters(:my_agg, {filters: {...}})
+        #   results.aggregations.my_agg
+        # ```
+        #
+        def filters(name, options = {}, *aggs)
+            options = {filters: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:filters)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module GeoBounds
+        # Perform a geo_bounds aggregation.
+        #
+        # This method is used to perform a geo_bounds aggregation, which allows you to find the bounding box containing all geo_point values for a particular 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 geo_bounds aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified geo_bounds aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Geo_bounds aggregation
+        #
+        # ```ruby
+        #   Model.geo_bounds(:my_agg, {field: 'location_field'})
+        #   Model.geo_bounds(:my_agg, {field: 'location_field'}, aggs: {...})
+        # ```
+        #
+        def geo_bounds(name, options = {}, *aggs)
+            options = {geo_bounds: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:geo_bounds)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module GeoCentroid
+        # Perform a geo_centroid aggregation.
+        #
+        # This method is used to perform a geo_centroid aggregation, which allows you to find the central point (centroid) of all geo_point values for a particular 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 geo_centroid aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified geo_centroid aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Geo_centroid aggregation
+        #
+        # ```ruby
+        #   Model.geo_centroid(:my_agg, {field: 'location_field'})
+        #   Model.geo_centroid(:my_agg, {field: 'location_field'}, aggs: {...})
+        # ```
+        #
+        def geo_centroid(name, options = {}, *aggs)
+            options = {geo_centroid: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:geo_centroid)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Global
+        # Perform a global aggregation.
+        #
+        # This method is used to perform a global aggregation, which allows you to count all documents matching a query, regardless of the search scope. 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: {}).
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified global aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Global aggregation
+        #
+        # ```ruby
+        #   Model.global(:my_agg)
+        #   Model.global(:my_agg, {}, aggs: {...})
+        # ```
+        #
+        def global(name, options = {}, *aggs)
+            options = {global: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:global)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Histogram
+        # Perform a histogram aggregation.
+        #
+        # This method is used to perform a histogram aggregation, which allows you to aggregate data into buckets of a certain interval. 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 histogram aggregation.
+        #     - `:interval:` The Integer representing the interval for the histogram aggregation.
+        #     - `:min_doc_count:` The Integer representing the minimum document count for the histogram aggregation.
+        #     - `:extended_bounds:` The Hash representing the extended bounds for the histogram aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified histogram aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Histogram aggregation
+        #
+        # ```ruby
+        #   Model.histogram(:my_agg, {field: 'field_name', interval: 5})
+        #   Model.histogram(:my_agg, {field: 'field_name', interval: 5}, aggs: {...})
+        # ```
+        #
+        def histogram(name, options = {}, *aggs)
+            options = {histogram: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:histogram)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module IpRange
+        # Perform an ip_range aggregation.
+        #
+        # This method is used to perform an ip_range aggregation, which allows you to aggregate IP values into specified IP 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 ip_range aggregation.
+        #     - `:ranges:` The Array of Hashes representing the ranges to use for the ip_range aggregation. Example: ranges: [{to: '10.0.0.5'}, {from: '10.0.0.5'}]
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified ip_range aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Ip_range aggregation
+        #
+        # ```ruby
+        #   Model.ip_range(:my_agg, {field: 'ip_field'})
+        #   Model.ip_range(:my_agg, {field: 'ip_field'}, aggs: {...})
+        # ```
+        #
+        def ip_range(name, options = {}, *aggs)
+          options = {ip_range: options}.merge(*aggs)
+          aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:ip_range)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Max
+        # Perform a max aggregation.
+        #
+        # This method is used to perform a max aggregation, which allows you to find the maximum value of a field in the 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 max aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified max aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Max aggregation
+        #
+        # ```ruby
+        #   Model.max(:my_agg, {field: 'field_name'})
+        #   Model.max(:my_agg, {field: 'field_name'}, aggs: {...})
+        # ```
+        #
+        def max(name, options = {}, *aggs)
+            options = {max: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:max)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Min
+
+        # Perform a min aggregation.
+        #
+        # This method is used to perform a min aggregation, which allows you to find the minimum value of a field in the 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 min aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified min aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Min aggregation
+        #
+        # ```ruby
+        #   Model.min(:my_agg, {field: 'field_name'})
+        #   Model.min(:my_agg, {field: 'field_name'}, aggs: {...})
+        # ```
+        #
+        def min(name, options = {}, *aggs)
+            options = {min: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:min)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Stretchy
+  module Relations
+    module AggregationMethods
+      module Missing
+        # Perform a missing aggregation.
+        #
+        # This method is used to perform a missing aggregation, which allows you to find all documents where a field is missing or null. 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 missing aggregation.
+        # - `aggs:` The Array of Hashes representing nested aggregations (optional).
+        #
+        # ### Returns
+        # Returns a new Stretchy::Relation with the specified missing aggregation.
+        #
+        # ---
+        #
+        # ### Examples
+        #
+        # #### Missing aggregation
+        #
+        # ```ruby
+        #   Model.missing(:my_agg, {field: 'field_name'})
+        #   Model.missing(:my_agg, {field: 'field_name'}, aggs: {...})
+        # ```
+        #
+        def missing(name, options = {}, *aggs)
+            options = {missing: options}.merge(*aggs)
+            aggregation(name, options)
+        end
+
+        AggregationMethods.register!(:missing)
+
+      end
+    end
+  end
+end