openapi3_parser 0.1.0

data/lib/openapi3_parser/node_factories/info.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/info"
+require "openapi3_parser/node_factories/license"
+require "openapi3_parser/node_factories/contact"
+require "openapi3_parser/node_factory/object"
+
+module Openapi3Parser
+  module NodeFactories
+    class Info
+      include NodeFactory::Object
+
+      allow_extensions
+      field "title", input_type: String, required: true
+      field "description", input_type: String
+      field "termsOfService", input_type: String
+      field "contact", factory: Contact
+      field "license", factory: License
+      field "version", input_type: String, required: true
+
+      private
+
+      def build_object(data, context)
+        Nodes::Info.new(data, context)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/license.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/license"
+require "openapi3_parser/node_factory/object"
+
+module Openapi3Parser
+  module NodeFactories
+    class License
+      include NodeFactory::Object
+
+      allow_extensions
+      field "name", input_type: String, required: true
+      field "url", input_type: String
+
+      private
+
+      def build_object(data, context)
+        Nodes::License.new(data, context)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/link.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/license"
+require "openapi3_parser/node_factory/object"
+require "openapi3_parser/node_factories/map"
+require "openapi3_parser/node_factories/server"
+
+module Openapi3Parser
+  module NodeFactories
+    class Link
+      include NodeFactory::Object
+
+      allow_extensions
+
+      # @TODO The link object in OAS is pretty meaty and there's lot of scope
+      # for further work here to make use of it's funcationality
+
+      field "operationRef", input_type: String
+      field "operationId", input_type: String
+      field "parameters", factory: :parameters_factory
+      field "requestBody"
+      field "description", input_type: String
+      field "server", factory: :server_factory
+
+      private
+
+      def build_object(data, context)
+        Nodes::Link.new(data, context)
+      end
+
+      def parameters_factory(context)
+        NodeFactories::Map.new(context)
+      end
+
+      def server_factory(context)
+        NodeFactories::Server.new(context)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/map.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/node_factory/map"
+require "openapi3_parser/nodes/map"
+require "openapi3_parser/validation/error"
+
+module Openapi3Parser
+  module NodeFactories
+    class Map
+      include NodeFactory::Map
+
+      def initialize(
+        context,
+        key_input_type: String,
+        value_input_type: nil,
+        value_factory: nil,
+        validate: nil
+      )
+        super(context)
+        @given_key_input_type = key_input_type
+        @given_value_input_type = value_input_type
+        @given_value_factory = value_factory
+        @given_validate = validate
+      end
+
+      private
+
+      attr_reader :given_key_input_type, :given_value_input_type,
+                  :given_value_factory, :given_validate
+
+      def process_input(input)
+        input.each_with_object({}) do |(key, value), memo|
+          memo[key] = if value_factory?
+                        initialize_value_factory(context.next_namespace(key))
+                      else
+                        value
+                      end
+        end
+      end
+
+      def validate_type
+        error = super
+        return error if error
+        return unless given_key_input_type
+        invalid_keys = context.input.keys.reject do |key|
+          key.is_a?(given_key_input_type)
+        end
+        error = "Expected keys to be of type #{given_key_input_type}"
+        return error if invalid_keys.any?
+      end
+
+      def validate(input, context)
+        given_validate&.call(input, context)
+      end
+
+      def validate_input(error_collection)
+        super(error_collection)
+        error_collection.merge(
+          validate_value_input_type(processed_input, context)
+        )
+      end
+
+      def build_node(input)
+        check_value_input_type(input)
+        super(input)
+      end
+
+      def build_map(data, context)
+        Nodes::Map.new(data, context)
+      end
+
+      def value_factory?
+        !given_value_factory.nil?
+      end
+
+      def initialize_value_factory(context)
+        factory = given_value_factory
+        return factory.new(context) if factory.is_a?(Class)
+        factory.call(context)
+      end
+
+      def validate_value_input_type(input, context)
+        input.each_with_object([]) do |(key, value), memo|
+          error = error_for_value_input_type(value)
+          next unless error
+          memo << Validation::Error.new(
+            context.next_namespace(key), error
+          )
+        end
+      end
+
+      def check_value_input_type(input)
+        input.each do |key, value|
+          error = error_for_value_input_type(value)
+          next unless error
+          next_context = context.next_namespace(key)
+          raise Openapi3Parser::Error,
+                "Invalid type for #{next_context.stringify_namespace}. "\
+                "#{error}"
+        end
+      end
+
+      def error_for_value_input_type(value)
+        type = given_value_input_type
+        return unless type
+        "Expected #{type}" unless value.is_a?(type)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/media_type.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/media_type"
+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"
+
+module Openapi3Parser
+  module NodeFactories
+    class MediaType
+      include NodeFactory::Object
+
+      allow_extensions
+      field "schema", factory: :schema_factory
+      field "example"
+      field "examples", factory: :examples_factory
+      field "encoding", factory: :encoding_factory
+
+      private
+
+      def build_object(data, context)
+        Nodes::MediaType.new(data, context)
+      end
+
+      def schema_factory(context)
+        factory = NodeFactories::Schema
+        NodeFactory::OptionalReference.new(factory).call(context)
+      end
+
+      def examples_factory(context)
+        factory = NodeFactory::OptionalReference.new(NodeFactories::Example)
+        NodeFactories::Map.new(context, value_factory: factory)
+      end
+
+      def encoding_factory(context)
+        factory = NodeFactories::Encoding
+        NodeFactories::Map.new(context, value_factory: factory)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/oauth_flow.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/oauth_flow"
+require "openapi3_parser/node_factory/object"
+
+module Openapi3Parser
+  module NodeFactories
+    class OauthFlow
+      include NodeFactory::Object
+
+      allow_extensions
+      field "authorizationUrl", input_type: String
+      field "tokenUrl", input_type: String
+      field "refreshUrl", input_type: String
+      field "scopes", input_type: Hash
+
+      private
+
+      def build_object(data, context)
+        Nodes::OauthFlow.new(data, context)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/oauth_flows.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/oauth_flows"
+require "openapi3_parser/node_factories/oauth_flow"
+require "openapi3_parser/node_factory/object"
+require "openapi3_parser/node_factory/optional_reference"
+
+module Openapi3Parser
+  module NodeFactories
+    class OauthFlows
+      include NodeFactory::Object
+
+      allow_extensions
+      field "implicit", factory: :oauth_flow_factory
+      field "password", factory: :oauth_flow_factory
+      field "clientCredentials", factory: :oauth_flow_factory
+      field "authorizationCode", factory: :oauth_flow_factory
+
+      private
+
+      def oauth_flow_factory(context)
+        NodeFactory::OptionalReference.new(NodeFactories::OauthFlow)
+                                      .call(context)
+      end
+
+      def build_object(data, context)
+        Nodes::OauthFlows.new(data, context)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/openapi.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/openapi"
+require "openapi3_parser/node_factory/object"
+require "openapi3_parser/node_factories/info"
+require "openapi3_parser/node_factories/array"
+require "openapi3_parser/node_factories/server"
+require "openapi3_parser/node_factories/paths"
+require "openapi3_parser/node_factories/components"
+require "openapi3_parser/node_factories/security_requirement"
+require "openapi3_parser/node_factories/tag"
+require "openapi3_parser/node_factories/external_documentation"
+
+module Openapi3Parser
+  module NodeFactories
+    class Openapi
+      include NodeFactory::Object
+
+      allow_extensions
+      field "openapi", input_type: String, required: true
+      field "info", factory: NodeFactories::Info, required: true
+      field "servers", factory: :servers_factory
+      field "paths", factory: NodeFactories::Paths, required: true
+      field "components", factory: NodeFactories::Components
+      field "security", factory: :security_factory
+      field "tags", factory: :tags_factory
+      field "externalDocs", factory: NodeFactories::ExternalDocumentation
+
+      private
+
+      def build_object(data, context)
+        Nodes::Openapi.new(data, context)
+      end
+
+      def servers_factory(context)
+        NodeFactories::Array.new(context, value_factory: NodeFactories::Server)
+      end
+
+      def security_factory(context)
+        NodeFactories::Array.new(
+          context, value_factory: NodeFactories::SecurityRequirement
+        )
+      end
+
+      def tags_factory(context)
+        NodeFactories::Array.new(context, value_factory: NodeFactories::Tag)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/operation.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/operation"
+require "openapi3_parser/node_factory/object"
+require "openapi3_parser/node_factory/optional_reference"
+require "openapi3_parser/node_factories/array"
+require "openapi3_parser/node_factories/external_documentation"
+require "openapi3_parser/node_factories/parameter"
+require "openapi3_parser/node_factories/request_body"
+require "openapi3_parser/node_factories/responses"
+require "openapi3_parser/node_factories/callback"
+require "openapi3_parser/node_factories/server"
+require "openapi3_parser/node_factories/security_requirement"
+
+module Openapi3Parser
+  module NodeFactories
+    class Operation
+      include NodeFactory::Object
+
+      allow_extensions
+      field "tags", factory: :tags_factory
+      field "summary", input_type: String
+      field "description", input_type: String
+      field "externalDocs", factory: NodeFactories::ExternalDocumentation
+      field "operationId", input_type: String
+      field "parameters", factory: :parameters_factory
+      field "requestBody", factory: :request_body_factory
+      field "responses", factory: NodeFactories::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)
+        Nodes::Operation.new(data, context)
+      end
+
+      def tags_factory(context)
+        NodeFactories::Array.new(context, value_input_type: String)
+      end
+
+      def parameters_factory(context)
+        factory = NodeFactory::OptionalReference.new(NodeFactories::Parameter)
+        NodeFactories::Array.new(context, value_factory: factory)
+      end
+
+      def request_body_factory(context)
+        factory = NodeFactories::RequestBody
+        NodeFactory::OptionalReference.new(factory).call(context)
+      end
+
+      def callbacks_factory(context)
+        factory = NodeFactory::OptionalReference.new(NodeFactories::Callback)
+        NodeFactories::Map.new(context, value_factory: factory)
+      end
+
+      def responses_factory(context)
+        factory = NodeFactories::RequestBody
+        NodeFactory::OptionalReference.new(factory).call(context)
+      end
+
+      def security_factory(context)
+        NodeFactories::Array.new(
+          context, value_factory: NodeFactories::SecurityRequirement
+        )
+      end
+
+      def servers_factory(context)
+        NodeFactories::Array.new(context, value_factory: NodeFactories::Server)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/parameter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/parameter"
+require "openapi3_parser/node_factories/parameter/parameter_like"
+require "openapi3_parser/node_factory/object"
+
+module Openapi3Parser
+  module NodeFactories
+    class Parameter
+      include NodeFactory::Object
+      include Parameter::ParameterLike
+
+      allow_extensions
+
+      field "name", input_type: String, required: true
+      field "in", input_type: String, required: true
+      field "description", input_type: String
+      field "required", input_type: :boolean, default: false
+      field "deprecated", input_type: :boolean, default: false
+      field "allowEmptyValue", input_type: :boolean, default: false
+
+      field "style", input_type: String, default: :default_style
+      field "explode", input_type: :boolean, default: :default_explode
+      field "allowReserved", input_type: :boolean, default: false
+      field "schema", factory: :schema_factory
+      field "example"
+      field "examples", factory: :examples_factory
+
+      field "content", factory: :content_factory
+
+      private
+
+      def build_object(data, context)
+        Nodes::Parameter.new(data, context)
+      end
+
+      def default_style
+        return "simple" if %w[path header].include?(context.input["in"])
+        "form"
+      end
+    end
+  end
+end