openapi3_parser 0.4.0 → 0.5.0

data/lib/openapi3_parser/node_factory/recursive_pointer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Openapi3Parser
+  module NodeFactory
+    class RecursivePointer
+      attr_reader :reference_context
+
+      def initialize(reference_context)
+        @reference_context = reference_context
+      end
+
+      def node
+        reference_context.node
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factory/reference.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/error"
+require "openapi3_parser/node_factory/fields/reference"
+require "openapi3_parser/node_factory/object"
+require "openapi3_parser/node_factory/recursive_pointer"
+
+module Openapi3Parser
+  module NodeFactory
+    class Reference < NodeFactory::Object
+      field "$ref", input_type: String, required: true, factory: :ref_factory
+
+      attr_reader :factory
+
+      def initialize(context, factory)
+        @factory = factory
+        super(context)
+      end
+
+      def in_recursive_loop?
+        data["$ref"].in_recursive_loop?
+      end
+
+      def recursive_pointer
+        NodeFactory::RecursivePointer.new(data["$ref"].reference_context)
+      end
+
+      private
+
+      def build_node
+        if in_recursive_loop?
+          raise Error::InRecursiveStructure,
+                "Can't build node as it references itself, use "\
+                "recursive_pointer"
+        end
+        data["$ref"].node
+      end
+
+      def ref_factory(context)
+        NodeFactory::Fields::Reference.new(context, factory)
+      end
+
+      def build_resolved_input
+        data["$ref"].resolved_input
+      end
+    end
+  end
+end

data/lib/openapi3_parser/{node_factories → node_factory}/request_body.rb

@@ -2,17 +2,15 @@
 
 require "openapi3_parser/context"
 require "openapi3_parser/node/request_body"
+require "openapi3_parser/node_factory/map"
 require "openapi3_parser/node_factory/object"
-require "openapi3_parser/node_factories/media_type"
-require "openapi3_parser/node_factories/map"
+require "openapi3_parser/node_factory/media_type"
 require "openapi3_parser/validation/error"
 require "openapi3_parser/validators/media_type"
 
 module Openapi3Parser
-  module NodeFactories
-    class RequestBody
-      include NodeFactory::Object
-
+  module NodeFactory
+    class RequestBody < NodeFactory::Object
       allow_extensions
       field "description", input_type: String
       field "content", factory: :content_factory, required: true
@@ -25,9 +23,9 @@ module Openapi3Parser
       end
 
       def content_factory(context)
