Add support for additionalProperties, unevaluatedItems and unevaluatedProperties

These schema properties return schemas but are commonly used as
booleans. Therefore I've added boolean helper methods for them.

Author: kevindew

json-schema-for-3.1.md

@@ -82,15 +82,15 @@ else - single schema - done
 dependentSchemas - map of schemas - done
 
 prefixItems: array of schema - done
-items: array of schema - in 3.0
+items: schema - in 3.0
 contains: schema - done
 
 properties: object, each value json schema - in 3.0
 patternProperties: object each value JSON schema key regex - done
-additionalProperties: single json schema (works with the boolean schema value that we don't support)
+additionalProperties: single json schema - done
 
-unevaluatedItems - single schema - somewhat complex because of booleanSchemas
-unevaluatedProperties: single schema - as above
+unevaluatedItems - single schema - done
+unevaluatedProperties: single schema - done
 
 
 ## Returning to this in 2025
@@ -112,9 +112,6 @@ Little things:
 - probably want a quick way to get coverage of the methods on nodes
 - could validate that pattern and patternProperties contain regexs
 
-Bigger things:
-- OpenAPI 3.1 supports boolean schemas that are just a true or false value, this code doesn't.
-
 JSON Schema specs:
 
 meta: https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-00

lib/openapi3_parser/node/schema/v3_1.rb

@@ -140,6 +140,42 @@ def contains
         def pattern_properties
           self["patternProperties"]
         end
+
+        # @return [Schema, nil]
+        def additional_properties
+          self["additionalProperties"]
+        end
+
+        # @return [Boolean]
+        def additional_properties?
+          return false unless additional_properties
+
+          !additional_properties.false?
+        end
+
+        # @return [Schema, nil]
+        def unevaluated_items
+          self["unevaluatedItems"]
+        end
+
+        # @return [Boolean]
+        def unevaluated_items?
+          return false unless unevaluated_items
+
+          !unevaluated_items.false?
+        end
+
+        # @return [Schema, nil]
+        def unevaluated_properties
+          self["unevaluatedProperties"]
+        end
+
+        # @return [Boolean]
+        def unevaluated_properties?
+          return false unless unevaluated_properties
+
+          !unevaluated_properties.false?
+        end
       end
     end
   end

lib/openapi3_parser/node_factory/schema/v3_1.rb

@@ -39,6 +39,9 @@ class V3_1 < NodeFactory::Object # rubocop:disable Naming/ClassAndModuleCamelCas
         field "prefixItems", factory: :prefix_items_factory
         field "contains", factory: :referenceable_schema
         field "patternProperties", factory: :schema_map_factory
+        field "additionalProperties", factory: :referenceable_schema
+        field "unevaluatedItems", factory: :referenceable_schema
+        field "unevaluatedProperties", factory: :referenceable_schema
 
         def boolean_input?
           [true, false].include?(resolved_input)

spec/lib/openapi3_parser/node/schema/v3_1_spec.rb

@@ -3,6 +3,85 @@
 RSpec.describe Openapi3Parser::Node::Schema::V3_1 do
   it_behaves_like "schema node", openapi_version: "3.1.0"
 
+  shared_examples "schema presence boolean" do |method_name, property|
+    describe "##{method_name}" do
+      let(:factory_context) do
+        create_node_factory_context(
+          { property => schema },
+          document_input: {
+            "openapi" => "3.1.0",
+            "info" => {
+              "title" => "Minimal Openapi definition",
+              "version" => "1.0.0"
+            }
+          }
+        )
+      end
+
+      let(:instance) do
+        Openapi3Parser::NodeFactory::Schema::V3_1
+          .new(factory_context)
+          .node(node_factory_context_to_node_context(factory_context))
+      end
+
+      context "when a schema object is provided" do
+        let(:schema) { { "type" => "string" } }
+
+        it "returns true" do
+          expect(instance.public_send(method_name)).to be(true)
+        end
+      end
+
+      context "when a schema of true is provided" do
+        let(:schema) { true }
+
+        it "returns true" do
+          expect(instance.public_send(method_name)).to be(true)
+        end
+      end
+
+      context "when a schema of false is provided" do
+        let(:schema) { false }
+
+        it "returns false" do
+          expect(instance.public_send(method_name)).to be(false)
+        end
+      end
+
+      context "when no schema is provided" do
+        let(:schema) { nil }
+
+        it "returns false" do
+          expect(instance.public_send(method_name)).to be(false)
+        end
+      end
+    end
+  end
+
+  shared_examples "ruby keyword method" do |method_name|
+    describe "##{method_name}" do
+      it "supports a Ruby reserved word as a method name" do
+        factory_context = create_node_factory_context(
+          { method_name.to_s => { "type" => "string" } },
+          document_input: {
+            "openapi" => "3.1.0",
+            "info" => {
+              "title" => "Minimal Openapi definition",
+              "version" => "1.0.0"
+            }
+          }
+        )
+
+        instance = Openapi3Parser::NodeFactory::Schema::V3_1
+                   .new(factory_context)
+                   .node(node_factory_context_to_node_context(factory_context))
+
+        expect(instance.public_send(method_name))
+          .to be_an_instance_of(described_class)
+      end
+    end
+  end
+
   describe "boolean methods" do
     let(:instance) do
       factory_context = create_node_factory_context(input)
@@ -46,27 +125,11 @@
     end
   end
 
-  %i[if then else].each do |method_name|
-    describe "##{method_name}" do
-      it "supports a Ruby reserved word as a method name" do
-        factory_context = create_node_factory_context(
-          { method_name.to_s => { "type" => "string" } },
-          document_input: {
-            "openapi" => "3.1.0",
-            "info" => {
-              "title" => "Minimal Openapi definition",
-              "version" => "1.0.0"
-            }
-          }
-        )
+  include_examples "schema presence boolean", :additional_properties?, "additionalProperties"
+  include_examples "schema presence boolean", :unevaluated_items?, "unevaluatedItems"
+  include_examples "schema presence boolean", :unevaluated_properties?, "unevaluatedProperties"
 
-        instance = Openapi3Parser::NodeFactory::Schema::V3_1
-                   .new(factory_context)
-                   .node(node_factory_context_to_node_context(factory_context))
-
-        expect(instance.public_send(method_name))
-          .to be_an_instance_of(described_class)
-      end
-    end
-  end
+  include_examples "ruby keyword method", :if
+  include_examples "ruby keyword method", :then
+  include_examples "ruby keyword method", :else
 end