grape-oas 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f97a967ef31212399ee7765f184a358e755b4364578cbc43d3fdaf75a919638
-  data.tar.gz: c56afb98329feaa1227d6ee252cbf5866ddc0144eac15dc6db8e34f9718d4731
+  metadata.gz: e5289691e338b77f7408ed384429c297bfcac143962085e4b02edc1b980b35ff
+  data.tar.gz: 1d03adce8e12922b769ce6679013d14cb4e9bb4bc3ceaa2a6d4fdc2a26d34625
 SHA512:
-  metadata.gz: efed55aaa9f34d9045e495b2c8cbccea7b4da8381b4d2c58628e20785947319f42cc3a1e9952bac87219cb290cdbb81ac31bca7107acc3be3db13e027087c1ac
-  data.tar.gz: aa0eebcf7dd0b7122346150adfdf6e5dbfc8ed0287470ecedfe18ff9a95afca3376479899e0dc1e6298be3e65da3711238988b329839b4af68d48dd622bcd1f0
+  metadata.gz: 850eee859637b8e5cab7606b8819931c5b59479aeab6247907fde7578c43b613694a0ab7b2ffb24c1530ac1e878982f555810a7afb83b34cf378d2f6b35cc020
+  data.tar.gz: 1298c51a115ec42502e011e50b41ae3b9bf9a553c834c49b7c3b628d285b7e2853ee8251cf55c742766d951f2ecfc525252aee1950a61ffe8fbd064a84550110

data/CHANGELOG.md

