openapi3_parser 0.1.0

data/lib/openapi3_parser/node_factories/server.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/server"
+require "openapi3_parser/node_factory/object"
+require "openapi3_parser/node_factories/server_variable"
+require "openapi3_parser/node_factories/map"
+
+module Openapi3Parser
+  module NodeFactories
+    class Server
+      include NodeFactory::Object
+
+      allow_extensions
+      field "url", input_type: String, required: true
+      field "description", input_type: String
+      field "variables", factory: :variables_factory
+
+      private
+
+      def build_object(data, context)
+        Nodes::Server.new(data, context)
+      end
+
+      def variables_factory(context)
+        NodeFactories::Map.new(
+          context,
+          value_factory: NodeFactories::ServerVariable
+        )
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/server_variable.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/server_variable"
+require "openapi3_parser/node_factory/object"
+
+module Openapi3Parser
+  module NodeFactories
+    class ServerVariable
+      include NodeFactory::Object
+
+      allow_extensions
+      field "enum", input_type: ::Array, validate: :validate_enum
+      field "default", input_type: String, required: true
+      field "description", input_type: String
+
+      private
+
+      def validate_enum(input)
+        return "Expected atleast one value" if input.empty?
+        "Expected String values" unless input.map(&:class).uniq == [String]
+      end
+
+      def build_object(data, context)
+        Nodes::ServerVariable.new(data, context)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factories/tag.rb

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

data/lib/openapi3_parser/node_factories/xml.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/nodes/xml"
+require "openapi3_parser/node_factory/object"
+
+module Openapi3Parser
+  module NodeFactories
+    class Xml
+      include NodeFactory::Object
+
+      allow_extensions
+      field "name", input_type: String
+      field "namespace", input_type: String
+      field "prefix", input_type: String
+      field "attribute", input_type: :boolean, default: false
+      field "wrapped", input_type: :boolean, default: false
+
+      private
+
+      def build_object(data, context)
+        Nodes::Xml.new(data, context)
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factory.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/error"
+require "openapi3_parser/validation/error"
+require "openapi3_parser/validation/error_collection"
+
+module Openapi3Parser
+  module NodeFactory
+    module ClassMethods
+      def input_type(type)
+        @input_type = type
+      end
+
+      def valid_input_type?(type)
+        return true unless @input_type
+        type.is_a?(@input_type)
+      end
+
+      def expected_input_type
+        @input_type
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    EXTENSION_REGEX = /^x-(.*)/
+
+    attr_reader :context
+
+    def initialize(context)
+      @context = context
+    end
+
+    def valid?
+      errors.empty?
+    end
+
+    def errors
+      @errors ||= build_errors
+    end
+
+    def node
+      @node ||= build_valid_node
+    end
+
+    private
+
+    def validate(_input, _context); end
+
+    def validate_input(error_collection)
+      add_validation_errors(
+        validate(context.input, context),
+        error_collection
+      )
+    end
+
+    def add_validation_errors(errors, error_collection)
+      errors = Array(errors)
+      errors.each do |error|
+        unless error.is_a?(Validation::Error)
+          error = Validation::Error.new(context.namespace, error)
+        end
+        error_collection.append(error)
+      end
+      error_collection
+    end
+
+    def build_errors
+      error_collection = Validation::ErrorCollection.new
+      unless valid_type?
+        error = Validation::Error.new(
+          context.namespace, "Invalid type. #{validate_type}"
+        )
+        return error_collection.tap { |ec| ec.append(error) }
+      end
+      validate_input(error_collection)
+      error_collection
+    end
+
+    def build_valid_node
+      unless valid_type?
+        raise Openapi3Parser::Error,
+              "Invalid type for #{context.stringify_namespace}. "\
+              "#{validate_type}"
+      end
+
+      validate_before_build
+      build_node(processed_input)
+    end
+
+    def validate_before_build
+      errors = Array(validate(context.input, context))
+      return unless errors.any?
+      raise Openapi3Parser::Error,
+            "Invalid data for #{context.stringify_namespace}. "\
+            "#{errors.join(', ')}"
+    end
+
+    def valid_type?
+      validate_type.nil?
+    end
+
+    def validate_type
+      valid_type = self.class.valid_input_type?(context.input)
+      return "Expected #{self.class.expected_input_type}" unless valid_type
+    end
+
+    def processed_input
+      @processed_input ||= process_input(context.input)
+    end
+
+    def process_input(input)
+      input
+    end
+
+    def build_node(input)
+      input
+    end
+
+    def extension?(key)
+      key.match(EXTENSION_REGEX)
+    end
+  end
+end

data/lib/openapi3_parser/node_factory/field_config.rb

@@ -0,0 +1,88 @@
+# 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/map.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/node_factory"
+
+module Openapi3Parser
+  module NodeFactory
+    module Map
+      include NodeFactory
+
+      def self.included(base)
+        base.extend(NodeFactory::ClassMethods)
+        base.class_eval do
+          input_type Hash
+        end
+      end
+
+      private
+
+      def build_node(input)
+        data = input.each_with_object({}) do |(key, value), memo|
+          memo[key] = value.respond_to?(:node) ? value.node : value
+        end
+        build_map(data, context)
+      end
+
+      def validate_input(error_collection)
+        super(error_collection)
+        processed_input.each_value do |value|
+          next unless value.respond_to?(:errors)
+          error_collection.merge(value.errors)
+        end
+      end
+
+      def build_map(data, _)
+        data
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factory/object.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/node_factory"
+require "openapi3_parser/node_factory/field_config"
+require "openapi3_parser/node_factory/object/node_builder"
+require "openapi3_parser/node_factory/object/validator"
+
+module Openapi3Parser
+  module NodeFactory
+    module Object
+      include NodeFactory
+
+      module ClassMethods
+        def field(name, **options)
+          @field_configs ||= {}
+          @field_configs[name] = FieldConfig.new(options)
+        end
+
+        def field_configs
+          @field_configs || {}
+        end
+
+        def allow_extensions
+          @allow_extensions = true
+        end
+
+        def disallow_extensions
+          @allow_extensions = false
+        end
+
+        def allowed_extensions?
+          @allow_extensions == true
+        end
+      end
+
+      def self.included(base)
+        base.extend(NodeFactory::ClassMethods)
+        base.extend(ClassMethods)
+        base.class_eval do
+          input_type Hash
+        end
+      end
+
+      def allowed_extensions?
+        self.class.allowed_extensions?
+      end
+
+      def field_configs
+        self.class.field_configs || {}
+      end
+
+      private
+
+      def process_input(input)
+        field_configs.each_with_object(input.dup) do |(field, config), memo|
+          next if !config.factory? || !memo[field]
+          next_context = context.next_namespace(field)
+          memo[field] = config.initialize_factory(
+            next_context, self
+          )
+        end
+      end
+
+      def validate_input(error_collection)
+        super(error_collection)
+        validator = Validator.new(processed_input, self)
+        error_collection.tap { |ec| ec.append(*validator.errors) }
+      end
+
+      def build_node(input)
+        data = NodeBuilder.new(input, self).data
+        build_object(data, context)
+      end
+
+      def build_object(data, _context)
+        data
+      end
+    end
+  end
+end