openapi3_parser 0.4.0 → 0.5.0

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

@@ -2,32 +2,30 @@
 
 require "openapi3_parser/node/server_variable"
 require "openapi3_parser/node_factory/object"
-require "openapi3_parser/node_factories/array"
+require "openapi3_parser/node_factory/array"
 
 module Openapi3Parser
-  module NodeFactories
-    class ServerVariable
-      include NodeFactory::Object
-
+  module NodeFactory
+    class ServerVariable < NodeFactory::Object
       allow_extensions
-      field "enum", factory: :enum_factory, validate: :validate_enum
+      field "enum", factory: :enum_factory
       field "default", input_type: String, required: true
       field "description", input_type: String
 
       private
 
       def enum_factory(context)
-        NodeFactories::Array.new(
+        NodeFactory::Array.new(
           context,
           default: nil,
-          value_input_type: String
+          value_input_type: String,
+          validate: lambda do |validatable|
+            return if validatable.input.any?
+            validatable.add_error("Expected atleast one value")
+          end
         )
       end
 
-      def validate_enum(input)
-        return "Expected atleast one value" if input.empty?
-      end
-
       def build_object(data, context)
         Node::ServerVariable.new(data, context)
       end

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

@@ -2,17 +2,15 @@
 
 require "openapi3_parser/node/tag"
 require "openapi3_parser/node_factory/object"
-require "openapi3_parser/node_factories/external_documentation"
+require "openapi3_parser/node_factory/external_documentation"
 
 module Openapi3Parser
-  module NodeFactories
-    class Tag
-      include NodeFactory::Object
-
+  module NodeFactory
+    class Tag < NodeFactory::Object
       allow_extensions
       field "name", input_type: String, required: true
       field "description", input_type: String
-      field "externalDocs", factory: NodeFactories::ExternalDocumentation
+      field "externalDocs", factory: NodeFactory::ExternalDocumentation
 
       private
 

data/lib/openapi3_parser/node_factory/type_checker.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/error"
+require "openapi3_parser/node_factory"
+
+module Openapi3Parser
+  module NodeFactory
+    class TypeChecker
+      def self.validate_type(validatable, type:, context: nil)
+        new(type).validate_type(validatable, context)
+      end
+
+      def self.raise_on_invalid_type(context, type:)
+        new(type).raise_on_invalid_type(context)
+      end
+
+      def self.validate_keys(validatable, type:, context: nil)
+        new(type).validate_keys(validatable, context)
+      end
+
+      def self.raise_on_invalid_keys(context, type:)
+        new(type).raise_on_invalid_keys(context)
+      end
+
+      private_class_method :new
+
+      def initialize(type)
+        @type = type
+      end
+
+      def validate_type(validatable, context)
+        return true unless type
+        context ||= validatable.context
+        valid_type?(context.input).tap do |valid|
+          next if valid
+          validatable.add_error("Invalid type. #{field_error_message}",
+                                context)
+        end
+      end
+
+      def validate_keys(validatable, context)
+        return true unless type
+        context ||= validatable.context
+        valid_keys?(context.input).tap do |valid|
+          next if valid
+          validatable.add_error("Invalid keys. #{keys_error_message}",
+                                context)
+        end
+      end
+
+      def raise_on_invalid_type(context)
+        return true if !type || valid_type?(context.input)
+        raise Error::InvalidType,
+              "Invalid type for #{context.location_summary}: "\
+              "#{field_error_message}"
+      end
+
+      def raise_on_invalid_keys(context)
+        return true if !type || valid_keys?(context.input)
+        raise Error::InvalidType,
+              "Invalid keys for #{context.location_summary}: "\
+              "#{keys_error_message}"
+      end
+
+      private
+
+      attr_reader :type
+
+      def valid_type?(input)
+        return [true, false].include?(input) if type == :boolean
+
+        unless type.is_a?(Class)
+          raise Error::UnvalidatableType,
+                "Expected #{type} to be a Class not a #{type.class}"
+        end
+
+        input.is_a?(type)
+      end
+
+      def field_error_message
+        "Expected #{type_name_for_error}"
+      end
+
+      def keys_error_message
+        "Expected keys to be of type #{type_name_for_error}"
+      end
+
+      def type_name_for_error
+        if type == Hash
+          "Object"
+        elsif type == :boolean
+          "Boolean"
+        else
+          type.to_s
+        end
+      end
+
+      def valid_keys?(input)
+        input.keys.all? { |key| valid_type?(key) }
+      end
+    end
+  end
+end

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

@@ -3,17 +3,16 @@
 require "openapi3_parser/node/xml"
 require "openapi3_parser/node_factory/object"
 require "openapi3_parser/validators/absolute_uri"
+require "openapi3_parser/validation/input_validator"
 
 module Openapi3Parser
-  module NodeFactories
-    class Xml
-      include NodeFactory::Object
-
+  module NodeFactory
+    class Xml < NodeFactory::Object
       allow_extensions
       field "name", input_type: String
       field "namespace",
             input_type: String,
-            validate: ->(input) { Validators::AbsoluteUri.call(input) }
+            validate: Validation::InputValidator.new(Validators::AbsoluteUri)
       field "prefix", input_type: String
       field "attribute", input_type: :boolean, default: false
       field "wrapped", input_type: :boolean, default: false

data/lib/openapi3_parser/source/reference_resolver.rb

@@ -16,7 +16,7 @@ module Openapi3Parser
         @reference_factory ||= begin
                                  next_context = Context.reference_field(
                                    context,
-                                   input: data,
+                                   input: source.data_at_pointer(json_pointer),
                                    source: source,
                                    pointer_segments: json_pointer
                                  )
@@ -24,8 +24,8 @@ module Openapi3Parser
                                end
       end
 
-      def data
-        source.data_at_pointer(json_pointer)
+      def resolved_input
+        reference_factory.resolved_input
       end
 
       def valid?

data/lib/openapi3_parser/validation/error.rb

@@ -34,6 +34,7 @@ module Openapi3Parser
       # @return [String, nil]
       def for_type
         return unless factory_class
+        return "(anonymous)" unless factory_class.name
         factory_class.name.split("::").last
       end
 
@@ -42,6 +43,14 @@ module Openapi3Parser
         "#{self.class.name}(message: #{message}, context: #{context}, " \
           "for_type: #{for_type})"
       end
+
+      # @return [Boolean]
+      def ==(other)
+        return false unless other.instance_of?(self.class)
+        message == other.message &&
+          context == other.context &&
+          factory_class == other.factory_class
+      end
     end
   end
 end

data/lib/openapi3_parser/validation/input_validator.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Openapi3Parser
+  module Validation
+    class InputValidator
+      attr_reader :callable
+
+      def initialize(callable)
+        @callable = callable
+      end
+
+      def call(validatable)
+        error = @callable.call(validatable.input)
+        validatable.add_error(error) if error
+      end
+    end
+  end
+end

data/lib/openapi3_parser/validation/validatable.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/validation/error"
+require "openapi3_parser/validation/error_collection"
+
+module Openapi3Parser
+  module Validation
+    class Validatable
+      attr_reader :context, :errors, :factory
+
+      UNDEFINED = Class.new
+
+      def initialize(factory, context: nil)
+        @factory = factory
+        @context = context || factory.context
+        @errors = []
+      end
+
+      def input
+        context.input
+      end
+
+      def add_error(error, given_context = nil, factory_class = UNDEFINED)
+        return unless error
+        return @errors << error if error.is_a?(Validation::Error)
+
+        @errors << Validation::Error.new(
+          error,
+          given_context || context,
+          factory_class == UNDEFINED ? factory.class : factory_class
+        )
+      end
+
+      def add_errors(errors)
+        errors = errors.to_a if errors.respond_to?(:to_a)
+        errors.each { |e| add_error(e) }
+      end
+
+      def collection
+        ErrorCollection.new(errors)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/validators/mutually_exclusive_fields.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/array_sentence"
+require "openapi3_parser/error"
+
+module Openapi3Parser
+  module Validators
+    class MutuallyExclusiveFields
+      using ArraySentence
+      private_class_method :new
+
+      def self.call(*args)
+        new.call(*args)
+      end
+
+      def call(validatable,
+               mutually_exclusive_fields:,
+               raise_on_invalid: true)
+        mutually_exclusive = MutuallyExclusiveFieldErrors.new(
+          mutually_exclusive_fields, validatable.input
+        )
+
+        handle_required_errors(validatable,
+                               mutually_exclusive.required_errors,
+                               raise_on_invalid)
+        handle_exclusive_errors(validatable,
+                                mutually_exclusive.exclusive_errors,
+                                raise_on_invalid)
+      end
+
+      private
+
+      def handle_required_errors(validatable,
+                                 required_errors,
+                                 raise_on_invalid)
+        return unless required_errors.any?
+
+        if raise_on_invalid
+          location_summary = validatable.context.location_summary
+          raise Error::MissingFields,
+                "Mutually exclusive fields for "\
+                "#{location_summary}: #{required_errors.first}"
+        else
+          validatable.add_errors(required_errors)
+        end
+      end
+
+      def handle_exclusive_errors(validatable,
+                                  exclusive_errors,
+                                  raise_on_invalid)
+        return unless exclusive_errors.any?
+
+        if raise_on_invalid
+          location_summary = validatable.context.location_summary
+          raise Error::UnexpectedFields,
+                "Mutually exclusive fields for "\
+                "#{location_summary}: "\
+                "#{exclusive_errors.first}"
+        else
+          validatable.add_errors(exclusive_errors)
+        end
+      end
+
+      class MutuallyExclusiveFieldErrors
+        using ArraySentence
+
+        def initialize(mutually_exclusive_fields, input)
+          @mutually_exclusive_fields = mutually_exclusive_fields
+          @input = input
+        end
+
+        def required_errors
+          errors[:required]
+        end
+
+        def exclusive_errors
+          errors[:exclusive]
+        end
+
+        def errors
+          @errors ||= begin
+                        default = { required: [], exclusive: [] }
+                        mutually_exclusive_fields
+                          .each_with_object(default) do |exclusive, errors|
+                            add_error(errors, exclusive)
+                          end
+                      end
+        end
+
+        private
+
+        attr_reader :mutually_exclusive_fields, :input
+
+        def add_error(errors, mutually_exclusive)
+          fields = mutually_exclusive.fields
+          number_non_nil = count_non_nil_fields(fields)
+          if number_non_nil.zero? && mutually_exclusive.required
+            errors[:required] << required_error(fields)
+          elsif number_non_nil > 1
+            errors[:exclusive] << exclusive_error(fields)
+          end
+        end
+
+        def count_non_nil_fields(fields)
+          fields.count do |field|
+            data = input[field]
+            data.respond_to?(:nil_input?) ? !data.nil_input? : !data.nil?
+          end
+        end
+
+        def required_error(fields)
+          "One of #{fields.sentence_join} is required"
+        end
+
+        def exclusive_error(fields)
+          "#{fields.sentence_join} are mutually exclusive fields"
+        end
+      end
+    end
+  end
+end

data/lib/openapi3_parser/validators/required_fields.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/array_sentence"
+require "openapi3_parser/error"
+
+module Openapi3Parser
+  module Validators
+    class RequiredFields
+      using ArraySentence
+      private_class_method :new
+
+      def self.call(*args)
+        new.call(*args)
+      end
+
+      def call(validatable,
+               required_fields:,
+               raise_on_invalid: true)
+        input = validatable.input
+        missing_fields = required_fields.select { |name| input[name].nil? }
+
+        return if missing_fields.empty?
+
+        if raise_on_invalid
+          location_summary = validatable.context.location_summary
+          raise Openapi3Parser::Error::MissingFields,
+                "Missing required fields for "\
+                "#{location_summary}: #{missing_fields.sentence_join}"
+        else
+          validatable.add_error(
+            "Missing required fields: #{missing_fields.sentence_join}"
+          )
+        end
+      end
+    end
+  end
+end