grape-oas 1.0.2 → 1.1.0

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

@@ -59,7 +59,6 @@ module GrapeOAS
           when :email? then constraints.format = "email"
           when :date? then constraints.format = "date"
           when :time?, :date_time? then constraints.format = "date-time"
-          when :bool?, :boolean? then constraints.type_predicate ||= :boolean
           when :type? then constraints.type_predicate = ArgumentExtractor.extract_literal(args.first)
           when :odd? then constraints.parity = :odd
           when :even? then constraints.parity = :even
@@ -68,7 +67,31 @@ module GrapeOAS
 
         def apply_enum_from_list(args)
           vals = ArgumentExtractor.extract_list(args.first)
-          constraints.enum = vals if vals
+          if vals
+            constraints.enum = vals
+          else
+            # For numeric ranges, extract min/max instead of enum
+            apply_min_max_from_range(args)
+          end
+        end
+
+        def apply_min_max_from_range(args)
+          rng = ArgumentExtractor.extract_range(args.first)
+          return unless rng
+          # Only apply min/max for numeric ranges; non-numeric ranges that can't
+          # be enumerated should be silently ignored rather than producing invalid schema
+          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
         end
 
         def apply_excluded_from_list(args)
@@ -97,19 +120,22 @@ module GrapeOAS
         end
 
         def handle_size(name, args)
-          min_val = ArgumentExtractor.extract_numeric(args[0])
-          max_val = ArgumentExtractor.extract_numeric(args[1]) if name == :size?
-          constraints.min_size = min_val if min_val
-          constraints.max_size = max_val if max_val
+          rng = ArgumentExtractor.extract_range(args.first)
+
+          if rng
+            constraints.min_size = rng.begin if rng.begin
+            constraints.max_size = rng.max if rng.end
+          else
+            min_val = ArgumentExtractor.extract_numeric(args[0])
+            max_val = ArgumentExtractor.extract_numeric(args[1]) if name == :size?
+            constraints.min_size = min_val if min_val
+            constraints.max_size = max_val if max_val
+          end
         end
 
         def handle_range(args)
