openapi3_parser 0.4.0 → 0.5.0

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

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
 require "openapi3_parser/node/header"
-require "openapi3_parser/node_factories/parameter/parameter_like"
+require "openapi3_parser/node_factory/parameter_like"
 require "openapi3_parser/node_factory/object"
 
 module Openapi3Parser
-  module NodeFactories
-    class Header
-      include NodeFactory::Object
-      include Parameter::ParameterLike
+  module NodeFactory
+    class Header < NodeFactory::Object
+      include ParameterLike
 
       allow_extensions
 

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

@@ -1,22 +1,21 @@
 # frozen_string_literal: true
 
 require "openapi3_parser/node/info"
-require "openapi3_parser/node_factories/license"
-require "openapi3_parser/node_factories/contact"
+require "openapi3_parser/node_factory/license"
+require "openapi3_parser/node_factory/contact"
 require "openapi3_parser/node_factory/object"
+require "openapi3_parser/validation/input_validator"
 require "openapi3_parser/validators/url"
 
 module Openapi3Parser
-  module NodeFactories
-    class Info
-      include NodeFactory::Object
-
+  module NodeFactory
+    class Info < NodeFactory::Object
       allow_extensions
       field "title", input_type: String, required: true
       field "description", input_type: String
       field "termsOfService",
             input_type: String,
-            validate: ->(input) { Validators::Url.call(input) }
+            validate: Validation::InputValidator.new(Validators::Url)
       field "contact", factory: Contact
       field "license", factory: License
       field "version", input_type: String, required: true

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

@@ -3,17 +3,16 @@
 require "openapi3_parser/node/license"
 require "openapi3_parser/node_factory/object"
 require "openapi3_parser/validators/url"
+require "openapi3_parser/validation/input_validator"
 
 module Openapi3Parser
-  module NodeFactories
-    class License
-      include NodeFactory::Object
-
+  module NodeFactory
+    class License < NodeFactory::Object
       allow_extensions
       field "name", input_type: String, required: true
       field "url",
             input_type: String,
-            validate: ->(input) { Validators::Url.call(input) }
+            validate: Validation::InputValidator.new(Validators::Url)
 
       private
 

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

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 
 require "openapi3_parser/node/license"
+require "openapi3_parser/node_factory/map"
 require "openapi3_parser/node_factory/object"
-require "openapi3_parser/node_factories/map"
-require "openapi3_parser/node_factories/server"
+require "openapi3_parser/node_factory/server"
 
 module Openapi3Parser
-  module NodeFactories
-    class Link
-      include NodeFactory::Object
-
+  module NodeFactory
+    class Link < NodeFactory::Object
       allow_extensions
 
       # @todo The link object in OAS is pretty meaty and there's lot of scope
@@ -31,11 +29,11 @@ module Openapi3Parser
       end
 
       def parameters_factory(context)
-        NodeFactories::Map.new(context)
+        NodeFactory::Map.new(context)
       end
 
       def server_factory(context)
-        NodeFactories::Server.new(context)
+        NodeFactory::Server.new(context)
       end
     end
   end

data/lib/openapi3_parser/node_factory/map.rb

@@ -1,42 +1,107 @@
 # frozen_string_literal: true
 
+require "openapi3_parser/array_sentence"
+require "openapi3_parser/context"
 require "openapi3_parser/node_factory"
-require "openapi3_parser/validation/error_collection"
+require "openapi3_parser/node_factory/type_checker"
+require "openapi3_parser/node/map"
+require "openapi3_parser/validation/validatable"
+require "openapi3_parser/validators/unexpected_fields"
 
 module Openapi3Parser
   module NodeFactory
-    module Map
-      include NodeFactory
+    class Map
+      attr_reader :allow_extensions, :context, :data, :default,
+                  :key_input_type, :value_input_type, :value_factory,
+                  :validation
 
