ruby-mcp-client 2.1.0 → 3.0.0

data/lib/mcp_client/schema_validator/scalars.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module MCPClient
+  module SchemaValidator
+    # The string and number keywords, and the budget a peer-supplied pattern
+    # is matched under. Both a pattern and the values it runs against come
+    # from the remote peer, so matching is bounded by the validation-wide
+    # deadline. Extended into SchemaValidator, so the methods are its own.
+    module Scalars
+      # Validate a string against minLength/maxLength/pattern.
+      # @param data [String] the string
+      # @param schema [Hash] string-keyed schema
+      # @param path [String] location for error messages
+      # @return [Array<String>] validation errors
+      def validate_string(data, schema, path, deadline = nil)
+        errors = []
+        min_length = schema['minLength']
+        max_length = schema['maxLength']
+        if min_length.is_a?(Numeric) && data.length < min_length
+          errors << "#{path}: string is shorter than minLength #{min_length}"
+        end
+        if max_length.is_a?(Numeric) && data.length > max_length
+          errors << "#{path}: string is longer than maxLength #{max_length}"
+        end
+        errors.concat(validate_pattern(data, schema['pattern'], path, deadline))
+        errors
+      end
+
+      # Validate a string against a regular-expression pattern. A pattern
+      # that is no ECMA-262 expression is a malformed keyword the preflight
+      # refuses; should one reach here it is an error, never a pass.
+      #
+      # The pattern comes from the tool's outputSchema, i.e. from the remote
+      # server, so matching runs against the validation-wide deadline: neither a
+      # single expensive expression nor many cheap-looking ones can pin the
+      # calling thread. A match that exceeds the budget aborts the validation
+      # rather than silently accepting the value — the value was never shown
+      # to satisfy the schema.
+      # @param data [String] the string
+      # @param pattern [Object] the pattern keyword value
+      # @param path [String] location for error messages
+      # @param deadline [Float, nil] monotonic deadline for the whole validation
+      # @return [Array<String>] validation errors
+      # @raise [Aborted] when the budget is exhausted
+      def validate_pattern(data, pattern, path, deadline = nil)
+        return [] unless pattern.is_a?(String)
+
+        remaining = pattern_budget_remaining(deadline)
+        raise Aborted, "validation time budget exhausted before pattern #{clip(pattern.inspect)}" if remaining.zero?
+
+        return [] if data.match?(ecma_regexp(pattern, remaining, deadline))
+
+        ["#{path}: string does not match pattern #{clip(pattern.inspect)}"]
+      rescue Regexp::TimeoutError
+        raise Aborted, "pattern #{clip(pattern.inspect)} exceeded the #{PATTERN_MATCH_TIMEOUT}s matching budget"
+      rescue EcmaPatterns::Untranslatable => e
+        ["#{path}: pattern #{clip(pattern.inspect)} cannot be evaluated faithfully (#{clip(e.message)})"]
+      rescue RegexpError => e
+        ["#{path}: pattern #{clip(pattern.inspect)} is not an ECMA-262 regular expression (#{clip(e.message)})"]
+      end
+
+      # Time left in the validation-wide budget.
+      # @param deadline [Float, nil] monotonic deadline, or nil for a lone match
+      # @return [Float] seconds available; 0.0 when exhausted
+      def pattern_budget_remaining(deadline)
+        return PATTERN_MATCH_TIMEOUT unless deadline
+
+        remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        return 0.0 if remaining <= 0
+
+        [remaining, MIN_PATTERN_MATCH_TIMEOUT].max
+      end
+
+      # Validate a number against its bounds. `minimum` / `maximum` and
+      # `exclusiveMinimum` / `exclusiveMaximum` are four independent numeric
+      # assertions in every supported dialect (draft-07 validation Sections
+      # 6.2.2-6.2.5); each present one is applied.
+      # @param data [Numeric] the number
+      # @param schema [Hash] string-keyed schema
+      # @param path [String] location for error messages
+      # @return [Array<String>] validation errors
+      def validate_number(data, schema, path, _dialect = nil)
+        errors = []
+        minimum = schema['minimum']
+        maximum = schema['maximum']
+        exclusive_min = schema['exclusiveMinimum']
+        exclusive_max = schema['exclusiveMaximum']
+        shown = clip_value(data)
+        if minimum.is_a?(Numeric) && data < minimum
+          errors << "#{path}: value #{shown} is less than minimum #{clip_value(minimum)}"
+        end
+        if maximum.is_a?(Numeric) && data > maximum
+          errors << "#{path}: value #{shown} is greater than maximum #{clip_value(maximum)}"
+        end
+        if exclusive_min.is_a?(Numeric) && data <= exclusive_min
+          errors << "#{path}: value #{shown} must be greater than exclusiveMinimum #{clip_value(exclusive_min)}"
+        end
+        if exclusive_max.is_a?(Numeric) && data >= exclusive_max
+          errors << "#{path}: value #{shown} must be less than exclusiveMaximum #{clip_value(exclusive_max)}"
+        end
+        factor = schema['multipleOf']
+        if factor.is_a?(Numeric) && factor.positive? && !multiple_of?(data, factor)
+          errors << "#{path}: value #{shown} is not a multiple of #{clip_value(factor)}"
+        end
+        errors
+      end
+
+      # Whether dividing the value by the factor gives an integer (JSON
+      # Schema 2020-12 Validation Section 6.2.1). The division is exact:
+      # 0.0075 is a multiple of 0.0001, which binary floating point says it
+      # is not, so the decimal each number was written as decides.
+      # @param data [Numeric] the instance
+      # @param factor [Numeric] the multipleOf value
+      # @return [Boolean]
+      def multiple_of?(data, factor)
+        return (data % factor).zero? if data.is_a?(Integer) && factor.is_a?(Integer)
+
+        (Rational(data.to_s) / Rational(factor.to_s)).denominator == 1
+      rescue ArgumentError, ZeroDivisionError, FloatDomainError, TypeError
+        # A value no decimal describes (an infinity a Ruby caller passed in;
+        # JSON carries none) falls back to the floating-point remainder.
+        (data % factor).zero?
+      end
+    end
+  end
+end

