openapi3_parser 0.4.0 → 0.5.0

data/lib/openapi3_parser/node_factories/openapi.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require "openapi3_parser/node/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
-      disallow_default
-
-      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)
-        Node::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)
-        validate_unique_tags = lambda do |input, _context|
-          names = input.map { |i| i["name"] }
-          return if names.uniq.count == names.count
-
-          dupes = names.find_all { |name| names.count(name) > 1 }
-          "Duplicate tag names: #{dupes.uniq.join(', ')}"
-        end
-
-        NodeFactories::Array.new(context,
-                                 value_factory: NodeFactories::Tag,
-                                 validate: validate_unique_tags)
-      end
-    end
-  end
-end

data/lib/openapi3_parser/node_factories/operation.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require "openapi3_parser/node/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"
-require "openapi3_parser/validators/duplicate_parameters"
-
-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)
-        Node::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)
-
-        validate = lambda do |_input, array_factory|
-          Validators::DuplicateParameters.call(array_factory.resolved_input)
-        end
-
-        NodeFactories::Array.new(context,
-                                 value_factory: factory,
-                                 validate: validate)
-      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/parameter_like.rb

@@ -1,41 +0,0 @@
-# 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, default: nil, value_factory: factory)
-        end
-
-        def content_factory(context)
-          NodeFactories::Map.new(context,
-                                 default: nil,
-                                 value_factory: NodeFactories::MediaType,
-                                 validate: method(:validate_content).to_proc)
-        end
-
-        def validate_content(input, _context)
-          "Must only have one item" unless input.size == 1
-        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/reference.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "openapi3_parser/node_factory/object"
-require "openapi3_parser/node_factory/fields/reference"
-
-module Openapi3Parser
-  module NodeFactories
-    class Reference
-      include NodeFactory::Object
-
-      field "$ref", input_type: String, required: true, factory: :ref_factory
-
-      attr_reader :factory
-
-      def initialize(context, factory)
-        @factory = factory
-        super(context)
-      end
-
-      private
-
-      def build_node(input)
-        input["$ref"].node
-      end
-
-      def ref_factory(context)
-        Fields::Reference.new(context, factory)
-      end
-
-      def build_resolved_input
-        processed_input["$ref"].data
-      end
-    end
-  end
-end

data/lib/openapi3_parser/node_factories/responses.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require "openapi3_parser/context"
-require "openapi3_parser/node_factories/response"
-require "openapi3_parser/node_factory/map"
-require "openapi3_parser/node_factory/optional_reference"
-require "openapi3_parser/node/responses"
-
-module Openapi3Parser
-  module NodeFactories
-    class Responses
-      include NodeFactory::Map
-
-      KEY_REGEX = /
-        \A
-        (
-        default
-        |
-        [1-5]([0-9][0-9]|XX)
-        )
-        \Z
-      /x
-
-      private
-
-      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
-      end
-
-      def child_factory(child_context)
-        NodeFactory::OptionalReference.new(NodeFactories::Response)
-                                      .call(child_context)
-      end
-
-      def build_map(data, context)
-        Node::Responses.new(data, context)
-      end
-
-      def validate(input, _context)
-        validate_keys(input.keys)
-      end
-
-      def validate_keys(keys)
-        invalid = keys.reject do |key|
-          extension?(key) || KEY_REGEX.match(key)
-        end
-
-        return if invalid.empty?
-
-        codes = invalid.map { |k| "'#{k}'" }.join(", ")
-        "Invalid responses keys: #{codes} - default, status codes and status "\
-        "code ranges allowed"
-      end
-    end
-  end
-end

data/lib/openapi3_parser/node_factories/security_requirement.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "openapi3_parser/node/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|
-          next_context = Context.next_field(context, key)
-          memo[key] = NodeFactories::Array.new(next_context)
-        end
-      end
-
-      def build_map(data, context)
-        Node::SecurityRequirement.new(data, context)
-      end
-    end
-  end
-end

