openapi3_parser 0.4.0 → 0.5.0

data/lib/openapi3_parser/node_factory/callback.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/context"
+require "openapi3_parser/node_factory/map"
+require "openapi3_parser/node_factory/path_item"
+require "openapi3_parser/node/callback"
+
+module Openapi3Parser
+  module NodeFactory
+    class Callback < NodeFactory::Map
+      def initialize(context)
+        super(context,
+              allow_extensions: true,
+              value_factory: NodeFactory::PathItem)
+      end
+
+      private
+
+      def build_node(data)
+        Node::Callback.new(data, context)
+      end
+    end
+  end
+end

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

@@ -3,23 +3,22 @@
 require "openapi3_parser/node/components"
 require "openapi3_parser/node_factory/object"
 require "openapi3_parser/node_factory/optional_reference"
-require "openapi3_parser/node_factories/map"
-require "openapi3_parser/node_factories/schema"
-require "openapi3_parser/node_factories/response"
-require "openapi3_parser/node_factories/parameter"
-require "openapi3_parser/node_factories/example"
-require "openapi3_parser/node_factories/request_body"
-require "openapi3_parser/node_factories/header"
-require "openapi3_parser/node_factories/security_scheme"
-require "openapi3_parser/node_factories/link"
-require "openapi3_parser/node_factories/callback"
+require "openapi3_parser/node_factory/map"
+require "openapi3_parser/node_factory/schema"
+require "openapi3_parser/node_factory/response"
+require "openapi3_parser/node_factory/parameter"
+require "openapi3_parser/node_factory/example"
+require "openapi3_parser/node_factory/request_body"
+require "openapi3_parser/node_factory/header"
+require "openapi3_parser/node_factory/security_scheme"
+require "openapi3_parser/node_factory/link"
+require "openapi3_parser/node_factory/callback"
+require "openapi3_parser/validation/input_validator"
 require "openapi3_parser/validators/component_keys"
 
 module Openapi3Parser
-  module NodeFactories
-    class Components
-      include NodeFactory::Object
-
+  module NodeFactory
+    class Components < NodeFactory::Object
       allow_extensions
       field "schemas", factory: :schemas_factory
       field "responses", factory: :responses_factory
@@ -38,46 +37,46 @@ module Openapi3Parser
       end
 
       def schemas_factory(context)
-        referenceable_map_factory(context, NodeFactories::Schema)
+        referenceable_map_factory(context, NodeFactory::Schema)
       end
 
       def responses_factory(context)
-        referenceable_map_factory(context, NodeFactories::Response)
+        referenceable_map_factory(context, NodeFactory::Response)
       end
 
       def parameters_factory(context)
-        referenceable_map_factory(context, NodeFactories::Parameter)
+        referenceable_map_factory(context, NodeFactory::Parameter)
       end
 
       def examples_factory(context)
-        referenceable_map_factory(context, NodeFactories::Example)
+        referenceable_map_factory(context, NodeFactory::Example)
       end
 
       def request_bodies_factory(context)
-        referenceable_map_factory(context, NodeFactories::RequestBody)
+        referenceable_map_factory(context, NodeFactory::RequestBody)
       end
 
       def headers_factory(context)
-        referenceable_map_factory(context, NodeFactories::Header)
+        referenceable_map_factory(context, NodeFactory::Header)
       end
 
       def security_schemes_factory(context)
-        referenceable_map_factory(context, NodeFactories::SecurityScheme)
+        referenceable_map_factory(context, NodeFactory::SecurityScheme)
       end
 
       def links_factory(context)
-        referenceable_map_factory(context, NodeFactories::Link)
+        referenceable_map_factory(context, NodeFactory::Link)
       end
 
       def callbacks_factory(context)
-        referenceable_map_factory(context, NodeFactories::Callback)
+        referenceable_map_factory(context, NodeFactory::Callback)
       end
 
       def referenceable_map_factory(context, factory)
