graphql 2.6.11 → 2.6.13

data/lib/graphql/schema/timeout.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
@@ -13,37 +14,53 @@ module GraphQL
     # Note that this will stop a query _in between_ field resolutions, but
     # it doesn't interrupt long-running `resolve` functions. Be sure to use
     # timeout options for external connections. For more info, see
-    # www.mikeperham.com/2015/05/08/timeout-rubys-most-dangerous-api/
+    # https://www.mikeperham.com/2015/05/08/timeout-rubys-most-dangerous-api/
     #
-    # @example Stop resolving fields after 2 seconds
-    #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Schema::Timeout, max_seconds: 2
-    #   end
+    # **Examples**
     #
-    # @example Notifying Bugsnag and logging a timeout
-    #   class MyTimeout < GraphQL::Schema::Timeout
-    #     def handle_timeout(error, query)
-    #        Rails.logger.warn("GraphQL Timeout: #{error.message}: #{query.query_string}")
-    #        Bugsnag.notify(error, {query_string: query.query_string})
-    #     end
-    #   end
+    # **Example: Stop resolving fields after 2 seconds**
+    #
+    # ```ruby
+    # class MySchema < GraphQL::Schema
+    #   use GraphQL::Schema::Timeout, max_seconds: 2
+    # end
+    # ```
     #
-    #   class MySchema < GraphQL::Schema
-    #     use MyTimeout, max_seconds: 2
+    # **Example: Notifying Bugsnag and logging a timeout**
+    #
+    # ```ruby
+    # class MyTimeout < GraphQL::Schema::Timeout
+    #   def handle_timeout(error, query)
+    #      Rails.logger.warn("GraphQL Timeout: #{error.message}: #{query.query_string}")
+    #      Bugsnag.notify(error, {query_string: query.query_string})
     #   end
+    # end
     #
+    # class MySchema < GraphQL::Schema
+    #   use MyTimeout, max_seconds: 2
+    # end
+    # ```
     class Timeout
       def self.use(schema, max_seconds: nil)
         timeout = self.new(max_seconds: max_seconds)
-        schema.trace_with(self::Trace, timeout: timeout)
+        schema.trace_with(const_get(:Trace), timeout: timeout)
       end
 
       def initialize(max_seconds:)
         @max_seconds = max_seconds
       end
 
+      #--
+
+      # @requires_ancestor: Kernel
+
       module Trace
-        # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
+        # **Parameters**
+        #
+        # - `max_seconds` (`Numeric`) — how many seconds the query should be allowed to resolve new fields
+        #
+        # :call-seq:
+        #   initialize(timeout:, **rest)
         def initialize(timeout:, **rest)
           @timeout = timeout
           super
@@ -97,34 +114,57 @@ module GraphQL
       # Called at the start of each query.
       # The default implementation returns the `max_seconds:` value from installing this plugin.
       #
-      # @param query [GraphQL::Query] The query that's about to run
-      # @return [Numeric, false] The number of seconds after which to interrupt query execution and call {#handle_error}, or `false` to bypass the timeout.
+      # **Parameters**
+      #
+      # - `query` (`GraphQL::Query`) — The query that's about to run
+      #
+      # **Returns**
+      #
+      # - `Numeric, false` — The number of seconds after which to interrupt query execution and call `handle_error`, or `false` to bypass the timeout.
+      #
+      # :call-seq:
+      #   max_seconds(GraphQL::Query query) -> Numeric | false
       def max_seconds(query)
         @max_seconds
       end
 
       # Invoked when a query times out.
-      # @param error [GraphQL::Schema::Timeout::TimeoutError]
-      # @param query [GraphQL::Error]
+      #
+      # **Parameters**
+      #
+      # - `error` (`GraphQL::Schema::Timeout::TimeoutError`)
+      # - `query` (`GraphQL::Error`)
+      #
+      # :call-seq:
+      #   handle_timeout(GraphQL::Schema::Timeout::TimeoutError error, GraphQL::Error query)
       def handle_timeout(error, query)
         # override to do something interesting
       end
 