-        NodeFactories::Map.new(
+        NodeFactory::Map.new(
           context,
-          value_factory: NodeFactories::MediaType,
+          value_factory: NodeFactory::MediaType,
           validate: ContentValidator
         )
       end
@@ -37,22 +35,20 @@ module Openapi3Parser
           new.call(*args)
         end
 
-        def call(input, context)
+        def call(validatable)
           # This validation isn't actually mentioned in the spec, but it
           # doesn't seem to make sense if this is an empty hash.
-          return "Expected to have at least 1 item" if input.size.zero?
-
-          input.keys.each_with_object([]) do |key, memo|
-            message = Validators::MediaType.call(key)
-            memo << create_error(key, context, message) if message
+          if validatable.input.size.zero?
+            return validatable.add_error("Expected to have at least 1 item")
           end
-        end
 
-        private
+          validatable.input.keys.each do |key|
+            message = Validators::MediaType.call(key)
+            next unless message
 
-        def create_error(key, parent_context, message)
-          context = Context.next_field(parent_context, key)
-          Validation::Error.new(message, context)
+            context = Context.next_field(validatable.context, key)
+            validatable.add_error(message, context)
+          end
         end
       end
     end

data/lib/openapi3_parser/{node_factories → node_factory}/response.rb

@@ -2,21 +2,19 @@
 
 require "openapi3_parser/context"
 require "openapi3_parser/node/response"
+require "openapi3_parser/node_factory/map"
 require "openapi3_parser/node_factory/object"
 require "openapi3_parser/node_factory/optional_reference"
-require "openapi3_parser/node_factories/map"
-require "openapi3_parser/node_factories/header"
-require "openapi3_parser/node_factories/media_type"
-require "openapi3_parser/node_factories/link"
-require "openapi3_parser/validation/error"
+require "openapi3_parser/node_factory/header"
+require "openapi3_parser/node_factory/media_type"
+require "openapi3_parser/node_factory/link"
+require "openapi3_parser/validation/input_validator"
 require "openapi3_parser/validators/media_type"
 require "openapi3_parser/validators/component_keys"
 
 module Openapi3Parser
-  module NodeFactories
-    class Response
-      include NodeFactory::Object
-
+  module NodeFactory
+    class Response < NodeFactory::Object
       allow_extensions
       field "description", input_type: String, required: true
       field "headers", factory: :headers_factory
@@ -30,34 +28,33 @@ module Openapi3Parser
       end
 
       def headers_factory(context)
-        factory = NodeFactory::OptionalReference.new(NodeFactories::Header)
-        NodeFactories::Map.new(context, value_factory: factory)
+        factory = NodeFactory::OptionalReference.new(NodeFactory::Header)
+        NodeFactory::Map.new(context, value_factory: factory)
       end
 
       def content_factory(context)
-        NodeFactories::Map.new(
+        NodeFactory::Map.new(
           context,
           validate: method(:validate_content),
-          value_factory: NodeFactories::MediaType
+          value_factory: NodeFactory::MediaType
         )
       end
 
       def links_factory(context)
-        factory = NodeFactory::OptionalReference.new(NodeFactories::Link)
-        NodeFactories::Map.new(
+        factory = NodeFactory::OptionalReference.new(NodeFactory::Link)
+        NodeFactory::Map.new(
           context,
-          validate: ->(input, _) { Validators::ComponentKeys.call(input) },
+          validate: Validation::InputValidator.new(Validators::ComponentKeys),
           value_factory: factory
         )
       end
 
-      def validate_content(input, context)
-        input.keys.each_with_object([]) do |key, memo|
+      def validate_content(validatable)
+        validatable.input.each_key do |key|
           message = Validators::MediaType.call(key)
           next unless message
-          memo << Validation::Error.new(
-            message, Context.next_field(context, key)
-          )
+          validatable.add_error(message,
+                                Context.next_field(validatable.context, key))
         end
       end
     end

data/lib/openapi3_parser/node_factory/responses.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/context"
+require "openapi3_parser/node_factory/map"
+require "openapi3_parser/node_factory/response"
+require "openapi3_parser/node_factory/optional_reference"
+require "openapi3_parser/node/responses"
+
+module Openapi3Parser
+  module NodeFactory
+    class Responses < NodeFactory::Map
+      KEY_REGEX = /
+        \A
+        (
+        default
+        |
+        [1-5]([0-9][0-9]|XX)
+        )
+        \Z
+      /x
+
+      def initialize(context)
+        factory = NodeFactory::OptionalReference.new(NodeFactory::Response)
+
+        super(context,
+              allow_extensions: true,
+              value_factory: factory,
+              validate: :validate_keys)
+      end
+
+      private
+
+      def build_node(data)
+        Node::Responses.new(data, context)
+      end
+
+      def validate_keys(validatable)
+        invalid = validatable.input.keys.reject do |key|
+          NodeFactory::EXTENSION_REGEX.match(key) ||
+            KEY_REGEX.match(key)
+        end
+
+        return if invalid.empty?
+
+        codes = invalid.map { |k| "'#{k}'" }.join(", ")
+        validatable.add_error("Invalid responses keys: #{codes} - default, "\
+                              "status codes and status code ranges allowed")
+      end
+    end
+  end
+end

data/lib/openapi3_parser/{node_factories → node_factory}/schema.rb

@@ -1,19 +1,17 @@
 # frozen_string_literal: true
 
 require "openapi3_parser/node/schema"
+require "openapi3_parser/node_factory/map"
 require "openapi3_parser/node_factory/object"
 require "openapi3_parser/node_factory/optional_reference"
-require "openapi3_parser/node_factories/map"
-require "openapi3_parser/node_factories/array"
-require "openapi3_parser/node_factories/external_documentation"
-require "openapi3_parser/node_factories/discriminator"
-require "openapi3_parser/node_factories/xml"
+require "openapi3_parser/node_factory/array"
+require "openapi3_parser/node_factory/external_documentation"
+require "openapi3_parser/node_factory/discriminator"
+require "openapi3_parser/node_factory/xml"
 
 module Openapi3Parser
-  module NodeFactories
-    class Schema
-      include NodeFactory::Object
-
+  module NodeFactory
+    class Schema < NodeFactory::Object
       allow_extensions
       field "title", input_type: String
       field "multipleOf", input_type: Numeric
@@ -40,7 +38,7 @@ module Openapi3Parser
       field "items", factory: :referenceable_schema
       field "properties", factory: :properties_factory
       field "additionalProperties",
-            input_type: :additional_properties_input_type,
+            validate: :additional_properties_input_type,
             factory: :additional_properties_factory,
             default: false
       field "description", input_type: String
@@ -56,28 +54,29 @@ module Openapi3Parser
       field "example"
       field "deprecated", input_type: :boolean, default: false
 
-      private
+      validate :items_for_array, :read_only_or_write_only
 
-      def build_object(data, context)
-        Node::Schema.new(data, context)
-      end
+      private
 
-      def validate(input, _context)
-        errors = []
+      def items_for_array(validatable)
+        return unless validatable.input["type"] == "array"
+        return unless validatable.factory.resolved_input["items"].nil?
 
-        if input["type"] == "array" && resolved_input["items"].nil?
-          errors << "items must be defined for a type of array"
-        end
+        validatable.add_error("items must be defined for a type of array")
+      end
 
-        if input["readOnly"] == true && input["writeOnly"] == true
-          errors << "readOnly and writeOnly cannot both be true"
-        end
+      def read_only_or_write_only(validatable)
+        input = validatable.input
+        return if [input["readOnly"], input["writeOnly"]].uniq != [true]
+        validatable.add_error("readOnly and writeOnly cannot both be true")
+      end
 
-        errors
+      def build_object(data, context)
+        Node::Schema.new(data, context)
       end
 
       def required_factory(context)
-        NodeFactories::Array.new(
+        NodeFactory::Array.new(
           context,
           default: nil,
           value_input_type: String
@@ -85,25 +84,25 @@ module Openapi3Parser
       end
 
       def enum_factory(context)
-        NodeFactories::Array.new(context, default: nil)
+        NodeFactory::Array.new(context, default: nil)
       end
 
       def disciminator_factory(context)
-        NodeFactories::Discriminator.new(context)
+        NodeFactory::Discriminator.new(context)
       end
 
       def xml_factory(context)
-        NodeFactories::Xml.new(context)
+        NodeFactory::Xml.new(context)
       end
 
       def external_docs_factory(context)
-        NodeFactories::ExternalDocumentation.new(context)
+        NodeFactory::ExternalDocumentation.new(context)
       end
 
       def properties_factory(context)
-        NodeFactories::Map.new(
+        NodeFactory::Map.new(
           context,
-          value_factory: NodeFactories::Schema
+          value_factory: NodeFactory::OptionalReference.new(self.class)
         )
       end
 
@@ -112,16 +111,17 @@ module Openapi3Parser
       end
 
       def referenceable_schema_array(context)
-        NodeFactories::Array.new(
+        NodeFactory::Array.new(
           context,
           default: nil,
           value_factory: NodeFactory::OptionalReference.new(self.class)
         )
       end
 
-      def additional_properties_input_type(input)
+      def additional_properties_input_type(validatable)
+        input = validatable.input
         return if [true, false].include?(input) || input.is_a?(Hash)
-        "Expected a boolean or an object"
+        validatable.add_error("Expected a Boolean or an Object")
       end
 
       def additional_properties_factory(context)

data/lib/openapi3_parser/node_factory/security_requirement.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/node/security_requirement"
+require "openapi3_parser/node_factory/array"
+require "openapi3_parser/node_factory/map"
+
+module Openapi3Parser
+  module NodeFactory
+    class SecurityRequirement < NodeFactory::Map
+      def initialize(context)
+        super(context, value_factory: NodeFactory::Array)
+      end
+
+      private
+
+      def build_node(data)
+        Node::SecurityRequirement.new(data, context)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/{node_factories → node_factory}/security_scheme.rb

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 
 require "openapi3_parser/node/security_scheme"
-require "openapi3_parser/node_factories/oauth_flows"
+require "openapi3_parser/node_factory/oauth_flows"
 require "openapi3_parser/node_factory/object"
 require "openapi3_parser/node_factory/optional_reference"
 
 module Openapi3Parser
-  module NodeFactories
-    class SecurityScheme
-      include NodeFactory::Object
-
+  module NodeFactory
+    class SecurityScheme < NodeFactory::Object
       allow_extensions
 
       field "type", input_type: String, required: true
@@ -28,7 +26,7 @@ module Openapi3Parser
       end
 
       def flows_factory(context)
-        NodeFactories::OauthFlows.new(context)
+        NodeFactory::OauthFlows.new(context)
       end
     end
   end

data/lib/openapi3_parser/{node_factories → node_factory}/server.rb

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 
 require "openapi3_parser/node/server"
+require "openapi3_parser/node_factory/map"
 require "openapi3_parser/node_factory/object"
-require "openapi3_parser/node_factories/server_variable"
-require "openapi3_parser/node_factories/map"
+require "openapi3_parser/node_factory/server_variable"
 
 module Openapi3Parser
-  module NodeFactories
-    class Server
-      include NodeFactory::Object
-
+  module NodeFactory
+    class Server < NodeFactory::Object
       allow_extensions
       field "url", input_type: String, required: true
       field "description", input_type: String
@@ -22,9 +20,9 @@ module Openapi3Parser
       end
 
       def variables_factory(context)
-        NodeFactories::Map.new(
+        NodeFactory::Map.new(
           context,
-          value_factory: NodeFactories::ServerVariable
+          value_factory: NodeFactory::ServerVariable
         )
       end
     end