openapi-ruby 3.0.2 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c80ade10ad457a2ce7b09f51f788c9bad884da32e462071349a3a3cac7627573
-  data.tar.gz: f26291466286fe326b0aa0e4223d50e6e6f4864c85d0cfec10e0f53cde8689a9
+  metadata.gz: e392a1235f97dc71aaf0ec1790ee0bd64c4bcbae412063af363af91e95cb608d
+  data.tar.gz: 90f056e8bc51aa18d6de20a38ac706c079955567066e034d9408a8bd75b2f966
 SHA512:
-  metadata.gz: d2fe17e3e72da93b6b50fef93dd2641f2814d1aaf964364d9cf324f1b9562336956b1706d264baf6515f1d9d8ceee07abf830f83c83117594adb5f2806313981
-  data.tar.gz: 61780c593073693c446d64f5088d495b0083c246989d5799f97b780945351a8f07aeee3e55d5cf1b87bc5c018e21bb4625029d108aed50a1172db9a54be09f5b
+  metadata.gz: bde611e9f9b188969e3bbc8a6f1062efe7738ebc15e7eef40079406cccd0eab35051c767db9abfbcba0eea1e91ec39a265f7654468f8478efef8462e63b67f42
+  data.tar.gz: c02da938cd7edd9053fc89730916dbc31b87829fc945c36248269e6a77a569cf77ea07c14938550517a16909615ee926fc05b1b54bf848a3997ac7cfa1bf4c47

data/lib/openapi_ruby/adapters/rspec.rb

@@ -26,7 +26,6 @@ module OpenapiRuby
           define_method(method) do |summary = nil, &block|
             path_ctx = metadata[:openapi_path_context]
             op_context = DSL::OperationContext.new(method, summary)
-            path_ctx.path_parameters.each { |p| op_context.parameter(p) }
             path_ctx.operations[method.to_s] = op_context
 
             describe "#{method.to_s.upcase} #{path_ctx.path_template}" do
@@ -118,6 +117,7 @@ module OpenapiRuby
           # Merge individual parameter let values
           operation&.parameters&.each do |param|
             name = param["name"]
+            next unless name
             val = resolve_let(name.to_sym)
             next if val.nil?
 

data/lib/openapi_ruby/components/loader.rb

@@ -13,10 +13,12 @@ module OpenapiRuby
       def load!
         define_namespace_modules!
         load_component_files!
+        @@loaded = true # rubocop:disable Style/ClassVars
         self
       end
 
       def to_openapi_hash
+        ensure_loaded!
         Registry.instance.to_openapi_hash(scope: @scope)
       end
 
@@ -137,6 +139,17 @@ module OpenapiRuby
           class_to_file[klass] = source_file if source_file
         end
 
+        # Correct cross-scope inheritance misattribution: when Admin::V1::Schemas::ItemPrice
+        # inherits from V1::Schemas::ItemPrice, loading the admin file auto-loads the parent
+        # via Ruby autoloading. The diff-based tracking then maps the parent to the admin file.
+        # Fix by preferring the conventional file path when it exists and differs.
+        class_to_file.each do |klass, file|
+          conventional_file = find_source_file_for(klass)
+          if conventional_file && conventional_file != file && file_scope_map.key?(conventional_file)
+            class_to_file[klass] = conventional_file
+          end
+        end
+
         # Assign scopes to all registered components based on their source file.
         class_to_file.each do |klass, file|
           next if klass._component_scopes_explicitly_set
@@ -146,6 +159,12 @@ module OpenapiRuby
 
           if inferred_scope == :shared
             klass._component_scopes = []
+            klass._component_scopes_explicitly_set = true
+          elsif inferred_scope.is_a?(Array)
+            Registry.instance.unregister(klass)
+            klass._component_scopes = inferred_scope
+            klass._component_scopes_explicitly_set = true
+            Registry.instance.register(klass)
           else
             Registry.instance.unregister(klass)
             klass._component_scopes = [inferred_scope]
@@ -169,14 +188,25 @@ module OpenapiRuby
 
       def infer_scope(relative_path, scope_paths)
         scope_paths.sort_by { |prefix, _| -prefix.length }.each do |prefix, scope|
-          return scope&.to_sym if relative_path.start_with?("#{prefix}/")
+          if relative_path.start_with?("#{prefix}/")
+            return scope.is_a?(Array) ? scope.map(&:to_sym) : scope&.to_sym
+          end
         end
         nil
       end
 
       def filter_type(type)
+        ensure_loaded!
         to_openapi_hash[type.to_s] || {}
       end