-          rng = args.first.is_a?(Range) ? args.first : ArgumentExtractor.extract_range(args.first)
-          return unless rng
-
-          constraints.minimum = rng.begin if rng.begin
-          constraints.maximum = rng.end if rng.end
-          constraints.exclusive_maximum = rng.exclude_end?
+          rng = ArgumentExtractor.extract_range(args.first)
+          apply_range_constraints(rng)
         end
 
         def handle_multiple_of(args)

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

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require_relative "ast_walker"
+require_relative "constraint_extractor"
+require_relative "constraint_merger"
+
+module GrapeOAS
+  module Introspectors
+    module DryIntrospectorSupport
+      # Builds path-aware constraint and required field indexes from dry-schema AST
+      class RuleIndex
+        def initialize(contract_schema)
+          @walker = AstWalker.new(ConstraintExtractor::ConstraintSet)
+          @merger = ConstraintMerger
+          @constraints_by_path = {}
+          @required_by_object_path = Hash.new { |h, k| h[k] = {} }
+
+          build_indexes(contract_schema)
+        end
+
+        def self.build(contract_schema)
+          new(contract_schema).to_a
+        end
+
+        def to_a
+          [@constraints_by_path, @required_by_object_path.transform_values(&:keys)]
+        end
+
+        private
+
+        def build_indexes(contract_schema)
+          rules = contract_schema.respond_to?(:rules) ? contract_schema.rules : {}
+          rules.each_value do |rule|
+            ast = rule.respond_to?(:to_ast) ? rule.to_ast : rule
+            collect_constraints(ast, [])
+            collect_required(ast, [], in_implication_condition: false)
+          end
+        end
+
+        def collect_constraints(ast, path)
+          return unless ast.is_a?(Array)
+
+          case ast[0]
+          when :key
+            key_name, value_ast = parse_key_node(ast)
+            return unless key_name && value_ast.is_a?(Array)
+
+            new_path = path + [key_name]
+            apply_node_constraints(value_ast, new_path)
+            collect_constraints(value_ast, new_path)
+
+          when :each
+            child = ast[1]
+            return unless child.is_a?(Array)
+
+            item_path = path + ["[]"]
+
+            # Index constraints that apply to the item schema itself
+            apply_node_constraints(child, item_path)
+
+            # Recurse so nested keys inside the item get their own paths
+            collect_constraints(child, item_path)
+          else
+            ast.each { |child| collect_constraints(child, path) if child.is_a?(Array) }
+          end
+        end
+
+        def collect_required(ast, object_path, in_implication_condition:)
+          return unless ast.is_a?(Array)
+
+          case ast[0]
+          when :implication
+            left, right = ast[1].is_a?(Array) ? ast[1] : [nil, nil]
+            collect_required(left, object_path, in_implication_condition: true) if left
+            collect_required(right, object_path, in_implication_condition: false) if right
+
+          when :predicate
+            mark_required_if_key_predicate(ast[1], object_path) unless in_implication_condition
+
+          when :key, :each
+            if ast[0] == :key
+              key_name, value_ast = parse_key_node(ast)
+              if key_name && value_ast.is_a?(Array)
+                collect_required(value_ast, object_path + [key_name],
+                                 in_implication_condition: in_implication_condition,)
+              end
+            elsif ast[1] # :each
+              collect_required(ast[1], object_path + ["[]"],
+                               in_implication_condition: in_implication_condition,)
+            end
+
+          else
+            ast.each do |child|
+              collect_required(child, object_path, in_implication_condition: in_implication_condition) if child.is_a?(Array)
+            end
+          end
+        end
+
+        def parse_key_node(ast)
+          info = ast[1]
+          return [nil, nil] unless info.is_a?(Array) && info.any?
+
+          key_name = info[0]
+          value_ast = info[1] || info[-1]
+          [key_name&.to_s, value_ast]
+        end
+
+        def apply_node_constraints(value_ast, path)
+          pruned = prune_nested_validations(value_ast)
+          return unless pruned
+
+          constraints = @walker.walk(pruned)
+          constraints.required = nil if constraints.respond_to?(:required=)
+
+          path_key = path.join("/")
+          if @constraints_by_path.key?(path_key)
+            @merger.merge(@constraints_by_path[path_key], constraints)
+          else
+            @constraints_by_path[path_key] = constraints
+          end
+        end
+
+        def prune_nested_validations(ast)
+          return ast unless ast.is_a?(Array)
+
+          tag = ast[0]
+          return ast unless tag.is_a?(Symbol)
+
+          case tag
+          when :each, :key
+            nil
+
+          when :set
+            children, wrapped = extract_children(ast)
+            pruned = children.filter_map { |c| c.is_a?(Array) ? prune_nested_validations(c) : c }
+            return nil if pruned.empty?
+
+            # rewrite set -> and, preserve wrapper style
+            wrapped ? [:and, pruned] : [:and, *pruned]
+
+          when :and, :or, :rule
+            children, wrapped = extract_children(ast)
+            pruned = children.filter_map { |c| c.is_a?(Array) ? prune_nested_validations(c) : c }
+            return nil if pruned.empty?
+
+            wrapped ? [tag, pruned] : [tag, *pruned]
+
+          when :implication
+            pair = ast[1]
+            return ast unless pair.is_a?(Array) && pair.size >= 2
+
+            left  = pair[0].is_a?(Array) ? prune_nested_validations(pair[0]) : pair[0]
+            right = pair[1].is_a?(Array) ? prune_nested_validations(pair[1]) : pair[1]
+            [:implication, [left, right]]
+
+          when :not
+            child = ast[1]
+            child = prune_nested_validations(child) if child.is_a?(Array)
+            [:not, child]
+
+          else
+            ast
+          end
+        end
+
+        def extract_children(ast)
+          # handles both shapes:
+          #   [:and, [node1, node2]]
+          #   [:and, node1, node2]
+          payload = ast[1]
+
+          if payload.is_a?(Array) && !payload.empty? && payload.all? { |x| x.is_a?(Array) && x[0].is_a?(Symbol) }
+            [payload, true]   # wrapped list
+          else
+            [ast[1..], false] # splatted
+          end
+        end
+
+        def mark_required_if_key_predicate(pred, object_path)
+          return unless pred.is_a?(Array) && pred[0] == :key?
+
+          name = extract_key_name(pred)
+          @required_by_object_path[object_path.join("/")][name] = true if name
+        end
+
+        def extract_key_name(pred_node)
+          args = pred_node[1]
+          return nil unless args.is_a?(Array)
+
+          name_pair = args.find { |x| x.is_a?(Array) && x[0] == :name }
+          name_pair&.dig(1)&.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -11,7 +11,39 @@ module GrapeOAS
         ConstraintSet = ConstraintExtractor::ConstraintSet
 
         def initialize