-      def self.included(base)
-        base.extend(NodeFactory::ClassMethods)
-        base.class_eval do
-          input_type Hash
-        end
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(
+        context,
+        allow_extensions: false,
+        default: {},
+        key_input_type: String,
+        value_input_type: nil,
+        value_factory: nil,
+        validate: nil
+      )
+        @context = context
+        @allow_extensions = allow_extensions
+        @default = default
+        @key_input_type = key_input_type
+        @value_input_type = value_input_type
+        @value_factory = value_factory
+        @validation = validate
+        @data = build_data(context.input)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def raw_input
+        context.input
+      end
+
+      def resolved_input
+        @resolved_input ||= build_resolved_input
+      end
+
+      def nil_input?
+        context.input.nil?
+      end
+
+      def valid?
+        errors.empty?
+      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(input)
-        data = input.each_with_object({}) do |(key, value), memo|
-          memo[key] = value.respond_to?(:node) ? value.node : value
+      def build_data(raw_input)
+        use_default = nil_input? || !raw_input.is_a?(::Hash)
+        return if use_default && default.nil?
+        process_data(use_default ? default : raw_input)
+      end
+
+      def process_data(data)
+        data.each_with_object({}) do |(key, value), memo|
+          memo[key] = if EXTENSION_REGEX =~ key || !value_factory
+                        value
+                      else
+                        next_context = Context.next_field(context, key)
+                        initialize_value_factory(next_context)
+                      end
         end
-        build_map(data, context)
       end
 
-      def validate_input
-        processed_input.each_value.inject(super) do |memo, value|
-          errors = value.respond_to?(:errors) ? value.errors : []
-          Validation::ErrorCollection.combine(memo, errors)
+      def initialize_value_factory(field_context)
+        if value_factory.is_a?(Class)
+          value_factory.new(field_context)
+        else
+          value_factory.call(field_context)
         end
       end
 
-      def build_map(data, _)
-        data
+      def build_node(data)
+        Node::Map.new(data, context) if data
       end
 
       def build_resolved_input
-        processed_input.each_with_object({}) do |(key, value), memo|
+        return unless data
+
+        data.each_with_object({}) do |(key, value), memo|
           memo[key] = if value.respond_to?(:resolved_input)
                         value.resolved_input
                       else
@@ -45,8 +110,128 @@ module Openapi3Parser
         end
       end
 
-      def default
-        {}
+      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: ::Hash)
+          return validatable.collection if validatable.errors.any?
+          collate_errors
+          validatable.collection
+        end
+
+        def data
+          return default_value if factory.nil_input?
+
+          TypeChecker.raise_on_invalid_type(factory.context, type: ::Hash)
+          check_unexpected_fields(raise_on_invalid: true)
+          check_keys(raise_on_invalid: true)
+          check_values(raise_on_invalid: true)
+          validate(raise_on_invalid: true)
+
+          factory.data.each_with_object({}) do |(key, value), memo|
+            memo[key] = value.respond_to?(:node) ? value.node : value
+          end
+        end
+
+        private_class_method :new
+
+        private
+
+        attr_reader :factory, :validatable
+
+        def collate_errors
+          check_unexpected_fields(raise_on_invalid: false)
+          check_keys(raise_on_invalid: false)
+          check_values(raise_on_invalid: false)
+          validate(raise_on_invalid: false)
+
+          factory.data.each_value do |value|
+            validatable.add_errors(value.errors) if value.respond_to?(:errors)
+          end
+        end
+
+        def default_value
+          if factory.nil_input? && factory.default.nil?
+            nil
+          else
+            factory.data
+          end
+        end
+
+        def check_unexpected_fields(raise_on_invalid: false)
+          Validators::UnexpectedFields.call(
+            validatable,
+            allowed_fields: nil,
+            raise_on_invalid: raise_on_invalid,
+            allow_extensions: factory.allow_extensions
+          )
+        end
+
+        def check_keys(raise_on_invalid: false)
+          return unless factory.key_input_type
+
+          if raise_on_invalid
+            TypeChecker.raise_on_invalid_keys(factory.context,
+                                              type: factory.key_input_type)
+          else
+            TypeChecker.validate_keys(validatable,
+                                      type: factory.key_input_type,
+                                      context: factory.context)
+          end
+        end
+
+        def check_values(raise_on_invalid: false)
+          return unless factory.value_input_type
+
+          factory.context.input.keys.each do |key|
+            check_field_type(
+              Context.next_field(factory.context, key), raise_on_invalid
+            )
+          end
+        end
+
+        def check_field_type(context, raise_on_invalid)
+          if raise_on_invalid
+            TypeChecker.raise_on_invalid_type(context,
+                                              type: factory.value_input_type)
+          else
+            TypeChecker.validate_type(validatable,
+                                      type: factory.value_input_type,
+                                      context: context)
+          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

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

