openapi3_parser 0.4.0 → 0.5.0

data/lib/openapi3_parser/node/map.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 module Openapi3Parser
   module Node
     class Map
+      extend Forwardable
       include Enumerable
 
+      def_delegators :node_data, :each, :keys, :empty?
       attr_reader :node_data, :node_context
 
       def initialize(data, context)
@@ -12,12 +16,50 @@ module Openapi3Parser
         @node_context = context
       end
 
+      # Look up an attribute of the node by the name it has in the OpenAPI
+      # document.
+      #
+      # @example Look up by OpenAPI naming
+      #   obj["externalDocs"]
+      #
+      # @example Look up by symbol
+      #   obj[:servers]
+      #
+      # @example Look up an extension
+      #   obj["x-myExtension"]
+      #
+      # @param [String, Symbol] value
+      #
+      # @return anything
       def [](value)
-        node_data[value]
+        node_data[value.to_s]
+      end
+
+      # Look up an extension provided for this map, doesn't need a prefix of
+      # "x-"
+      #
+      # @example Looking up an extension provided as "x-extra"
+      #   obj.extension("extra")
+      #
+      # @param [String, Symbol] value
+      #
+      # @return [Hash, Array, Numeric, String, true, false, nil]
+      def extension(value)
+        node_data["x-#{value}"]
+      end
+
+      # Used to access a node relative to this node
+      # @param  [Context::Pointer, ::Array, ::String] pointer_like
+      # @return anything
+      def node_at(pointer_like)
+        current_pointer = node_context.document_location.pointer
+        node_context.document.node_at(pointer_like, current_pointer)
       end
 
