grape-oas 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5289691e338b77f7408ed384429c297bfcac143962085e4b02edc1b980b35ff
-  data.tar.gz: 1d03adce8e12922b769ce6679013d14cb4e9bb4bc3ceaa2a6d4fdc2a26d34625
+  metadata.gz: 585f37dd85b6630ef0d9599e3c1a02172cda35ff81ba6b9782e500d6bdaf8115
+  data.tar.gz: b7e2cec6f5c24f7927e7290c87dffd2a488fe77768c039d9bc711cc79e868373
 SHA512:
-  metadata.gz: 850eee859637b8e5cab7606b8819931c5b59479aeab6247907fde7578c43b613694a0ab7b2ffb24c1530ac1e878982f555810a7afb83b34cf378d2f6b35cc020
-  data.tar.gz: 1298c51a115ec42502e011e50b41ae3b9bf9a553c834c49b7c3b628d285b7e2853ee8251cf55c742766d951f2ecfc525252aee1950a61ffe8fbd064a84550110
+  metadata.gz: 74106be01a4e9d0a9625d4b328df7b319de5dfe1da3d74d37f605d9328eb7fe200dccc761a865a66963797ad209871f71402f0c601e7f9d27ef9fbfe23408c69
+  data.tar.gz: fbc867bb5e8167fe096a6024285986ac410385b3bc07cdca2b1c62c73bb0cbd7a4e9e1f0dff271212637dac1ac43842e8417d36b93bc39984d396cc8cd9329f3

data/CHANGELOG.md

