grape-oas 1.2.0 → 1.4.0

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

@@ -32,9 +32,26 @@ 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["default"] = @schema.default unless @schema.default.nil?
           schema_hash
         end
 
@@ -56,49 +73,54 @@ 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
         end
 
         # 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
@@ -146,13 +168,20 @@ 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
+            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
@@ -161,10 +190,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
 
@@ -197,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)
@@ -244,13 +279,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.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/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