grape-oas 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0520e8f719a37c5e33b330a681a9e8da8b1c3a9b921aa245ef328d716bf2bd9
-  data.tar.gz: aa612915b60e40933256692bb9ad33b2dcf77bc1f68c52d2a9c32cd0befc0bff
+  metadata.gz: 683920ecd4af815a8dd0a58b8e36b5feb4be21030566842474f33a1c804fa008
+  data.tar.gz: c5c3035f9038878338b836cb09b096164723e012af2066b120b63535f062f5ed
 SHA512:
-  metadata.gz: 312f2f0c9dfae0735187b4b7e6ab1969c619e36d58b74e094d990354fdc827a809b49a2ab7ec910bb1e67ac586b9fa4da54742b2f2cd449cca289832e88e5ae3
-  data.tar.gz: 0e94d7856bc9e94c354b56196f8a77a1689f17281298dc56810de7792fc4d91988fe38f4943a98c9dbf855dae644a36ca01df376a3176210c6d1ef5764ff1db0
+  metadata.gz: 820d58e88ffe10735ef72a72c41b4feeaedbcfb6d7a5cb3a3f5f5a50d8c91c6d7db5203fce40289511d9adc57ca605ec1ca3a2f6158ce043e58baf89c30a9d3a
+  data.tar.gz: ac0862ed30858730c19d7afc1592a53ca2aef1f14c789c407e535ab482f4ea497ab342b2967730aed4ffdf542497f445766def91d22e19c8810c0dded172b80d

data/CHANGELOG.md

@@ -5,7 +5,14 @@ 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.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-
+## [1.0.3] - 2025-12-23
+
+* Your contribution here
+- [#21](https://github.com/numbata/grape-oas/pull/21): Remove unnecessary require_relative in favor of Zeitwerk autoloadin [@numbata](https://github.com/numbata)
+- [#17](https://github.com/numbata/grape-oas/pull/17): Support for nested rules and predicates in dry-schema introspection [@slbug](https://github.com/slbug)
+- [#20](https://github.com/numbata/grape-oas/pull/20): Use annotation for coverage report [@numbata](https://github.com/numbata)
+- [#18](https://github.com/numbata/grape-oas/pull/18): Support for range in size? predicate `required(:tags).value(:array, size?: 1..10).each(:string)` [@slbug](https://github.com/slbug)
+- [#19](https://github.com/numbata/grape-oas/pull/19): Temporary disable memory profiler workflow for PRs [@numbata](https://github.com/numbata).
 
 ## [1.0.2] - 2025-12-15
 

data/lib/grape_oas/api_model_builders/request.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "bigdecimal"
-require_relative "concerns/type_resolver"
 
 module GrapeOAS
   module ApiModelBuilders

data/lib/grape_oas/api_model_builders/request_params.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "request_params_support/param_location_resolver"
-require_relative "request_params_support/param_schema_builder"
-require_relative "request_params_support/schema_enhancer"
-require_relative "request_params_support/nested_params_builder"
-
 module GrapeOAS
   module ApiModelBuilders
     class RequestParams

data/lib/grape_oas/exporter/oas2_schema.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "concerns/tag_builder"
-require_relative "concerns/schema_indexer"
-
 module GrapeOAS
   module Exporter
     class OAS2Schema

data/lib/grape_oas/exporter/oas3_schema.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "concerns/tag_builder"
-require_relative "concerns/schema_indexer"
-
 module GrapeOAS
   module Exporter
     class OAS3Schema

data/lib/grape_oas/introspectors/dry_introspector.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-require_relative "dry_introspector_support/contract_resolver"
-require_relative "dry_introspector_support/inheritance_handler"
-require_relative "dry_introspector_support/type_schema_builder"
-
 module GrapeOAS
   module Introspectors
     # Introspector for Dry::Validation contracts and Dry::Schema.
@@ -92,16 +87,30 @@ module GrapeOAS
       end
 
       def build_flat_schema
-        rule_constraints = DryIntrospectorSupport::ConstraintExtractor.extract(contract_resolver.contract_schema)
+        contract_schema = contract_resolver.contract_schema
+
+        constraints_by_path, required_by_object_path =
+          DryIntrospectorSupport::RuleIndex.build(contract_schema)
+
+        type_schema_builder.configure_path_aware_mode(constraints_by_path, required_by_object_path)
+
         schema = ApiModel::Schema.new(
           type: Constants::SchemaTypes::OBJECT,
           canonical_name: contract_resolver.canonical_name,
         )
 
-        contract_resolver.contract_schema.types.each do |name, dry_type|
-          constraints = rule_constraints[name]
-          prop_schema = type_schema_builder.build_schema_for_type(dry_type, constraints)
-          schema.add_property(name, prop_schema, required: type_schema_builder.required?(dry_type, constraints))
+        root_required = required_by_object_path.fetch("", [])
+
+        contract_schema.types.each do |name, dry_type|
+          name_s = name.to_s
+          prop_schema = nil
+
+          type_schema_builder.with_path(name_s) do
+            prop_schema = type_schema_builder.build_schema_for_type(dry_type,
+                                                                    type_schema_builder.constraints_for_current_path,)
+          end
+
+          schema.add_property(name, prop_schema, required: root_required.include?(name_s))
         end
 
         # Use canonical_name as registry key for schema objects (they don't have unique classes),

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

@@ -17,6 +17,7 @@ module GrapeOAS
         def extract_range(arg)
           return arg if arg.is_a?(Range)
           return arg[1] if arg.is_a?(Array) && arg.first == :range
+          return arg[1] if arg.is_a?(Array) && arg.first == :size && arg[1].is_a?(Range)
 
           nil
         end

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

@@ -68,15 +68,27 @@ module GrapeOAS
         def build_child_only_schema(parent_contract, type_schema_builder)
           child_schema = ApiModel::Schema.new(type: Constants::SchemaTypes::OBJECT)
           parent_keys = parent_contract_types(parent_contract)
-          rule_constraints = ConstraintExtractor.extract(@contract_resolver.contract_schema)
+          contract_schema = @contract_resolver.contract_schema
 
-          @contract_resolver.contract_schema.types.each do |name, dry_type|
+          constraints_by_path, required_by_object_path =
+            RuleIndex.build(contract_schema)
+
+          type_schema_builder.configure_path_aware_mode(constraints_by_path, required_by_object_path)
+          root_required = required_by_object_path.fetch("", [])
+
+          contract_schema.types.each do |name, dry_type|
             # Skip inherited properties
             next if parent_keys.include?(name.to_s)
 
-            constraints = rule_constraints[name]
-            prop_schema = type_schema_builder.build_schema_for_type(dry_type, constraints)
-            child_schema.add_property(name, prop_schema, required: type_schema_builder.required?(dry_type, constraints))
+            name_s = name.to_s
+            prop_schema = nil
+
+            type_schema_builder.with_path(name_s) do
+              prop_schema = type_schema_builder.build_schema_for_type(dry_type,
+                                                                      type_schema_builder.constraints_for_current_path,)
+            end
+
+            child_schema.add_property(name, prop_schema, required: root_required.include?(name_s))
           end
 
           child_schema

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

@@ -97,10 +97,17 @@ 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)

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/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/version.rb

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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: grape-oas
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Andrei Subbota
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-15 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grape
@@ -114,6 +113,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
@@ -136,7 +136,6 @@ metadata:
   documentation_uri: https://github.com/numbata/grape-oas#readme
   bug_tracker_uri: https://github.com/numbata/grape-oas/issues
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -151,8 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.8
 specification_version: 4
 summary: OpenAPI (Swagger) v2 and v3 documentation for Grape APIs
 test_files: []