+
+      @@loaded = false # rubocop:disable Style/ClassVars
+
+      def ensure_loaded!
+        return if @@loaded
+
+        load!
+      end
     end
   end
 end

data/lib/openapi_ruby/components/registry.rb

@@ -89,16 +89,18 @@ module OpenapiRuby
 
       def to_openapi_hash(scope: nil)
         result = {}
+        # Track which components are scope-specific vs multi-scope/shared
+        # so scope-specific ones take precedence on name collisions.
+        specificity = {}
+
         @components.each do |type, components|
           type_key = type.to_s
           result[type_key] = {}
+          specificity[type_key] = {}
+
           components.each_value do |klass|
             next if klass._schema_hidden
-            # When filtering by scope:
-            # - Components with matching scope: included
-            # - Components explicitly marked as shared (empty scopes + explicitly_set): included
-            # - Components with non-matching scope: excluded
-            # - Components with no scope assigned (empty scopes + NOT explicitly_set): excluded
+
             if scope
               if klass._component_scopes.empty?
                 next unless klass._component_scopes_explicitly_set
@@ -107,7 +109,16 @@ module OpenapiRuby
               end
             end
 
-            result[type_key][klass.component_name] = klass.to_openapi
+            name = klass.component_name
+            is_specific = klass._component_scopes.length == 1 && klass._component_scopes.include?(scope)
+
+            # Scope-specific components take precedence over shared/multi-scope
+            if specificity[type_key][name] && !is_specific
+              next
+            end
+
+            result[type_key][name] = klass.to_openapi
+            specificity[type_key][name] = is_specific
           end
           result.delete(type_key) if result[type_key].empty?
         end

data/lib/openapi_ruby/core/document.rb

@@ -15,7 +15,7 @@ module OpenapiRuby
           "info" => normalize_info(info),
           "paths" => {}
         }
-        @data["servers"] = servers.map { |s| s.transform_keys(&:to_s) } if servers.any?
+        @data["servers"] = servers.map { |s| deep_stringify_keys(s) } if servers.any?
       end
 
       def add_path(template, path_item)
@@ -75,11 +75,22 @@ module OpenapiRuby
       end
 
       def normalize_info(info)
-        result = info.transform_keys(&:to_s)
+        result = deep_stringify_keys(info)
         result["title"] ||= ""
         result["version"] ||= "0.0.0"
         result
       end
+
+      def deep_stringify_keys(obj)
+        case obj
+        when Hash
+          obj.each_with_object({}) { |(k, v), h| h[k.to_s] = deep_stringify_keys(v) }
+        when Array
+          obj.map { |v| deep_stringify_keys(v) }
+        else
+          obj
+        end
+      end
     end
   end
 end

data/lib/openapi_ruby/core/document_builder.rb

@@ -60,12 +60,18 @@ module OpenapiRuby
           }
         }
 
-        # Add 400 to every operation that doesn't already define one
+        # Add 400 to operations that have parameters or a request body
         @paths.each_value do |path_item|
+          path_params = path_item["parameters"]
+
           path_item.each do |key, operation|
             next unless operation.is_a?(Hash) && operation.key?("responses")
             next if key == "parameters"
 
+            has_params = operation.key?("parameters") || path_params
+            has_body = operation.key?("requestBody")
+            next unless has_params || has_body
+
             operation["responses"]["400"] ||= {"$ref" => "#/components/responses/SchemaValidationError"}
           end
         end

data/lib/openapi_ruby/dsl/context.rb

@@ -23,8 +23,6 @@ module OpenapiRuby
       HTTP_METHODS.each do |method|
         define_method(method) do |summary = nil, &block|
           op = OperationContext.new(method, summary)
-          # Copy path-level parameters to operation
-          @path_parameters.each { |p| op.parameter(p) }
           op.instance_eval(&block) if block
           @operations[method.to_s] = op
           op
@@ -34,8 +32,8 @@ module OpenapiRuby
       def to_openapi
         result = {}
 
-        # Path-level parameters are already copied into each operation (line 27),
-        # so we don't output them at the path level to avoid duplicates.
+        result["parameters"] = @path_parameters if @path_parameters.any?
+
         @operations.each do |verb, op|
           result[verb] = op.to_openapi
         end

data/lib/openapi_ruby/engine.rb

@@ -7,6 +7,8 @@ module OpenapiRuby
     initializer "openapi_ruby.middleware" do |app|
       config = OpenapiRuby.configuration
 
