openapi3_parser 0.5.2 → 0.6.0

data/lib/openapi3_parser/node/security_scheme.rb

@@ -8,12 +8,12 @@ module Openapi3Parser
     class SecurityScheme < Node::Object
       # @return [String, nil]
       def type
-        node_data["type"]
+        self["type"]
       end
 
       # @return [String, nil]
       def description
-        node_data["description"]
+        self["description"]
       end
 
       # @return [String, nil]
@@ -23,32 +23,32 @@ module Openapi3Parser
 
       # @return [String, nil]
       def name
-        node_data["name"]
+        self["name"]
       end
 
       # @return [String, nil]
       def in
-        node_data["in"]
+        self["in"]
       end
 
       # @return [String, nil]
       def scheme
-        node_data["scheme"]
+        self["scheme"]
       end
 
       # @return [String, nil]
       def bearer_format
-        node_data["bearerFormat"]
+        self["bearerFormat"]
       end
 
       # @return [OauthFlows, nil]
       def flows
-        node_data["flows"]
+        self["flows"]
       end
 
       # @return [String, nil]
       def open_id_connect_url
-        node_data["openIdConnectUrl"]
+        self["openIdConnectUrl"]
       end
     end
   end

data/lib/openapi3_parser/node/server.rb

@@ -8,12 +8,12 @@ module Openapi3Parser
     class Server < Node::Object
       # @return [String]
       def url
-        node_data["url"]
+        self["url"]
       end
 
       # @return [String, nil]
       def description
-        node_data["description"]
+        self["description"]
       end
 
       # @return [String, nil]
@@ -23,7 +23,7 @@ module Openapi3Parser
 
       # @return [Map<String, ServerVariable>]
       def variables
-        node_data["variables"]
+        self["variables"]
       end
     end
   end

data/lib/openapi3_parser/node/server_variable.rb

@@ -8,17 +8,17 @@ module Openapi3Parser
     class ServerVariable < Node::Object
       # @return [Node::Array<String>, nil]
       def enum
-        node_data["enum"]
+        self["enum"]
       end
 
       # @return [String]
       def default
-        node_data["default"]
+        self["default"]
       end
 
       # @return [String, nil]
       def description
-        node_data["description"]
+        self["description"]
       end
 
       # @return [String, nil]

data/lib/openapi3_parser/node/tag.rb

@@ -8,12 +8,12 @@ module Openapi3Parser
     class Tag < Node::Object
       # @return [String]
       def name
-        node_data["name"]
+        self["name"]
       end
 
       # @return [String, nil]
       def description
-        node_data["description"]
+        self["description"]
       end
 
       # @return [String, nil]
@@ -23,7 +23,7 @@ module Openapi3Parser
 
       # @return [ExternalDocumentation, nil]
       def external_docs
-        node_data["externalDocs"]
+        self["externalDocs"]
       end
     end
   end

data/lib/openapi3_parser/node/xml.rb

@@ -8,27 +8,27 @@ module Openapi3Parser
     class Xml < Node::Object
       # @return [String, nil]
       def name
-        node_data["name"]
+        self["name"]
       end
 
       # @return [String, nil]
       def namespace
-        node_data["namespace"]
+        self["namespace"]
       end
 
       # @return [String, nil]
       def prefix
-        node_data["prefix"]
+        self["prefix"]
       end
 
       # @return [Boolean]
       def attribute?
-        node_data["attribute"]
+        self["attribute"]
       end
 
       # @return [Boolean]
       def wrapped?
-        node_data["wrapped"]
+        self["wrapped"]
       end
     end
   end

data/lib/openapi3_parser/node_factory/array.rb

@@ -41,11 +41,9 @@ module Openapi3Parser
         @errors ||= ValidNodeBuilder.errors(self)
       end
 
-      def node
-        @node ||= begin
-                    data = ValidNodeBuilder.data(self)
-                    data.nil? ? nil : build_node(data)
-                  end
+      def node(node_context)
+        data = ValidNodeBuilder.data(self, node_context)
+        data.nil? ? nil : build_node(data, node_context)
       end
 
       def inspect
@@ -78,8 +76,8 @@ module Openapi3Parser
         end
       end
 
-      def build_node(data)
-        Node::Array.new(data, context) if data
+      def build_node(data, node_context)
+        Node::Array.new(data, node_context) if data
       end
 
       def build_resolved_input