data/lib/openapi3_parser/node_factory/field_config.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require "openapi3_parser/error"
-
-module Openapi3Parser
-  module NodeFactory
-    class FieldConfig
-      attr_reader :given_input_type, :given_factory, :given_required,
-                  :given_default, :given_validate
-
-      def initialize(
-        input_type: nil,
-        factory: nil,
-        required: false,
-        default: nil,
-        validate: nil
-      )
-        @given_input_type = input_type
-        @given_factory = factory
-        @given_required = required
-        @given_default = default
-        @given_validate = validate
-      end
-
-      def factory?
-        !given_factory.nil?
-      end
-
-      def initialize_factory(context, factory)
-        if given_factory.is_a?(Class)
-          given_factory.new(context)
-        elsif given_factory.is_a?(Symbol)
-          factory.send(given_factory, context)
-        else
-          given_factory.call(context)
-        end
-      end
-
-      def required?(_factory)
-        given_required
-      end
-
-      def input_type_error(input, factory)
-        return if !given_input_type || input.nil?
-        return boolean_error(input) if given_input_type == :boolean
-        resolve_type_error(input, factory)
-      end
-
-      def validation_errors(input, factory)
-        return [] if !given_validate || input.nil?
-        errors = resolve_validation_errors(input, factory)
-        Array(errors)
-      end
-
-      def default(factory)
-        return given_default.call if given_default.is_a?(Proc)
-        return factory.send(given_default) if given_default.is_a?(Symbol)
-        given_default
-      end
-
-      private
-
-      def boolean_error(input)
-        "Expected a boolean" unless [true, false].include?(input)
-      end
-
-      def resolve_type_error(input, factory)
-        if given_input_type.is_a?(Proc)
-          given_input_type.call(input)
-        elsif given_input_type.is_a?(Symbol)
-          factory.send(given_input_type, input)
-        elsif !input.is_a?(given_input_type)
-          "Expected a #{given_input_type}"
-        end
-      end
-
-      def resolve_validation_errors(input, factory)
-        if given_validate.is_a?(Proc)
-          given_validate.call(input)
-        elsif given_validate.is_a?(Symbol)
-          factory.send(given_validate, input)
-        else
-          raise Error, "Expected a Proc or Symbol for validate"
-        end
-      end
-    end
-  end
-end

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

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-require "openapi3_parser/context"
-require "openapi3_parser/error"
-require "openapi3_parser/node_factory/object/validator"
-
-module Openapi3Parser
-  module NodeFactory
-    module Object
-      class NodeBuilder
-        def initialize(input, factory)
-          @input = input
-          @factory = factory
-        end
-
-        def data
-          check_required_fields
-          check_unexpected_fields
-          check_fields_valid
-          input.each_with_object({}) do |(key, value), memo|
-            memo[key] = resolve_value(key, value)
-          end
-        end
-
-        private
-
-        attr_reader :input, :factory
-
-        def context
-          factory.context
-        end
-
-        def check_required_fields
-          fields = Validator.missing_required_fields(input, factory)
-          return if fields.empty?
-          raise Openapi3Parser::Error::MissingFields,
-                "Missing required fields for "\
-                  "#{context.location_summary}: #{fields.join(', ')}"
-        end
-
-        def check_unexpected_fields
-          fields = Validator.unexpected_fields(input, factory)
-          return if fields.empty?
-          raise Openapi3Parser::Error::UnexpectedFields,
-                "Unexpected fields for #{context.location_summary}: "\
-                  "#{fields.join(', ')}"
-        end
-
-        def check_fields_valid
-          factory.field_configs.each do |name, field_config|
-            check_type_error(name, field_config)
-            check_validation_errors(name, field_config)
-          end
-        end
-
-        def check_type_error(name, field_config)
-          field_context = Context.next_field(context, name)
-          input = context.input.nil? ? nil : context.input[name]
-          error = field_config.input_type_error(input, factory)
-
-          return unless error
-          raise Openapi3Parser::Error::InvalidType,
-                "Invalid type for "\
-                  "#{field_context.location_summary}: #{error}"
-        end
-
-        def check_validation_errors(name, field_config)
-          field_context = Context.next_field(context, name)
-          errors = field_config.validation_errors(field_context.input, factory)
-
-          return unless errors.any?
-          raise Openapi3Parser::Error::InvalidData,
-                "Invalid field for #{field_context.location_summary}: "\
-                "#{errors.join(', ')}"
-        end
-
-        def resolve_value(key, value)
-          configs = factory.field_configs
-          return configs[key]&.default(factory) if value.nil?
-          default_value(configs[key], value)
-        end
-
-        def default_value(config, value)
-          resolved_value = value.respond_to?(:node) ? value.node : value
-
-          # let a field config default take precedence if value is a nil_input?
-          if value.respond_to?(:nil_input?) && value.nil_input?
-            default = config&.default(factory)
-            default.nil? ? resolved_value : default
-          else
-            resolved_value
-          end
-        end
-      end
-    end
-  end
-end