-          # Stateless builder - no initialization needed
+          @path_stack = []
+          @constraints_by_path = nil
+          @required_by_object_path = nil
+        end
+
+        def configure_path_aware_mode(constraints_by_path, required_by_object_path)
+          @path_stack = []
+          @constraints_by_path = constraints_by_path
+          @required_by_object_path = required_by_object_path
+        end
+
+        def with_path(part)
+          @path_stack << part
+          yield
+        ensure
+          @path_stack.pop
+        end
+
+        def current_object_path
+          @path_stack.join("/")
+        end
+
+        def constraints_for_current_path
+          return nil unless @constraints_by_path
+
+          @constraints_by_path[current_object_path]
+        end
+
+        def required_keys_for_current_object
+          return nil unless @required_by_object_path
+
+          # In path-aware mode we rely entirely on rule-index requiredness
+          @required_by_object_path[current_object_path] || []
         end
 
         # Builds a schema for a Dry type.
@@ -20,7 +52,7 @@ module GrapeOAS
         # @param constraints [ConstraintSet, nil] extracted constraints
         # @return [ApiModel::Schema] the built schema
         def build_schema_for_type(dry_type, constraints = nil)
-          constraints ||= ConstraintSet.new(unhandled_predicates: [])
+          constraints ||= constraints_for_current_path || ConstraintSet.new(unhandled_predicates: [])
           meta = dry_type.respond_to?(:meta) ? dry_type.meta : {}
 
           # Check for Sum type first (TypeA | TypeB) -> anyOf
@@ -29,6 +61,10 @@ module GrapeOAS
           # Check for Hash schema type (nested schemas like .hash(SomeSchema))
           return build_hash_schema(dry_type) if hash_schema_type?(dry_type)
 
+          # Check for object schema (unwrapped hash with keys)
+          unwrapped = TypeUnwrapper.unwrap(dry_type)
+          return build_object_schema(unwrapped) if unwrapped.respond_to?(:keys)
+
           primitive, member = TypeUnwrapper.derive_primitive_and_member(dry_type)
           enum_vals = extract_enum_from_type(dry_type)
 
@@ -59,6 +95,36 @@ module GrapeOAS
 
         private
 
+        def build_object_schema(unwrapped_schema_type)
+          schema = ApiModel::Schema.new(type: Constants::SchemaTypes::OBJECT)
+          required_keys = required_keys_for_current_object
+
+          # Dry::Types::Schema does not have each_key, so we disable the cop here
+          unwrapped_schema_type.keys.each do |key| # rubocop:disable Style/HashEachMethods
+            key_name = key.respond_to?(:name) ? key.name.to_s : key.to_s
+            key_type = key.respond_to?(:type) ? key.type : nil
+
+            prop_schema = nil
+            with_path(key_name) do
+              prop_schema = if key_type
+                              build_schema_for_type(key_type, constraints_for_current_path)
+                            else
+                              default_string_schema
+                            end
+            end
+
+            is_required = if required_keys
+                            required_keys.include?(key_name)
+                          else
+                            key.respond_to?(:required?) ? key.required? : false
+                          end
+
+            schema.add_property(key_name, prop_schema, required: is_required)
+          end
+
+          schema
+        end
+
         def build_any_of_schema(sum_type)
           types = TypeUnwrapper.extract_sum_types(sum_type)
 
@@ -86,29 +152,35 @@ module GrapeOAS
         end
 
         def build_hash_schema(dry_type)
-          schema = ApiModel::Schema.new(type: Constants::SchemaTypes::OBJECT)
           unwrapped = TypeUnwrapper.unwrap(dry_type)
 
-          return schema unless unwrapped.respond_to?(:keys)
+          # Delegate to the same path-aware logic as regular object schemas.
+          # This ensures nested rule constraints (e.g. max_size?, gteq?, format?) are applied
+          # to properties inside `.hash do ... end` blocks.
+          return ApiModel::Schema.new(type: Constants::SchemaTypes::OBJECT) unless unwrapped.respond_to?(:keys)
 
-          # Dry::Schema keys method returns an array of Key objects, not a Hash
-          schema_keys = unwrapped.keys
-          schema_keys.each do |key|
-            key_name = key.respond_to?(:name) ? key.name.to_s : key.to_s
-            key_type = key.respond_to?(:type) ? key.type : nil
-
-            prop_schema = key_type ? build_schema_for_type(key_type) : default_string_schema
-            req = key.respond_to?(:required?) ? key.required? : true
-            schema.add_property(key_name, prop_schema, required: req)
-          end
-
-          schema
+          build_object_schema(unwrapped)
         end
 
         def build_base_schema(primitive, member)
           if primitive == Array