-        NodeFactories::Map.new(
+        NodeFactory::Map.new(
           context,
           value_factory: NodeFactory::OptionalReference.new(factory),
-          validate: ->(input, _) { Validators::ComponentKeys.call(input) }
+          validate: Validation::InputValidator.new(Validators::ComponentKeys)
         )
       end
 

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

@@ -4,21 +4,20 @@ require "openapi3_parser/node/contact"
 require "openapi3_parser/node_factory/object"
 require "openapi3_parser/validators/url"
 require "openapi3_parser/validators/email"
+require "openapi3_parser/validation/input_validator"
 
 module Openapi3Parser
-  module NodeFactories
-    class Contact
-      include NodeFactory::Object
-
+  module NodeFactory
+    class Contact < NodeFactory::Object
       allow_extensions
 
       field "name", input_type: String
       field "url",
             input_type: String,
-            validate: ->(input) { Validators::Url.call(input) }
+            validate: Validation::InputValidator.new(Validators::Url)
       field "email",
             input_type: String,
-            validate: ->(input) { Validators::Email.call(input) }
+            validate: Validation::InputValidator.new(Validators::Email)
 
       private
 

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

@@ -4,10 +4,8 @@ require "openapi3_parser/node/discriminator"
 require "openapi3_parser/node_factory/object"
 
 module Openapi3Parser
-  module NodeFactories
-    class Discriminator
-      include NodeFactory::Object
-
+  module NodeFactory
+    class Discriminator < NodeFactory::Object
       field "propertyName", input_type: String, required: true
       field "mapping", input_type: Hash,
                        validate: :validate_mapping,
@@ -19,12 +17,13 @@ module Openapi3Parser
         Node::Discriminator.new(data, context)
       end
 
-      def validate_mapping(input)
+      def validate_mapping(validatable)
+        input = validatable.input
         return if input.empty?
         string_keys = input.keys.map(&:class).uniq == [String]
         string_values = input.values.map(&:class).uniq == [String]
-        valid = string_keys && string_values
-        return "Expected string keys and string values" unless valid
+        return if string_keys && string_values
+        validatable.add_error("Expected string keys and string values")
       end
     end
   end

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

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
 
 require "openapi3_parser/node/encoding"
+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_factory/header"
 
 module Openapi3Parser
-  module NodeFactories
-    class Encoding
-      include NodeFactory::Object
-
+  module NodeFactory
+    class Encoding < NodeFactory::Object
       allow_extensions
 
       field "contentType", input_type: String
@@ -26,8 +24,8 @@ 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 default_explode

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

@@ -3,12 +3,11 @@
 require "openapi3_parser/node/example"
 require "openapi3_parser/node_factory/object"
 require "openapi3_parser/validators/url"
+require "openapi3_parser/validation/input_validator"
 
 module Openapi3Parser
-  module NodeFactories
-    class Example
-      include NodeFactory::Object
-
+  module NodeFactory
+    class Example < NodeFactory::Object
       allow_extensions
 
       field "summary", input_type: String
@@ -16,7 +15,7 @@ module Openapi3Parser
       field "value"
       field "externalValue",
             input_type: String,
-            validate: ->(input) { Validators::Url.call(input) }
+            validate: Validation::InputValidator.new(Validators::Url)
 
       mutually_exclusive "value", "externalValue"
 

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

@@ -2,20 +2,19 @@
 
 require "openapi3_parser/node/external_documentation"
 require "openapi3_parser/node_factory/object"
+require "openapi3_parser/validation/input_validator"
 require "openapi3_parser/validators/url"
 
 module Openapi3Parser
-  module NodeFactories
-    class ExternalDocumentation
-      include NodeFactory::Object
-
+  module NodeFactory
+    class ExternalDocumentation < NodeFactory::Object
       allow_extensions
 
       field "description", input_type: String
       field "url",
             required: true,
             input_type: String,
-            validate: ->(input) { Validators::Url.call(input) }
+            validate: Validation::InputValidator.new(Validators::Url)
 
       private
 

data/lib/openapi3_parser/node_factory/field.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/node_factory"
+require "openapi3_parser/node_factory/type_checker"
+require "openapi3_parser/validation/validatable"
+
+module Openapi3Parser
+  module NodeFactory
+    class Field
+      attr_reader :context, :input_type, :validation
+
+      def initialize(context, input_type: nil, validate: nil)
+        @context = context
+        @input_type = input_type
+        @validation = validate
+      end
+
+      def data
+        context.input
+      end
+
+      def resolved_input
+        context.input
+      end
+
+      def raw_input
+        context.input
+      end
+
+      def nil_input?
+        context.input.nil?
+      end
+
+      def valid?
+        errors.empty?
+      end
+
+      def default
+        nil
+      end
+
+      def errors
+        @errors ||= ValidNodeBuilder.errors(self)
+      end
+
+      def node
+        @node ||= begin
+                    data = ValidNodeBuilder.data(self)
+                    data.nil? ? nil : build_node(data)
+                  end
+      end
+
+      def inspect
+        %{#{self.class.name}(#{context.source_location.inspect})}
+      end
+
+      private
+
+      def build_node(data)
+        data
+      end
+
+      class ValidNodeBuilder
+        def self.errors(factory)
+          new(factory).errors
+        end
+
+        def self.data(factory)
+          new(factory).data
+        end
+
+        def initialize(factory)
+          @factory = factory
+          @validatable = Validation::Validatable.new(factory)
+        end
+
+        def errors
+          return validatable.collection if factory.nil_input?
+          TypeChecker.validate_type(validatable, type: factory.input_type)
+          return validatable.collection if validatable.errors.any?
+          validate(raise_on_invalid: false)
+          validatable.collection
+        end
+
+        def data
+          return default_value if factory.nil_input?
+
+          TypeChecker.raise_on_invalid_type(factory.context,
+                                            type: factory.input_type)
+          validate(raise_on_invalid: true)
+          factory.data
+        end
+
+        private_class_method :new
+
+        private
+
+        attr_reader :factory, :validatable
+
+        def default_value
+          if factory.nil_input? && factory.default.nil?
+            nil
+          else
+            factory.data
+          end
+        end
+
+        def validate(raise_on_invalid: false)
+          run_validation
+
+          return if !raise_on_invalid || validatable.errors.empty?
+
+          first_error = validatable.errors.first
+          raise Openapi3Parser::Error::InvalidData,
+                "Invalid data for #{first_error.context.location_summary}. "\
+                "#{first_error.message}"
+        end
+
+        def run_validation
+          if factory.validation.is_a?(Symbol)
+            factory.send(factory.validation, validatable)
+          else
+            factory.validation&.call(validatable)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factory/fields/reference.rb

@@ -1,46 +1,82 @@
 # frozen_string_literal: true
 
-require "openapi3_parser/node_factory"
+require "forwardable"
+
+require "openapi3_parser/context"
+require "openapi3_parser/node_factory/field"
 require "openapi3_parser/validators/reference"
 
 module Openapi3Parser
   module NodeFactory
     module Fields
-      class Reference
-        include NodeFactory
-        input_type ::String
-
+      class Reference < NodeFactory::Field
         def initialize(context, factory)
-          super(context)
+          context = Context.as_reference(context)
+          super(context, input_type: String, validate: :validate)
           @factory = factory
-          @given_reference = context.input
+          @reference = context.input
           @reference_resolver = create_reference_resolver
         end
 
-        def data
-          reference_resolver&.data
+        def resolved_input
+          return unless reference_resolver
+
+          if in_recursive_loop?
+            RecursiveResolvedInput.new(reference_context)
+          else
+            reference_resolver.resolved_input
+          end
+        end
+
+        def in_recursive_loop?
+          context.source_location == reference_context&.source_location
+        end
+
+        def reference_context
+          context.referenced_by
         end
 
         private
 
-        attr_reader :given_reference, :factory, :reference_resolver
+        attr_reader :reference, :factory, :reference_resolver
 
-        def validate(_, _)
-          return reference_validator.errors unless reference_validator.valid?
-          reference_resolver&.errors
+        def build_node(_data)
+          reference_resolver&.node
         end
 
-        def build_node(_)
-          reference_resolver&.node
+        def validate(validatable)
+          if !reference_validator.valid?
+            validatable.add_errors(reference_validator.errors)
+          else
+            validatable.add_errors(reference_resolver&.errors)
+          end
         end
 
         def reference_validator
-          @reference_validator ||= Validators::Reference.new(given_reference)
+          @reference_validator ||= Validators::Reference.new(reference)
         end
 
         def create_reference_resolver
-          return unless given_reference
-          context.register_reference(given_reference, factory)
+          return unless reference_validator.valid?
+          context.register_reference(reference, factory)
+        end
+
+        # Used in the place of a hash for resolved input so the value can
+        # be looked up at runtime avoiding a recursive loop.
+        class RecursiveResolvedInput
+          extend Forwardable
+          include Enumerable
+
+          def_delegators :resolved_input, :each, :[], :keys
+          attr_reader :context
+
+          def initialize(context)
+            @context = context
+          end
+
+          def resolved_input
+            context.resolved_input
+          end
         end
       end
     end