rspec-openapi 0.21.0 → 0.21.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b40fcb7598d29cf3c8bf2f95f6aafb5a011ddbb2beff06d6366052d11effa02
-  data.tar.gz: 85bd479d5b7e4da9e19dcc8bbbb963a594eed99437cb911a965695d04768a4bd
+  metadata.gz: 3d8b74f9e75f015e91e3ebc37ab353459d0a8d887fb096ad7e9fcf829898290e
+  data.tar.gz: 1fdbc903fdb61f685ca02d63a88a82eb9a3184e00a0766f1e31e82001ed068b1
 SHA512:
-  metadata.gz: 89c7e3788cfccd022711d1ce76be3ee1b1568af4bade87908afb3384e64e88714a0d4b30499f0eeebb45909fe5eab5267c96afc231ea1db60a6b2fe8fc0155d6
-  data.tar.gz: 71e418493c5f3db1c8a5388bd2826fe36e15375445d3ddc7c1b2364cdfb7d160cdf3c9b02554e6134abf82e0f994355b725223c773857fb034e3b7eb034c2db7
+  metadata.gz: eb64851800a090a4cf4d9f78921f1203456ddf8b9d4e820af73d9449a259c7d6e5dd9997e01058136b0dc7b551bc5406e2e176f2818c27b6d7e5a6a00a136fb3
+  data.tar.gz: 82600b4917083f3b4a27f7bf4ee8b8b4314dc76a4c9c03f5143e5e182d652edea3cb6cef97f7b2f3598a2c27f143fdcb714058143d47fb44d2ccb6181fafe4fd

data/.github/workflows/codeql-analysis.yml

@@ -25,7 +25,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v5
+      uses: actions/checkout@v6
 
     - name: Initialize CodeQL
       uses: github/codeql-action/init@v4

data/.github/workflows/rubocop.yml

@@ -14,7 +14,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v5
+      uses: actions/checkout@v6
 
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1

data/.github/workflows/test.yml

@@ -32,7 +32,7 @@ jobs:
       RAILS_VERSION: ${{ matrix.rails == '' && '6.1.6' || matrix.rails }}
       COVERAGE: ${{ matrix.coverage || '' }}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: bundle install
         run: bundle install -j$(nproc) --retry 3
       - run: bundle exec rspec

data/.gitignore

@@ -7,6 +7,7 @@
 /spec/reports/
 /tmp/
 /Gemfile.lock
+.DS_Store
 
 # rspec failure tracking
 .rspec_status

data/lib/rspec/openapi/schema_builder.rb

@@ -246,69 +246,99 @@ class << RSpec::OpenAPI::SchemaBuilder = Object.new
 
   def build_array_items_schema(array, record: nil)
     return {} if array.empty?
+    return build_property(array.first, record: record) if array.size == 1
+    return build_property(array.first, record: record) unless array.all? { |item| item.is_a?(Hash) }
 
-    merged_schema = build_property(array.first, record: record)
+    all_schemas = array.map { |item| build_property(item, record: record) }
+    merged_schema = all_schemas.first.dup
+    merged_schema[:properties] = {}
 
-    # Future improvement - cover other types than just hashes
-    if array.size > 1 && array.all? { |item| item.is_a?(Hash) }
-      array[1..].each do |item|
-        item_schema = build_property(item, record: record)
-        merged_schema = merge_object_schemas(merged_schema, item_schema)
-      end
-    end
+    all_keys = all_schemas.flat_map { |s| s[:properties]&.keys || [] }.uniq
 
-    merged_schema
-  end
+    all_keys.each do |key|
+      all_property_schemas = all_schemas.map { |s| s[:properties]&.[](key) }
+
+      nullable_only_schemas = all_property_schemas.select { |p| p && p.keys == [:nullable] }
+      property_variations = all_property_schemas.select { |p| p && p.keys != [:nullable] }
 
-  def merge_object_schemas(schema1, schema2)
-    return schema1 unless schema2.is_a?(Hash) && schema1.is_a?(Hash)
-    return schema1 unless schema1[:type] == 'object' && schema2[:type] == 'object'
+      has_nullable = all_property_schemas.any?(&:nil?) || nullable_only_schemas.any?
 
-    merged = schema1.dup
+      next if property_variations.empty? && !has_nullable
 
-    if schema1[:properties] && schema2[:properties]
-      merged[:properties] = schema1[:properties].dup
+      if property_variations.empty? && has_nullable
+        merged_schema[:properties][key] = { nullable: true }
+      elsif property_variations.size == 1
+        merged_schema[:properties][key] = property_variations.first.dup
+      else
+        unique_types = property_variations.map { |p| p[:type] }.compact.uniq
 