@@ -5,6 +5,22 @@ 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.4.0] - 2026-04-23
+
+### Fixed
+
+- [#60](https://github.com/numbata/grape-oas/pull/60): Fix `Dangerfile` to properly look for tests - [@olivier-thatch](https://github.com/olivier-thatch).
+- [#58](https://github.com/numbata/grape-oas/pull/58): Fix contract extraction compatibility with Grape 3.2 - [@numbata](https://github.com/numbata).
+- [#57](https://github.com/numbata/grape-oas/pull/57): Fix `Array<Array<...>>` double-wrap when `is_array: true` is used with typed array notation like `type: [String]` — the redundant `is_array` flag no longer produces a nested array schema - [@numbata](https://github.com/numbata).
+- [#59](https://github.com/numbata/grape-oas/pull/59): Export `default` param values to OAS2 and OAS3 output - [@olivier-thatch](https://github.com/olivier-thatch).
+- [#61](https://github.com/numbata/grape-oas/pull/61): Respect `entity_name` on `grape::entity` subclasses - [@olivier-thatch](https://github.com/olivier-thatch).
+- [#68](https://github.com/numbata/grape-oas/pull/68): De-duplicate parameter `description` between the Parameter Object and its nested `schema` in OAS 3 output - [@olivier-thatch](https://github.com/olivier-thatch).
+- [#70](https://github.com/numbata/grape-oas/pull/70): Propagate schema attributes (`default`, `enum`, constraints, extensions) through `$ref` and composition paths - [@numbata](https://github.com/numbata).
+
+### Changed
+
+- [#64](https://github.com/numbata/grape-oas/pull/64): Memoize content-type and default-format resolution per generation — eliminates redundant calls that scaled with route × response count - [@JuniorJoanis](https://github.com/JuniorJoanis).
+- [#62](https://github.com/numbata/grape-oas/pull/62): Default to body params for post/put/patch routes - [@olivier-thatch](https://github.com/olivier-thatch).
 
 ## [1.3.0] - 2026-03-27
 

data/lib/grape_oas/api_model/api.rb

@@ -38,6 +38,10 @@ module GrapeOAS
       def add_tags(*tags)
         @tag_defs.merge(tags)
       end
+
+      def builder_cache
+        @builder_cache ||= {}
+      end
     end
   end
 end

data/lib/grape_oas/api_model/schema.rb

@@ -11,7 +11,7 @@ module GrapeOAS
       VALID_ATTRIBUTES = %i[
         canonical_name type format properties items description
         required nullable enum additional_properties unevaluated_properties defs
-        examples extensions
+        examples default extensions
         min_length max_length pattern
         minimum maximum exclusive_minimum exclusive_maximum
         min_items max_items

data/lib/grape_oas/api_model_builders/concerns/content_type_resolver.rb

@@ -57,6 +57,16 @@ module GrapeOAS
         end
 
         def default_format_from_app_or_api
+          return uncached_default_format_from_app_or_api unless api.respond_to?(:builder_cache)
+
+          cache = api.builder_cache
+          key = [:default_format, app.object_id]
+          return cache[key] if cache.key?(key)
+
+          cache[key] = uncached_default_format_from_app_or_api
+        end
+
+        def uncached_default_format_from_app_or_api
           return api.default_format if api.respond_to?(:default_format)
           return app.default_format if app_responds_to?(:default_format)
 
@@ -66,6 +76,17 @@ module GrapeOAS
         end
 
         def content_types_from_app_or_api(default_format)
+          return uncached_content_types_from_app_or_api(default_format) unless api.respond_to?(:builder_cache)
+
+          cache = api.builder_cache
+          key = [:content_types, app.object_id, default_format]
+          return cache[key] if cache.key?(key)
+
+          value = uncached_content_types_from_app_or_api(default_format)
+          cache[key] = value.is_a?(Hash) ? value.dup.freeze : value
+        end
+
+        def uncached_content_types_from_app_or_api(default_format)
           source = if api.respond_to?(:content_types)
                      api.content_types
                    elsif app_responds_to?(:content_types)

data/lib/grape_oas/api_model_builders/concerns/type_resolver.rb

@@ -12,11 +12,8 @@ module GrapeOAS
       # Centralizes Ruby type to OpenAPI schema type resolution.
       # Used by request builders and introspectors to avoid duplicated type switching logic.
       module TypeResolver
-        # Regex to match Grape's typed array notation like "[String]", "[Integer]", "[MyModule::MyType]"
-        TYPED_ARRAY_PATTERN = /\A\[(\w+(?:::\w+)*)\]\z/
-
-        # Regex to match Grape's multi-type notation like "[String, Integer]", "[String, Float]"
-        MULTI_TYPE_PATTERN = /\A\[(\w+(?:::\w+)*(?:,\s*\w+(?:::\w+)*)+)\]\z/
+        TYPED_ARRAY_PATTERN = Constants::TypePatterns::TYPED_ARRAY
+        MULTI_TYPE_PATTERN = Constants::TypePatterns::MULTI_TYPE
 
         # Resolves a Ruby class or type name to its OpenAPI schema type string.
         # Handles both Ruby classes (Integer, Float) and string type names ("integer", "float").
@@ -65,7 +62,7 @@ module GrapeOAS
           return nil unless type.is_a?(String)
 
           match = type.match(TYPED_ARRAY_PATTERN)
-          match ? match[1] : nil
+          match ? match[:inner] : nil
         end
 
         # Checks if type is a multi-type notation like "[String, Integer]"

data/lib/grape_oas/api_model_builders/request.rb

@@ -134,20 +134,29 @@ module GrapeOAS
         validations = setting.route[:saved_validations]
         return unless validations.is_a?(Array)
 
-        # Find ContractScopeValidator which holds the Dry contract/schema
-        contract_validation = validations.find do |v|
-          next unless v.is_a?(Hash)
-
-          validator_class = v[:validator_class]
-          validator_class.is_a?(Class) &&
-            defined?(Grape::Validations::Validators::ContractScopeValidator) &&
-            validator_class <= Grape::Validations::Validators::ContractScopeValidator
-        end
+        # Find ContractScopeValidator which holds the Dry contract/schema.
+        # Grape < 3.2 stores hashes: {validator_class: ..., opts: {schema: ...}}
+        # Grape >= 3.2 stores validator instances directly (instantiated at definition time)
+        return unless defined?(Grape::Validations::Validators::ContractScopeValidator)
 
-        return unless contract_validation
+        validations.each do |v|
+          case v
+          when Hash
+            next unless v[:validator_class].is_a?(Class) &&
+                        v[:validator_class] <= Grape::Validations::Validators::ContractScopeValidator
+
+            return v.dig(:opts, :schema)
+          when Grape::Validations::Validators::ContractScopeValidator
+            # Grape 3.2 removed attr_reader :schema and freezes the validator,
+            # so instance_variable_get is the only way to access the schema.
+            # TODO: use v.schema once ruby-grape/grape#2657 restores the accessor.
+            schema = v.instance_variable_get(:@schema)
+            GrapeOAS.logger&.warn("ContractScopeValidator found but @schema is nil") if schema.nil?
+            return schema
+          end
+        end
 
-        # The contract instance is stored in opts[:schema]
-        contract_validation.dig(:opts, :schema)
+        nil
       end
 
       def build_contract_schema

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

@@ -65,7 +65,7 @@ module GrapeOAS
           # Precedence (highest to lowest):
           #   1. `param_type` option (e.g., `documentation: { param_type: 'query' }`)
           #   2. `in` option (e.g., `documentation: { in: 'query' }`)
-          #   3. Falls back to "query" if neither is specified
+          #   3. Defaults to "body" for write methods (POST/PUT/PATCH), "query" for read methods
           #
           # Note: If both `param_type` and `in` are specified, `param_type` takes precedence.
           # For example, `{ param_type: 'query', in: 'body' }` will be treated as query.
@@ -81,7 +81,12 @@ module GrapeOAS
 
             # Support both param_type and in for grape-swagger compatibility
             # param_type takes precedence over in when both are specified
-            (param_type || in_location)&.to_s&.downcase || "query"
+            explicit_location = (param_type || in_location)&.to_s&.downcase
+            return explicit_location if explicit_location
+
+            # Default: body for write methods (POST/PUT/PATCH), query for read methods (GET/DELETE/HEAD)
+            http_method = route.request_method.to_s.downcase
+            Constants::HttpMethods::BODYLESS_HTTP_METHODS.include?(http_method) ? "query" : "body"
           end
         end
       end

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

@@ -33,6 +33,10 @@ 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)
+
+          # is_array: true on a typed array like "[String]" is redundant and would
+          # double-wrap it as Array<Array<...>> via build_primitive_array_schema.
+          return GrapeOAS.type_resolvers.build_schema(raw_type) if doc[:is_array] && extract_typed_array_member(raw_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)

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

@@ -21,6 +21,7 @@ module GrapeOAS
           apply_format_and_example(schema, doc)
           SchemaConstraints.apply(schema, doc)
           apply_values(schema, spec)
+          apply_default(schema, spec, doc)
         end
 
         # Extracts nullable flag from a documentation hash.
@@ -45,6 +46,16 @@ module GrapeOAS
             schema.defs = defs if defs.is_a?(Hash) && schema.respond_to?(:defs=)
           end
 
+          def apply_default(schema, spec, doc)
+            return unless schema.respond_to?(:default=)
+
+            if spec.key?(:default)
+              schema.default = spec[:default]
+            elsif doc.key?(:default)
+              schema.default = doc[:default]
+            end
+          end
+
           def apply_format_and_example(schema, doc)
             schema.format = doc[:format] if doc[:format] && schema.respond_to?(:format=)
             schema.examples = doc[:example] if doc[:example] && schema.respond_to?(:examples=)

data/lib/grape_oas/constants.rb

@@ -51,6 +51,15 @@ module GrapeOAS
     # Prevents OOM on wide string ranges (e.g. "a".."zzzzzz").
     MAX_ENUM_RANGE_SIZE = 100
 
+    # Regex patterns for Grape's stringified type notations.
+    # Grape converts `type: [SomeClass]` to "[SomeClass]" and
+    # `type: [String, Integer]` to "[String, Integer]" for documentation.
+    module TypePatterns
+      CONST_NAME = /(?:::)?[A-Z]\w*(?:::[A-Z]\w*)*/
+      TYPED_ARRAY = /\A\[(?<inner>#{CONST_NAME})\]\z/
+      MULTI_TYPE = /\A\[(#{CONST_NAME}(?:,\s*#{CONST_NAME})+)\]\z/
+    end
+
     # Default values for OpenAPI spec when not provided by user
     module Defaults
       LICENSE_NAME = "Proprietary"

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

@@ -78,6 +78,7 @@ module GrapeOAS
           result["maxItems"] = schema.max_items if schema.respond_to?(:max_items) && !schema.max_items.nil?
           result["pattern"] = schema.pattern if schema.respond_to?(:pattern) && schema.pattern
           result["enum"] = normalize_enum(schema.enum, result["type"]) if schema.respond_to?(:enum) && schema.enum
+          result["default"] = schema.default if schema.respond_to?(:default) && !schema.default.nil?
         end
 
         def normalize_enum(enum_vals, type)

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

@@ -52,19 +52,20 @@ module GrapeOAS
           schema_hash["example"] = @schema.examples if @schema.examples
           schema_hash["required"] = @schema.required if @schema.required && !@schema.required.empty?
           schema_hash["discriminator"] = @schema.discriminator if @schema.discriminator
+          schema_hash["default"] = @schema.default unless @schema.default.nil?
           schema_hash
         end
 
-        def apply_constraints(schema_hash)
-          schema_hash["minLength"] = @schema.min_length if @schema.min_length
-          schema_hash["maxLength"] = @schema.max_length if @schema.max_length
-          schema_hash["pattern"] = @schema.pattern if @schema.pattern
-          schema_hash["minimum"] = @schema.minimum if @schema.minimum
-          schema_hash["maximum"] = @schema.maximum if @schema.maximum
-          schema_hash["exclusiveMinimum"] = @schema.exclusive_minimum if @schema.exclusive_minimum
-          schema_hash["exclusiveMaximum"] = @schema.exclusive_maximum if @schema.exclusive_maximum
-          schema_hash["minItems"] = @schema.min_items if @schema.min_items
-          schema_hash["maxItems"] = @schema.max_items if @schema.max_items
+        def apply_constraints(schema_hash, schema = @schema)
+          schema_hash["minimum"] = schema.minimum unless schema.minimum.nil?
+          schema_hash["maximum"] = schema.maximum unless schema.maximum.nil?
+          schema_hash["exclusiveMinimum"] = schema.exclusive_minimum if schema.exclusive_minimum
+          schema_hash["exclusiveMaximum"] = schema.exclusive_maximum if schema.exclusive_maximum
+          schema_hash["minLength"] = schema.min_length unless schema.min_length.nil?
+          schema_hash["maxLength"] = schema.max_length unless schema.max_length.nil?
+          schema_hash["pattern"] = schema.pattern if schema.pattern
+          schema_hash["minItems"] = schema.min_items unless schema.min_items.nil?
+          schema_hash["maxItems"] = schema.max_items unless schema.max_items.nil?
         end
 
         def apply_extensions(schema_hash)
@@ -80,28 +81,42 @@ module GrapeOAS
 
         # Build schema from oneOf/anyOf by using first type (OAS2 doesn't support these)
         # Extensions are merged to allow x-anyOf/x-oneOf for consumers that support them
+        #
+        # Only description and extensions are applied from the composition node.
+        # Type-specific attributes (default, enum, format, constraints) are omitted
+        # because they describe the multi-type composition, not the single fallback
+        # branch selected here.
         def build_first_of_schema(composition_type)
           schemas = @schema.send(composition_type)
           first_schema = schemas.first
           return {} unless first_schema
 
-          # Build the first schema as the fallback
           result = build_schema_or_ref(first_schema)
           result["description"] = @schema.description.to_s if @schema.description
           apply_extensions(result)
+          if result.key?("$ref") && result.size > 1
+            ref = { "$ref" => result.delete("$ref") }
+            result["allOf"] = [ref]
+          end
           result
         end
 
         # Build allOf schema for inheritance
         def build_all_of_schema
-          all_of_items = @schema.all_of.map do |item|
-            build_schema_or_ref(item)
-          end
+          items = @schema.all_of.map { |item| build_schema_or_ref(item) }
+          result = { "allOf" => items }
+          apply_composition_attributes(result)
+          result
+        end
 
-          result = { "allOf" => all_of_items }
+        def apply_composition_attributes(result)
+          result["type"] = @schema.type if @schema.type
+          result["format"] = @schema.format if @schema.format
           result["description"] = @schema.description.to_s if @schema.description
-          result["x-nullable"] = true if @nullable_strategy == Constants::NullableStrategy::EXTENSION && nullable?
-          result
+          result["default"] = @schema.default unless @schema.default.nil?
+          result["enum"] = normalize_enum(@schema.enum, @schema.type) if @schema.enum
+          apply_constraints(result)
+          apply_extensions(result)
         end
 
         def build_properties(properties)
@@ -125,6 +140,10 @@ module GrapeOAS
               result["x-nullable"] = true
             end
             result["description"] = schema.description.to_s if schema.description
+            result["default"] = schema.default unless schema.default.nil?
+            result["enum"] = normalize_enum(schema.enum, schema.type) if schema.enum
+            apply_constraints(result, schema)
+            result.merge!(schema.extensions) if schema.extensions
             if result.empty?
               ref_hash
             else

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

@@ -12,14 +12,17 @@ module GrapeOAS
 
         def build
           Array(@op.parameters).map do |param|
+            schema_hash = Schema.new(param.schema, @ref_tracker, nullable_strategy: @nullable_strategy).build
+            schema_description = schema_hash.delete("description")
+            description = param.description || schema_description
             {
               "name" => param.name,
               "in" => param.location,
               "required" => param.required,
-              "description" => param.description,
+              "description" => description,
               "style" => param.style,
               "explode" => param.explode,
-              "schema" => Schema.new(param.schema, @ref_tracker, nullable_strategy: @nullable_strategy).build
+              "schema" => schema_hash
             }.compact
           end.presence
         end

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

@@ -51,6 +51,7 @@ module GrapeOAS
           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["default"] = @schema.default unless @schema.default.nil?
           schema_hash
         end
 
@@ -72,34 +73,28 @@ module GrapeOAS
           schema_hash["discriminator"] = build_discriminator if @schema.discriminator
         end
 
-        def apply_all_constraints(schema_hash)
-          apply_numeric_constraints(schema_hash)
-          apply_string_constraints(schema_hash)
-          apply_array_constraints(schema_hash)
+        def apply_all_constraints(schema_hash, schema = @schema)
+          apply_numeric_constraints(schema_hash, schema)
+          apply_string_constraints(schema_hash, schema)
+          apply_array_constraints(schema_hash, schema)
         end
 
         private
 
         # Build allOf schema for inheritance
         def build_all_of_schema
-          all_of_items = @schema.all_of.map do |item|
-            build_schema_or_ref(item)
-          end
-
-          result = { "allOf" => all_of_items }
-          result["description"] = @schema.description.to_s if @schema.description
+          items = @schema.all_of.map { |item| build_schema_or_ref(item) }
+          result = { "allOf" => items }
+          apply_composition_attributes(result)
           apply_nullable(result)
           result
         end
 
         # Build oneOf schema for polymorphism
         def build_one_of_schema
-          one_of_items = @schema.one_of.map do |item|
-            build_schema_or_ref(item)
-          end
-
-          result = { "oneOf" => one_of_items }
-          result["description"] = @schema.description.to_s if @schema.description
+          items = @schema.one_of.map { |item| build_schema_or_ref(item) }
+          result = { "oneOf" => items }
+          apply_composition_attributes(result)
           result["discriminator"] = build_discriminator if @schema.discriminator
           apply_nullable(result)
           result
@@ -107,17 +102,25 @@ module GrapeOAS
 
         # Build anyOf schema for polymorphism
         def build_any_of_schema
-          any_of_items = @schema.any_of.map do |item|
-            build_schema_or_ref(item)
-          end
-
-          result = { "anyOf" => any_of_items }
-          result["description"] = @schema.description.to_s if @schema.description
+          items = @schema.any_of.map { |item| build_schema_or_ref(item) }
+          result = { "anyOf" => items }
+          apply_composition_attributes(result)
           result["discriminator"] = build_discriminator if @schema.discriminator
           apply_nullable(result)
           result
         end
 
+        def apply_composition_attributes(result)
+          result["type"] = nullable_type if @schema.type
+          result["format"] = @schema.format if @schema.format
+          result["description"] = @schema.description.to_s if @schema.description
+          result["default"] = @schema.default unless @schema.default.nil?
+          result["enum"] = normalize_enum(@schema.enum, result["type"]) if @schema.enum
+          sanitize_enum_against_type(result)
+          apply_all_constraints(result)
+          result.merge!(@schema.extensions) if @schema.extensions
+        end
+
         # Build OAS3 discriminator object
         def build_discriminator
           return nil unless @schema.discriminator
@@ -174,6 +177,11 @@ module GrapeOAS
 
             result = {}
             result["description"] = schema.description.to_s if schema.description
+            result["default"] = schema.default unless schema.default.nil?
+            result["enum"] = normalize_enum(schema.enum, schema.type) if schema.enum
+            sanitize_enum_against_type(result, type: schema.type)
+            apply_all_constraints(result, schema)
+            result.merge!(schema.extensions) if schema.extensions
             apply_nullable_to_ref(result, schema)
             if result.empty?
               ref_hash
@@ -224,40 +232,40 @@ module GrapeOAS
           result
         end
 
-        def apply_numeric_constraints(hash)
-          hash["minimum"] = @schema.minimum unless @schema.minimum.nil?
-          hash["maximum"] = @schema.maximum unless @schema.maximum.nil?
+        def apply_numeric_constraints(hash, schema = @schema)
+          hash["minimum"] = schema.minimum unless schema.minimum.nil?
+          hash["maximum"] = schema.maximum unless schema.maximum.nil?
 
           if @nullable_strategy == Constants::NullableStrategy::TYPE_ARRAY
-            if @schema.exclusive_minimum && !@schema.minimum.nil?
-              hash["exclusiveMinimum"] = @schema.minimum
+            if schema.exclusive_minimum && !schema.minimum.nil?
+              hash["exclusiveMinimum"] = schema.minimum
               hash.delete("minimum")
             end
-            if @schema.exclusive_maximum && !@schema.maximum.nil?
-              hash["exclusiveMaximum"] = @schema.maximum
+            if schema.exclusive_maximum && !schema.maximum.nil?
+              hash["exclusiveMaximum"] = schema.maximum
               hash.delete("maximum")
             end
           else
-            hash["exclusiveMinimum"] = @schema.exclusive_minimum if @schema.exclusive_minimum
-            hash["exclusiveMaximum"] = @schema.exclusive_maximum if @schema.exclusive_maximum
+            hash["exclusiveMinimum"] = schema.exclusive_minimum if schema.exclusive_minimum
+            hash["exclusiveMaximum"] = schema.exclusive_maximum if schema.exclusive_maximum
           end
         end
 
-        def apply_string_constraints(hash)
-          hash["minLength"] = @schema.min_length unless @schema.min_length.nil?
-          hash["maxLength"] = @schema.max_length unless @schema.max_length.nil?
-          hash["pattern"] = @schema.pattern if @schema.pattern
+        def apply_string_constraints(hash, schema = @schema)
+          hash["minLength"] = schema.min_length unless schema.min_length.nil?
+          hash["maxLength"] = schema.max_length unless schema.max_length.nil?
+          hash["pattern"] = schema.pattern if schema.pattern
         end
 
-        def apply_array_constraints(hash)
-          hash["minItems"] = @schema.min_items unless @schema.min_items.nil?
-          hash["maxItems"] = @schema.max_items unless @schema.max_items.nil?
+        def apply_array_constraints(hash, schema = @schema)
+          hash["minItems"] = schema.min_items unless schema.min_items.nil?
+          hash["maxItems"] = schema.max_items unless schema.max_items.nil?
         end
 
         # Ensure enum values match the declared type; drop enum if incompatible to avoid invalid specs
-        def sanitize_enum_against_type(hash)
+        def sanitize_enum_against_type(hash, type: nil)
           enum_vals = hash["enum"]
-          type_val = hash["type"]
+          type_val = type || hash["type"]
           return unless enum_vals && type_val
 
           base_type = if type_val.is_a?(Array)

data/lib/grape_oas/introspectors/entity_introspector.rb

@@ -88,12 +88,16 @@ module GrapeOAS
       def initialize_or_reuse_schema
         @registry[@entity_class] ||= ApiModel::Schema.new(
           type: Constants::SchemaTypes::OBJECT,
-          canonical_name: @entity_class.name,
+          canonical_name: resolve_canonical_name,
           description: nil,
           nullable: nil,
         )
       end
 
+      def resolve_canonical_name
+        EntityIntrospectorSupport.resolve_canonical_name(@entity_class)
+      end
+
       def populate_schema(schema)
         doc = entity_doc
         apply_schema_metadata(schema, doc)

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

@@ -41,7 +41,7 @@ module GrapeOAS
 
           # Create allOf schema with ref to parent + child properties
           schema = ApiModel::Schema.new(
-            canonical_name: @entity_class.name,
+            canonical_name: EntityIntrospectorSupport.resolve_canonical_name(@entity_class),
             all_of: [parent_schema, child_schema],
           )
 

data/lib/grape_oas/introspectors/entity_introspector_support.rb

@@ -19,6 +19,30 @@ module GrapeOAS
         []
       end
 
+      # Resolves the canonical name for an entity class, preferring entity_name
+      # when defined on the class itself (via def self. or extend) and non-blank,
+      # falling back to the Ruby class name. Inherited entity_name is ignored to
+      # avoid collisions between parent and child schemas.
+      def self.resolve_canonical_name(entity_class)
+        if defines_own_entity_name?(entity_class)
+          name = entity_class.entity_name
+          name.is_a?(String) && !name.strip.empty? ? name : entity_class.name
+        else
+          entity_class.name
+        end
+      end
+
+      def self.defines_own_entity_name?(entity_class)
+        return false unless entity_class.respond_to?(:entity_name)
+
+        parent = find_parent_entity(entity_class)
+        return true if parent.nil? || !parent.respond_to?(:entity_name)
+
+        entity_class.method(:entity_name).owner !=
+          parent.method(:entity_name).owner
+      end
+      private_class_method :defines_own_entity_name?
+
       # Finds the parent entity class if one exists in the Grape::Entity hierarchy.
       def self.find_parent_entity(entity_class)
         return nil unless defined?(Grape::Entity)

data/lib/grape_oas/type_resolvers/array_resolver.rb

@@ -20,15 +20,13 @@ module GrapeOAS
     class ArrayResolver
       extend Base
 
-      # Pattern to match Grape's array notation: "[Type]" or "[Module::Type]"
-      # Intentionally narrow: avoid treating multi-type strings like "[String, Integer]" as arrays.
-      ARRAY_PATTERN = /\A\[(?<inner>(?:::)?[A-Z]\w*(?:::[A-Z]\w*)*)\]\z/
+      TYPED_ARRAY_PATTERN = Constants::TypePatterns::TYPED_ARRAY
 
       class << self
         def handles?(type)
           return false unless type.is_a?(String)
 
-          type.match?(ARRAY_PATTERN)
+          type.match?(TYPED_ARRAY_PATTERN)
         end
 
         def build_schema(type)
@@ -53,7 +51,7 @@ module GrapeOAS
         private
 
         def extract_inner_type(type)
-          match = type.match(ARRAY_PATTERN)
+          match = type.match(TYPED_ARRAY_PATTERN)
           match[:inner] if match
         end
 

data/lib/grape_oas/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GrapeOAS
-  VERSION = "1.3.0"
+  VERSION = "1.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grape-oas
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Andrei Subbota
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-27 00:00:00.000000000 Z
+date: 2026-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grape