-      # Call this method (eg, from {#handle_timeout}) to disable timeout tracking
+      # Call this method (eg, from [handle timeout](rdoc-ref:#handle_timeout)) to disable timeout tracking
       # for the given query.
-      # @param query [GraphQL::Query]
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `query` (`GraphQL::Query`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   disable_timeout(GraphQL::Query query) -> void
       def disable_timeout(query)
         query.context.namespace(self)[:state] = false
         nil
       end
 
       # This error is raised when a query exceeds `max_seconds`.
-      # Since it's a child of {GraphQL::ExecutionError},
+      # Since it's a child of [GraphQL::ExecutionError](rdoc-ref:GraphQL::ExecutionError),
       # its message will be added to the response's `errors` key.
       #
       # To raise an error that will stop query resolution, use a custom block
-      # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
+      # to take this error and raise a new one which _doesn't_ descend from [GraphQL::ExecutionError](rdoc-ref:GraphQL::ExecutionError),
       # such as `RuntimeError`.
       class TimeoutError < GraphQL::ExecutionError
         def initialize(field)

data/lib/graphql/schema/type_expression.rb

@@ -1,13 +1,22 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   class Schema
-    # @api private
-    module TypeExpression
+    module TypeExpression # :nodoc:
       # Fetch a type from a type map by its AST specification.
       # Return `nil` if not found.
-      # @param type_owner [#type] A thing for looking up types by name
-      # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
-      # @return [Class, GraphQL::Schema::NonNull, GraphQL::Schema:List]
+      #
+      # **Parameters**
+      #
+      # - `type_owner` (`#type`) — A thing for looking up types by name
+      # - `ast_node` (`GraphQL::Language::Nodes::AbstractNode`)
+      #
+      # **Returns**
+      #
+      # - `Class, GraphQL::Schema::NonNull, GraphQL::Schema:List`
+      #
+      # :call-seq:
+      #   build_type(#type type_owner, GraphQL::Language::Nodes::AbstractNode ast_node) -> Class | GraphQL::Schema::NonNull | GraphQL::Schema:List
       def self.build_type(type_owner, ast_node)
         case ast_node
         when GraphQL::Language::Nodes::TypeName

data/lib/graphql/schema/type_membership.rb

@@ -1,32 +1,49 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
     # This class joins an object type to an abstract type (interface or union) of which
     # it is a member.
     class TypeMembership
-      # @return [Class<GraphQL::Schema::Object>]
+      # **Returns**
+      #
+      # - `Class<GraphQL::Schema::Object>`
       attr_accessor :object_type
 
-      # @return [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
+      # **Returns**
+      #
+      # - `Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>`
       attr_reader :abstract_type
 
-      # @return [Hash]
+      # **Returns**
+      #
+      # - `Hash`
       attr_reader :options
 
-      # Called when an object is hooked up to an abstract type, such as {Schema::Union.possible_types}
-      # or {Schema::Object.implements} (for interfaces).
+      # Called when an object is hooked up to an abstract type, such as [Schema::Union.possible_types](rdoc-ref:Schema::Union.possible_types)
+      # or `Schema::Object.implements` (for interfaces).
+      #
+      # **Parameters**
       #
-      # @param abstract_type [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
-      # @param object_type [Class<GraphQL::Schema::Object>]
-      # @param options [Hash] Any options passed to `.possible_types` or `.implements`
+      # - `abstract_type` (`Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>`)
+      # - `object_type` (`Class<GraphQL::Schema::Object>`)
+      # - `options` (`Hash`) — Any options passed to `.possible_types` or `.implements`
+      #
+      # :call-seq:
+      #   initialize(Class[GraphQL::Schema::Union] | Module[GraphQL::Schema::Interface] abstract_type, Class[GraphQL::Schema::Object] object_type, Hash **options)
       def initialize(abstract_type, object_type, **options)
         @abstract_type = abstract_type
         @object_type = object_type
         @options = options
       end
 
-      # @return [Boolean] if false, {#object_type} will be treated as _not_ a member of {#abstract_type}
+      # **Returns**
+      #
+      # - `Boolean` — if false, [object type](rdoc-ref:#object_type) will be treated as _not_ a member of [abstract type](rdoc-ref:#abstract_type)
+      #
+      # :call-seq:
+      #   visible?(ctx) -> bool
       def visible?(ctx)
         warden = Warden.from_context(ctx)
         (@object_type.respond_to?(:visible?) ? warden.visible_type?(@object_type, ctx) : true) &&
@@ -45,7 +62,9 @@ module GraphQL
         "#<#{self.class} #{@object_type.inspect} => #{@abstract_type.inspect}>"
       end
 
-      alias :type_class :itself
+      def type_class
+        self
+      end
     end
   end
 end

data/lib/graphql/schema/union.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   class Schema
     class Union < GraphQL::Schema::Member
@@ -51,8 +52,7 @@ module GraphQL
         # Update a type membership whose `.object_type` is a string or late-bound type
         # so that the type membership's `.object_type` is the given `object_type`.
         # (This is used for updating the union after the schema as lazily loaded the union member.)
-        # @api private
-        def assign_type_membership_object_type(object_type)
+        def assign_type_membership_object_type(object_type) # :nodoc:
           assert_valid_union_member(object_type)
           type_memberships.each { |tm|
             possible_type = tm.object_type
@@ -72,11 +72,13 @@ module GraphQL
         def assert_valid_union_member(type_defn)
           case type_defn
           when Class
+            type_defn = type_defn #: as GraphQL::Schema::Member::type_definition
             if !type_defn.kind.object?
               raise ArgumentError, "Union possible_types can only be object types (not #{type_defn.kind.name}, #{type_defn.inspect})"
             end
           when Module
             # it's an interface type, defined as a module
+            type_defn = type_defn #: as GraphQL::Schema::Member::type_definition
             raise ArgumentError, "Union possible_types can only be object types (not interface types), remove #{type_defn.graphql_name} (#{type_defn.inspect})"
           when String, GraphQL::Schema::LateBoundType
             # Ok - assume it will get checked later

data/lib/graphql/schema/unique_within_type.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
+# typed: true
 require "base64"
 
 module GraphQL
   class Schema
+    #--
+    # @requires_ancestor: Kernel
     module UniqueWithinType
       class << self
         attr_accessor :default_id_separator
@@ -11,9 +14,17 @@ module GraphQL
 
       module_function
 
-      # @param type_name [String]
-      # @param object_value [Any]
-      # @return [String] a unique, opaque ID generated as a function of the two inputs
+      # **Parameters**
+      #
+      # - `type_name` (`String`)
+      # - `object_value` (`Any`)
+      #
+      # **Returns**
+      #
+      # - `String` — a unique, opaque ID generated as a function of the two inputs
+      #
+      # :call-seq:
+      #   encode(String type_name, Any object_value, separator:) -> String
       def encode(type_name, object_value, separator: self.default_id_separator)
         object_value_str = object_value.to_s
 
@@ -24,8 +35,16 @@ module GraphQL
         Base64.strict_encode64([type_name, object_value_str].join(separator))
       end
 
-      # @param node_id [String] A unique ID generated by {.encode}
-      # @return [Array<(String, String)>] The type name & value passed to {.encode}
+      # **Parameters**
+      #
+      # - `node_id` (`String`) — A unique ID generated by [.encode](rdoc-ref:.encode)
+      #
+      # **Returns**
+      #
+      # - `Array<(String, String)>` — The type name & value passed to [.encode](rdoc-ref:.encode)
+      #
+      # :call-seq:
+      #   decode(String node_id, separator:) -> Array[(String, String)]
       def decode(node_id, separator: self.default_id_separator)
         GraphQL::Schema::Base64Encoder.decode(node_id).split(separator, 2)
       end

data/lib/graphql/schema/validator/all_validator.rb

@@ -1,25 +1,33 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
     class Validator
       # Use this to validate each member of an array value.
       #
-      # @example validate format of all strings in an array
+      # **Examples**
       #
-      #   argument :handles, [String],
-      #     validates: { all: { format: { with: /\A[a-z0-9_]+\Z/ } } }
+      # **Example: validate format of all strings in an array**
       #
-      # @example multiple validators can be combined
+      # ```ruby
+      # argument :handles, [String],
+      #   validates: { all: { format: { with: /\A[a-z0-9_]+\Z/ } } }
+      # ```
       #
-      #   argument :handles, [String],
-      #     validates: { all: { format: { with: /\A[a-z0-9_]+\Z/ }, length: { maximum: 32 } } }
+      # **Example: multiple validators can be combined**
       #
-      # @example any type can be used
+      # ```ruby
+      # argument :handles, [String],
+      #   validates: { all: { format: { with: /\A[a-z0-9_]+\Z/ }, length: { maximum: 32 } } }
+      # ```
       #
-      #   argument :choices, [Integer],
-      #     validates: { all: { inclusion: { in: 1..12 } } }
+      # **Example: any type can be used**
       #
+      # ```ruby
+      # argument :choices, [Integer],
+      #   validates: { all: { inclusion: { in: 1..12 } } }
+      # ```
       class AllValidator < Validator
         def initialize(validated:, allow_blank: false, allow_null: false, **validators)
           super(validated: validated, allow_blank: allow_blank, allow_null: allow_null)

data/lib/graphql/schema/validator/allow_blank_validator.rb

@@ -1,12 +1,18 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
     class Validator
       # Use this to specifically reject values that respond to `.blank?` and respond truthy for that method.
       #
-      # @example Require a non-empty string for an argument
-      #   argument :name, String, required: true, validate: { allow_blank: false }
+      # **Examples**
+      #
+      # **Example: Require a non-empty string for an argument**
+      #
+      # ```ruby
+      # argument :name, String, required: true, validate: { allow_blank: false }
+      # ```
       class AllowBlankValidator < Validator
         def initialize(allow_blank_positional = nil, allow_blank: nil, message: "%{validated} can't be blank", **default_options)
           @message = message

data/lib/graphql/schema/validator/allow_null_validator.rb

@@ -1,12 +1,18 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
     class Validator
       # Use this to specifically reject or permit `nil` values (given as `null` from GraphQL).
       #
-      # @example require a non-null value for an argument if it is provided
-      #   argument :name, String, required: false, validates: { allow_null: false }
+      # **Examples**
+      #
+      # **Example: require a non-null value for an argument if it is provided**
+      #
+      # ```ruby
+      # argument :name, String, required: false, validates: { allow_null: false }
+      # ```
       class AllowNullValidator < Validator
         MESSAGE = "%{validated} can't be null"
         def initialize(allow_null_positional = nil, allow_null: nil, message: MESSAGE, **default_options)

data/lib/graphql/schema/validator/exclusion_validator.rb

@@ -1,18 +1,27 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
     class Validator
       # Use this to specifically reject values from an argument.
       #
-      # @example disallow certain values
+      # **Examples**
       #
-      #   argument :favorite_non_prime, Integer, required: true,
-      #     validates: { exclusion: { in: [2, 3, 5, 7, ... ]} }
+      # **Example: disallow certain values**
       #
+      # ```ruby
+      # argument :favorite_non_prime, Integer, required: true,
+      #   validates: { exclusion: { in: [2, 3, 5, 7, ... ]} }
+      # ```
       class ExclusionValidator < Validator
-        # @param message [String]
-        # @param in [Array] The values to reject
+        # **Parameters**
+        #
+        # - `message` (`String`)
+        # - `in` (`Array`) — The values to reject
+        #
+        # :call-seq:
+        #   initialize(String message:, Array in:, **default_options)
         def initialize(message: "%{validated} is reserved", in:, **default_options)
           # `in` is a reserved word, so work around that
           @in_list = binding.local_variable_get(:in)

data/lib/graphql/schema/validator/format_validator.rb

@@ -1,26 +1,37 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
     class Validator
       # Use this to assert that string values match (or don't match) the given RegExp.
       #
-      # @example requiring input to match a pattern
+      # **Examples**
       #
-      #   argument :handle, String, required: true,
-      #     validates: { format: { with: /\A[a-z0-9_]+\Z/ } }
+      # **Example: requiring input to match a pattern**
       #
-      # @example reject inputs that match a pattern
+      # ```ruby
+      # argument :handle, String, required: true,
+      #   validates: { format: { with: /\A[a-z0-9_]+\Z/ } }
+      # ```
       #
-      #   argument :word_that_doesnt_begin_with_a_vowel, String, required: true,
-      #     validates: { format: { without: /\A[aeiou]/ } }
+      # **Example: reject inputs that match a pattern**
       #
-      #   # It's pretty hard to come up with a legitimate use case for `without:`
+      # ```ruby
+      # argument :word_that_doesnt_begin_with_a_vowel, String, required: true,
+      #   validates: { format: { without: /\A[aeiou]/ } }
       #
+      # # It's pretty hard to come up with a legitimate use case for `without:`
+      # ```
       class FormatValidator < Validator
-        # @param with [RegExp, nil]
-        # @param without [Regexp, nil]
-        # @param message [String]
+        # **Parameters**
+        #
+        # - `with` (`RegExp, nil`)
+        # - `without` (`Regexp, nil`)
+        # - `message` (`String`)
+        #
+        # :call-seq:
+        #   initialize(RegExp | nil with:, Regexp | nil without:, String message:, **default_options)
         def initialize(
           with: nil,
           without: nil,

data/lib/graphql/schema/validator/inclusion_validator.rb

@@ -1,20 +1,29 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
     class Validator
       # You can use this to allow certain values for an argument.
       #
-      # Usually, a {GraphQL::Schema::Enum} is better for this, because it's self-documenting.
+      # Usually, a [GraphQL::Schema::Enum](rdoc-ref:GraphQL::Schema::Enum) is better for this, because it's self-documenting.
       #
-      # @example only allow certain values for an argument
+      # **Examples**
       #
-      #   argument :favorite_prime, Integer, required: true,
-      #     validates: { inclusion: { in: [2, 3, 5, 7, 11, ... ] } }
+      # **Example: only allow certain values for an argument**
       #
+      # ```ruby
+      # argument :favorite_prime, Integer, required: true,
+      #   validates: { inclusion: { in: [2, 3, 5, 7, 11, ... ] } }
+      # ```
       class InclusionValidator < Validator
-        # @param message [String]
-        # @param in [Array] The values to allow
+        # **Parameters**
+        #
+        # - `message` (`String`)
+        # - `in` (`Array`) — The values to allow
+        #
+        # :call-seq:
+        #   initialize(Array in:, String message:, **default_options)
         def initialize(in:, message: "%{validated} is not included in the list", **default_options)
           # `in` is a reserved word, so work around that
           @in_list = binding.local_variable_get(:in)

data/lib/graphql/schema/validator/length_validator.rb

@@ -1,27 +1,38 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
     class Validator
       # Use this to enforce a `.length` restriction on incoming values. It works for both Strings and Lists.
       #
-      # @example Allow no more than 10 IDs
+      # **Examples**
       #
-      #   argument :ids, [ID], required: true, validates: { length: { maximum: 10 } }
+      # **Example: Allow no more than 10 IDs**
       #
-      # @example Require three selections
+      # ```ruby
+      # argument :ids, [ID], required: true, validates: { length: { maximum: 10 } }
+      # ```
       #
-      #   argument :ice_cream_preferences, [ICE_CREAM_FLAVOR], required: true, validates: { length: { is: 3 } }
+      # **Example: Require three selections**
       #
+      # ```ruby
+      # argument :ice_cream_preferences, [ICE_CREAM_FLAVOR], required: true, validates: { length: { is: 3 } }
+      # ```
       class LengthValidator < Validator
-        # @param maximum [Integer]
-        # @param too_long [String] Used when `maximum` is exceeded or value is greater than `within`
-        # @param minimum [Integer]
-        # @param too_short [String] Used with value is less than `minimum` or less than `within`
-        # @param is [Integer] Exact length requirement
-        # @param wrong_length [String] Used when value doesn't match `is`
-        # @param within [Range] An allowed range (becomes `minimum:` and `maximum:` under the hood)
-        # @param message [String]
+        # **Parameters**
+        #
+        # - `maximum` (`Integer`)
+        # - `too_long` (`String`) — Used when `maximum` is exceeded or value is greater than `within`
+        # - `minimum` (`Integer`)
+        # - `too_short` (`String`) — Used with value is less than `minimum` or less than `within`
+        # - `is` (`Integer`) — Exact length requirement
+        # - `wrong_length` (`String`) — Used when value doesn't match `is`
+        # - `within` (`Range`) — An allowed range (becomes `minimum:` and `maximum:` under the hood)
+        # - `message` (`String`)
+        #
+        # :call-seq:
+        #   initialize(Integer maximum:, String too_long:)
         def initialize(
           maximum: nil, too_long: "%{validated} is too long (maximum is %{count})",
           minimum: nil, too_short: "%{validated} is too short (minimum is %{count})",

data/lib/graphql/schema/validator/numericality_validator.rb

@@ -1,32 +1,45 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   class Schema
     class Validator
       # Use this to assert numerical comparisons hold true for inputs.
       #
-      # @example Require a number between 0 and 1
+      # **Examples**
       #
-      #   argument :batting_average, Float, required: true, validates: { numericality: { within: 0..1 } }
+      # **Example: Require a number between 0 and 1**
       #
-      # @example Require the number 42
+      # ```ruby
+      # argument :batting_average, Float, required: true, validates: { numericality: { within: 0..1 } }
+      # ```
       #
-      #   argument :the_answer, Integer, required: true, validates: { numericality: { equal_to: 42 } }
+      # **Example: Require the number 42**
       #
-      # @example Require a real number
+      # ```ruby
+      # argument :the_answer, Integer, required: true, validates: { numericality: { equal_to: 42 } }
+      # ```
       #
-      #   argument :items_count, Integer, required: true, validates: { numericality: { greater_than_or_equal_to: 0 } }
+      # **Example: Require a real number**
       #
+      # ```ruby
+      # argument :items_count, Integer, required: true, validates: { numericality: { greater_than_or_equal_to: 0 } }
+      # ```
       class NumericalityValidator < Validator
-        # @param greater_than [Integer]
-        # @param greater_than_or_equal_to [Integer]
-        # @param less_than [Integer]
-        # @param less_than_or_equal_to [Integer]
-        # @param equal_to [Integer]
-        # @param other_than [Integer]
-        # @param odd [Boolean]
-        # @param even [Boolean]
-        # @param within [Range]
-        # @param message [String] used for all validation failures
+        # **Parameters**
+        #
+        # - `greater_than` (`Integer`)
+        # - `greater_than_or_equal_to` (`Integer`)
+        # - `less_than` (`Integer`)
+        # - `less_than_or_equal_to` (`Integer`)
+        # - `equal_to` (`Integer`)
+        # - `other_than` (`Integer`)
+        # - `odd` (`Boolean`)
+        # - `even` (`Boolean`)
+        # - `within` (`Range`)
+        # - `message` (`String`) — used for all validation failures
+        #
+        # :call-seq:
+        #   initialize(Integer greater_than:, Integer greater_than_or_equal_to:, Integer less_than:, Integer less_than_or_equal_to:, Integer equal_to:, Integer other_than:, bool odd:, bool even:, Range within:, String message:, null_message:, **default_options)
         def initialize(
             greater_than: nil, greater_than_or_equal_to: nil,
             less_than: nil, less_than_or_equal_to: nil,