uri_pattern 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6bb66ae7537c5bdaf93dfa53686ed10a17f773a41524312132e7b44912332a34
+  data.tar.gz: bbfccbdcc181b33bc8a1abdc13a21a1e87006c8c8df2a3c4b328d94ceba84910
+SHA512:
+  metadata.gz: 67f62acc8dac39fe7528926aca10b230409d353fdc7ab5cb7130bd03b49fb17ccc48883aaa8652142610630234da77273d784955a7e110e88d7b6d991ca40bfb
+  data.tar.gz: b9b61835ebfcedc03f2832277507513d64b9cdbabf4876a5715839be11836fc2119219c18fd4850228cd34afa782d6d8fa8f3a16b3312039af7ff679243b8f7d

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"uri_pattern" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["yuuji.yaginuma@gmail.com"](mailto:"yuuji.yaginuma@gmail.com").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yuji Yaginuma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,109 @@
+# URIPattern
+
+Ruby port of the [WHATWG URLPattern specification](https://urlpattern.spec.whatwg.org/).
+
+It lets you match URLs against patterns that contain named groups, wildcards, optional segments, and custom regular expressions, and read the captured values back out — the same matching model the `URLPattern` API provides in browsers, adapted to Ruby conventions (snake_case, keyword arguments, and `nil` in place of `undefined`).
+
+## Installation
+
+Install the gem and add it to the application's Gemfile by executing:
+
+```bash
+bundle add uri_pattern
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install uri_pattern
+```
+
+## Usage
+
+### Constructing a pattern
+
+A pattern can be built from a full URL pattern string, or from a hash of
+per-component pattern strings. Any component you omit defaults to the wildcard
+`*`.
+
+```ruby
+require "uri_pattern"
+
+# From a string
+pattern = URIPattern.new("https://example.com/users/:id")
+
+# From a hash of components
+pattern = URIPattern.new({ hostname: "example.com", pathname: "/users/:id" })
+
+# A relative pattern, resolved against a base URL
+pattern = URIPattern.new("/users/:id", "https://example.com")
+
+# Case-insensitive matching
+pattern = URIPattern.new("https://example.com/Users/:id", ignore_case: true)
+```
+
+### Testing for a match
+
+`#match?` returns a boolean and is the fastest way to check a URL:
+
+```ruby
+pattern = URIPattern.new("https://example.com/users/:id")
+
+pattern.match?("https://example.com/users/42")  # => true
+pattern.match?("https://example.com/posts/42")  # => false
+pattern.match?("https://other.com/users/42")    # => false
+```
+
+### Capturing values
+
+`#match` returns a `URIPattern::MatchResult` on success, or `nil` when the URL
+does not match. Each component exposes its matched `input` and named `groups`:
+
+```ruby
+pattern = URIPattern.new("https://example.com/users/:id")
+result  = pattern.match("https://example.com/users/42")
+
+result.pathname.input   # => "/users/42"
+result.pathname.groups  # => { "id" => "42" }
+result.hostname.input   # => "example.com"
+result.hostname.groups  # => {}
+
+pattern.match("https://other.com/users/42")  # => nil
+```
+
+Groups can be captured from any component, including the query string:
+
+```ruby
+pattern = URIPattern.new("https://example.com/search?q=:term")
+result  = pattern.match("https://example.com/search?q=ruby")
+
+result.query.groups  # => { "term" => "ruby" }
+```
+
+### Reading components back
+
+Each component reader returns the pattern string for that component:
+
+```ruby
+pattern = URIPattern.new("https://*.example.com/books/:id?")
+
+pattern.protocol  # => "https"
+pattern.hostname  # => "*.example.com"
+pattern.pathname  # => "/books/:id?"
+pattern.query     # => "*"
+pattern.fragment  # => "*"
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/y-yagi/uri_pattern.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: :test

data/lib/uri_pattern/canonicalization.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+class URIPattern
+  # Per-component canonicalization of fixed (literal) text, shared by the regexp
+  # Compiler and the pattern-string generator so both apply identical encoding.
+  # Including classes must define @component, @opaque_path and @ipv6.
+  module Canonicalization
+    # Canonicalize one fixed-text run for the current component. The percent-encode
+    # components (pathname/query/fragment/username/password) are delegated to the
+    # spec's "dummy URL" canonicalizers in URLParser so the URL parser applies the
+    # exact spec encode set and dot-segment handling. Hostname/port keep their
+    # dedicated parsers; protocol (and anything else) passes through unchanged.
+    def encode_run(run)
+      case @component
+      when :hostname
+        @ipv6 ? canonicalize_ipv6(run) : canonicalize_hostname(run)
+      when :port
+        canonicalize_port(run)
+      when :pathname
+        URIPattern::URLParser.canonicalize_pathname_run(run, opaque_path: @opaque_path)
+      when :query
+        URIPattern::URLParser.canonicalize_search_run(run)
+      when :fragment
+        URIPattern::URLParser.canonicalize_hash_run(run)
+      when :username
+        URIPattern::URLParser.canonicalize_username_run(run)
+      when :password
+        URIPattern::URLParser.canonicalize_password_run(run)
+      else
+        run
+      end
+    end
+
+    # WHATWG basic URL parser "port state": read leading ASCII digits, stop at the
+    # first non-digit, fail if the number exceeds 65535, and serialize without
+    # leading zeros. (Default-port stripping is protocol-dependent and not applied
+    # to the pattern string.)
+    def canonicalize_port(run)
+      return run if run.empty?
+      digits = run[/\A[0-9]*/]
+      raise URIPattern::Error, "Invalid port #{run.inspect}" if digits.empty?
+      number = digits.to_i
+      raise URIPattern::Error, "Invalid port #{run.inspect}" if number > 65_535
+      number.to_s
+    end
+
+    # WHATWG "canonicalize a hostname": strip tab/newline/CR, end the host at the
+    # first path delimiter ("/", "\\", "#", "?"), then run the host parser. A host
+    # that fails to parse (forbidden code points, bad IDN, etc.) raises.
+    def canonicalize_hostname(run)
+      return run if run.empty?
+      value = run.gsub(/[\t\n\r]/, "")
+      return "" if value.empty?
+      if (idx = value.index(/[\/\\#?]/))
+        value = value[0, idx]
+      end
+      return "" if value.empty?
+      URI::WhatwgParser::HostParser.new.parse(value)
+    rescue => e
+      raise URIPattern::Error, "Invalid hostname #{run.inspect}: #{e.message}"
+    end
+
+    # WHATWG "canonicalize an IPv6 hostname": only "[", "]", ":" and ASCII hex
+    # digits are permitted; hex letters are lowercased.
+    def canonicalize_ipv6(run)
+      run.each_char.map do |c|
+        case c
+        when "[", "]", ":" then c
+        when /[0-9a-fA-F]/  then c.downcase
+        else
+          raise URIPattern::Error, "Invalid IPv6 hostname character #{c.inspect} in #{run.inspect}"
+        end
+      end.join
+    end
+  end
+end

data/lib/uri_pattern/compiler.rb

@@ -0,0 +1,380 @@
+# frozen_string_literal: true
+
+class URIPattern
+  class Compiler
+    SEGMENT_REGEXPS = {
+      pathname: "[^/]+?",
+      hostname: "[^.]+?"
+    }.freeze
+    DEFAULT_SEGMENT = "[^#?{}]+?"
+
+    DELIMITER_CHARS = {
+      pathname: "/",
+      hostname: "."
+    }.freeze
+
+    # Token types that carry literal text and are buffered (not turned into a
+    # capture). Shared by the top-level and in-group compile loops.
+    LITERAL_TOKEN_TYPES = %i[char escaped_char invalid_char].freeze
+
+    include URIPattern::Canonicalization
+
+    # Accumulate consecutive literal characters; flush_literals canonicalizes the
+    # whole run through the component's encode callback (which may raise) and
+    # appends the Regexp-escaped result. This mirrors the spec applying an
+    # encoding callback to each fixed-text part of a pattern.
+    def flush_literals(result, before_part: false)
+      return if @literal_buf.empty?
+      run = @literal_buf
+      @literal_buf = +""
+      delim = delimiter_char
+      # When this run is immediately followed by a part (name/group/wildcard), a
+      # trailing delimiter ("/" for pathname, "." for hostname) is that part's
+      # prefix, not part of this fixed run. Canonicalize the run WITHOUT it — so e.g.
+      # pathname dot-segments collapse correctly (`/a/../` → run `/a/..` → `/`) — and
+      # re-append the delimiter verbatim for pull_delimiter_prefix / the next literal
+      # to consume. This keeps the Compiler consistent with PatternString and the
+      # spec, which treat the prefix as a separate token.
+      if before_part && !delim.empty? && run != delim && run.end_with?(delim)
+        result << Regexp.escape(encode_run(run[0...-delim.length]))
+        result << Regexp.escape(delim)
+      else
+        result << Regexp.escape(encode_run(run))
+      end
+    end
+
+    WILDCARD_PREFIX = "_w"
+
+    def initialize(tokens, component:, ignore_case: false, opaque_path: false, ipv6: false)
+      @tokens = tokens
+      @component = component
+      @ignore_case = ignore_case
+      @opaque_path = opaque_path
+      @ipv6 = ipv6
+      @wildcard_index = 0
+      @names_order = []
+      @wildcard_name_map = {}
+      @literal_buf = +""
+      @seen_names = {}
+    end
+
+    def compile
+      regexp_str = translate_v_class_sets(build_regexp_string)
+      flags = @ignore_case ? Regexp::IGNORECASE : 0
+      begin
+        regexp = Regexp.new("\\A#{regexp_str}\\z", flags)
+      rescue RegexpError => e
+        raise URIPattern::Error, "Invalid pattern: #{e.message}"
+      end
+      { regexp: regexp, names: @names_order, wildcard_name_map: @wildcard_name_map }
+    end
+
+    private
+
+    # ECMAScript "v"-flag character classes support a "--" set-subtraction operator
+    # (e.g. "[[a-z]--a]" = "[a-z]" minus "a") that Ruby's regexp engine lacks. Ruby
+    # does support "&&" intersection, so rewrite "[A--B]" as "[A&&[^B]]".
+    V_CLASS_SUBTRACTION = /(\[[^\[\]]+\])--(\[[^\[\]]+\]|[^\]]+?)(?=\])/
+
+    def translate_v_class_sets(source)
+      source.gsub(V_CLASS_SUBTRACTION) do
+        lhs, rhs = $1, $2
+        rhs_chars = rhs.start_with?("[") ? rhs[1..-2] : rhs
+        "#{lhs}&&[^#{rhs_chars}]"
+      end
+    end
+
+    def segment_regexp
+      SEGMENT_REGEXPS.fetch(@component, DEFAULT_SEGMENT)
+    end
+
+    def delimiter_char
+      # Opaque paths (non-special schemes like "data:") are not hierarchical, so
+      # there is no "/" segment delimiter and no delimiter prefix is pulled into
+      # an optional/repeated group.
+      return "" if @component == :pathname && @opaque_path
+      DELIMITER_CHARS[@component] || ""
+    end
+
+    def pull_delimiter_prefix(result)
+      delim = delimiter_char
+      return "" if delim.empty?
+      escaped = Regexp.escape(delim)
+      if result.end_with?(escaped)
+        result.slice!(result.length - escaped.length, escaped.length)
+        escaped
+      else
+        ""
+      end
+    end
+
+    # A duplicate group name is a spec-level error ("URLPattern" raises TypeError).
+    def register_name(name)
+      if @seen_names[name]
+        raise URIPattern::Error, "Duplicate group name #{name.inspect} in pattern"
+      end
+      @seen_names[name] = true
+      @names_order << name
+    end
+
+    def next_wildcard_name
+      external = @wildcard_index.to_s
+      internal = "#{WILDCARD_PREFIX}#{@wildcard_index}"
+      @wildcard_index += 1
+      @wildcard_name_map[internal] = external
+      @names_order << external
+      internal
+    end
+
+    def modifier_regex(name, core, prefix, mod)
+      case mod
+      when "+"
+        # One or more: capture all repetitions in a single group
+        # prefix + (core)(delimiter+core)* → all in one named group
+        delim = delimiter_char.empty? ? "" : Regexp.escape(delimiter_char)
+        if delim.empty? || prefix.empty?
+          "#{prefix}(?<#{name}>(?:#{core})+)"
+        else
+          "#{prefix}(?<#{name}>#{core}(?:#{delim}#{core})*)"
+        end
+      when "*"
+        # Zero or more: optional group, nil on zero occurrences
+        delim = delimiter_char.empty? ? "" : Regexp.escape(delimiter_char)
+        if delim.empty? || prefix.empty?
+          "(?:#{prefix}(?<#{name}>(?:#{core})*))?".dup
+        else
+          "(?:#{prefix}(?<#{name}>#{core}(?:#{delim}#{core})*))?".dup
+        end
+      when "?"
+        # Zero or one
+        "(?:#{prefix}(?<#{name}>#{core}))?"
+      else
+        "(?:#{prefix}(?<#{name}>#{core}))#{mod}"
+      end
+    end
+
+    def build_regexp_string
+      result = +""
+      i = 0
+
+      while i < @tokens.length
+        token = @tokens[i]
+
+        if LITERAL_TOKEN_TYPES.include?(token.type)
+          @literal_buf << token.value
+          i += 1
+          next
+        end
+
+        # A "{...}" group whose body is pure literal text and which carries no
+        # modifier is a fixed-text part, not a group. Merge its text into the
+        # literal run so adjacent literals canonicalize together (e.g. hostname
+        # "example{.com/}foo" → the run "example.com/foo" → host-truncated at "/").
+        if token.type == :open && (fixed = fixed_text_group(i))
+          @literal_buf << fixed[:text]
+          i = fixed[:next_index]
+          next
+        end
+
+        flush_literals(result, before_part: %i[asterisk name open regexp].include?(token.type))
+
+        case token.type
+        when :end
+          break
+
+        when :asterisk
+          internal_name = next_wildcard_name
+          next_tok = @tokens[i + 1]
+          if next_tok && next_tok.type == :other_modifier
+            prefix = pull_delimiter_prefix(result)
+            # Wildcards match greedily; optional/one-or-more modifiers use lazy outer quantifier
+            case next_tok.value
+            when "+"
+              result << "#{prefix}(?<#{internal_name}>.*)"
+            when "*", "?"
+              result << "(?:#{prefix}(?<#{internal_name}>.*))?\?"
+            else
+              result << "#{prefix}(?<#{internal_name}>.*)#{next_tok.value}"
+            end
+            i += 2
+          else
+            result << "(?<#{internal_name}>.*)"
+            i += 1
+          end
+
+        when :name
+          name = token.value
+          register_name(name)
+          next_tok = @tokens[i + 1]
+          seg = segment_regexp
+          if next_tok&.type == :other_modifier
+            prefix = pull_delimiter_prefix(result)
+            result << modifier_regex(name, seg, prefix, next_tok.value)
+            i += 2
+          elsif next_tok&.type == :regexp
+            inner = regexp_inner(next_tok)
+            mod_tok = @tokens[i + 2]
+            if mod_tok&.type == :other_modifier
+              prefix = pull_delimiter_prefix(result)
+              result << modifier_regex(name, inner, prefix, mod_tok.value)
+              i += 3
+            else
+              result << "(?<#{name}>(?:#{inner}))"
+              i += 2
+            end
+          else
+            result << "(?<#{name}>#{seg})"
+            i += 1
+          end
+
+        when :open
+          i += 1
+          inner_result, i = compile_group_inner(i)
+          mod_tok = @tokens[i]
+          if mod_tok&.type == :other_modifier
+            prefix = pull_delimiter_prefix(result)
+            result << "(?:#{prefix}#{inner_result})#{mod_tok.value}"
+            i += 1
+          else
+            result << "(?:#{inner_result})"
+          end
+
+        when :regexp
+          inner = regexp_inner(token)
+          internal_name = next_wildcard_name
+          mod_tok = @tokens[i + 1]
+          if mod_tok&.type == :other_modifier
+            prefix = pull_delimiter_prefix(result)
+            result << modifier_regex(internal_name, inner, prefix, mod_tok.value)
+            i += 2
+          else
+            result << "(?<#{internal_name}>(?:#{inner}))"
+            i += 1
+          end
+
+        when :other_modifier
+          # A modifier here did not follow a group/name/regexp/wildcard.
+          raise URIPattern::Error, "Dangling modifier #{token.value.inspect} in pattern"
+
+        else
+          i += 1
+        end
+      end
+
+      flush_literals(result)
+      result
+    end
+
+    # If the "{" group starting at index i contains only literal characters and is
+    # not followed by a modifier, return its text and the index just past "}".
+    # Otherwise return nil (it is a real group with a capture/wildcard/modifier).
+    def fixed_text_group(i)
+      j = i + 1
+      text = +""
+      while j < @tokens.length
+        tok = @tokens[j]
+        case tok.type
+        when :char, :escaped_char, :invalid_char
+          text << tok.value
+          j += 1
+        when :close
+          return nil if @tokens[j + 1]&.type == :other_modifier
+          return { text: text, next_index: j + 1 }
+        else
+          return nil
+        end
+      end
+      nil
+    end
+
+    def compile_group_inner(i)
+      result = +""
+      while i < @tokens.length
+        token = @tokens[i]
+
+        if LITERAL_TOKEN_TYPES.include?(token.type)
+          @literal_buf << token.value
+          i += 1
+          next
+        end
+
+        flush_literals(result)
+
+        case token.type
+        when :close
+          i += 1
+          return [result, i]
+        when :end
+          raise URIPattern::Error, "Unclosed '{' group in pattern"
+        when :name
+          name = token.value
+          register_name(name)
+          next_tok = @tokens[i + 1]
+          seg = segment_regexp
+          if next_tok&.type == :other_modifier
+            result << "(?<#{name}>#{seg})#{next_tok.value}"
+            i += 2
+          elsif next_tok&.type == :regexp
+            inner = regexp_inner(next_tok)
+            result << "(?<#{name}>(?:#{inner}))"
+            i += 2
+          else
+            result << "(?<#{name}>#{seg})"
+            i += 1
+          end
+        when :asterisk
+          internal_name = next_wildcard_name
+          result << "(?<#{internal_name}>.*)"
+          i += 1
+        when :regexp
+          inner = regexp_inner(token)
+          internal_name = next_wildcard_name
+          result << "(?<#{internal_name}>(?:#{inner}))"
+          i += 1
+        when :open
+          # A "{" group nested inside another "{" group is not allowed.
+          raise URIPattern::Error, "Nested '{' group in pattern"
+        when :other_modifier
+          raise URIPattern::Error, "Dangling modifier #{token.value.inspect} in pattern"
+        else
+          i += 1
+        end
+      end
+      raise URIPattern::Error, "Unclosed '{' group in pattern"
+    end
+
+    # Prepare a :regexp token's raw inner source for embedding: validate its identity
+    # escapes (ECMAScript "u"-mode rules) and neutralize any author-written named
+    # captures so only URLPattern-level names surface. The tokenizer already enforced
+    # the structural rules (balance, no capturing sub-groups, ASCII, non-empty).
+    def regexp_inner(token)
+      inner = token.value.to_s
+      validate_regexp_escapes(inner)
+      strip_named_captures(inner)
+    end
+
+    # Validate every "\X" identity escape in a regexp group's source.
+    def validate_regexp_escapes(inner)
+      inner.scan(/\\(.)/m) { validate_regexp_escape($1) }
+    end
+
+    # Named captures written inside a custom regexp group — "(?<x>...)" / "(?'x'...)"
+    # — must not surface in the match result's groups (only URLPattern-level names
+    # and wildcard indices do). Convert them to plain non-capturing groups, while
+    # leaving lookbehind assertions "(?<=...)" / "(?<!...)" untouched.
+    def strip_named_captures(inner)
+      inner.gsub(/\(\?<(?![=!])[^>]*>/, "(?:").gsub(/\(\?'[^']*'/, "(?:")
+    end
+
+    # The spec compiles each custom regexp group as a Unicode-mode ECMAScript
+    # regexp, where an identity escape ("\\x" for a literal x) is only valid for a
+    # SyntaxCharacter, "/", or a recognized escape class. Letters like "m" or "H"
+    # have no such escape and make the whole pattern invalid, even though Ruby
+    # would silently accept them.
+    VALID_REGEXP_ESCAPE = /\A[\^$\\.*+?()\[\]{}|\/dDsSwWbBfnrtvcxukpP0-9]\z/
+    def validate_regexp_escape(char)
+      return if char.match?(VALID_REGEXP_ESCAPE)
+      raise URIPattern::Error, "Invalid regexp escape \\#{char}"
+    end
+  end
+end

data/lib/uri_pattern/component_pattern.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class URIPattern
+  class ComponentPattern
+    attr_reader :pattern
+
+    def initialize(pattern_string, component:, ignore_case: false, opaque_path: false)
+      tokens = Tokenizer.new(pattern_string, policy: :strict).tokenize
+      ipv6 = component == :hostname && ipv6_hostname_pattern?(pattern_string)
+      compiled = Compiler.new(tokens, component: component, ignore_case: ignore_case,
+                               opaque_path: opaque_path, ipv6: ipv6).compile
+      @regexp = compiled[:regexp]
+      @wildcard_name_map = compiled[:wildcard_name_map]
+      # The getter exposes the canonicalized "component pattern string", not the
+      # raw input (see PatternString).
+      @pattern = PatternString.generate(pattern_string, component: component,
+                                        opaque_path: opaque_path, ipv6: ipv6)
+    end
+
+    # WHATWG "hostname pattern is an IPv6 address": true when the pattern starts
+    # with "[" (optionally wrapped in a "{" group). Such hostnames use the IPv6
+    # encode callback (lowercase hex + char validation) instead of host parsing.
+    def ipv6_hostname_pattern?(str)
+      return false if str.length < 2
+      str[0] == "[" || (str[0] == "{" && str[1] == "[")
+    end
+
+    def match(string)
+      @regexp.match(string)
+    end
+
+    def groups_for(string)
+      md = @regexp.match(string)
+      return nil unless md
+      caps = md.named_captures
+      @wildcard_name_map.each do |internal, external|
+        caps[external] = caps.delete(internal) if caps.key?(internal)
+      end
+      caps
+    end
+  end
+end

data/lib/uri_pattern/match_result.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class URIPattern
+  ComponentResult = Struct.new(:input, :groups, keyword_init: true)
+
+  class MatchResult
+    # +inputs+ is the array of arguments passed to #match: [input] or
+    # [input, base_url], mirroring URLPatternResult.inputs in the spec.
+    attr_reader :inputs, :protocol, :username, :password, :hostname,
+                :port, :pathname, :query, :fragment
+
+    def initialize(inputs:, protocol:, username:, password:, hostname:,
+                   port:, pathname:, query:, fragment:)
+      @inputs   = inputs
+      @protocol = protocol
+      @username = username
+      @password = password
+      @hostname = hostname
+      @port     = port
+      @pathname = pathname
+      @query    = query
+      @fragment = fragment
+    end
+  end
+end