@@ -5,6 +5,32 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+
+## [1.3.0] - 2026-03-27
+
+### Added
+
+- [#48](https://github.com/numbata/grape-oas/pull/48): Add configurable `GrapeOAS.logger` for schema generation warnings - [@numbata](https://github.com/numbata).
+- [#43](https://github.com/numbata/grape-oas/pull/43): Bump actions/upload-artifact from 6 to 7 - [@dependabot[bot]](https://github.com/dependabot[bot]).
+- [#51](https://github.com/numbata/grape-oas/pull/51): Add inline nesting exposure support — block-based `expose :key do ... end` now produces inline object schemas with preserved enum values, min/max constraints, and metadata - [@numbata](https://github.com/numbata).
+
+### Changed
+
+- [#52](https://github.com/numbata/grape-oas/pull/52): Extract `SchemaConstraints` — centralizes numeric/string constraint application (min/max, exclusive flags, length, pattern) and adds `exclusive_minimum`/`exclusive_maximum` support - [@numbata](https://github.com/numbata).
+- [#50](https://github.com/numbata/grape-oas/pull/50): Extract `ValuesNormalizer` — consolidates Proc/Set/Hash value normalization into a single module used by both request params and entity exposures - [@numbata](https://github.com/numbata).
+
+### Fixed
+
+- [#55](https://github.com/numbata/grape-oas/pull/55): Preserve enum values on cached entity schemas — dup the shared schema before applying enum instead of silently discarding the constraint; emit a warning naming the entity - [@numbata](https://github.com/numbata).
+- [#56](https://github.com/numbata/grape-oas/pull/56): Make `NestingMerger` depth-cap warning actionable — include property name and depth cap value in the message - [@numbata](https://github.com/numbata).
+- [#50](https://github.com/numbata/grape-oas/pull/50): Fix `[false]` enum silently dropped — `[false].any?` returns `false` in Ruby, causing boolean-only enum constraints to be discarded - [@numbata](https://github.com/numbata).
+
+- [#49](https://github.com/numbata/grape-oas/pull/49): Fix OOM on wide string range expansion in `values:` — replace unbounded `range.to_a` with bounded enumeration; non-numeric ranges on numeric schemas and numeric ranges on non-numeric schemas now warn and are ignored instead of silently producing invalid output - [@numbata](https://github.com/numbata).
+- [#46](https://github.com/numbata/grape-oas/pull/46): Fix `is_array: true` in request param documentation being ignored for primitive types — only entity types were wrapped in array schema - [@numbata](https://github.com/numbata).
+- [#42](https://github.com/numbata/grape-oas/pull/42): Fix array items `description` and `nullable` placement — hoist to outer array schema instead of wrapping `items` in `allOf`; fix `:description` field naming collision in `PropertyExtractor` - [@numbata](https://github.com/numbata).
+- [#44](https://github.com/numbata/grape-oas/pull/44): Fix RuboCop 1.85 offenses - [@numbata](https://github.com/numbata).
+- [#47](https://github.com/numbata/grape-oas/pull/47): Fix duplicate entries in `Schema#required` array when the same property is added multiple times with `required: true` - [@numbata](https://github.com/numbata).
+
 ## [1.2.0] - 2026-03-02
 
 ### Added

data/README.md

@@ -150,6 +150,12 @@ class Entity::User < Grape::Entity
   expose :id, documentation: { type: Integer }
   expose :name, documentation: { type: String }
   expose :posts, using: Entity::Post, documentation: { is_array: true }
+
+  # Block-based nesting produces an inline object schema
+  expose :meta do
+    expose :role, documentation: { type: String, values: %w[admin user guest] }
+    expose :verified, documentation: { type: 'Boolean' }
+  end
 end
 ```
 

data/lib/grape_oas/api_model/schema.rb

@@ -51,10 +51,25 @@ module GrapeOAS
       end
 
       def add_property(name, schema, required: false)
-        @properties[name.to_s] = schema
-        @required << name.to_s if required
+        key = name.to_s
+        @properties[key] = schema
+        @required << key if required && !@required.include?(key)
         schema
       end
+
+      protected
+
+      # Ensure dup produces an independent copy — without this, the shallow
+      # copy shares @properties, @required, and @defs with the original.
+      # Property values are duped one level deep (via transform_values(&:dup)),
+      # which triggers initialize_copy recursively on each nested Schema,
+      # producing a full deep copy of the property tree.
+      def initialize_copy(source)
+        super
+        @properties = source.properties.transform_values(&:dup)
+        @required   = source.required.dup
+        @defs       = source.defs.dup
+      end
     end
   end
 end

data/lib/grape_oas/api_model_builders/request_params_support/param_schema_builder.rb

@@ -33,6 +33,7 @@ module GrapeOAS
 
           return build_entity_array_schema(spec, raw_type, doc_type) if entity_array_type?(type_source, doc_type, spec)
           return build_doc_entity_array_schema(doc_type) if doc[:is_array] && grape_entity?(doc_type)
+          return build_primitive_array_schema(doc_type, raw_type) if doc[:is_array]
           return build_entity_schema(doc_type) if grape_entity?(doc_type)
           return build_entity_schema(raw_type) if grape_entity?(raw_type)
           return build_elements_array_schema(spec) if array_with_elements?(raw_type, spec)
@@ -92,6 +93,15 @@ module GrapeOAS
           ApiModel::Schema.new(type: Constants::SchemaTypes::ARRAY, items: items_schema)
         end
 
+        def build_primitive_array_schema(doc_type, raw_type)
+          type_source = doc_type || raw_type
+          item_type = resolve_schema_type(type_source)
+          ApiModel::Schema.new(
+            type: Constants::SchemaTypes::ARRAY,
+            items: ApiModel::Schema.new(type: item_type, format: Constants.format_for_type(type_source)),
+          )
+        end
+
         def build_simple_array_schema
           ApiModel::Schema.new(
             type: Constants::SchemaTypes::ARRAY,
@@ -191,7 +201,7 @@ module GrapeOAS
           klass = Object.const_get(const_name, false)
           klass if klass.is_a?(Class) && klass <= Grape::Entity
         rescue NameError => e
-          warn "[grape-oas] Could not resolve entity constant '#{const_name}': #{e.message}"
+          GrapeOAS.logger.warn("Could not resolve entity constant '#{const_name}': #{e.message}")
           nil
         end
       end

data/lib/grape_oas/api_model_builders/request_params_support/schema_enhancer.rb

@@ -19,7 +19,7 @@ module GrapeOAS
 
           apply_additional_properties(schema, doc)
           apply_format_and_example(schema, doc)
-          apply_constraints(schema, doc)
+          SchemaConstraints.apply(schema, doc)
           apply_values(schema, spec)
         end
 
@@ -50,40 +50,25 @@ module GrapeOAS
             schema.examples = doc[:example] if doc[:example] && schema.respond_to?(:examples=)
           end
 
-          def apply_constraints(schema, doc)
-            schema.minimum = doc[:minimum] if doc.key?(:minimum) && schema.respond_to?(:minimum=)
-            schema.maximum = doc[:maximum] if doc.key?(:maximum) && schema.respond_to?(:maximum=)
-            schema.min_length = doc[:min_length] if doc.key?(:min_length) && schema.respond_to?(:min_length=)
-            schema.max_length = doc[:max_length] if doc.key?(:max_length) && schema.respond_to?(:max_length=)
-            schema.pattern = doc[:pattern] if doc.key?(:pattern) && schema.respond_to?(:pattern=)
-          end
-
-          # Applies values from spec[:values] - converts Range to min/max,
-          # evaluates Proc (arity 0), and sets enum for arrays.
-          # Skips Proc/Lambda validators (arity > 0) used for custom validation.
-          # For array schemas, applies enum to items (since values constrain array elements).
-          # For oneOf schemas, applies enum to each non-null variant.
           def apply_values(schema, spec)
-            values = spec[:values]
+            values = ValuesNormalizer.normalize(spec[:values], context: "parameter values")
             return unless values
 
-            # Handle Hash format { value: ..., message: ... } - extract the value
-            values = values[:value] if values.is_a?(Hash) && values.key?(:value)
-
-            # Handle Proc/Lambda
-            if values.respond_to?(:call)
-              # Skip validators (arity > 0) - they validate individual values
-              return if values.arity != 0
-
-              # Evaluate arity-0 procs - they return enum arrays
-              values = values.call
-            end
-
             if values.is_a?(Range)
-              apply_range_values(schema, values)
-            else
-              enum_values = defined?(Set) && values.is_a?(Set) ? values.to_a : values
-              apply_enum_values(schema, enum_values) if enum_values.is_a?(Array) && enum_values.any?
+              if one_of_schema?(schema)
+                schema.one_of.each do |variant|
+                  next if null_type_schema?(variant)
+                  next unless range_compatible_with_schema?(values, variant)
+
+                  RangeUtils.apply_to_schema(variant, values)
+                end
+              elsif array_schema_with_items?(schema)
+                RangeUtils.apply_to_schema(schema.items, values)
+              else
+                RangeUtils.apply_to_schema(schema, values)
+              end
+            elsif values.is_a?(Array) && !values.empty?
+              apply_enum_values(schema, values)
             end
           end
 
@@ -98,7 +83,7 @@ module GrapeOAS
                 compatible_values = filter_compatible_values(variant, values)
 
                 # Only apply enum if there are compatible values
-                variant.enum = compatible_values if compatible_values.any? && variant.respond_to?(:enum=)
+                variant.enum = compatible_values if !compatible_values.empty? && variant.respond_to?(:enum=)
               end
             elsif array_schema_with_items?(schema)
               # For array schemas, apply enum to items (values constrain array elements)
@@ -110,7 +95,7 @@ module GrapeOAS
           end
 
           def one_of_schema?(schema)
-            schema.respond_to?(:one_of) && schema.one_of.is_a?(Array) && schema.one_of.any?
+            schema.respond_to?(:one_of) && schema.one_of.is_a?(Array) && !schema.one_of.empty?
           end
 
           def null_type_schema?(schema)
@@ -159,26 +144,14 @@ module GrapeOAS
             end
           end
 
-          # Converts a Range to minimum/maximum constraints.
-          # For numeric ranges (Integer, Float), uses min/max.
-          # For other ranges (e.g., 'a'..'z'), expands to enum array.
-          # Handles endless/beginless ranges (e.g., 1.., ..10).
-          def apply_range_values(schema, range)
-            first_val = range.begin
-            last_val = range.end
-
-            if first_val.is_a?(Numeric) || last_val.is_a?(Numeric)
-              schema.minimum = first_val if first_val && schema.respond_to?(:minimum=)
-              schema.maximum = last_val if last_val && schema.respond_to?(:maximum=)
-            elsif first_val && last_val && schema.respond_to?(:enum=)
-              # Non-numeric bounded range (e.g., 'a'..'z') - expand to enum
-              schema.enum = range.to_a
-            end
-          end
-
           def extract_defs(doc)
             doc[:defs] || doc[:$defs]
           end
+
+          def range_compatible_with_schema?(range, schema)
+            numeric_type = RangeUtils::NUMERIC_TYPES.include?(schema.type)
+            RangeUtils.numeric_range?(range) ? numeric_type : !numeric_type
+          end
         end
       end
     end

data/lib/grape_oas/constants.rb

@@ -47,6 +47,10 @@ module GrapeOAS
       EXTENSION = :extension
     end
 
+    # Maximum number of elements to expand from a non-numeric Range into an enum array.
+    # Prevents OOM on wide string ranges (e.g. "a".."zzzzzz").
+    MAX_ENUM_RANGE_SIZE = 100
+
     # Default values for OpenAPI spec when not provided by user
     module Defaults
       LICENSE_NAME = "Proprietary"

data/lib/grape_oas/doc_key_normalizer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module GrapeOAS
+  # Normalizes documentation hash keys so callers can use symbol access
+  # uniformly. String keys that look like OpenAPI extensions ("x-*") are
+  # kept as strings; all other keys are converted to symbols.
+  module DocKeyNormalizer
+    def self.normalize(doc)
+      return doc if doc.empty?
+
+      doc.transform_keys { |k| k.to_s.start_with?("x-") ? k.to_s : k.to_sym }
+    end
+  end
+end

data/lib/grape_oas/exporter/oas2/schema.rb

@@ -33,9 +33,19 @@ module GrapeOAS
             "format" => @schema.format,
             "description" => @schema.description&.to_s,
             "properties" => build_properties(@schema.properties),
-            "items" => (@schema.items ? build_schema_or_ref(@schema.items) : nil),
             "enum" => normalize_enum(@schema.enum, @schema.type)
           }
+          if @schema.items
+            schema_hash["items"] = build_schema_or_ref(@schema.items, include_metadata: false)
+            if !schema_hash["description"] && @schema.items.respond_to?(:description) && @schema.items.description
+              schema_hash["description"] = @schema.items.description.to_s
+            end
+            if @schema.items.respond_to?(:canonical_name) && @schema.items.canonical_name &&
+               @nullable_strategy == Constants::NullableStrategy::EXTENSION &&
+               @schema.items.respond_to?(:nullable) && @schema.items.nullable
+              schema_hash["x-nullable"] = true
+            end
+          end
           if schema_hash["properties"].nil? || schema_hash["properties"].empty? || @schema.type != Constants::SchemaTypes::OBJECT
             schema_hash.delete("properties")
           end
@@ -90,6 +100,7 @@ module GrapeOAS
 
           result = { "allOf" => all_of_items }
           result["description"] = @schema.description.to_s if @schema.description
+          result["x-nullable"] = true if @nullable_strategy == Constants::NullableStrategy::EXTENSION && nullable?
           result
         end
 
@@ -102,11 +113,13 @@ module GrapeOAS
           end
         end
 
-        def build_schema_or_ref(schema)
+        def build_schema_or_ref(schema, include_metadata: true)
           if schema.respond_to?(:canonical_name) && schema.canonical_name
             @ref_tracker << schema.canonical_name if @ref_tracker
             ref_name = schema.canonical_name.gsub("::", "_")
             ref_hash = { "$ref" => "#/definitions/#{ref_name}" }
+            return ref_hash unless include_metadata
+
             result = {}
             if @nullable_strategy == Constants::NullableStrategy::EXTENSION && schema.respond_to?(:nullable) && schema.nullable
               result["x-nullable"] = true
@@ -119,7 +132,9 @@ module GrapeOAS
               result
             end
           else
-            Schema.new(schema, @ref_tracker, nullable_strategy: @nullable_strategy).build
+            built = Schema.new(schema, @ref_tracker, nullable_strategy: @nullable_strategy).build
+            built.delete("description") unless include_metadata
+            built
           end
         end
 

data/lib/grape_oas/exporter/oas3/schema.rb

@@ -32,7 +32,23 @@ module GrapeOAS
           apply_nullable(schema_hash)
           props = build_properties(@schema.properties)
           schema_hash["properties"] = props if props
-          schema_hash["items"] = @schema.items ? build_schema_or_ref(@schema.items) : nil
+          if @schema.items
+            schema_hash["items"] = build_schema_or_ref(@schema.items, include_metadata: false)
+            if !schema_hash["description"] && @schema.items.respond_to?(:description) && @schema.items.description
+              schema_hash["description"] = @schema.items.description.to_s
+            end
+            if @schema.items.respond_to?(:canonical_name) && @schema.items.canonical_name &&
+               @schema.items.respond_to?(:nullable) && @schema.items.nullable
+              case @nullable_strategy
+              when Constants::NullableStrategy::KEYWORD
+                schema_hash["nullable"] = true
+              when Constants::NullableStrategy::EXTENSION
+                schema_hash["x-nullable"] = true
+              when Constants::NullableStrategy::TYPE_ARRAY
+                schema_hash["type"] = (Array(schema_hash["type"]) | ["null"])
+              end
+            end
+          end
           schema_hash["required"] = @schema.required if @schema.required && !@schema.required.empty?
           schema_hash["enum"] = normalize_enum(@schema.enum, schema_hash["type"]) if @schema.enum
           schema_hash
@@ -72,6 +88,7 @@ module GrapeOAS
 
           result = { "allOf" => all_of_items }
           result["description"] = @schema.description.to_s if @schema.description
+          apply_nullable(result)
           result
         end
 
@@ -84,6 +101,7 @@ module GrapeOAS
           result = { "oneOf" => one_of_items }
           result["description"] = @schema.description.to_s if @schema.description
           result["discriminator"] = build_discriminator if @schema.discriminator
+          apply_nullable(result)
           result
         end
 
@@ -96,6 +114,7 @@ module GrapeOAS
           result = { "anyOf" => any_of_items }
           result["description"] = @schema.description.to_s if @schema.description
           result["discriminator"] = build_discriminator if @schema.discriminator
+          apply_nullable(result)
           result
         end
 
@@ -146,11 +165,13 @@ module GrapeOAS
           end
         end
 
-        def build_schema_or_ref(schema)
+        def build_schema_or_ref(schema, include_metadata: true)
           if schema.respond_to?(:canonical_name) && schema.canonical_name
             @ref_tracker << schema.canonical_name if @ref_tracker
             ref_name = schema.canonical_name.gsub("::", "_")
             ref_hash = { "$ref" => "#/components/schemas/#{ref_name}" }
+            return ref_hash unless include_metadata
+
             result = {}
             result["description"] = schema.description.to_s if schema.description
             apply_nullable_to_ref(result, schema)
@@ -161,10 +182,16 @@ module GrapeOAS
               result
             end
           else
-            Schema.new(schema, @ref_tracker, nullable_strategy: @nullable_strategy).build
+            built = Schema.new(schema, @ref_tracker, nullable_strategy: @nullable_strategy).build
+            strip_items_metadata(built) unless include_metadata
+            built
           end
         end
 
+        def strip_items_metadata(hash)
+          hash.delete("description")
+        end
+
         def apply_nullable_to_ref(result, schema)
           return unless schema.respond_to?(:nullable) && schema.nullable
 
@@ -244,13 +271,13 @@ module GrapeOAS
           when Constants::SchemaTypes::ARRAY, Constants::SchemaTypes::OBJECT, nil
             hash.delete("enum")
           when Constants::SchemaTypes::INTEGER
-            hash.delete("enum") unless enum_vals.all? { |v| v.is_a?(Integer) }
+            hash.delete("enum") unless enum_vals.all?(Integer)
           when Constants::SchemaTypes::NUMBER
-            hash.delete("enum") unless enum_vals.all? { |v| v.is_a?(Numeric) }
+            hash.delete("enum") unless enum_vals.all?(Numeric)
           when Constants::SchemaTypes::BOOLEAN
             hash.delete("enum") unless enum_vals.all? { |v| [true, false].include?(v) }
           else # string and fallback
-            hash.delete("enum") unless enum_vals.all? { |v| v.is_a?(String) }
+            hash.delete("enum") unless enum_vals.all?(String)
           end
         end
 

data/lib/grape_oas/introspectors/dry_introspector_support/argument_extractor.rb

@@ -13,8 +13,6 @@ module GrapeOAS
         LITERAL_TAGS = %i[value val literal class left right].freeze
         # AST node tags for regex patterns
         PATTERN_TAGS = %i[regexp regex].freeze
-        # Maximum size for converting ranges to enum arrays
-        MAX_ENUM_RANGE_SIZE = 100
 
         def extract_numeric(arg)
           return arg if arg.is_a?(Numeric)
@@ -36,43 +34,16 @@ module GrapeOAS
         def extract_list(arg)
           if list_node?(arg)
             inner = arg[1]
-            # For non-numeric ranges (e.g., 'a'..'z'), expand to array
-            # Numeric ranges should use min/max constraints instead
-            return range_to_enum_array(inner) if inner.is_a?(Range)
+            return RangeUtils.expand_range_to_enum(inner) if inner.is_a?(Range)
 
             return inner
           end
           return arg if arg.is_a?(Array)
-          return range_to_enum_array(arg) if arg.is_a?(Range)
+          return RangeUtils.expand_range_to_enum(arg) if arg.is_a?(Range)
 
           nil
         end
 
-        # Converts a non-numeric bounded Range to an array for enum values.
-        # Returns nil for numeric ranges (should use min/max instead).
-        # Returns nil for unbounded (endless/beginless) or excessively large ranges.
-        def range_to_enum_array(range)
-          # Reject unbounded ranges (endless/beginless)
-          return nil if range.begin.nil? || range.end.nil?
-
-          # Numeric ranges should use min/max constraints, not enum
-          return nil if range.begin.is_a?(Numeric) || range.end.is_a?(Numeric)
-
-          # Use bounded iteration to avoid memory exhaustion on large ranges.
-          # Take one more than max to detect oversized ranges without full enumeration.
-          begin
-            array = range.take(MAX_ENUM_RANGE_SIZE + 1)
-          rescue TypeError
-            # Range can't be iterated (e.g., non-discrete types)
-            return nil
-          end
-
-          # Reject ranges exceeding the size limit
-          return nil if array.size > MAX_ENUM_RANGE_SIZE
-
-          array
-        end
-
         def extract_literal(arg)
           return arg unless arg.is_a?(Array)
           return arg[1] if arg.length == 2 && LITERAL_TAGS.include?(arg.first)

data/lib/grape_oas/introspectors/dry_introspector_support/constraint_extractor.rb

@@ -7,25 +7,16 @@ module GrapeOAS
       # Delegates AST walking to AstWalker and merging to ConstraintMerger.
       class ConstraintExtractor
         # Value object holding all possible constraints extracted from a Dry contract.
-        ConstraintSet = Struct.new(
-          :enum,
-          :nullable,
-          :min_size,
-          :max_size,
-          :minimum,
-          :maximum,
-          :exclusive_minimum,
-          :exclusive_maximum,
-          :pattern,
-          :excluded_values,
-          :unhandled_predicates,
-          :required,
-          :type_predicate,
-          :parity,
-          :format,
-          :extensions,
-          keyword_init: true,
-        )
+        class ConstraintSet
+          attr_accessor :enum, :nullable, :min_size, :max_size,
+                        :minimum, :maximum, :exclusive_minimum, :exclusive_maximum,
+                        :pattern, :excluded_values, :unhandled_predicates,
+                        :required, :type_predicate, :parity, :format, :extensions
+
+          def initialize(**attrs)
+            attrs.each { |k, v| public_send(:"#{k}=", v) }
+          end
+        end
 
         def self.extract(contract)
           new(contract).extract

data/lib/grape_oas/introspectors/dry_introspector_support/predicate_handler.rb

@@ -83,15 +83,7 @@ module GrapeOAS
           return if rng.begin && !rng.begin.is_a?(Numeric)
           return if rng.end && !rng.end.is_a?(Numeric)
 
-          apply_range_constraints(rng)
-        end
-
-        def apply_range_constraints(rng)
-          return unless rng
-
-          constraints.minimum = rng.begin if rng.begin
-          constraints.maximum = rng.end if rng.end
-          constraints.exclusive_maximum = rng.exclude_end? if rng.end
+          RangeUtils.apply_numeric_range(constraints, rng)
         end
 
         def apply_excluded_from_list(args)
@@ -135,7 +127,7 @@ module GrapeOAS
 
         def handle_range(args)
           rng = ArgumentExtractor.extract_range(args.first)
-          apply_range_constraints(rng)
+          RangeUtils.apply_numeric_range(constraints, rng) if rng
         end
 
         def handle_multiple_of(args)

data/lib/grape_oas/introspectors/entity_introspector_support/discriminator_handler.rb

@@ -5,26 +5,12 @@ module GrapeOAS
     module EntityIntrospectorSupport
       # Handles discriminator fields in entity inheritance for polymorphic schemas.
       class DiscriminatorHandler
-        # Checks if an entity inherits from a parent that uses discriminator.
-        #
-        # @param entity_class [Class] the entity class to check
-        # @return [Boolean] true if parent has a discriminator field
-        def self.inherits_with_discriminator?(entity_class)
-          parent = find_parent_entity(entity_class)
-          parent && new(parent).discriminator?
-        end
-
         # Finds the parent entity class if one exists.
         #
         # @param entity_class [Class] the entity class
         # @return [Class, nil] the parent entity class or nil
         def self.find_parent_entity(entity_class)
-          return nil unless defined?(Grape::Entity)
-
-          parent = entity_class.superclass
-          return nil unless parent && parent < Grape::Entity && parent != Grape::Entity
-
-          parent
+          EntityIntrospectorSupport.find_parent_entity(entity_class)
         end
 
         def initialize(entity_class)
@@ -65,17 +51,8 @@ module GrapeOAS
 
         private
 
-        # Gets the exposures defined on the entity class.
-        #
-        # @return [Array] list of entity exposures
         def exposures
-          return [] unless @entity_class.respond_to?(:root_exposures)
-
-          root = @entity_class.root_exposures
-          list = root.instance_variable_get(:@exposures) || []
-          Array(list)
-        rescue NoMethodError
-          []
+          EntityIntrospectorSupport.exposures(@entity_class)
         end
       end
     end