openapi3_parser 0.5.2 → 0.6.0

data/lib/openapi3_parser/node_factory/link.rb

@@ -8,7 +8,7 @@ module Openapi3Parser
       allow_extensions
 
       # @todo The link object in OAS is pretty meaty and there's lot of scope
-      # for further work here to make use of it's funcationality
+      # for further work here to make use of its functionality
 
       field "operationRef", input_type: String
       field "operationId", input_type: String

data/lib/openapi3_parser/node_factory/map.rb

@@ -46,11 +46,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
@@ -84,8 +82,8 @@ module Openapi3Parser
         end
       end
 
-      def build_node(data)
-        Node::Map.new(data, context) if data
+      def build_node(data, node_context)
+        Node::Map.new(data, node_context) if data
       end
 
       def build_resolved_input
@@ -105,8 +103,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)
@@ -122,7 +120,7 @@ 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: ::Hash)
@@ -131,7 +129,11 @@ module Openapi3Parser
           validate(raise_on_invalid: true)
 
           factory.data.each_with_object({}) do |(key, value), memo|
-            memo[key] = value.respond_to?(:node) ? value.node : value
+            memo[key] = if value.respond_to?(:node)
+                          Node::Placeholder.new(value, key, parent_context)
+                        else
+                          value
+                        end
           end
         end
 
@@ -200,7 +202,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/object.rb

@@ -18,6 +18,10 @@ module Openapi3Parser
 
       attr_reader :context, :data
 
+      def self.object_type
+        to_s
+      end
+
       def initialize(context)
         @context = context
         @data = build_data(context.input)
@@ -43,8 +47,8 @@ module Openapi3Parser
         @errors ||= ObjectFactory::NodeBuilder.errors(self)
       end
 
-      def node
-        @node ||= build_node
+      def node(node_context)
+        build_node(node_context)
       end
 
       def can_use_default?
@@ -99,9 +103,9 @@ module Openapi3Parser
         end
       end
 
-      def build_node
-        data = ObjectFactory::NodeBuilder.node_data(self)
-        build_object(data, context) if data
+      def build_node(node_context)
+        data = ObjectFactory::NodeBuilder.node_data(self, node_context)
+        build_object(data, node_context) if data
       end
     end
   end

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

@@ -8,8 +8,8 @@ module Openapi3Parser
           new(factory).errors
         end
 
-        def self.node_data(factory)
-          new(factory).node_data
+        def self.node_data(factory, parent_context)
+          new(factory).node_data(parent_context)
         end
 
         def initialize(factory)
@@ -29,11 +29,11 @@ module Openapi3Parser
           validatable.collection
         end
 
-        def node_data
-          return build_node_data if empty_and_allowed_to_be?
+        def node_data(parent_context)
+          return build_node_data(parent_context) if empty_and_allowed_to_be?
           TypeChecker.raise_on_invalid_type(factory.context, type: ::Hash)
           validate(raise_on_invalid: true)
-          build_node_data
+          build_node_data(parent_context)
         end
 
         private_class_method :new
@@ -50,40 +50,33 @@ module Openapi3Parser
           Validator.call(factory, raise_on_invalid)
         end
 
-        def build_node_data
+        def build_node_data(parent_context)
           return if factory.nil_input? && factory.data.nil?
 
-          factory.data.each_with_object(NodeData.new) do |(key, value), memo|
-            memo[key] = if node_is_recursive_pointer?(value)
-                          value.recursive_pointer
-                        else
-                          resolve_value(key, value)
-                        end
+          factory.data.each_with_object({}) do |(key, value), memo|
+            memo[key] = resolve_value(key, value, parent_context)
           end
         end
 
-        def resolve_value(key, value)
-          config = factory.field_configs[key]
-          resolved_value = value.respond_to?(:node) ? value.node : value
+        def resolve_value(key, value, parent_context)
+          resolved = determine_value_or_default(key, value)
 
-          # let a field config default take precedence if value is a nil_input?
-          if (value.respond_to?(:nil_input?) && value.nil_input?) || value.nil?
-            default = config&.default(factory)
-            default.nil? ? resolved_value : default
+          if resolved.respond_to?(:node)
+            Node::Placeholder.new(value, key, parent_context)
           else
-            resolved_value
+            resolved
           end
         end
 
-        def node_is_recursive_pointer?(value_factory)
-          return false unless value_factory.respond_to?(:in_recursive_loop?)
-          value_factory.in_recursive_loop?
-        end
+        def determine_value_or_default(key, value)
+          config = factory.field_configs[key]
 
-        class NodeData < ::Hash
-          def [](key)
-            item = super(key)
-            item.is_a?(NodeFactory::RecursivePointer) ? item.node : item
+          # let a field config default take precedence if value is a nil_input?
+          if (value.respond_to?(:nil_input?) && value.nil_input?) || value.nil?
+            default = config&.default(factory)
+            default.nil? ? value : default
+          else
+            value
           end
         end
       end

data/lib/openapi3_parser/node_factory/optional_reference.rb

@@ -7,6 +7,10 @@ module Openapi3Parser
         @factory = factory
       end
 
+      def object_type
+        "#{self.class}[#{factory.object_type}]}"
+      end
+
       def call(context)
         reference = context.input.is_a?(Hash) && context.input["$ref"]
 

data/lib/openapi3_parser/node_factory/parameter_like.rb

@@ -33,5 +33,3 @@ module Openapi3Parser
     end
   end
 end
-
-# These are in the footer as a cyclic dependency can stop this module loading

data/lib/openapi3_parser/node_factory/path_item.rb

@@ -22,11 +22,14 @@ module Openapi3Parser
 
       private
 
-      def build_object(data, context)
-        ref = data.delete("$ref")
-        return Node::PathItem.new(data, context) unless ref
+      def build_object(data, node_context)
+        ref = data.delete("$ref").node
+        return Node::PathItem.new(data, node_context) unless ref
 
-        Node::PathItem.new(merge_data(ref.node_data, data), ref.node_context)
+        context = data.empty? ? ref.node_context : node_context
+        data = merge_data(ref.node_data, data)
+
+        Node::PathItem.new(data, context)
       end
 
       def ref_factory(context)

data/lib/openapi3_parser/node_factory/paths.rb

@@ -31,8 +31,8 @@ module Openapi3Parser
 
       private
 
-      def build_node(data)
-        Node::Paths.new(data, context)
+      def build_node(data, node_context)
+        Node::Paths.new(data, node_context)
       end
 
       def validate(validatable)

data/lib/openapi3_parser/node_factory/reference.rb

@@ -15,22 +15,29 @@ module Openapi3Parser
       end
 
       def in_recursive_loop?
-        data["$ref"].in_recursive_loop?
+        data["$ref"].self_referencing?
       end
 
-      def recursive_pointer
-        NodeFactory::RecursivePointer.new(data["$ref"].reference_context)
+      def referenced_factory
+        data["$ref"].referenced_factory
+      end
+
+      def resolves?(control_factory = nil)
+        control_factory ||= self
+
+        return true unless referenced_factory.is_a?(Reference)
+        # recursive loop of references that never references an object
+        return false if referenced_factory == control_factory
+
+        referenced_factory.resolves?(control_factory)
       end
 
       private
 
-      def build_node
-        if in_recursive_loop?
-          raise Error::InRecursiveStructure,
-                "Can't build node as it references itself, use "\
-                "recursive_pointer"
-        end
-        data["$ref"].node
+      def build_node(node_context)
+        TypeChecker.raise_on_invalid_type(context, type: ::Hash)
+        ObjectFactory::Validator.call(self, true)
+        data["$ref"].node(node_context)
       end
 
       def ref_factory(context)

data/lib/openapi3_parser/node_factory/responses.rb

@@ -26,8 +26,8 @@ module Openapi3Parser
 
       private
 
-      def build_node(data)
-        Node::Responses.new(data, context)
+      def build_node(data, node_context)
+        Node::Responses.new(data, node_context)
       end
 
       def validate_keys(validatable)

data/lib/openapi3_parser/node_factory/security_requirement.rb

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

data/lib/openapi3_parser/source.rb

@@ -9,22 +9,22 @@ module Openapi3Parser
   #   The source input which provides the data
   # @attr_reader [Document]                     document
   #   The document that this source is associated with
-  # @attr_reader [Document::ReferenceRegister]  reference_register
-  #   An object to track references for a document
+  # @attr_reader [Document::ReferenceRegistry]  reference_registry
+  #   An object that tracks factories for all references
   # @attr_reader [Source, nil]                  parent
   #   Set to a Source if this source was created due to a reference within
   #   a different Source
   class Source
-    attr_reader :source_input, :document, :reference_register, :parent
+    attr_reader :source_input, :document, :reference_registry, :parent
 
     # @param  [SourceInput]                   source_input
     # @param  [Document]                      document
-    # @param  [Document::ReferenceRegister]   reference_register
+    # @param  [Document::ReferenceRegistry]   reference_registry
     # @param  [Source, nil]                   parent
-    def initialize(source_input, document, reference_register, parent = nil)
+    def initialize(source_input, document, reference_registry, parent = nil)
       @source_input = source_input
       @document = document
-      @reference_register = reference_register
+      @reference_registry = reference_registry
       @parent = parent
     end
 
@@ -43,23 +43,26 @@ module Openapi3Parser
       document.root_source == self
     end
 
-    # Used to register a reference with the underlying document and return a
-    # reference resolver to access the object referenced
-    #
-    # @param  [String]        given_reference   The reference as text
-    # @param  [NodeFactory]   factory           Factory class for the expected
-    #                                           eventual resource
-    # @param  [Context]       context           The context of the object
-    #                                           calling this reference
-    # @return [ReferenceResolver]
-    def register_reference(given_reference, factory, context)
+    def resolve_reference(given_reference,
+                          unbuilt_factory,
+                          context,
+                          recursive: false)
       reference = Reference.new(given_reference)
-      ReferenceResolver.new(
-        reference, factory, context
-      ).tap do |resolver|
-        next if resolver.in_root_source?
-        reference_register.register(resolver.reference_factory)
+      resolved_source = resolve_source(reference)
+      source_location = Source::Location.new(resolved_source,
+                                             reference.json_pointer)
+
+      unless recursive
+        reference_registry.register(unbuilt_factory,
+                                    source_location,
+                                    context)
       end
+
+      ResolvedReference.new(
+        source_location: source_location,
+        object_type: unbuilt_factory.object_type,
+        reference_registry: reference_registry
+      )
     end
 
     # Access/create the source object for a reference
@@ -71,15 +74,15 @@ module Openapi3Parser
         # I found the spec wasn't fully clear on expected behaviour if a source
         # references a fragment that doesn't exist in it's current document
         # and just the root source. I'm assuming to be consistent with URI a
-        # fragment only reference only references current JSON document. This
-        # could be incorrect though.
+        # fragment only references the current JSON document. This could be
+        # incorrect though.
         self
       else
         next_source_input = source_input.resolve_next(reference)
         source = document.source_for_source_input(next_source_input)
         source || self.class.new(next_source_input,
                                  document,
-                                 reference_register,
+                                 reference_registry,
                                  self)
       end
     end

data/lib/openapi3_parser/{context → source}/location.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Openapi3Parser
-  class Context
+  class Source
     # Class used to represent a location within an OpenAPI document.
     # It contains a source, which is the source file/data used for the contents
     # and the pointer which indicates where in the object like file the data is
@@ -28,6 +28,18 @@ module Openapi3Parser
         source.relative_to_root + pointer.fragment
       end
 
+      def data
+        source.data_at_pointer(pointer.segments)
+      end
+
+      def pointer_defined?
+        source.has_pointer?(pointer.segments)
+      end
+
+      def source_available?
+        source.available?
+      end
+
       def inspect
         %{#{self.class.name}(source: #{source.inspect}, pointer: #{pointer})}
       end

data/lib/openapi3_parser/{context → source}/pointer.rb

@@ -3,7 +3,7 @@
 require "cgi"
 
 module Openapi3Parser
-  class Context
+  class Source
     # A class to decorate the array of fields that make up a pointer and
     # provide common means to convert it into different representations.
     class Pointer
@@ -13,7 +13,7 @@ module Openapi3Parser
         segments = fragment.split("/").map do |part|
           next if part == ""
           unescaped = CGI.unescape(part.gsub("%20", "+"))
-          unescaped =~ /\A\d+\z/ ? unescaped.to_i : unescaped
+          unescaped.match?(/\A\d+\z/) ? unescaped.to_i : unescaped
         end
         new(segments.compact, absolute)
       end

data/lib/openapi3_parser/source/resolved_reference.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Openapi3Parser
+  class Source
+    class ResolvedReference
+      extend Forwardable
+
+      def_delegators :source_location, :source
+      def_delegators :factory, :resolved_input, :node
+
+      attr_reader :source_location, :object_type
+
+      def initialize(source_location:,
+                     object_type:,
+                     reference_registry:)
+        @source_location = source_location
+        @object_type = object_type
+        @reference_registry = reference_registry
+      end
+
+      def valid?
+        errors.empty?
+      end
+
+      def errors
+        @errors ||= Array(build_errors)
+      end
+
+      def factory
+        @factory ||= begin
+          reference_registry
+            .factory(object_type, source_location)
+            .tap do |factory|
+              message = "Unregistered node factory at #{source_location}"
+              raise Openapi3Parser::Error, message unless factory
+            end
+        end
+      end
+
+      private
+
+      attr_reader :reference_registry
+
+      def build_errors
+        return source_unavailabe_error unless source.available?
+        return pointer_missing_error unless source_location.pointer_defined?
+
+        resolution_error unless factory.valid?
+      end
+
+      def source_unavailabe_error
+        "Failed to open source #{source.relative_to_root}"
+      end
+
+      def pointer_missing_error
+        suffix = source.root? ? "" : " in source #{source.relative_to_root}"
+        "#{source_location.pointer} is not defined#{suffix}"
+      end
+
+      def resolution_error
+        "#{source_location} does not resolve to a valid object"
+      end
+    end
+  end
+end