-            items_schema = member ? build_schema_for_type(member) : default_string_schema
+            items_schema = nil
+
+            with_path("[]") do
+              if member
+                unwrapped = TypeUnwrapper.unwrap(member)
+                items_schema = if unwrapped.respond_to?(:keys)
+                                 build_object_schema(unwrapped)
+                               else
+                                 build_schema_for_type(member, constraints_for_current_path)
+                               end
+              else
+                items_schema = default_string_schema
+              end
+            end
+
             ApiModel::Schema.new(type: Constants::SchemaTypes::ARRAY, items: items_schema)
+
           else
             build_schema_for_primitive(primitive)
           end

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

@@ -24,6 +24,9 @@ module GrapeOAS
         # @param dry_type [Dry::Types::Type] the type to analyze
         # @return [Array(Class, Object)] tuple of [primitive_class, member_type_or_nil]
         def derive_primitive_and_member(dry_type)
+          # Handle boolean Sum types (TrueClass | FalseClass)
+          return [TrueClass, nil] if boolean_sum_type?(dry_type)
+
           core = unwrap(dry_type)
 
           return [Array, core.type.member] if array_member_type?(core)
@@ -137,6 +140,22 @@ module GrapeOAS
             core.primitive == Array
         end
         private_class_method :array_with_member?
+
+        def boolean_sum_type?(dry_type)
+          return false unless dry_type.respond_to?(:left) && dry_type.respond_to?(:right)
+
+          boolean_type?(dry_type.left) && boolean_type?(dry_type.right)
+        end
+        private_class_method :boolean_sum_type?
+
+        def boolean_type?(dry_type)
+          return false unless dry_type
+
+          return [TrueClass, FalseClass].include?(dry_type.primitive) if dry_type.respond_to?(:primitive)
+
+          false
+        end
+        private_class_method :boolean_type?
       end
     end
   end

data/lib/grape_oas/introspectors/entity_introspector.rb

@@ -1,13 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-require_relative "../api_model_builders/concerns/type_resolver"
-require_relative "entity_introspector_support/cycle_tracker"
-require_relative "entity_introspector_support/discriminator_handler"
-require_relative "entity_introspector_support/inheritance_builder"
-require_relative "entity_introspector_support/property_extractor"
-require_relative "entity_introspector_support/exposure_processor"
-
 module GrapeOAS
   module Introspectors
     # Introspector for Grape::Entity classes.

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

@@ -59,7 +59,7 @@ module GrapeOAS
         # @return [ApiModel::Schema] the built schema
         def schema_for_exposure(exposure, doc)
           opts = exposure.instance_variable_get(:@options) || {}
-          type = doc[:type] || doc["type"] || opts[:using]
+          type = opts[:using] || doc[:type] || doc["type"]
 
           schema = build_exposure_base_schema(type)
           apply_exposure_properties(schema, doc)
@@ -243,7 +243,7 @@ module GrapeOAS
 
         def resolve_entity_from_opts(exposure, doc)
           opts = exposure.instance_variable_get(:@options) || {}
-          type = doc[:type] || doc["type"] || opts[:using]
+          type = opts[:using] || doc[:type] || doc["type"]
           return type if defined?(Grape::Entity) && type.is_a?(Class) && type <= Grape::Entity
 
           nil
@@ -253,7 +253,10 @@ module GrapeOAS
           schema_type = Constants.primitive_type(type)
           return nil unless schema_type
 
-          ApiModel::Schema.new(type: schema_type)
+          ApiModel::Schema.new(
+            type: schema_type,
+            format: Constants.format_for_type(type),
+          )
         end
       end
     end

data/lib/grape_oas/version.rb

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

data/lib/grape_oas.rb

@@ -124,7 +124,7 @@ module GrapeOAS
   #     app: MyAPI,
   #     schema_type: :oas3,
   #     title: "My API",
-  #     version: "1.0.0"
+  #     version: "1.1.0"
   #   )
   #
   # @example Filter by namespace

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grape-oas
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Andrei Subbota
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-15 00:00:00.000000000 Z
+date: 2026-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grape
@@ -114,6 +114,7 @@ files:
 - lib/grape_oas/introspectors/dry_introspector_support/contract_resolver.rb
 - lib/grape_oas/introspectors/dry_introspector_support/inheritance_handler.rb
 - lib/grape_oas/introspectors/dry_introspector_support/predicate_handler.rb
+- lib/grape_oas/introspectors/dry_introspector_support/rule_index.rb
 - lib/grape_oas/introspectors/dry_introspector_support/type_schema_builder.rb
 - lib/grape_oas/introspectors/dry_introspector_support/type_unwrapper.rb
 - lib/grape_oas/introspectors/entity_introspector.rb