openapi3_parser 0.4.0 → 0.5.0

data/lib/openapi3_parser/node_factory/openapi.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/node/openapi"
+require "openapi3_parser/node_factory/object"
+require "openapi3_parser/node_factory/info"
+require "openapi3_parser/node_factory/array"
+require "openapi3_parser/node_factory/server"
+require "openapi3_parser/node_factory/paths"
+require "openapi3_parser/node_factory/components"
+require "openapi3_parser/node_factory/security_requirement"
+require "openapi3_parser/node_factory/tag"
+require "openapi3_parser/node_factory/external_documentation"
+
+module Openapi3Parser
+  module NodeFactory
+    class Openapi < NodeFactory::Object
+      allow_extensions
+
+      field "openapi", input_type: String, required: true
+      field "info", factory: NodeFactory::Info, required: true
+      field "servers", factory: :servers_factory
+      field "paths", factory: NodeFactory::Paths, required: true
+      field "components", factory: NodeFactory::Components
+      field "security", factory: :security_factory
+      field "tags", factory: :tags_factory
+      field "externalDocs", factory: NodeFactory::ExternalDocumentation
+
+      def can_use_default?
+        false
+      end
+
+      private
+
+      def build_object(data, context)
+        Node::Openapi.new(data, context)
+      end
+
+      def servers_factory(context)
+        NodeFactory::Array.new(context,
+                               value_factory: NodeFactory::Server)
+      end
+
+      def security_factory(context)
+        NodeFactory::Array.new(context,
+                               value_factory: NodeFactory::SecurityRequirement)
+      end
+
+      def tags_factory(context)
+        validate_unique_tags = lambda do |validatable|
+          names = validatable.factory.context.input.map { |i| i["name"] }
+          return if names.uniq.count == names.count
+
+          dupes = names.find_all { |name| names.count(name) > 1 }
+          validatable.add_error(
+            "Duplicate tag names: #{dupes.uniq.join(', ')}"
+          )
+        end
+
+        NodeFactory::Array.new(context,
+                               value_factory: NodeFactory::Tag,
+                               validate: validate_unique_tags)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factory/operation.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/node/operation"
+require "openapi3_parser/node_factory/map"
+require "openapi3_parser/node_factory/object"
+require "openapi3_parser/node_factory/optional_reference"
+require "openapi3_parser/node_factory/array"
+require "openapi3_parser/node_factory/external_documentation"
+require "openapi3_parser/node_factory/parameter"
+require "openapi3_parser/node_factory/request_body"
+require "openapi3_parser/node_factory/responses"
+require "openapi3_parser/node_factory/callback"
+require "openapi3_parser/node_factory/server"
+require "openapi3_parser/node_factory/security_requirement"
+require "openapi3_parser/validators/duplicate_parameters"
+
+module Openapi3Parser
+  module NodeFactory
+    class Operation < NodeFactory::Object
+      allow_extensions
+      field "tags", factory: :tags_factory
+      field "summary", input_type: String
+      field "description", input_type: String
+      field "externalDocs", factory: NodeFactory::ExternalDocumentation
+      field "operationId", input_type: String
+      field "parameters", factory: :parameters_factory
+      field "requestBody", factory: :request_body_factory
+      field "responses", factory: NodeFactory::Responses,
+                         required: true
+      field "callbacks", factory: :callbacks_factory
+      field "deprecated", input_type: :boolean, default: false
+      field "security", factory: :security_factory
+      field "servers", factory: :servers_factory
+
+      private
+
+      def build_object(data, context)
+        Node::Operation.new(data, context)
+      end
+
+      def tags_factory(context)
+        NodeFactory::Array.new(context, value_input_type: String)
+      end
+
+      def parameters_factory(context)
+        factory = NodeFactory::OptionalReference.new(NodeFactory::Parameter)
+
+        validate_parameters = lambda do |validatable|
+          validatable.add_error(
+            Validators::DuplicateParameters.call(
+              validatable.factory.resolved_input
+            )
+          )
+        end
+
+        NodeFactory::Array.new(context,
+                               value_factory: factory,
+                               validate: validate_parameters)
+      end
+
+      def request_body_factory(context)
+        factory = NodeFactory::RequestBody
+        NodeFactory::OptionalReference.new(factory).call(context)
+      end
+
+      def callbacks_factory(context)
+        factory = NodeFactory::OptionalReference.new(NodeFactory::Callback)
+        NodeFactory::Map.new(context, value_factory: factory)
+      end
+
+      def responses_factory(context)
+        factory = NodeFactory::RequestBody
+        NodeFactory::OptionalReference.new(factory).call(context)
+      end
+
+      def security_factory(context)
+        NodeFactory::Array.new(context,
+                               value_factory: NodeFactory::SecurityRequirement)
+      end
+
+      def servers_factory(context)
+        NodeFactory::Array.new(context,
+                               value_factory: NodeFactory::Server)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factory/optional_reference.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "openapi3_parser/node_factories/reference"
+require "openapi3_parser/node_factory/reference"
 
 module Openapi3Parser
   module NodeFactory