@@ -95,8 +93,8 @@ module Openapi3Parser
           new(factory).errors
         end
 
-        def self.data(factory)
-          new(factory).data
+        def self.data(factory, parent_context)
+          new(factory).data(parent_context)
         end
 
         def initialize(factory)
@@ -112,15 +110,19 @@ module Openapi3Parser
           validatable.collection
         end
 
-        def data
+        def data(parent_context)
           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
+          factory.data.each_with_index.map do |value, i|
+            if value.respond_to?(:node)
+              Node::Placeholder.new(value, i, parent_context)
+            else
+              value
+            end
           end
         end
 
@@ -175,7 +177,7 @@ module Openapi3Parser
 
           first_error = validatable.errors.first
           raise Openapi3Parser::Error::InvalidData,
-                "Invalid data for #{first_error.context.location_summary}. "\
+                "Invalid data for #{first_error.context.location_summary}: "\
                 "#{first_error.message}"
         end
 

data/lib/openapi3_parser/node_factory/callback.rb

@@ -13,8 +13,8 @@ module Openapi3Parser
 
       private
 
-      def build_node(data)
-        Node::Callback.new(data, context)
+      def build_node(data, node_context)
+        Node::Callback.new(data, node_context)
       end
     end
   end

data/lib/openapi3_parser/node_factory/context.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Openapi3Parser
+  module NodeFactory
+    # This class is used to specify the data and source information for a
+    # NodeFactory. The same NodeFactory can be used multiple times if the
+    # object is referenced so it is limited in data about it's location
+    # within the document.
+    #
+    # @attr_reader  [Any]                     input
+    # @attr_reader  [Source::Location]        source_location
+    # @attr_reader  [Array<Source::Location>] refernce_locations
+    #
+    class Context
+      # Create a context for the root of a document
+      #
+      # @param  [Any]     input
+      # @param  [Source]  source
+      # @return [Context]
+      def self.root(input, source)
+        new(input, source_location: Source::Location.new(source, []))
+      end
+
+      # Create a factory context for a field within the current contexts data
+      # eg for a context of:
+      #   root = Context.root({ "test" => {} }, source)
+      # we can get the context of "test" with:
+      #   test = Context.next_field(root, "test")
+      #
+      # @param  [Context] parent_context
+      # @param  [String]  field
+      # @return [Context]
+      def self.next_field(parent_context, field)
+        pc = parent_context
+        input = pc.input.respond_to?(:[]) ? pc.input[field] : nil
+        source_location = Source::Location.next_field(pc.source_location, field)
+        new(input,
+            source_location: source_location,
+            reference_locations: pc.reference_locations)
+      end
+
+      # Creates the context for a field that references another field
+      #
+      # @param  [Context]           reference_context
+      # @param  [Source::Location]  source_location
+      # @return [Context]
+      def self.resolved_reference(reference_context, source_location:)
+        reference_locations = [reference_context.source_location] +
+                              reference_context.reference_locations
+
+        data = source_location.data if source_location.source_available?
+        new(data,
+            source_location: source_location,
+            reference_locations: reference_locations)
+      end
+
+      attr_reader :input, :source_location, :reference_locations
+
+      # @param  [Any]                     input
+      # @param  [Source::Location]        source_location
+      # @param  [Array<Source::Location>] reference_locations
+      def initialize(input,
+                     source_location:,
+                     reference_locations: [])
+        @input = input
+        @source_location = source_location
+        @reference_locations = reference_locations
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        input == other.input &&
+          source_location == other.source_location &&
+          reference_locations == other.reference_locations
+      end
+
+      # @return [Source]
+      def source
+        source_location.source
+      end
+
+      # @param  [String]              reference
+      # @param  [Object, Map, Array]  factory
+      # @param  [Boolean]             recursive
+      # @return [Source::ResolvedReference]
+      def resolve_reference(reference, factory, recursive: false)
+        source.resolve_reference(reference, factory, self, recursive: recursive)
+      end
+
+      # Used to show when an recursive reference loop has begun
+      #
+      # @return [Boolean]
+      def self_referencing?
+        reference_locations.include?(source_location)
+      end
+
+      def inspect
+        %{#{self.class.name}(source_location: #{source_location}, } +
+          %{referenced_by: #{reference_locations.map(&:to_s).join(', ')})}
+      end
+
+      def location_summary
+        source_location.to_s
+      end
+
+      def to_s
+        location_summary
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factory/field.rb

@@ -39,11 +39,9 @@ module Openapi3Parser
         @errors ||= ValidNodeBuilder.errors(self)
       end
 
-      def node
-        @node ||= begin
-                    data = ValidNodeBuilder.data(self)
-                    data.nil? ? nil : build_node(data)
-                  end
+      def node(node_context)
+        data = ValidNodeBuilder.data(self)
+        data.nil? ? nil : build_node(data, node_context)
       end
 
       def inspect
@@ -52,7 +50,7 @@ module Openapi3Parser
 
       private
 
-      def build_node(data)
+      def build_node(data, _node_context)
         data
       end
 
@@ -108,7 +106,7 @@ module Openapi3Parser
 
           first_error = validatable.errors.first
           raise Openapi3Parser::Error::InvalidData,
-                "Invalid data for #{first_error.context.location_summary}. "\
+                "Invalid data for #{first_error.context.location_summary}: "\
                 "#{first_error.message}"
         end
 

data/lib/openapi3_parser/node_factory/fields/reference.rb

@@ -7,55 +7,74 @@ module Openapi3Parser
   module NodeFactory
     module Fields
       class Reference < NodeFactory::Field
+        extend Forwardable
+
+        def_delegator :context, :self_referencing?
+
         def initialize(context, factory)
-          context = Context.as_reference(context)
           super(context, input_type: String, validate: :validate)
           @factory = factory
           @reference = context.input
-          @reference_resolver = create_reference_resolver
+          @resolved_reference = create_resolved_reference
         end
 
         def resolved_input
-          return unless reference_resolver
+          return unless resolved_reference
 
-          if in_recursive_loop?
-            RecursiveResolvedInput.new(reference_context)
+          if context.self_referencing?
+            RecursiveResolvedInput.new(resolved_reference.factory)
           else
-            reference_resolver.resolved_input
+            resolved_reference.resolved_input
           end
         end
 
-        def in_recursive_loop?
-          context.source_location == reference_context&.source_location
-        end
-
-        def reference_context
-          context.referenced_by
+        def referenced_factory
+          resolved_reference&.factory
         end
 
         private
 
-        attr_reader :reference, :factory, :reference_resolver
+        attr_reader :reference, :factory, :resolved_reference
+
+        def build_node(_data, node_context)
+          if resolved_reference.nil?
+            # this shouldn't happen unless dependant code changes
+            raise Openapi3Parser::Error,
+                  "can't build node without a resolved reference"
+          end
+
+          reference_context = Node::Context.resolved_reference(
+            node_context, resolved_reference.factory.context
+          )
 
-        def build_node(_data)
-          reference_resolver&.node
+          resolved_reference.node(reference_context)
         end
 
         def validate(validatable)
           if !reference_validator.valid?
             validatable.add_errors(reference_validator.errors)
+          elsif !reference_resolves?
+            validatable.add_error("Reference doesn't resolve to an object")
           else
-            validatable.add_errors(reference_resolver&.errors)
+            validatable.add_errors(resolved_reference&.errors)
           end
         end
 
+        def reference_resolves?
+          return true unless referenced_factory.is_a?(NodeFactory::Reference)
+
+          referenced_factory.resolves?
+        end
+
         def reference_validator
           @reference_validator ||= Validators::Reference.new(reference)
         end
 
-        def create_reference_resolver
+        def create_resolved_reference
           return unless reference_validator.valid?
-          context.register_reference(reference, factory)
+          context.resolve_reference(reference,
+                                    factory,
+                                    recursive: context.self_referencing?)
         end
 
         # Used in the place of a hash for resolved input so the value can
@@ -64,15 +83,15 @@ module Openapi3Parser
           extend Forwardable
           include Enumerable
 
-          def_delegators :resolved_input, :each, :[], :keys
-          attr_reader :context
+          def_delegators :value, :each, :[], :keys
+          attr_reader :factory
 
-          def initialize(context)
-            @context = context
+          def initialize(factory)
+            @factory = factory
           end
 
-          def resolved_input
-            context.resolved_input
+          def value
+            @factory.resolved_input
           end
         end
       end