+      next if ENV["OPENAPI_RUBY_GENERATING"]
+
       if config.request_validation != :disabled || config.response_validation != :disabled
         config.schemas.each do |name, schema_config|
           schema_path = resolve_schema_path(config, name)
@@ -36,9 +38,6 @@ module OpenapiRuby
       end
     end
 
-    # Components are loaded on demand via Components::Loader (e.g. in test helpers),
-    # not at boot time — avoids cross-file dependency ordering issues.
-
     private
 
     def resolve_schema_path(config, schema_name)

data/lib/openapi_ruby/generator/schema_writer.rb

@@ -38,9 +38,10 @@ module OpenapiRuby
           builder.add_path(context.path_template, context.to_openapi)
         end
 
-        # Merge components from registry
+        # Merge components from registry (Loader ensures files are loaded)
         scope = @schema_config[:component_scope]
-        components = Components::Registry.instance.to_openapi_hash(scope: scope)
+        loader = Components::Loader.new(scope: scope)
+        components = loader.to_openapi_hash
         builder.merge_components(components)
 
         builder.build

data/lib/openapi_ruby/middleware/path_matcher.rb

@@ -21,7 +21,11 @@ module OpenapiRuby
       private
 
       def build_matchers(templates)
-        templates.map do |template|
+        # Sort templates so that static paths come before parameterized ones.
+        # This ensures `/admin_users/me` matches before `/admin_users/{id}`.
+        sorted = templates.sort_by { |t| [t.count("{"), t] }
+
+        sorted.map do |template|
           pattern = Regexp.new("\\A" + template.gsub(/\{(\w+)\}/) { "(?<#{::Regexp.last_match(1)}>[^/]+)" } + "\\z")
           [template, pattern]
         end

data/lib/openapi_ruby/middleware/request_validation.rb

@@ -139,8 +139,8 @@ module OpenapiRuby
         errors = []
         # Coerce string values for validation based on schema type
         coerced = coerce_for_validation(value, schema)
-        schemer = JSONSchemer.schema(schema)
-        schemer.validate(coerced).each do |err|
+        schema_validator = resolve_schema(schema)
+        schema_validator.validate(coerced).each do |err|
           msg = err["error"] || err["type"] || "validation failed"
           errors << "Invalid #{context}: #{msg}"
         end
@@ -170,9 +170,26 @@ module OpenapiRuby
       end
 
       def coerce_for_validation(value, schema)
-        return value unless value.is_a?(String)
+        resolved = resolve_schema_definition(schema)
+
+        if value.is_a?(Hash) && resolved.is_a?(Hash)
+          properties = resolved["properties"] || {}
+          value.each_with_object({}) do |(k, v), coerced|
+            prop_schema = properties[k] || properties[k.to_s]
+            coerced[k] = prop_schema ? coerce_for_validation(v, prop_schema) : v
+          end
+        elsif value.is_a?(String)
+          coerce_string(value, resolved)
+        else
+          value
+        end
+      rescue ArgumentError, TypeError
+        value
+      end
 
-        case schema["type"]
+      def coerce_string(value, schema)
+        type = schema.is_a?(Hash) ? schema["type"] : nil
+        case type
         when "integer"
           Integer(value)
         when "number"
@@ -190,6 +207,19 @@ module OpenapiRuby
         value
       end
 
+      def resolve_schema_definition(schema)
+        return schema unless schema.is_a?(Hash) && schema["$ref"]
+
+        ref_path = schema["$ref"].sub("#/", "").split("/")
+        ref_path.reduce(document) { |doc, key| doc&.dig(key) } || schema
+      rescue
+        schema
+      end
+
+      def document
+        @resolver.respond_to?(:document) ? @resolver.document : {}
+      end
+
       def read_request_body(request)
         return nil unless request.body
 

data/lib/openapi_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenapiRuby
-  VERSION = "3.0.2"
+  VERSION = "3.1.0"
 end

data/lib/tasks/openapi_ruby.rake

@@ -8,7 +8,7 @@ namespace :openapi_ruby do
 
     # Spawn a subprocess so RAILS_ENV defaults to "test" cleanly,
     # just like rswag did with RSpec::Core::RakeTask.
-    env = {"RAILS_ENV" => ENV.fetch("RAILS_ENV", "test")}
+    env = {"RAILS_ENV" => ENV.fetch("RAILS_ENV", "test"), "OPENAPI_RUBY_GENERATING" => "true"}
     script = generate_script(framework, pattern)
     command = "bundle exec ruby -e #{Shellwords.escape(script)}"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openapi-ruby
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.1.0
 platform: ruby
 authors:
 - Morten Hartvig