-      def each(&block)
-        node_data.each(&block)
+      # @return [String]
+      def inspect
+        fragment = node_context.document_location.pointer.fragment
+        %{#{self.class.name}(#{fragment})}
       end
     end
   end

data/lib/openapi3_parser/node/object.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 require "openapi3_parser/markdown"
 
 module Openapi3Parser
   module Node
     class Object
+      extend Forwardable
       include Enumerable
 
+      def_delegators :node_data, :each, :keys, :empty?
       attr_reader :node_data, :node_context
 
       def initialize(data, context)
@@ -46,11 +50,6 @@ module Openapi3Parser
         node_data["x-#{value}"]
       end
 
-      # Iterate through the attributes of this object
-      def each(&block)
-        node_data.each(&block)
-      end
-
       # Used to render fields that can be in markdown syntax into HTML
       # @param  [String, nil] value
       # @return [String, nil]
@@ -58,6 +57,27 @@ module Openapi3Parser
         return if value.nil?
         Markdown.to_html(value)
       end
+
+      # Used to access a node relative to this node
+      #
+      # @example Looking up the parent node of this node
+      #   obj.node_at("#..")
+      #
+      # @example Jumping way down the tree
+      #   obj.node_at("#properties/Field/type")
+      #
+      # @param  [Context::Pointer, ::Array, ::String] pointer_like
+      # @return anything
+      def node_at(pointer_like)
+        current_pointer = node_context.document_location.pointer
+        node_context.document.node_at(pointer_like, current_pointer)
+      end
+
+      # @return [String]
+      def inspect
+        fragment = node_context.document_location.pointer.fragment
+        %{#{self.class.name}(#{fragment})}
+      end
     end
   end
 end

data/lib/openapi3_parser/node_factory.rb

@@ -1,157 +1,7 @@
 # frozen_string_literal: true
 
-require "openapi3_parser/context"
-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
-
-      def allow_default
-        @allow_default = true
-      end
-
-      def disallow_default
-        @allow_default = false
-      end
-
-      def allowed_default?
-        @allow_default.nil? || @allow_default
-      end
-    end
-
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    def allowed_default?
-      self.class.allowed_default?
-    end
-
     EXTENSION_REGEX = /^x-(.*)/
-
-    attr_reader :context, :processed_input
-
-    def initialize(context)
-      @context = context
-      input = nil_input? ? default : context.input
-      @processed_input = input.nil? ? nil : process_input(input)
-    end
-
-    def valid?
-      errors.empty?
-    end
-
-    def errors
-      @errors ||= build_errors
-    end
-
-    def node
-      @node ||= build_valid_node
-    end
-
-    def nil_input?
-      context.input.nil?
-    end
-
-    def resolved_input
-      @resolved_input ||= processed_input ? build_resolved_input : nil
-    end
-
-    private
-
-    def validate(_input, _context); end
-
-    def validate_input
-      transform_errors(validate(context.input, context))
-    end
-
-    def build_resolved_input
-      context.input
-    end
-
-    def transform_errors(errors)
-      error_objects = Array(errors).map do |error|
-        if error.is_a?(Validation::Error)
-          error
-        else
-          Validation::Error.new(error, context, self.class)
-        end
-      end
-      Validation::ErrorCollection.new(error_objects)
-    end
-
-    def build_errors
-      return Validation::ErrorCollection.new if nil_input? && allowed_default?
-      unless valid_type?
-        error = Validation::Error.new(
-          "Invalid type. #{validate_type}", context, self.class
-        )
-        return Validation::ErrorCollection.new([error])
-      end
-      validate_input
-    end
-
-    def build_valid_node
-      if nil_input? && allowed_default?
-        return default.nil? ? nil : build_node(processed_input)
-      end
-
-      unless valid_type?
-        raise Openapi3Parser::Error::InvalidType,
-              "Invalid type for #{context.location_summary}. "\
-              "#{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::InvalidData,
-            "Invalid data for #{context.location_summary}. "\
-            "#{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 process_input(input)
-      input
-    end
-
-    def build_node(input)
-      input
-    end
-
-    def default
-      nil
-    end
-
-    def extension?(key)
-      key.match(EXTENSION_REGEX)
-    end
   end
 end

data/lib/openapi3_parser/node_factory/array.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/context"
+require "openapi3_parser/node_factory"
+require "openapi3_parser/node_factory/type_checker"
+require "openapi3_parser/node/array"
+require "openapi3_parser/validation/validatable"
+
+module Openapi3Parser
+  module NodeFactory
+    class Array
+      attr_reader :context, :data, :default, :value_input_type,
+                  :value_factory, :validation
+
+      def initialize(
+        context,
+        default: [],
+        value_input_type: nil,
+        value_factory: nil,
+        validate: nil
+      )
+        @context = context
+        @default = default
+        @value_input_type = value_input_type
+        @value_factory = value_factory
+        @validation = validate
+        @data = build_data(context.input)
+      end
+
+      def raw_input
+        context.input
+      end
+
+      def resolved_input
+        @resolved_input ||= build_resolved_input
+      end
+
+      def nil_input?
+        context.input.nil?
+      end
+
+      def valid?
+        errors.empty?
+      end
+
+      def errors
+        @errors ||= ValidNodeBuilder.errors(self)
+      end
+
+      def node
+        @node ||= begin
+                    data = ValidNodeBuilder.data(self)
+                    data.nil? ? nil : build_node(data)
+                  end
+      end
+
+      def inspect
+        %{#{self.class.name}(#{context.source_location.inspect})}
+      end
+
+      private
+
+      def build_data(raw_input)
+        use_default = nil_input? || !raw_input.is_a?(::Array)
+        return if use_default && default.nil?
+        process_data(use_default ? default : raw_input)
+      end
+
+      def process_data(data)
+        data.each_with_index.map do |value, i|
+          if value_factory
+            initialize_value_factory(Context.next_field(context, i))
+          else
+            value
+          end
+        end
+      end
+
+      def initialize_value_factory(field_context)
+        if value_factory.is_a?(Class)
+          value_factory.new(field_context)
+        else
+          value_factory.call(field_context)
+        end
+      end
+
+      def build_node(data)
+        Node::Array.new(data, context) if data
+      end
+
+      def build_resolved_input
+        return unless data
+
+        data.map do |value|
+          value.respond_to?(:resolved_input) ? value.resolved_input : value
+        end
+      end
+
+      class ValidNodeBuilder
+        def self.errors(factory)
+          new(factory).errors
+        end
+
+        def self.data(factory)
+          new(factory).data
+        end
+
+        def initialize(factory)
+          @factory = factory
+          @validatable = Validation::Validatable.new(factory)
+        end
+
+        def errors
+          return validatable.collection if factory.nil_input?
+          TypeChecker.validate_type(validatable, type: ::Array)
+          return validatable.collection if validatable.errors.any?
+          collate_errors
+          validatable.collection
+        end
+
+        def data
+          return default_value if factory.nil_input?
+
+          TypeChecker.raise_on_invalid_type(factory.context, type: ::Array)
+          check_values(raise_on_invalid: true)
+          validate(raise_on_invalid: true)
+
+          factory.data.map do |value|
+            value.respond_to?(:node) ? value.node : value
+          end
+        end
+
+        private_class_method :new
+
+        private
+
+        attr_reader :factory, :validatable
+
+        def collate_errors
+          check_values(raise_on_invalid: false)
+          validate(raise_on_invalid: false)
+
+          factory.data.each do |value|
+            validatable.add_errors(value.errors) if value.respond_to?(:errors)
+          end
+        end
+
+        def default_value
+          if factory.nil_input? && factory.default.nil?
+            nil
+          else
+            factory.data
+          end
+        end
+
+        def check_values(raise_on_invalid: false)
+          return unless factory.value_input_type
+
+          factory.context.input.each_index do |index|
+            check_field_type(
+              Context.next_field(factory.context, index), raise_on_invalid
+            )
+          end
+        end
+
+        def check_field_type(context, raise_on_invalid)
+          if raise_on_invalid
+            TypeChecker.raise_on_invalid_type(context,
+                                              type: factory.value_input_type)
+          else
+            TypeChecker.validate_type(validatable,
+                                      type: factory.value_input_type,
+                                      context: context)
+          end
+        end
+
+        def validate(raise_on_invalid: false)
+          run_validation
+
+          return if !raise_on_invalid || validatable.errors.empty?
+
+          first_error = validatable.errors.first
+          raise Openapi3Parser::Error::InvalidData,
+                "Invalid data for #{first_error.context.location_summary}. "\
+                "#{first_error.message}"
+        end
+
+        def run_validation
+          if factory.validation.is_a?(Symbol)
+            factory.send(:validation, validatable)
+          else
+            factory.validation&.call(validatable)
+          end
+        end
+      end
+    end
+  end
+end