data/lib/mcp_client/schema_validator/shapes.rb

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+module MCPClient
+  module SchemaValidator
+    # The shape every keyword value must have before a schema can be used:
+    # an applicator must hold schemas, and an assertion this validator reads
+    # must hold what its keyword is defined to hold. A value of the wrong
+    # shape is neither ignored (that would turn an assertion into a pass)
+    # nor read as written (that would fail every instance): the schema is
+    # unusable, and the preflight says which keyword is at fault. Extended
+    # into SchemaValidator, so the methods are its own.
+    module Shapes
+      # Every applicator value must be a schema (object or boolean), an array
+      # of schemas or a map of schemas; anything else is not silently read as
+      # "true". Keywords the dialect does not define are ignored.
+      # @return [void]
+      def check_applicator_shapes(schema, dialect, problems)
+        schema.each do |keyword, value|
+          next unless keyword_known?(keyword, dialect)
+
+          problem = applicator_shape_problem(keyword, value)
+          problems << problem if problem
+        end
+      end
+
+      # @return [String, nil] why an applicator value is malformed
+      def applicator_shape_problem(keyword, value)
+        if SUBSCHEMA_KEYWORDS.include?(keyword)
+          tuple = keyword == 'items' && all_schemas?(value)
+          "#{keyword} must be a schema" unless schema_value?(value) || tuple
+        elsif keyword == 'dependencies'
+          dependencies_shape_problem(value)
+        elsif SUBSCHEMA_MAP_KEYWORDS.include?(keyword)
+          # A definition bag holds reusable schemas, whatever a reference ends
+          # up pointing at (JSON Schema 2020-12 Core Section 8.2.4).
+          "#{keyword} must be an object of schemas" unless value.is_a?(Hash) && all_schemas?(value.values)
+        elsif SUBSCHEMA_ARRAY_KEYWORDS.include?(keyword)
+          # allOf / anyOf / oneOf / prefixItems: "MUST be a non-empty array".
+          "#{keyword} must be a non-empty array of schemas" unless all_schemas?(value) && !value.empty?
+        end
+      end
+
+      # Assertion keywords whose value shape this validator reads, with what
+      # each must be. A malformed value is not silently ignored (that would
+      # turn an assertion into a pass) nor read as data (that would fail every
+      # instance): the schema is unusable, and the caller is told why.
+      ASSERTION_SHAPES = {
+        'type' => :type_names, 'enum' => :array, 'required' => :property_names, 'pattern' => :string,
+        'minLength' => :non_negative_integer, 'maxLength' => :non_negative_integer,
+        'minItems' => :non_negative_integer, 'maxItems' => :non_negative_integer,
+        'minimum' => :number, 'maximum' => :number,
+        'multipleOf' => :positive_number, 'uniqueItems' => :boolean,
+        'minContains' => :non_negative_integer, 'maxContains' => :non_negative_integer,
+        'minProperties' => :non_negative_integer, 'maxProperties' => :non_negative_integer,
+        'dependentRequired' => :dependent_required
+      }.freeze
+
+      # The standard keywords that only annotate, with the type JSON Schema
+      # 2020-12 Validation Section 9 (and Section 8 for the content
+      # keywords) gives each. Annotating rather than asserting does not
+      # exempt a keyword from being written correctly: a schema that spells
+      # one wrong is a malformed document, and reading it as usable let
+      # :strict check results against a schema no validator could read.
+      ANNOTATION_SHAPES = {
+        'title' => :string, 'description' => :string, '$comment' => :string, 'format' => :string,
+        'contentEncoding' => :string, 'contentMediaType' => :string,
+        'readOnly' => :boolean, 'writeOnly' => :boolean, 'deprecated' => :boolean, 'examples' => :array
+      }.freeze
+
+      # Every keyword whose value shape the preflight reads.
+      KEYWORD_SHAPES = ASSERTION_SHAPES.merge(ANNOTATION_SHAPES).freeze
+
+      # The JSON Schema type names (2020-12 Validation Section 6.1.1).
+      JSON_TYPE_NAMES = %w[array boolean integer null number object string].freeze
+
+      # Check the assertion keyword values a schema object carries. A keyword
+      # the dialect does not define (`minContains` under draft-07) is an
+      # unknown one there: ignored, never malformed.
+      # @return [void]
+      def check_assertion_shapes(schema, dialect, problems)
+        schema.each do |keyword, value|
+          next unless keyword_known?(keyword, dialect)
+
+          problem = assertion_shape_problem(keyword, value)
+          problems << problem if problem
+        end
+      end
+
+      # @return [String, nil] why an assertion or annotation value is malformed
+      def assertion_shape_problem(keyword, value)
+        shape = KEYWORD_SHAPES[keyword]
+        return nil unless shape
+        return type_shape_problem(value) if shape == :type_names
+        return dependent_required_shape_problem(keyword, value) if shape == :dependent_required
+
+        requirement = shape_requirement(shape, value)
+        "#{keyword} must be #{requirement}" if requirement
+      end
+
+      # Each simple assertion shape: the predicate that admits a value, and
+      # how the requirement reads in a problem.
+      VALUE_SHAPES = {
+        array: [:array_value?, 'an array'],
+        property_names: [:property_names?, 'an array of distinct property names'],
+        string: [:string_value?, 'a string'],
+        non_negative_integer: [:non_negative_integer?, 'a non-negative integer'],
+        number: [:number_value?, 'a number'],
+        positive_number: [:positive_number?, 'a number greater than zero'],
+        boolean: [:boolean_value?, 'a boolean']
+      }.freeze
+
+      # @return [String, nil] what a malformed value should have been
+      def shape_requirement(shape, value)
+        predicate, requirement = VALUE_SHAPES[shape]
+        requirement unless predicate.nil? || send(predicate, value)
+      end
+
+      # @return [Boolean]
+      def array_value?(value)
+        value.is_a?(Array)
+      end
+
+      # @return [Boolean]
+      def string_value?(value)
+        value.is_a?(String)
+      end
+
+      # @return [Boolean]
+      def number_value?(value)
+        value.is_a?(Numeric)
+      end
+
+      # @return [Boolean]
+      def positive_number?(value)
+        value.is_a?(Numeric) && value.positive?
+      end
+
+      # @return [Boolean]
+      def non_negative_integer?(value)
+        integer?(value) && !value.negative?
+      end
+
+      # @return [Boolean]
+      def boolean_value?(value)
+        [true, false].include?(value)
+      end
+
+      # `dependentRequired` maps a property name to the names it requires
+      # (JSON Schema 2020-12 Validation Section 6.5.4).
+      # @return [String, nil]
+      def dependent_required_shape_problem(keyword, value)
+        return if value.is_a?(Hash) && value.each_value.all? { |v| property_names?(v) }
+
+        "#{keyword} must be an object of arrays of distinct property names"
+      end
+
+      # @return [String, nil] why a `type` value is malformed
+      def type_shape_problem(value)
+        names = value.is_a?(Array) ? value : [value]
+        known = !names.empty? && names.all? do |name|
+          (name.is_a?(String) || name.is_a?(Symbol)) && JSON_TYPE_NAMES.include?(name.to_s)
+        end
+        return nil if known && (!value.is_a?(Array) || names.uniq.size == names.size)
+
+        "type must be one of #{JSON_TYPE_NAMES.join(', ')}, or a non-empty array of distinct such names"
+      end
+
+      # draft-07: each dependencies entry is a schema or an array of property
+      # names.
+      # @return [String, nil]
+      def dependencies_shape_problem(value)
+        return if value.is_a?(Hash) && value.each_value.all? { |v| schema_value?(v) || property_names?(v) }
+
+        'dependencies entries must be schemas or arrays of property names'
+      end
+
+      # JSON Schema 2020-12 Validation Sections 6.5.3 and 6.5.4: the elements
+      # of `required` (and of a `dependentRequired` entry) are strings, and
+      # they MUST be unique — a name written twice is a malformed keyword,
+      # not the same assertion made again.
+      # @param value [Object]
+      # @return [Boolean] whether value is an array of distinct property names
+      def property_names?(value)
+        value.is_a?(Array) && value.all?(String) && value.uniq.size == value.size
+      end
+
+      # An identifier must have the shape its dialect defines: `$id` is a URI
+      # reference without a non-empty fragment (JSON Schema 2020-12 Core
+      # Section 8.2.1) — draft-07 additionally spells a plain-name identifier
+      # as a bare fragment (Core Section 8.2.3) — and `$anchor` /
+      # `$dynamicAnchor` hold a plain name (Core Section 8.2.2). An
+      # identifier the validator cannot read names nothing, so a reference
+      # written to it would silently resolve elsewhere.
+      # @return [void]
+      def check_identifier_shapes(schema, dialect, problems)
+        id_problem = id_shape_problem(schema['$id'], dialect) if schema.key?('$id')
+        problems << id_problem if id_problem
+        %w[$anchor $dynamicAnchor].each do |keyword|
+          next unless schema.key?(keyword) && keyword_known?(keyword, dialect)
+
+          problems << "#{keyword} must be a plain name" unless anchor_name?(schema[keyword], dialect)
+        end
+      end
+
+      # @return [String, nil] why an `$id` is malformed
+      def id_shape_problem(id, dialect)
+        return '$id must be a non-empty string' unless id.is_a?(String) && !id.empty?
+        # JSON Schema 2020-12 Core Section 8.2.1: the value is a URI
+        # reference. One that is not (a space in it, say) names no resource,
+        # and a reference written to it would resolve elsewhere or nowhere.
+        return "$id #{clip(id.inspect)} must be a URI reference" unless uri_reference?(id)
+        # draft-07 Core Section 8.2.3: an $id that is exactly a fragment
+        # declares a plain name rather than a base URI.
+        return nil if dialect == DRAFT_07 && id.start_with?('#')
+
+        fragment = id.split('#', 2)[1]
+        return nil if fragment.nil? || fragment.empty?
+
+        "$id #{clip(id.inspect)} must not contain a non-empty fragment"
+      end
+
+      # @return [Boolean] whether a string parses as an RFC 3986 URI reference
+      def uri_reference?(value)
+        URI::RFC3986_PARSER.parse(value)
+        true
+      rescue URI::InvalidURIError
+        false
+      end
+
+      # The core keywords with a fixed shape beyond the identifiers:
+      # `$vocabulary` is an object mapping vocabulary URIs to booleans (Core
+      # Section 8.1.2) and 2019-09's `$recursiveAnchor` is a boolean (2019-09
+      # Core Section 8.2.4.2.2). A keyword the dialect does not define is
+      # unknown there, never malformed.
+      # @return [void]
+      def check_core_keyword_shapes(schema, dialect, problems)
+        if schema.key?('$vocabulary') && keyword_known?('$vocabulary',
+                                                        dialect) && !vocabulary_map?(schema['$vocabulary'])
+          problems << '$vocabulary must be an object of booleans keyed by URI'
+        end
+        return unless schema.key?('$recursiveAnchor') && keyword_known?('$recursiveAnchor', dialect)
+
+        problems << '$recursiveAnchor must be a boolean' unless boolean_value?(schema['$recursiveAnchor'])
+      end
+
+      # A vocabulary is identified by a URI (Core Section 8.1.2), never by a
+      # relative reference.
+      # @return [Boolean]
+      def vocabulary_map?(value)
+        value.is_a?(Hash) && value.all? { |uri, required| absolute_uri?(uri.to_s) && boolean_value?(required) }
+      end
+
+      # @return [Boolean] whether the value is a URI with a scheme
+      def absolute_uri?(value)
+        !URI::RFC3986_PARSER.parse(value).scheme.nil?
+      rescue URI::InvalidURIError
+        false
+      end
+
+      # A `pattern`, and every `patternProperties` key, must be an ECMA-262
+      # regular expression the validator can read (JSON Schema 2020-12 Core
+      # Section 4.3) within the length bound. One that is not is a malformed
+      # keyword: the schema is unusable, not a schema without the pattern
+      # (which admitted every string).
+      # @param deadline [Float, nil] monotonic deadline the check runs under
+      # @return [void]
+      def check_pattern_shapes(schema, dialect, problems, deadline = nil)
+        pattern = schema['pattern']
+        problem = pattern_shape_problem('pattern', pattern, deadline) if pattern.is_a?(String)
+        problems << problem if problem
+        patterns = schema['patternProperties'] if keyword_known?('patternProperties', dialect)
+        return unless patterns.is_a?(Hash)
+
+        patterns.each_key do |key|
+          break unless problems.empty?
+
+          problem = pattern_shape_problem('patternProperties pattern', key.to_s, deadline)
+          problems << problem if problem
+        end
+      end
+
+      # @return [String, nil] why a pattern cannot be used
+      def pattern_shape_problem(keyword, pattern, deadline = nil)
+        return "#{keyword} is longer than #{MAX_PATTERN_LENGTH} characters" if pattern.length > MAX_PATTERN_LENGTH
+        return 'validation aborted: validation time budget exhausted during the schema check' if
+          budget_exhausted?(deadline)
+
+        ecma_regexp(pattern, PATTERN_MATCH_TIMEOUT, deadline)
+        nil
+      rescue EcmaPatterns::Untranslatable => e
+        "#{keyword} #{clip(pattern.inspect)} cannot be evaluated faithfully (#{clip(e.message)})"
+      rescue RegexpError => e
+        "#{keyword} #{clip(pattern.inspect)} is not an ECMA-262 regular expression (#{clip(e.message)})"
+      rescue Aborted => e
+        "validation aborted: #{e.message}"
+      end
+
+      # exclusiveMinimum / exclusiveMaximum are numbers in every supported
+      # dialect (draft-07 validation Sections 6.2.3 and 6.2.5, kept by 2019-09
+      # and 2020-12); the boolean modifier form belongs to draft-04, which is
+      # not supported, and is not silently ignored (it would turn a bound
+      # into a pass).
+      # @return [void]
+      def check_exclusive_bounds(schema, _dialect, problems)
+        %w[exclusiveMinimum exclusiveMaximum].each do |keyword|
+          next if !schema.key?(keyword) || schema[keyword].is_a?(Numeric)
+
+          problems << "#{keyword} must be a number (the draft-04 boolean form is not supported)"
+        end
+      end
+
+      # @param values [Object]
+      # @return [Boolean] whether values is an array of schemas
+      def all_schemas?(values)
+        values.is_a?(Array) && values.all? { |v| schema_value?(v) }
+      end
+    end
+  end
+end

