openapi3_parser 0.6.1 → 0.9.0

data/lib/openapi3_parser/node_factory/object_factory/dsl.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
-require "ostruct"
 require "openapi3_parser/node_factory/object_factory/field_config"
 
 module Openapi3Parser
   module NodeFactory
     module ObjectFactory
       module Dsl
+        MutuallyExclusiveField = Struct.new(:fields, :required, keyword_init: true)
+
         def field(name, **options)
           @field_configs ||= {}
-          @field_configs[name] = FieldConfig.new(options)
+          @field_configs[name] = FieldConfig.new(**options)
         end
 
         def field_configs
@@ -30,8 +31,9 @@ module Openapi3Parser
 
         def mutually_exclusive(*fields, required: false)
           @mutually_exclusive_fields ||= []
-          @mutually_exclusive_fields << OpenStruct.new(
-            fields: fields, required: required
+          @mutually_exclusive_fields << MutuallyExclusiveField.new(
+            fields: fields,
+            required: required
           )
         end
 
@@ -41,7 +43,7 @@ module Openapi3Parser
 
         def validate(*items, &block)
           @validations ||= []
-          @validations = @validations.concat(items)
+          @validations.concat(items)
           @validations << block if block
         end
 

data/lib/openapi3_parser/node_factory/object_factory/field_config.rb

@@ -22,10 +22,11 @@ module Openapi3Parser
           !given_factory.nil?
         end
 
-        def initialize_factory(context, parent_factory)
-          if given_factory.is_a?(Class)
+        def initialize_factory(context, parent_factory = nil)
+          case given_factory
+          when Class
             given_factory.new(context)
-          elsif given_factory.is_a?(Symbol)
+          when Symbol
             parent_factory.send(given_factory, context)
           else
             given_factory.call(context)
@@ -36,7 +37,7 @@ module Openapi3Parser
           given_required
         end
 
-        def check_input_type(validatable, building_node)
+        def check_input_type(validatable, building_node: false)
           return true if !given_input_type || validatable.input.nil?
 
           if building_node
@@ -47,7 +48,7 @@ module Openapi3Parser
           end
         end
 
-        def validate_field(validatable, building_node)
+        def validate_field(validatable, building_node: false)
           return true if !given_validate || validatable.input.nil?
 
           run_validation(validatable)
@@ -61,9 +62,10 @@ module Openapi3Parser
                 "Invalid data for #{location_summary}: #{error.message}"
         end
 
-        def default(factory)
+        def default(factory = nil)
           return given_default.call if given_default.is_a?(Proc)
-          return factory.send(given_default) if given_default.is_a?(Symbol)
+          return factory&.send(given_default) if given_default.is_a?(Symbol)
+
           given_default
         end
 

data/lib/openapi3_parser/node_factory/object_factory/node_builder.rb

@@ -8,8 +8,8 @@ module Openapi3Parser
           new(factory).errors
         end
 
-        def self.node_data(factory, parent_context)
-          new(factory).node_data(parent_context)
+        def self.node_data(factory, node_context)
+          new(factory).node_data(node_context)
         end
 
         def initialize(factory)
@@ -22,18 +22,17 @@ module Openapi3Parser
 
           TypeChecker.validate_type(validatable, type: ::Hash)
 
-          if validatable.errors.empty?
-            validatable.add_errors(validate(raise_on_invalid: false))
-          end
+          validatable.add_errors(validate(raise_on_invalid: false)) if validatable.errors.empty?
 
           validatable.collection
         end
 
-        def node_data(parent_context)
-          return build_node_data(parent_context) if empty_and_allowed_to_be?
+        def node_data(node_context)
+          return build_node_data(node_context) if empty_and_allowed_to_be?
+
           TypeChecker.raise_on_invalid_type(factory.context, type: ::Hash)
           validate(raise_on_invalid: true)
-          build_node_data(parent_context)
+          build_node_data(node_context)
         end
 
         private_class_method :new
@@ -47,22 +46,22 @@ module Openapi3Parser
         end
 
         def validate(raise_on_invalid:)
-          Validator.call(factory, raise_on_invalid)
+          Validator.call(factory, raise_on_invalid: raise_on_invalid)
         end
 
-        def build_node_data(parent_context)
+        def build_node_data(node_context)
           return if factory.nil_input? && factory.data.nil?
 
           factory.data.each_with_object({}) do |(key, value), memo|
-            memo[key] = resolve_value(key, value, parent_context)
+            memo[key] = resolve_value(key, value, node_context)
           end
         end
 
-        def resolve_value(key, value, parent_context)
+        def resolve_value(key, value, node_context)
           resolved = determine_value_or_default(key, value)
 
           if resolved.respond_to?(:node)
-            Node::Placeholder.new(value, key, parent_context)
+            Node::Placeholder.new(value, key, node_context)
           else
             resolved
           end

data/lib/openapi3_parser/node_factory/object_factory/validator.rb

@@ -7,15 +7,15 @@ module Openapi3Parser
     module ObjectFactory
       class Validator
         private_class_method :new
-        attr_reader :factory, :validatable, :building_node
+        attr_reader :factory, :validatable, :raise_on_invalid
 
-        def self.call(*args)
-          new(*args).call
+        def self.call(*args, **kwargs)
+          new(*args, **kwargs).call
         end
 
-        def initialize(factory, building_node)
+        def initialize(factory, raise_on_invalid: false)
           @factory = factory
-          @building_node = building_node
+          @raise_on_invalid = raise_on_invalid
           @validatable = Validation::Validatable.new(factory)
         end
 
@@ -34,7 +34,7 @@ module Openapi3Parser
           Validators::RequiredFields.call(
             validatable,
             required_fields: factory.required_fields,
-            raise_on_invalid: building_node
+            raise_on_invalid: raise_on_invalid
           )
         end
 
@@ -43,7 +43,7 @@ module Openapi3Parser
             validatable,
             allow_extensions: factory.allowed_extensions?,
             allowed_fields: factory.allowed_fields,
-            raise_on_invalid: building_node
+            raise_on_invalid: raise_on_invalid
           )
         end
 