@@ -1,18 +1,16 @@
 # frozen_string_literal: true
 
 require "openapi3_parser/node/media_type"
+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/schema"
-require "openapi3_parser/node_factories/example"
-require "openapi3_parser/node_factories/encoding"
+require "openapi3_parser/node_factory/schema"
+require "openapi3_parser/node_factory/example"
+require "openapi3_parser/node_factory/encoding"
 
 module Openapi3Parser
-  module NodeFactories
-    class MediaType
-      include NodeFactory::Object
-
+  module NodeFactory
+    class MediaType < NodeFactory::Object
       allow_extensions
 
       field "schema", factory: :schema_factory
@@ -29,20 +27,22 @@ module Openapi3Parser
       end
 
       def schema_factory(context)
-        factory = NodeFactories::Schema
+        factory = NodeFactory::Schema
         NodeFactory::OptionalReference.new(factory).call(context)
       end
 
       def examples_factory(context)
-        factory = NodeFactory::OptionalReference.new(NodeFactories::Example)
-        NodeFactories::Map.new(context, default: nil, value_factory: factory)
+        factory = NodeFactory::OptionalReference.new(NodeFactory::Example)
+        NodeFactory::Map.new(context,
+                             default: nil,
+                             value_factory: factory)
       end
 
       def encoding_factory(context)
-        NodeFactories::Map.new(
+        NodeFactory::Map.new(
           context,
           validate: EncodingValidator.new(self),
-          value_factory: NodeFactories::Encoding
+          value_factory: NodeFactory::Encoding
         )
       end
 
@@ -51,9 +51,10 @@ module Openapi3Parser
           @factory = factory
         end
 
-        def call(input, _context)
-          missing_keys = input.keys - properties
-          error_message(missing_keys) unless missing_keys.empty?
+        def call(validatable)
+          missing_keys = validatable.input.keys - properties
+          return if missing_keys.empty?
+          validatable.add_error(error_message(missing_keys))
         end
 
         private

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

@@ -4,10 +4,8 @@ require "openapi3_parser/node/oauth_flow"
 require "openapi3_parser/node_factory/object"
 
 module Openapi3Parser
-  module NodeFactories
-    class OauthFlow
-      include NodeFactory::Object
-
+  module NodeFactory
+    class OauthFlow < NodeFactory::Object
       allow_extensions
       field "authorizationUrl", input_type: String
       field "tokenUrl", input_type: String

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

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 
 require "openapi3_parser/node/oauth_flows"
-require "openapi3_parser/node_factories/oauth_flow"
+require "openapi3_parser/node_factory/oauth_flow"
 require "openapi3_parser/node_factory/object"
 require "openapi3_parser/node_factory/optional_reference"
 
 module Openapi3Parser
-  module NodeFactories
-    class OauthFlows
-      include NodeFactory::Object
-
+  module NodeFactory
+    class OauthFlows < NodeFactory::Object
       allow_extensions
       field "implicit", factory: :oauth_flow_factory
       field "password", factory: :oauth_flow_factory
@@ -19,7 +17,7 @@ module Openapi3Parser
       private
 
       def oauth_flow_factory(context)
-        NodeFactory::OptionalReference.new(NodeFactories::OauthFlow)
+        NodeFactory::OptionalReference.new(NodeFactory::OauthFlow)
                                       .call(context)
       end