openapi3_parser 0.1.0

data/lib/openapi3_parser/node_factories/parameter/parameter_like.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Openapi3Parser
+  module NodeFactories
+    class Parameter
+      module ParameterLike
+        def default_explode
+          context.input["style"] == "form"
+        end
+
+        def schema_factory(context)
+          factory = NodeFactory::OptionalReference.new(NodeFactories::Schema)
+          factory.call(context)
+        end
+
+        def examples_factory(context)
+          factory = NodeFactory::OptionalReference.new(NodeFactories::Schema)
+          NodeFactories::Map.new(context, value_factory: factory)
+        end
+
+        def content_factory(context)
+          factory = NodeFactory::OptionalReference.new(
+            NodeFactories::MediaType
+          )
+          NodeFactories::Map.new(context, value_factory: factory)
+        end
+      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_factories/schema"
+require "openapi3_parser/node_factories/map"
+require "openapi3_parser/node_factories/example"
+require "openapi3_parser/node_factories/media_type"

data/lib/openapi3_parser/node_factories/path_item.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/path_item"
+require "openapi3_parser/node_factory/object"
+require "openapi3_parser/node_factory/object/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"
+
+module Openapi3Parser
+  module NodeFactories
+    class PathItem
+      include NodeFactory::Object
+
+      allow_extensions
+      field "$ref", input_type: String
+      field "summary", input_type: String
+      field "description", input_type: String
+      field "get", factory: :operation_factory
+      field "put", factory: :operation_factory
+      field "post", factory: :operation_factory
+      field "delete", factory: :operation_factory
+      field "options", factory: :operation_factory
+      field "head", factory: :operation_factory
+      field "patch", factory: :operation_factory
+      field "trace", factory: :operation_factory
+      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)
+        merged_data = merge_reference(data, context)
+        merged_data.delete("$ref")
+        Nodes::PathItem.new(merged_data, context)
+      end
+
+      def operation_factory(context)
+        NodeFactories::Operation.new(context)
+      end
+
+      def servers_factory(context)
+        NodeFactories::Array.new(
+          context,
+          value_factory: NodeFactories::Server
+        )
+      end
+
+      def parameters_factory(context)
+        factory = NodeFactory::OptionalReference.new(NodeFactories::Parameter)
+        NodeFactories::Array.new(context, value_factory: factory)
+      end
+
+      def merge_reference(data, context)
+        return data unless data["$ref"]
+        factory = context.resolve_reference do |ref_context|
+          self.class.new(ref_context)
+        end
+
+        # @TODO In this situation we're basically sacrificing the reference
+        # context as we don't know how to merge them. Should develop a system
+        # to have a dual context
+        factory.node_data.merge(data) do |_, new, old|
+          new.nil? ? old : new
+        end
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/paths.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/node_factory/map"
+require "openapi3_parser/node_factory/optional_reference"
+require "openapi3_parser/node_factories/path_item"
+require "openapi3_parser/nodes/paths"
+
+module Openapi3Parser
+  module NodeFactories
+    class Paths
+      include NodeFactory::Map
+
+      private
+
+      def process_input(input)
+        input.each_with_object({}) do |(key, value), memo|
+          memo[key] = value if extension?(key)
+          memo[key] = child_factory(context.next_namespace(key))
+        end
+      end
+
+      def child_factory(child_context)
+        NodeFactory::OptionalReference.new(NodeFactories::PathItem)
+                                      .call(child_context)
+      end
+
+      def build_map(data, context)
+        Nodes::Paths.new(data, context)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/reference.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/node_factory/object"
+
+module Openapi3Parser
+  module NodeFactories
+    class Reference
+      include NodeFactory::Object
+
+      field "$ref", input_type: String, required: true
+
+      attr_reader :factory
+
+      def initialize(context, factory)
+        super(context)
+        @factory = factory
+      end
+
+      private
+
+      def build_object(_, context)
+        context.resolve_reference do |ref_context|
+          resolve_factory(ref_context).node
+        end
+      end
+
+      def resolve_factory(ref_context)
+        return factory.new(ref_context) if factory.is_a?(Class)
+        factory.call(ref_context)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/request_body.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/request_body"
+require "openapi3_parser/node_factory/object"
+require "openapi3_parser/node_factories/media_type"
+require "openapi3_parser/node_factories/map"
+
+module Openapi3Parser
+  module NodeFactories
+    class RequestBody
+      include NodeFactory::Object
+
+      allow_extensions
+      field "description", input_type: String
+      field "content", factory: :content_factory, required: true
+      field "required", input_type: :boolean, default: false
+
+      private
+
+      def build_object(data, context)
+        Nodes::RequestBody.new(data, context)
+      end
+
+      def content_factory(context)
+        NodeFactories::Map.new(
+          context, value_factory: NodeFactories::MediaType
+        )
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/response.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/response"
+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_factories/media_type"
+require "openapi3_parser/node_factories/link"
+
+module Openapi3Parser
+  module NodeFactories
+    class Response
+      include NodeFactory::Object
+
+      allow_extensions
+      field "description", input_type: String, required: true
+      field "headers", factory: :headers_factory
+      field "content", factory: :content_factory
+      field "links", factory: :links_factory
+
+      private
+
+      def build_object(data, context)
+        Nodes::Response.new(data, context)
+      end
+
+      def headers_factory(context)
+        factory = NodeFactory::OptionalReference.new(NodeFactories::Header)
+        NodeFactories::Map.new(context, value_factory: factory)
+      end
+
+      def content_factory(context)
+        NodeFactories::Map.new(
+          context, value_factory: NodeFactories::MediaType
+        )
+      end
+
+      def links_factory(context)
+        factory = NodeFactory::OptionalReference.new(NodeFactories::Link)
+        NodeFactories::Map.new(context, value_factory: factory)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/responses.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/node_factory/map"
+require "openapi3_parser/node_factory/optional_reference"
+require "openapi3_parser/nodes/responses"
+require "openapi3_parser/node_factories/response"
+
+module Openapi3Parser
+  module NodeFactories
+    class Responses
+      include NodeFactory::Map
+
+      private
+
+      def process_input(input)
+        input.each_with_object({}) do |(key, value), memo|
+          memo[key] = value if extension?(key)
+          memo[key] = child_factory(context.next_namespace(key))
+        end
+      end
+
+      def child_factory(child_context)
+        NodeFactory::OptionalReference.new(NodeFactories::Response)
+                                      .call(child_context)
+      end
+
+      def build_map(data, context)
+        Nodes::Responses.new(data, context)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/schema.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/schema"
+require "openapi3_parser/node_factory/object"
+require "openapi3_parser/node_factory/optional_reference"
+require "openapi3_parser/node_factories/map"
+require "openapi3_parser/node_factories/array"
+require "openapi3_parser/node_factories/external_documentation"
+require "openapi3_parser/node_factories/discriminator"
+require "openapi3_parser/node_factories/xml"
+
+module Openapi3Parser
+  module NodeFactories
+    class Schema
+      include NodeFactory::Object
+
+      allow_extensions
+      field "title", input_type: String
+      field "multipleOf", input_type: Numeric
+      field "maximum", input_type: Integer
+      field "exclusiveMaximum", input_type: :boolean, default: false
+      field "minimum", input_type: Integer
+      field "exclusiveMinimum", input_type: :boolean, default: false
+      field "maxLength", input_type: Integer
+      field "minLength", input_type: Integer, default: 0
+      field :pattern, input_type: String
+      field "maxItems", input_type: Integer
+      field "minItems", input_type: Integer, default: 0
+      field "uniqueItems", input_type: :boolean, default: false
+      field "maxProperties", input_type: Integer
+      field "minProperties", input_type: Integer, default: 0
+      field "required", input_type: ::Array
+      field "enum", input_type: ::Array
+
+      field "type", input_type: String
+      field "allOf", factory: :referenceable_schema_array
+      field "oneOf", factory: :referenceable_schema_array
+      field "anyOf", factory: :referenceable_schema_array
+      field "not", factory: :referenceable_schema
+      field "items", factory: :referenceable_schema
+      field "properties", factory: :properties_factory
+      field "additionalProperties",
+            input_type: :additional_properties_input_type,
+            factory: :additional_properties_factory,
+            default: false
+      field "description", input_type: String
+      field "format", input_type: String
+      field "default"
+
+      field "nullable", input_type: :boolean, default: false
+      field "discriminator", factory: :disciminator_factory
+      field "readOnly", input_type: :boolean, default: false
+      field "writeOnly", input_type: :boolean, default: false
+      field "xml", factory: :xml_factory
+      field "externalDocs", factory: :external_docs_factory
+      field "example"
+      field "deprecated", input_type: :boolean, default: false
+
+      private
+
+      def build_object(data, context)
+        Nodes::Schema.new(data, context)
+      end
+
+      def disciminator_factory(context)
+        NodeFactories::Discriminator.new(context)
+      end
+
+      def xml_factory(context)
+        NodeFactories::Xml.new(context)
+      end
+
+      def external_docs_factory(context)
+        NodeFactories::ExternalDocumentation.new(context)
+      end
+
+      def properties_factory(context)
+        NodeFactories::Map.new(
+          context,
+          value_factory: NodeFactories::Schema
+        )
+      end
+
+      def referenceable_schema(context)
+        NodeFactory::OptionalReference.new(self.class).call(context)
+      end
+
+      def referenceable_schema_array(context)
+        NodeFactories::Array.new(
+          context,
+          value_factory: NodeFactory::OptionalReference.new(self.class)
+        )
+      end
+
+      def additional_properties_input_type(input)
+        return if [true, false].include?(input) || input.is_a?(Hash)
+        "Expected a boolean or an object"
+      end
+
+      def additional_properties_factory(context)
+        return context.input if [true, false].include?(context.input)
+        referenceable_schema(context)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/security_requirement.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/security_requirement"
+require "openapi3_parser/node_factory/map"
+require "openapi3_parser/node_factories/array"
+
+module Openapi3Parser
+  module NodeFactories
+    class SecurityRequirement
+      include NodeFactory::Map
+
+      private
+
+      def process_input(input)
+        input.keys.each_with_object({}) do |key, memo|
+          memo[key] = NodeFactories::Array.new(context.next_namespace(key))
+        end
+      end
+
+      def build_map(data, context)
+        Nodes::SecurityRequirement.new(data, context)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/security_scheme.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/security_scheme"
+require "openapi3_parser/node_factories/oauth_flows"
+require "openapi3_parser/node_factory/object"
+require "openapi3_parser/node_factory/optional_reference"
+
+module Openapi3Parser
+  module NodeFactories
+    class SecurityScheme
+      include NodeFactory::Object
+
+      allow_extensions
+
+      field "type", input_type: String, required: true
+      field "description", input_type: String
+      field "name", input_type: String
+      field "in", input_type: String
+      field "scheme", input_type: String
+      field "bearerFormat", input_type: String
+      field "flows", factory: :flows_factory
+      field "openIdConnectUrl", input_type: String
+
+      private
+
+      def build_object(data, context)
+        Nodes::SecurityScheme.new(data, context)
+      end
+
+      def flows_factory(context)
+        NodeFactories::OauthFlows.new(context)
+      end
+    end
+  end
+end