@@ -51,7 +51,7 @@ module Openapi3Parser
           Validators::MutuallyExclusiveFields.call(
             validatable,
             mutually_exclusive_fields: factory.mutually_exclusive_fields,
-            raise_on_invalid: building_node
+            raise_on_invalid: raise_on_invalid
           )
         end
 
@@ -66,7 +66,8 @@ module Openapi3Parser
         class CheckInvalidFields
           extend Forwardable
           attr_reader :validator
-          def_delegators :validator, :factory, :building_node, :validatable
+
+          def_delegators :validator, :factory, :raise_on_invalid, :validatable
           private_class_method :new
 
           def self.call(validator)
@@ -81,22 +82,21 @@ module Openapi3Parser
             factory.data.each do |name, field|
               # references can reference themselves and become in a loop
               next if in_recursive_loop?(field)
+
               has_factory_errors = handle_factory_checks(name)
 
               next if has_factory_errors || !field.respond_to?(:errors)
 
               # We don't add errors when we're building a node as they will
               # be raised when that child node is built
-              validatable.add_errors(field.errors) unless building_node
+              validatable.add_errors(field.errors) unless raise_on_invalid
             end
           end
 
           private
 
           def handle_factory_checks(name)
-            field_errors = if factory.field_configs[name]
-                             check_field(name, factory.field_configs[name])
-                           end
+            field_errors = (check_field(name, factory.field_configs[name]) if factory.field_configs[name])
 
             (field_errors || []).any?
           end
@@ -108,16 +108,20 @@ module Openapi3Parser
           def check_field(name, field_config)
             return if factory.raw_input[name].nil?
 
-            field_validatable = Validation::Validatable.new(
-              factory,
-              context: Context.next_field(factory.context, name)
-            )
+            context = Context.next_field(factory.context,
+                                         name,
+                                         factory.raw_input[name])
+            field_validatable = Validation::Validatable.new(factory,
+                                                            context: context)
 
-            valid_input_type = field_config.check_input_type(field_validatable,
-                                                             building_node)
+            valid_input_type = field_config.check_input_type(
+              field_validatable,
+              building_node: raise_on_invalid
+            )
 
             if valid_input_type
-              field_config.validate_field(field_validatable, building_node)
+              field_config.validate_field(field_validatable,
+                                          building_node: raise_on_invalid)
             end
 
             validatable.add_errors(field_validatable.errors)
@@ -137,7 +141,7 @@ module Openapi3Parser
 
             errors = validator.validatable.errors
 
-            return if errors.empty? || !validator.building_node
+            return if errors.empty? || !validator.raise_on_invalid
 
             location_summary = errors.first.context.location_summary
             raise Error::InvalidData,

data/lib/openapi3_parser/node_factory/openapi.rb

@@ -32,6 +32,8 @@ module Openapi3Parser
 
       def servers_factory(context)
         NodeFactory::Array.new(context,
+                               default: [{ "url" => "/" }],
+                               use_default_on_empty: true,
                                value_factory: NodeFactory::Server)
       end
 

data/lib/openapi3_parser/node_factory/operation.rb

@@ -25,6 +25,8 @@ module Openapi3Parser
       private
 
       def build_object(data, context)
+        data["servers"] = path_item_server_data(context) if data["servers"].node.empty?
+
         Node::Operation.new(data, context)
       end
 
@@ -72,6 +74,13 @@ module Openapi3Parser
         NodeFactory::Array.new(context,
                                value_factory: NodeFactory::Server)
       end
+
+      def path_item_server_data(node_context)
+        path_item_servers = node_context.parent_node.node_data["servers"]
+        Node::Placeholder.new(path_item_servers.node_factory,
+                              "servers",
+                              node_context)
+      end
     end
   end
 end

