openapi3_parser 0.1.0

data/lib/openapi3_parser/node/map.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Openapi3Parser
+  module Node
+    module Map
+      include Enumerable
+
+      attr_reader :node_data, :node_context
+
+      def initialize(data, context)
+        @node_data = data
+        @node_context = context
+      end
+
+      def [](value)
+        node_data[value]
+      end
+
+      def each(&block)
+        node_data.each(&block)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node/object.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Openapi3Parser
+  module Node
+    module Object
+      include Enumerable
+
+      attr_reader :node_data, :node_context
+
+      def initialize(data, context)
+        @node_data = data
+        @node_context = context
+      end
+
+      def [](value)
+        node_data[value]
+      end
+
+      def extension(value)
+        node_data["x-#{value}"]
+      end
+
+      def each(&block)
+        node_data.each(&block)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/array.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/node_factory"
+require "openapi3_parser/nodes/array"
+require "openapi3_parser/validation/error"
+
+module Openapi3Parser
+  module NodeFactories
+    class Array
+      include NodeFactory
+      input_type ::Array
+
+      def initialize(
+        context,
+        value_input_type: nil,
+        value_factory: nil,
+        validate: nil
+      )
+        super(context)
+        @given_value_input_type = value_input_type
+        @given_value_factory = value_factory
+        @given_validate = validate
+      end
+
+      private
+
+      attr_reader :given_value_input_type, :given_value_factory,
+                  :given_validate
+
+      def process_input(input)
+        input.each_with_index.map do |value, i|
+          if value_factory?
+            initialize_value_factory(context.next_namespace(i))
+          else
+            value
+          end
+        end
+      end
+
+      def validate(input, context)
+        given_validate&.call(input, context)
+      end
+
+      def validate_input(error_collection)
+        super(error_collection)
+        processed_input.each do |value|
+          next unless value.respond_to?(:errors)
+          error_collection.merge(value.errors)
+        end
+        error_collection.merge(
+          validate_value_input_type(processed_input, context)
+        )
+      end
+
+      def build_node(input)
+        check_value_input_type(input)
+        data = input.map do |value|
+          value.respond_to?(:node) ? value.node : value
+        end
+        build_array(data, context)
+      end
+
+      def build_array(data, context)
+        Nodes::Array.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_index.each_with_object([]) do |(value, i), memo|
+          error = error_for_value_input_type(value)
+          next unless error
+          memo << Validation::Error.new(
+            context.next_namespace(i), error
+          )
+        end
+      end
+
+      def check_value_input_type(input)
+        input.each_with_index do |value, i|
+          error = error_for_value_input_type(value)
+          next unless error
+          next_context = context.next_namespace(i)
+          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/callback.rb

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

data/lib/openapi3_parser/node_factories/components.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/components"
+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/response"
+require "openapi3_parser/node_factories/parameter"
+require "openapi3_parser/node_factories/example"
+require "openapi3_parser/node_factories/request_body"
+require "openapi3_parser/node_factories/header"
+require "openapi3_parser/node_factories/security_scheme"
+require "openapi3_parser/node_factories/link"
+require "openapi3_parser/node_factories/callback"
+
+module Openapi3Parser
+  module NodeFactories
+    class Components
+      include NodeFactory::Object
+
+      allow_extensions
+      field "schemas", factory: :schemas_factory
+      field "responses", factory: :responses_factory
+      field "parameters", factory: :parameters_factory
+      field "examples", factory: :examples_factory
+      field "requestBodies", factory: :request_bodies_factory
+      field "headers", factory: :headers_factory
+      field "securitySchemes", factory: :security_schemes_factory
+      field "links", factory: :links_factory
+      field "callbacks", factory: :callbacks_factory
+
+      private
+
+      def build_object(data, context)
+        Nodes::Components.new(data, context)
+      end
+
+      def schemas_factory(context)
+        referenceable_map_factory(context, NodeFactories::Schema)
+      end
+
+      def responses_factory(context)
+        referenceable_map_factory(context, NodeFactories::Response)
+      end
+
+      def parameters_factory(context)
+        referenceable_map_factory(context, NodeFactories::Parameter)
+      end
+
+      def examples_factory(context)
+        referenceable_map_factory(context, NodeFactories::Example)
+      end
+
+      def request_bodies_factory(context)
+        referenceable_map_factory(context, NodeFactories::RequestBody)
+      end
+
+      def headers_factory(context)
+        referenceable_map_factory(context, NodeFactories::Header)
+      end
+
+      def security_schemes_factory(context)
+        referenceable_map_factory(context, NodeFactories::SecurityScheme)
+      end
+
+      def links_factory(context)
+        referenceable_map_factory(context, NodeFactories::Link)
+      end
+
+      def callbacks_factory(context)
+        referenceable_map_factory(context, NodeFactories::Callback)
+      end
+
+      def referenceable_map_factory(context, factory)
+        NodeFactories::Map.new(
+          context,
+          value_factory: NodeFactory::OptionalReference.new(factory)
+        )
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/contact.rb

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

data/lib/openapi3_parser/node_factories/discriminator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/discriminator"
+require "openapi3_parser/node_factory/object"
+
+module Openapi3Parser
+  module NodeFactories
+    class Discriminator
+      include NodeFactory::Object
+
+      field "propertyName", input_type: String, required: true
+      field "mapping", input_type: Hash,
+                       validate: :validate_mapping,
+                       default: -> { {}.freeze }
+
+      private
+
+      def build_object(data, context)
+        Nodes::Discriminator.new(data, context)
+      end
+
+      def validate_mapping(input)
+        return if input.empty?
+        string_keys = input.keys.map(&:class).uniq == [String]
+        string_values = input.values.map(&:class).uniq == [String]
+        valid = string_keys && string_values
+        return "Expected string keys and string values" unless valid
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/encoding.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/encoding"
+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"
+
+module Openapi3Parser
+  module NodeFactories
+    class Encoding
+      include NodeFactory::Object
+
+      allow_extensions
+
+      field "contentType", input_type: String
+      field "headers", factory: :headers_factory
+      field "style", input_type: String
+      field "explode", input_type: :boolean, default: true
+      field "allowReserved", input_type: :boolean, default: false
+
+      private
+
+      def build_object(data, context)
+        Nodes::Encoding.new(data, context)
+      end
+
+      def headers_factory(context)
+        factory = NodeFactory::OptionalReference.new(NodeFactories::Header)
+        NodeFactories::Map.new(context, value_factory: factory)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/example.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/example"
+require "openapi3_parser/node_factory/object"
+
+module Openapi3Parser
+  module NodeFactories
+    class Example
+      include NodeFactory::Object
+
+      allow_extensions
+
+      field "summary", input_type: String
+      field "description", input_type: String
+      field "value"
+      field "externalValue", input_type: String
+
+      private
+
+      def build_object(data, context)
+        Nodes::Example.new(data, context)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/external_documentation.rb

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

data/lib/openapi3_parser/node_factories/header.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/header"
+require "openapi3_parser/node_factories/parameter/parameter_like"
+require "openapi3_parser/node_factory/object"
+
+module Openapi3Parser
+  module NodeFactories
+    class Header
+      include NodeFactory::Object
+      include Parameter::ParameterLike
+
+      allow_extensions
+
+      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: "simple"
+      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::Header.new(data, context)
+      end
+    end
+  end
+end