@@ -11,8 +11,12 @@ module Openapi3Parser
 
       def call(context)
         reference = context.input.is_a?(Hash) && context.input["$ref"]
-        return NodeFactories::Reference.new(context, self) if reference
-        factory.new(context)
+
+        if reference
+          NodeFactory::Reference.new(context, self)
+        else
+          factory.new(context)
+        end
       end
 
       private

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

@@ -2,15 +2,14 @@
 
 require "openapi3_parser/context"
 require "openapi3_parser/node/parameter"
-require "openapi3_parser/node_factories/parameter/parameter_like"
+require "openapi3_parser/node_factory/parameter_like"
 require "openapi3_parser/node_factory/object"
 require "openapi3_parser/validation/error"
 
 module Openapi3Parser
-  module NodeFactories
-    class Parameter
-      include NodeFactory::Object
-      include Parameter::ParameterLike
+  module NodeFactory
+    class Parameter < NodeFactory::Object
+      include ParameterLike
 
       allow_extensions
 
@@ -34,24 +33,19 @@ module Openapi3Parser
 
       mutually_exclusive "example", "examples"
 
-      private
-
-      def build_object(data, context)
-        Node::Parameter.new(data, context)
-      end
-
-      def validate(input, context)
-        errors = []
-
-        if input["in"] == "path" && !input["required"]
-          errors << Validation::Error.new(
+      validate do |validatable|
+        if validatable.input["in"] == "path" && !validatable.input["required"]
+          validatable.add_error(
             "Must be included and true for a path parameter",
-            Context.next_field(context, "required"),
-            self.class
+            Context.next_field(validatable.context, "required")
           )
         end
+      end
+
+      private
 
-        errors
+      def build_object(data, context)
+        Node::Parameter.new(data, context)
       end
 
       def default_style
@@ -59,9 +53,9 @@ module Openapi3Parser
         "form"
       end
 
-      def validate_in(input)
-        valid = %w[header query cookie path].include?(input)
-        "in can only be header, query, cookie, or path" unless valid
+      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
   end

data/lib/openapi3_parser/node_factory/parameter_like.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Openapi3Parser
+  module NodeFactory
+    module ParameterLike
+      def default_explode
+        context.input["style"] == "form"
+      end
+
+      def schema_factory(context)
+        factory = NodeFactory::OptionalReference.new(NodeFactory::Schema)
+        factory.call(context)
+      end
+
+      def examples_factory(context)
+        factory = NodeFactory::OptionalReference.new(NodeFactory::Schema)
+        NodeFactory::Map.new(context,
+                             default: nil,
+                             value_factory: factory)
+      end
+
+      def content_factory(context)
+        NodeFactory::Map.new(context,
+                             default: nil,
+                             value_factory: NodeFactory::MediaType,
+                             validate: method(:validate_content))
+      end
+
+      def validate_content(validatable)
+        return if validatable.input.size == 1
+        validatable.add_error("Must only have one item")
+      end
+    end
+  end
+end
+
+# These are in the footer as a cyclic dependency can stop this module loading
+require "openapi3_parser/node_factory/optional_reference"
+require "openapi3_parser/node_factory/map"
+require "openapi3_parser/node_factory/schema"
+require "openapi3_parser/node_factory/example"
+require "openapi3_parser/node_factory/media_type"

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

@@ -3,19 +3,17 @@
 require "openapi3_parser/node/path_item"
 require "openapi3_parser/node_factory/fields/reference"
 require "openapi3_parser/node_factory/object"
-require "openapi3_parser/node_factory/object/node_builder"
+require "openapi3_parser/node_factory/object_factory/node_builder"
 require "openapi3_parser/node_factory/optional_reference"
-require "openapi3_parser/node_factories/array"
-require "openapi3_parser/node_factories/server"
-require "openapi3_parser/node_factories/operation"
-require "openapi3_parser/node_factories/parameter"
+require "openapi3_parser/node_factory/array"
+require "openapi3_parser/node_factory/server"
+require "openapi3_parser/node_factory/operation"
+require "openapi3_parser/node_factory/parameter"
 require "openapi3_parser/validators/duplicate_parameters"
 
 module Openapi3Parser
-  module NodeFactories
-    class PathItem
-      include NodeFactory::Object
-
+  module NodeFactory
+    class PathItem < NodeFactory::Object
       allow_extensions
       field "$ref", input_type: String, factory: :ref_factory
       field "summary", input_type: String
@@ -31,10 +29,6 @@ module Openapi3Parser
       field "servers", factory: :servers_factory
       field "parameters", factory: :parameters_factory
 
-      def node_data
-        NodeBuilder.new(processed_input, self).data
-      end
-
       private
 
       def build_object(data, context)
@@ -45,44 +39,48 @@ module Openapi3Parser
       end
 
       def ref_factory(context)
-        Fields::Reference.new(context, self.class)
+        NodeFactory::Fields::Reference.new(context, self.class)
       end
 
       def operation_factory(context)
-        NodeFactories::Operation.new(context)
+        NodeFactory::Operation.new(context)
       end
 
       def servers_factory(context)
-        NodeFactories::Array.new(
+        NodeFactory::Array.new(
           context,
-          value_factory: NodeFactories::Server
+          value_factory: NodeFactory::Server
         )
       end
 
       def build_resolved_input
-        ref = processed_input["$ref"]
-        data = super.tap { |d| d.delete("$ref") }
-        return data unless ref
+        ref = data["$ref"]
+        data_without_ref = super.tap { |d| d.delete("$ref") }
+        return data_without_ref unless ref
 
-        merge_data(ref.data || {}, data)
+        merge_data(ref.resolved_input || {}, data_without_ref)
       end
 
       def merge_data(base, priority)
-        base.merge(priority) do |_, new, old|
+        base.merge(priority) do |_, old, new|
           new.nil? ? old : new
         end
       end
 
       def parameters_factory(context)
-        factory = NodeFactory::OptionalReference.new(NodeFactories::Parameter)
-
-        validate = lambda do |_input, array_factory|
-          Validators::DuplicateParameters.call(array_factory.resolved_input)
+        factory = NodeFactory::OptionalReference.new(NodeFactory::Parameter)
+
+        validate_parameters = lambda do |validatable|
+          validatable.add_error(
+            Validators::DuplicateParameters.call(
+              validatable.factory.resolved_input
+            )
+          )
         end
 
-        NodeFactories::Array.new(context,
-                                 value_factory: factory,
-                                 validate: validate)
+        NodeFactory::Array.new(context,
+                               value_factory: factory,
+                               validate: validate_parameters)
       end
     end
   end

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

@@ -2,13 +2,12 @@
 
 require "openapi3_parser/node_factory/map"
 require "openapi3_parser/node_factory/optional_reference"
-require "openapi3_parser/node_factories/path_item"
+require "openapi3_parser/node_factory/path_item"
 require "openapi3_parser/node/paths"
 
 module Openapi3Parser
-  module NodeFactories
-    class Paths
-      include NodeFactory::Map
+  module NodeFactory
+    class Paths < NodeFactory::Map
       PATH_REGEX = %r{
         \A
         # required prefix slash
@@ -24,46 +23,41 @@ module Openapi3Parser
         \Z
       }x
 
-      private
+      def initialize(context)
+        factory = NodeFactory::OptionalReference.new(NodeFactory::PathItem)
 
-      def process_input(input)
-        input.each_with_object({}) do |(key, value), memo|
-          memo[key] = value if extension?(key)
-          next_context = Context.next_field(context, key)
-          memo[key] = child_factory(next_context)
-        end
+        super(context,
+              allow_extensions: true,
+              value_factory: factory,
+              validate: :validate)
       end
 
-      def child_factory(child_context)
-        NodeFactory::OptionalReference.new(NodeFactories::PathItem)
-                                      .call(child_context)
-      end
+      private
 
-      def build_map(data, context)
+      def build_node(data)
         Node::Paths.new(data, context)
       end
 
-      def validate(input, _context)
-        paths = input.keys.reject { |key| extension?(key) }
-        validate_paths(paths)
+      def validate(validatable)
+        paths = validatable.input.keys.reject do |key|
+          NodeFactory::EXTENSION_REGEX =~ key
+        end
+        validate_paths(validatable, paths)
       end
 
-      def validate_paths(paths)
+      def validate_paths(validatable, paths)
         invalid_paths = paths.reject { |p| PATH_REGEX.match(p) }
-        errors = []
         unless invalid_paths.empty?
           joined = invalid_paths.map { |p| "'#{p}'" }.join(", ")
-          errors << %(There are invalid paths: #{joined})
+          validatable.add_error("There are invalid paths: #{joined}")
         end
 
         conflicts = conflicting_paths(paths)
 
-        unless conflicts.empty?
-          joined = conflicts.map { |p| "'#{p}'" }.join(", ")
-          errors << %(There are paths that conflict: #{joined})
-        end
+        return if conflicts.empty?
 
-        errors
+        joined = conflicts.map { |p| "'#{p}'" }.join(", ")
+        validatable.add_error("There are paths that conflict: #{joined}")
       end
 
       def conflicting_paths(paths)