data/lib/mcp_client/schema_validator/uri_references.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module MCPClient
+  module SchemaValidator
+    # URI reference resolution (RFC 3986 Section 5), used to decide which
+    # schema resource a `$ref` names. A JSON Schema document may bundle the
+    # resources it uses (JSON Schema 2020-12 Core Section 9.3.1): a reference
+    # written as an absolute URI, as a URI relative to the base an enclosing
+    # `$id` established, or as the empty reference then names a resource the
+    # document already carries, and resolving it needs no retrieval. Nothing
+    # here fetches or normalizes anything beyond what RFC 3986 defines, and
+    # nothing here raises: a reference a peer wrote that cannot be parsed
+    # simply names no local resource. Extended into SchemaValidator, so the
+    # methods are its own.
+    module UriReferences
+      # RFC 3986 Appendix B: the components of a URI reference.
+      URI_REFERENCE = %r{
+        \A
+        (?:(?<scheme>[A-Za-z][A-Za-z0-9+\-.]*):)?
+        (?://(?<authority>[^/?\#]*))?
+        (?<path>[^?\#]*)
+        (?:\?(?<query>[^\#]*))?
+        (?:\#(?<fragment>.*))?
+        \z
+      }mx
+
+      # Resolve a URI reference against a base URI (RFC 3986 Section 5.2.2),
+      # dropping the fragment: what comes back identifies a resource, which
+      # is what an `$id` declares and what a `$ref` selects before its
+      # fragment is applied.
+      # @param base [String] the base URI (may be empty when the document
+      #   declares none: relative references still resolve consistently
+      #   against each other)
+      # @param ref [String] the reference to resolve
+      # @return [String, nil] nil when either side is not a URI reference
+      def merge_uri(base, ref)
+        target = parse_uri_reference(ref)
+        origin = parse_uri_reference(base)
+        return nil unless target && origin
+        return merge_relative_uri(origin, target) unless target[:scheme]
+
+        compose_uri(target[:scheme], target[:authority], remove_dot_segments(target[:path]), target[:query])
+      end
+
+      # The RFC 3986 Section 5.2.2 branches for a reference without a scheme.
+      # @param origin [Hash] the parsed base URI
+      # @param target [Hash] the parsed reference
+      # @return [String]
+      def merge_relative_uri(origin, target)
+        if target[:authority]
+          compose_uri(origin[:scheme], target[:authority], remove_dot_segments(target[:path]), target[:query])
+        elsif target[:path].empty?
+          compose_uri(origin[:scheme], origin[:authority], origin[:path], target[:query] || origin[:query])
+        elsif target[:path].start_with?('/')
+          compose_uri(origin[:scheme], origin[:authority], remove_dot_segments(target[:path]), target[:query])
+        else
+          path = remove_dot_segments(merge_paths(origin, target[:path]))
+          compose_uri(origin[:scheme], origin[:authority], path, target[:query])
+        end
+      end
+
+      # @param uri [String]
+      # @return [Hash, nil] :scheme, :authority, :query (each String or nil)
+      #   and :path (always a String); nil when the text is not a URI
+      #   reference (or is not readable text at all)
+      def parse_uri_reference(uri)
+        return nil unless uri.is_a?(String)
+
+        match = URI_REFERENCE.match(uri)
+        return nil unless match
+
+        # A scheme is case-insensitive (RFC 3986 Section 3.1), so two
+        # spellings of one resource identify the same one.
+        { scheme: match[:scheme]&.downcase, authority: match[:authority], path: match[:path].to_s,
+          query: match[:query] }
+      rescue ArgumentError
+        nil
+      end
+
+      # RFC 3986 Section 5.3.
+      # @return [String]
+      def compose_uri(scheme, authority, path, query)
+        composed = +''
+        composed << "#{scheme}:" if scheme
+        composed << "//#{authority}" if authority
+        composed << path
+        composed << "?#{query}" if query
+        composed
+      end
+
+      # RFC 3986 Section 5.2.3: a relative path is merged onto the base's.
+      # @param origin [Hash] the parsed base URI
+      # @param path [String] the reference's relative path
+      # @return [String]
+      def merge_paths(origin, path)
+        return "/#{path}" if origin[:authority] && origin[:path].empty?
+
+        "#{origin[:path].sub(%r{[^/]*\z}, '')}#{path}"
+      end
+
+      # RFC 3986 Section 5.2.4.
+      # @param path [String]
+      # @return [String]
+      def remove_dot_segments(path)
+        input = path
+        output = []
+        until input.empty?
+          stripped = strip_leading_dots(input)
+          unless stripped.equal?(input)
+            input = stripped
+            next
+          end
+
+          stepped = dot_segment_step(input, output)
+          if stepped
+            input = stepped
+            next
+          end
+
+          segment = input[%r{\A/?[^/]*}]
+          output << segment
+          input = input[segment.length..]
+        end
+        output.join
+      end
+
+      # The RFC 3986 Section 5.2.4 A and B prefixes, which are simply dropped.
+      # @return [String] the input itself when neither applies
+      def strip_leading_dots(input)
+        return input.sub(%r{\A\.\.?/}, '') if input.start_with?('../', './')
+        return '' if ['.', '..'].include?(input)
+
+        input
+      end
+
+      # The RFC 3986 Section 5.2.4 C and D prefixes, which also pop an
+      # already-emitted segment for "..".
+      # @return [String, false] the remaining input, or false when the
+      #   prefix does not apply
+      def dot_segment_step(input, output)
+        return "/#{input[3..]}" if input.start_with?('/./')
+        return '/' if input == '/.'
+
+        if input.start_with?('/../') || input == '/..'
+          output.pop
+          return input == '/..' ? '/' : "/#{input[4..]}"
+        end
+
+        false
+      end
+    end
+  end
+end