data/lib/openapi3_parser/node_factory/parameter.rb

@@ -47,11 +47,13 @@ module Openapi3Parser
 
       def default_style
         return "simple" if %w[path header].include?(context.input["in"])
+
         "form"
       end
 
       def validate_in(validatable)
         return if %w[header query cookie path].include?(validatable.input)
+
         validatable.add_error("in can only be header, query, cookie, or path")
       end
     end

data/lib/openapi3_parser/node_factory/parameter_like.rb

@@ -13,7 +13,7 @@ module Openapi3Parser
       end
 
       def examples_factory(context)
-        factory = NodeFactory::OptionalReference.new(NodeFactory::Schema)
+        factory = NodeFactory::OptionalReference.new(NodeFactory::Example)
         NodeFactory::Map.new(context,
                              default: nil,
                              value_factory: factory)
@@ -28,6 +28,7 @@ module Openapi3Parser
 
       def validate_content(validatable)
         return if validatable.input.size == 1
+
         validatable.add_error("Must only have one item")
       end
     end

data/lib/openapi3_parser/node_factory/path_item.rb

@@ -23,11 +23,22 @@ module Openapi3Parser
       private
 
       def build_object(data, node_context)
-        ref = data.delete("$ref").node
-        return Node::PathItem.new(data, node_context) unless ref
+        ref = data.delete("$ref")
+        context = if node_context.input.keys == %w[$ref]
+                    referenced_factory = ref.node_factory.referenced_factory
+                    Node::Context.resolved_reference(
+                      node_context,
+                      referenced_factory.context
+                    )
+                  else
+                    node_context
+                  end
 
-        context = data.empty? ? ref.node_context : node_context
-        data = merge_data(ref.node_data, data)
+        reference_data = ref.nil_input? ? {} : ref.node.node_data
+
+        data = merge_data(reference_data, data).tap do |d|
+          d["servers"] = root_server_data(context) if d["servers"].node.empty?
+        end
 
         Node::PathItem.new(data, context)
       end
@@ -57,7 +68,11 @@ module Openapi3Parser
 
       def merge_data(base, priority)
         base.merge(priority) do |_, old, new|
-          new.nil? ? old : new
+          if new.nil? || new.respond_to?(:nil_input?) && new.nil_input?
+            old
+          else
+            new
+          end
         end
       end
 
@@ -76,6 +91,13 @@ module Openapi3Parser
                                value_factory: factory,
                                validate: validate_parameters)
       end
+
+      def root_server_data(node_context)
+        root_servers = node_context.document.root.node_data["servers"]
+        Node::Placeholder.new(root_servers.node_factory,
+                              "servers",
+                              node_context)
+      end
     end
   end
 end

data/lib/openapi3_parser/node_factory/paths.rb

@@ -18,7 +18,7 @@ module Openapi3Parser
           /?
         )*
         \Z
-      }x
+      }x.freeze
 
       def initialize(context)
         factory = NodeFactory::OptionalReference.new(NodeFactory::PathItem)

data/lib/openapi3_parser/node_factory/reference.rb

@@ -32,11 +32,19 @@ module Openapi3Parser
         referenced_factory.resolves?(control_factory)
       end
 
+      def errors
+        if in_recursive_loop?
+          @errors ||= Validation::ErrorCollection.new
+        else
+          super
+        end
+      end
+
       private
 
       def build_node(node_context)
         TypeChecker.raise_on_invalid_type(context, type: ::Hash)
-        ObjectFactory::Validator.call(self, true)
+        ObjectFactory::Validator.call(self, raise_on_invalid: true)
         data["$ref"].node(node_context)
       end
 

data/lib/openapi3_parser/node_factory/request_body.rb

@@ -32,11 +32,9 @@ module Openapi3Parser
         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.
-          if validatable.input.size.zero?
-            return validatable.add_error("Expected to have at least 1 item")
-          end
+          return validatable.add_error("Expected to have at least 1 item") if validatable.input.size.zero?
 
-          validatable.input.keys.each do |key|
+          validatable.input.each_key do |key|
             message = Validators::MediaType.call(key)
             next unless message
 

data/lib/openapi3_parser/node_factory/response.rb

@@ -43,6 +43,7 @@ module Openapi3Parser
         validatable.input.each_key do |key|
           message = Validators::MediaType.call(key)
           next unless message
+
           validatable.add_error(message,
                                 Context.next_field(validatable.context, key))
         end

data/lib/openapi3_parser/node_factory/responses.rb

@@ -13,7 +13,7 @@ module Openapi3Parser
         [1-5]([0-9][0-9]|XX)
         )
         \Z
-      /x
+      /x.freeze
 
       def initialize(context)
         factory = NodeFactory::OptionalReference.new(NodeFactory::Response)