-      schema2[:properties].each do |key, prop2|
-        if merged[:properties][key]
-          prop1 = merged[:properties][key]
-          merged[:properties][key] = merge_property_schemas(prop1, prop2)
+        case unique_types.first
+        when 'array'
+          merged_schema[:properties][key] = { type: 'array' }
+          items_variations = property_variations.map { |p| p[:items] }.compact
+          merged_schema[:properties][key][:items] = build_merged_schema_from_variations(items_variations)
+        when 'object'
+          merged_schema[:properties][key] = build_merged_schema_from_variations(property_variations)
         else
-          merged[:properties][key] = make_property_nullable(prop2)
+          merged_schema[:properties][key] = property_variations.first.dup
         end
       end
 
-      schema1[:properties].each do |key, prop1|
-        merged[:properties][key] = make_property_nullable(prop1) unless schema2[:properties][key]
-      end
-
-      required1 = Set.new(schema1[:required] || [])
-      required2 = Set.new(schema2[:required] || [])
-      merged[:required] = (required1 & required2).to_a
+      merged_schema[:properties][key][:nullable] = true if has_nullable && merged_schema[:properties][key].is_a?(Hash)
     end
 
-    merged
+    all_required_sets = all_schemas.map { |s| s[:required] || [] }
+    merged_schema[:required] = all_required_sets.reduce(:&) || []
+
+    merged_schema
   end
 
-  def merge_property_schemas(prop1, prop2)
-    return prop1 unless prop2.is_a?(Hash) && prop1.is_a?(Hash)
+  def build_merged_schema_from_variations(variations)
+    return {} if variations.empty?
+    return variations.first if variations.size == 1
 
-    merged = prop1.dup
+    types = variations.map { |v| v[:type] }.compact.uniq
 
-    # If either property is nullable, the merged property should be nullable
-    merged[:nullable] = true if prop2[:nullable] && !prop1[:nullable]
+    if types.size == 1 && types.first == 'object'
+      merged = { type: 'object', properties: {} }
+      all_keys = variations.flat_map { |v| v[:properties]&.keys || [] }.uniq
 
-    # If both are objects, recursively merge their properties
-    merged = merge_object_schemas(prop1, prop2) if prop1[:type] == 'object' && prop2[:type] == 'object'
+      all_keys.each do |key|
+        all_prop_variations = variations.map { |v| v[:properties]&.[](key) }
 
-    merged
-  end
+        nullable_only = all_prop_variations.select { |p| p && p.keys == [:nullable] }
+        prop_variations = all_prop_variations.select { |p| p && p.keys != [:nullable] }.compact
 
-  def make_property_nullable(property)
-    return property unless property.is_a?(Hash)
+        has_nullable = all_prop_variations.any?(&:nil?) || nullable_only.any?
 
-    nullable_prop = property.dup
-    nullable_prop[:nullable] = true unless nullable_prop[:nullable]
-    nullable_prop
+        if prop_variations.size == 1
+          merged[:properties][key] = prop_variations.first.dup
+          merged[:properties][key][:nullable] = true if has_nullable
+        elsif prop_variations.size > 1
+          prop_types = prop_variations.map { |p| p[:type] }.compact.uniq
+
+          if prop_types.size == 1
+            # Only recursively merge if it's an object type
+            merged[:properties][key] = if prop_types.first == 'object'
+                                         build_merged_schema_from_variations(prop_variations)
+                                       else
+                                         prop_variations.first.dup
+                                       end
+          else
+            unique_props = prop_variations.map { |p| p.reject { |k, _| k == :nullable } }.uniq
+            merged[:properties][key] = { oneOf: unique_props }
+          end
+
+          merged[:properties][key][:nullable] = true if has_nullable || prop_variations.size < variations.size
+        end
+      end
+
+      all_required = variations.map { |v| v[:required] || [] }
+      merged[:required] = all_required.reduce(:&) || []
+
+      merged
+    else
+      variations.first
+    end
   end
 end

data/lib/rspec/openapi/schema_merger.rb

@@ -77,6 +77,8 @@ class << RSpec::OpenAPI::SchemaMerger = Object.new
 
     return if option&.key?(:$ref)
 
+    return if spec[:oneOf]
+
     if score.to_f > SIMILARITY_THRESHOLD
       merge_schema!(option, spec)
     else

data/lib/rspec/openapi/version.rb

@@ -2,6 +2,6 @@
 
 module RSpec
   module OpenAPI
-    VERSION = '0.21.0'
+    VERSION = '0.21.2'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-openapi
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.21.2
 platform: ruby
 authors:
 - Takashi Kokubun
@@ -108,7 +108,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/exoego/rspec-openapi
   source_code_uri: https://github.com/exoego/rspec-openapi
-  changelog_uri: https://github.com/exoego/rspec-openapi/releases/tag/v0.21.0
+  changelog_uri: https://github.com/exoego/rspec-openapi/releases/tag/v0.21.2
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: