openapi3_parser 0.3.0 → 0.4.0

data/lib/openapi3_parser/node_factories/map.rb

@@ -3,7 +3,7 @@
 require "openapi3_parser/context"
 require "openapi3_parser/error"
 require "openapi3_parser/node_factory/map"
-require "openapi3_parser/nodes/map"
+require "openapi3_parser/node/map"
 require "openapi3_parser/validation/error"
 require "openapi3_parser/validation/error_collection"
 
@@ -12,24 +12,28 @@ module Openapi3Parser
     class Map
       include NodeFactory::Map
 
+      # rubocop:disable Metrics/ParameterLists
       def initialize(
         context,
         key_input_type: String,
         value_input_type: nil,
         value_factory: nil,
-        validate: nil
+        validate: nil,
+        default: {}
       )
         @given_key_input_type = key_input_type
         @given_value_input_type = value_input_type
         @given_value_factory = value_factory
         @given_validate = validate
+        @given_default = default
         super(context)
       end
+      # rubocop:enable Metrics/ParameterLists
 
       private
 
       attr_reader :given_key_input_type, :given_value_input_type,
-                  :given_value_factory, :given_validate
+                  :given_value_factory, :given_validate, :given_default
 
       def process_input(input)
         input.each_with_object({}) do |(key, value), memo|
@@ -68,7 +72,7 @@ module Openapi3Parser
       end
 
       def build_map(data, context)
-        Nodes::Map.new(data, context)
+        Node::Map.new(data, context)
       end
 
       def value_factory?
@@ -107,6 +111,10 @@ module Openapi3Parser
         return unless type
         "Expected #{type}" unless value.is_a?(type)
       end
+
+      def default
+        given_default
+      end
     end
   end
 end

data/lib/openapi3_parser/node_factories/media_type.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "openapi3_parser/nodes/media_type"
+require "openapi3_parser/node/media_type"
 require "openapi3_parser/node_factory/object"
 require "openapi3_parser/node_factory/optional_reference"
 require "openapi3_parser/node_factories/map"
@@ -14,15 +14,18 @@ module Openapi3Parser
       include NodeFactory::Object
 
       allow_extensions
+
       field "schema", factory: :schema_factory
       field "example"
       field "examples", factory: :examples_factory
       field "encoding", factory: :encoding_factory
 
+      mutually_exclusive "example", "examples"
+
       private
 
       def build_object(data, context)
-        Nodes::MediaType.new(data, context)
+        Node::MediaType.new(data, context)
       end
 
       def schema_factory(context)
@@ -32,12 +35,40 @@ module Openapi3Parser
 
       def examples_factory(context)
         factory = NodeFactory::OptionalReference.new(NodeFactories::Example)
-        NodeFactories::Map.new(context, value_factory: factory)
+        NodeFactories::Map.new(context, default: nil, value_factory: factory)
       end
 
       def encoding_factory(context)
-        factory = NodeFactories::Encoding
-        NodeFactories::Map.new(context, value_factory: factory)
+        NodeFactories::Map.new(
+          context,
+          validate: EncodingValidator.new(self),
+          value_factory: NodeFactories::Encoding
+        )
+      end
+
+      class EncodingValidator
+        def initialize(factory)
+          @factory = factory
+        end
+
+        def call(input, _context)
+          missing_keys = input.keys - properties
+          error_message(missing_keys) unless missing_keys.empty?
+        end
+
+        private
+
+        attr_reader :factory
+
+        def properties
+          properties = factory.resolved_input.dig("schema", "properties")
+          properties.respond_to?(:keys) ? properties.keys : []
+        end
+
+        def error_message(missing_keys)
+          keys = missing_keys.join(", ")
+          "Keys are not defined as schema properties: #{keys}"
+        end
       end
     end
   end

data/lib/openapi3_parser/node_factories/oauth_flow.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "openapi3_parser/nodes/oauth_flow"
+require "openapi3_parser/node/oauth_flow"
 require "openapi3_parser/node_factory/object"
 
 module Openapi3Parser
@@ -17,7 +17,7 @@ module Openapi3Parser
       private
 
       def build_object(data, context)
-        Nodes::OauthFlow.new(data, context)
+        Node::OauthFlow.new(data, context)
       end
     end
   end

data/lib/openapi3_parser/node_factories/oauth_flows.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "openapi3_parser/nodes/oauth_flows"
+require "openapi3_parser/node/oauth_flows"
 require "openapi3_parser/node_factories/oauth_flow"
 require "openapi3_parser/node_factory/object"
 require "openapi3_parser/node_factory/optional_reference"
@@ -24,7 +24,7 @@ module Openapi3Parser
       end
 
       def build_object(data, context)
-        Nodes::OauthFlows.new(data, context)
+        Node::OauthFlows.new(data, context)
       end
     end
   end

data/lib/openapi3_parser/node_factories/openapi.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "openapi3_parser/nodes/openapi"
+require "openapi3_parser/node/openapi"
 require "openapi3_parser/node_factory/object"
 require "openapi3_parser/node_factories/info"
 require "openapi3_parser/node_factories/array"
@@ -31,7 +31,7 @@ module Openapi3Parser
       private
 
       def build_object(data, context)
-        Nodes::Openapi.new(data, context)
+        Node::Openapi.new(data, context)
       end
 
       def servers_factory(context)
@@ -45,7 +45,17 @@ module Openapi3Parser
       end
 
       def tags_factory(context)
-        NodeFactories::Array.new(context, value_factory: NodeFactories::Tag)
+        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

data/lib/openapi3_parser/node_factories/operation.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "openapi3_parser/nodes/operation"
+require "openapi3_parser/node/operation"
 require "openapi3_parser/node_factory/object"
 require "openapi3_parser/node_factory/optional_reference"
 require "openapi3_parser/node_factories/array"
@@ -11,6 +11,7 @@ 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
@@ -35,7 +36,7 @@ module Openapi3Parser
       private
 
       def build_object(data, context)
-        Nodes::Operation.new(data, context)
+        Node::Operation.new(data, context)
       end
 
       def tags_factory(context)
@@ -44,7 +45,14 @@ module Openapi3Parser
 
       def parameters_factory(context)
         factory = NodeFactory::OptionalReference.new(NodeFactories::Parameter)
-        NodeFactories::Array.new(context, value_factory: factory)
+
+        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)

data/lib/openapi3_parser/node_factories/parameter.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
-require "openapi3_parser/nodes/parameter"
+require "openapi3_parser/context"
+require "openapi3_parser/node/parameter"
 require "openapi3_parser/node_factories/parameter/parameter_like"
 require "openapi3_parser/node_factory/object"
+require "openapi3_parser/validation/error"
 
 module Openapi3Parser
   module NodeFactories
@@ -13,7 +15,9 @@ module Openapi3Parser
       allow_extensions
 
       field "name", input_type: String, required: true
-      field "in", input_type: String, required: true
+      field "in", input_type: String,
+                  required: true,
+                  validate: :validate_in
       field "description", input_type: String
       field "required", input_type: :boolean, default: false
       field "deprecated", input_type: :boolean, default: false
@@ -28,16 +32,37 @@ module Openapi3Parser
 
       field "content", factory: :content_factory
 
+      mutually_exclusive "example", "examples"
+
       private
 
       def build_object(data, context)
-        Nodes::Parameter.new(data, context)
+        Node::Parameter.new(data, context)
+      end
+
+      def validate(input, context)
+        errors = []
+
+        if input["in"] == "path" && !input["required"]
+          errors << Validation::Error.new(
+            "Must be included and true for a path parameter",
+            Context.next_field(context, "required"),
+            self.class
+          )
+        end
+
+        errors
       end
 
       def default_style
         return "simple" if %w[path header].include?(context.input["in"])
         "form"
       end
+
+      def validate_in(input)
+        valid = %w[header query cookie path].include?(input)
+        "in can only be header, query, cookie, or path" unless valid
+      end
     end
   end
 end

data/lib/openapi3_parser/node_factories/parameter/parameter_like.rb

@@ -15,14 +15,18 @@ module Openapi3Parser
 
         def examples_factory(context)
           factory = NodeFactory::OptionalReference.new(NodeFactories::Schema)
-          NodeFactories::Map.new(context, value_factory: factory)
+          NodeFactories::Map.new(context, default: nil, value_factory: factory)
         end
 
         def content_factory(context)
-          factory = NodeFactory::OptionalReference.new(
-            NodeFactories::MediaType
-          )
-          NodeFactories::Map.new(context, value_factory: factory)
+          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

data/lib/openapi3_parser/node_factories/path_item.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "openapi3_parser/nodes/path_item"
+require "openapi3_parser/node/path_item"
 require "openapi3_parser/node_factory/fields/reference"
 require "openapi3_parser/node_factory/object"
 require "openapi3_parser/node_factory/object/node_builder"
@@ -9,6 +9,7 @@ require "openapi3_parser/node_factories/array"
 require "openapi3_parser/node_factories/server"
 require "openapi3_parser/node_factories/operation"
 require "openapi3_parser/node_factories/parameter"
+require "openapi3_parser/validators/duplicate_parameters"
 
 module Openapi3Parser
   module NodeFactories
@@ -38,12 +39,9 @@ module Openapi3Parser
 
       def build_object(data, context)
         ref = data.delete("$ref")
-        return Nodes::PathItem.new(data, context) unless ref
+        return Node::PathItem.new(data, context) unless ref
 
-        merged_data = ref.node_data.merge(data) do |_, new, old|
-          new.nil? ? old : new
-        end
-        Nodes::PathItem.new(merged_data, ref.node_context)
+        Node::PathItem.new(merge_data(ref.node_data, data), ref.node_context)
       end
 
       def ref_factory(context)
@@ -61,9 +59,30 @@ module Openapi3Parser
         )
       end
 
+      def build_resolved_input
+        ref = processed_input["$ref"]
+        data = super.tap { |d| d.delete("$ref") }
+        return data unless ref
+
+        merge_data(ref.data || {}, data)
+      end
+
+      def merge_data(base, priority)
+        base.merge(priority) do |_, new, old|
+          new.nil? ? old : new
+        end
+      end
+
       def parameters_factory(context)
         factory = NodeFactory::OptionalReference.new(NodeFactories::Parameter)
-        NodeFactories::Array.new(context, value_factory: factory)
+
+        validate = lambda do |_input, array_factory|
+          Validators::DuplicateParameters.call(array_factory.resolved_input)
+        end
+
+        NodeFactories::Array.new(context,
+                                 value_factory: factory,
+                                 validate: validate)
       end
     end
   end

data/lib/openapi3_parser/node_factories/paths.rb

@@ -3,12 +3,26 @@
 require "openapi3_parser/node_factory/map"
 require "openapi3_parser/node_factory/optional_reference"
 require "openapi3_parser/node_factories/path_item"
-require "openapi3_parser/nodes/paths"
+require "openapi3_parser/node/paths"
 
 module Openapi3Parser
   module NodeFactories
     class Paths
       include NodeFactory::Map
+      PATH_REGEX = %r{
+        \A
+        # required prefix slash
+        /
+        (
+          # Match a path
+          ([\-;_.!~*'()a-zA-Z\d:@&=+$,]|%[a-fA-F\d]{2})*
+          # Match a path template parameter
+          ({([\-;_.!~*'()a-zA-Z\d:@&=+$,]|%[a-fA-F\d]{2})+})*
+          # optional segment separating slash
+          /?
+        )*
+        \Z
+      }x
 
       private
 
@@ -26,7 +40,42 @@ module Openapi3Parser
       end
 
       def build_map(data, context)
-        Nodes::Paths.new(data, context)
+        Node::Paths.new(data, context)
+      end
+
+      def validate(input, _context)
+        paths = input.keys.reject { |key| extension?(key) }
+        validate_paths(paths)
+      end
+
+      def validate_paths(paths)
+        invalid_paths = paths.reject { |p| PATH_REGEX.match(p) }
+        errors = []
+        unless invalid_paths.empty?
+          joined = invalid_paths.map { |p| "'#{p}'" }.join(", ")
+          errors << %(There are invalid paths: #{joined})
+        end
+
+        conflicts = conflicting_paths(paths)
+
+        unless conflicts.empty?
+          joined = conflicts.map { |p| "'#{p}'" }.join(", ")
+          errors << %(There are paths that conflict: #{joined})
+        end
+
+        errors
+      end
+
+      def conflicting_paths(paths)
+        potential_conflicts = paths.each_with_object({}) do |path, memo|
+          without_params = path.gsub(/{.*?}/, "")
+          memo[path] = without_params if path != without_params
+        end
+
+        grouped_paths = potential_conflicts.group_by(&:last)
+                                           .map { |_k, v| v.map(&:first) }
+
+        grouped_paths.select { |group| group.size > 1 }.flatten
       end
     end
   end