implement URLPattern

.clang-format

@@ -1,2 +1,2 @@
 BasedOnStyle: Google
-SortIncludes: false
+SortIncludes: Never

.editorconfig

@@ -3,3 +3,5 @@ root = true
 [*]
 end_of_line = lf
 insert_final_newline = true
+indent_size = 2
+indent_style = space

.github/workflows/macos_install.yml

@@ -21,12 +21,12 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  ubuntu-build:
+  macos-build:
     runs-on: macos-latest
     strategy:
       matrix:
         include:
-          shared: [ON, OFF]
+          - shared: OFF
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       - name: Prepare

.gitignore

@@ -25,6 +25,7 @@ benchmarks/competitors/servo-url/target
 
 #ignore VScode
 .vscode/
+.idea
 
 # bazel output
 bazel-*

fuzz/build.sh

@@ -37,6 +37,14 @@ $CXX $CFLAGS $CXXFLAGS \
 $CXX $CFLAGS $CXXFLAGS $LIB_FUZZING_ENGINE url_search_params.o \
      -o $OUT/url_search_params
 
+$CXX $CFLAGS $CXXFLAGS \
+     -std=c++20 \
+     -I build/singleheader \
+     -c fuzz/url_pattern.cc -o url_pattern.o
+
+$CXX $CFLAGS $CXXFLAGS $LIB_FUZZING_ENGINE url_pattern.o \
+     -o $OUT/url_pattern
+
 $CXX $CFLAGS $CXXFLAGS \
      -std=c++20 \
      -I build/singleheader \

fuzz/url_pattern.cc

@@ -0,0 +1,44 @@
+#include <fuzzer/FuzzedDataProvider.h>
+
+#include <memory>
+#include <string>
+
+#include "ada.cpp"
+#include "ada.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  FuzzedDataProvider fdp(data, size);
+  std::string source = fdp.ConsumeRandomLengthString(256);
+  std::string base_source = fdp.ConsumeRandomLengthString(256);
+
+  // Without base or options
+  auto result = ada::parse_url_pattern(source, nullptr, nullptr);
+  (void)result;
+
+  // Testing with base_url
+  std::string_view base_source_view(base_source.data(), base_source.length());
+  auto result_with_base =
+      ada::parse_url_pattern(source, &base_source_view, nullptr);
+  (void)result_with_base;
+
+  // Testing with base_url and options
+  ada::url_pattern_options options{.ignore_case = true};
+  auto result_with_base_and_options =
+      ada::parse_url_pattern(source, &base_source_view, &options);
+  (void)result_with_base_and_options;
+
+  // Testing with url_pattern_init and base url.
+  ada::url_pattern_init init{.protocol = source,
+                             .username = source,
+                             .password = source,
+                             .hostname = source,
+                             .port = source,
+                             .pathname = source,
+                             .search = source,
+                             .hash = source};
+  auto result_with_init =
+      ada::parse_url_pattern(init, &base_source_view, nullptr);
+  (void)result_with_init;
+
+  return 0;
+}

include/ada.h

@@ -26,6 +26,10 @@
 #include "ada/url_aggregator-inl.h"
 #include "ada/url_search_params.h"
 #include "ada/url_search_params-inl.h"
+#include "ada/url_pattern.h"
+#include "ada/url_pattern-inl.h"
+#include "ada/url_pattern_helpers.h"
+#include "ada/url_pattern_helpers-inl.h"
 
 // Public API
 #include "ada/ada_version.h"

include/ada/ada_idna.h

@@ -1,4 +1,4 @@
-/* auto-generated on 2024-12-05 20:44:13 -0500. Do not edit! */
+/* auto-generated on 2024-12-18 09:44:34 -0500. Do not edit! */
 /* begin file include/idna.h */
 #ifndef ADA_IDNA_H
 #define ADA_IDNA_H
@@ -141,6 +141,29 @@ std::string to_unicode(std::string_view input);
 
 #endif  // ADA_IDNA_TO_UNICODE_H
 /* end file include/ada/idna/to_unicode.h */
+/* begin file include/ada/idna/identifier.h */
+#ifndef ADA_IDNA_IDENTIFIER_H
+#define ADA_IDNA_IDENTIFIER_H
+
+#include <string>
+#include <string_view>
+
+namespace ada::idna {
+
+// Access the first code point of the input string.
+// Verify if it is valid name code point given a Unicode code point and a
+// boolean first: If first is true return the result of checking if code point
+// is contained in the IdentifierStart set of code points. Otherwise return the
+// result of checking if code point is contained in the IdentifierPart set of
+// code points. Returns false if the input is empty or the code point is not
+// valid. There is minimal Unicode error handling: the input should be valid
+// UTF-8. https://urlpattern.spec.whatwg.org/#is-a-valid-name-code-point
+bool valid_name_code_point(char32_t input, bool first);
+
+}  // namespace ada::idna
+
+#endif
+/* end file include/ada/idna/identifier.h */
 
 #endif
 /* end file include/idna.h */

include/ada/checkers.h

@@ -7,8 +7,8 @@
 
 #include "ada/common_defs.h"
 
-#include <string_view>
 #include <cstring>
+#include <string_view>
 
 /**
  * These functions are not part of our public API and may

include/ada/common_defs.h

@@ -5,6 +5,10 @@
 #ifndef ADA_COMMON_DEFS_H
 #define ADA_COMMON_DEFS_H
 
+// https://en.cppreference.com/w/cpp/feature_test#Library_features
+// detect C++20 features
+#include <version>
+
 #ifdef _MSC_VER
 #define ADA_VISUAL_STUDIO 1
 /**
@@ -250,4 +254,11 @@ namespace ada {
 #define ada_lifetime_bound
 #endif
 
+#ifdef __cpp_lib_format
+#if __cpp_lib_format >= 202110L
+#include <format>
+#define ADA_HAS_FORMAT 1
+#endif
+#endif
+
 #endif  // ADA_COMMON_DEFS_H

include/ada/helpers.h

@@ -139,7 +139,7 @@ ada_really_inline std::pair<size_t, bool> get_host_delimiter_location(
  * Removes leading and trailing C0 control and whitespace characters from
  * string.
  */
-ada_really_inline void trim_c0_whitespace(std::string_view& input) noexcept;
+void trim_c0_whitespace(std::string_view& input) noexcept;
 
 /**
  * @private

include/ada/implementation.h

@@ -17,7 +17,7 @@
 #include "ada/url_aggregator.h"
 
 namespace ada {
-enum class errors { generic_error };
+enum class errors : uint8_t { type_error };
 
 template <class result_type = ada::url_aggregator>
 using result = tl::expected<result_type, ada::errors>;
@@ -49,6 +49,20 @@ extern template ada::result<url_aggregator> parse<url_aggregator>(
 bool can_parse(std::string_view input,
                const std::string_view* base_input = nullptr);
 
+/**
+ * Implementation of the URL pattern parsing algorithm.
+ * @see https://urlpattern.spec.whatwg.org
+ *
+ * @param input valid UTF-8 string or URLPatternInit struct
+ * @param base_url an optional valid UTF-8 string
+ * @param options an optional url_pattern_options struct
+ * @return url_pattern instance
+ */
+ada_warn_unused tl::expected<url_pattern, errors> parse_url_pattern(
+    std::variant<std::string_view, url_pattern_init> input,
+    const std::string_view* base_url = nullptr,
+    const url_pattern_options* options = nullptr);
+
 /**
  * Computes a href string from a file path. The function assumes
  * that the input is a valid ASCII or UTF-8 string.

include/ada/parser.h

@@ -5,19 +5,21 @@
 #ifndef ADA_PARSER_H
 #define ADA_PARSER_H
 
-#include <optional>
 #include <string_view>
+#include <variant>
 
-#include "ada/encoding_type.h"
 #include "ada/expected.h"
-#include "ada/state.h"
 
 /**
  * @private
  */
 namespace ada {
 struct url_aggregator;
 struct url;
+class url_pattern;
+struct url_pattern_options;
+struct url_pattern_init;
+enum class errors : uint8_t;
 }  // namespace ada
 
 /**
@@ -31,7 +33,7 @@ namespace ada::parser {
  * parameter that can be used to resolve relative URLs. If the base_url is
  * provided, the user_input is resolved against the base_url.
  */
-template <typename result_type = ada::url_aggregator>
+template <typename result_type = url_aggregator>
 result_type parse_url(std::string_view user_input,
                       const result_type* base_url = nullptr);
 
@@ -40,14 +42,19 @@ extern template url_aggregator parse_url<url_aggregator>(
 extern template url parse_url<url>(std::string_view user_input,
                                    const url* base_url);
 
-template <typename result_type = ada::url_aggregator, bool store_values = true>
+template <typename result_type = url_aggregator, bool store_values = true>
 result_type parse_url_impl(std::string_view user_input,
                            const result_type* base_url = nullptr);
 
 extern template url_aggregator parse_url_impl<url_aggregator>(
     std::string_view user_input, const url_aggregator* base_url);
 extern template url parse_url_impl<url>(std::string_view user_input,
                                         const url* base_url);
+
+tl::expected<url_pattern, errors> parse_url_pattern_impl(
+    std::variant<std::string_view, url_pattern_init> input,
+    const std::string_view* base_url, const url_pattern_options* options);
+
 }  // namespace ada::parser
 
 #endif  // ADA_PARSER_H

include/ada/unicode-inl.h

@@ -4,8 +4,8 @@
  */
 #ifndef ADA_UNICODE_INL_H
 #define ADA_UNICODE_INL_H
-#include <algorithm>
 #include "ada/unicode.h"
+#include "ada/character_sets-inl.h"
 
 /**
  * Unicode operations. These functions are not part of our public API and may

include/ada/unicode.h

@@ -124,6 +124,20 @@ ada_really_inline constexpr bool is_alnum_plus(char c) noexcept;
  */
 ada_really_inline constexpr bool is_ascii_hex_digit(char c) noexcept;
 
+/**
+ * @private
+ * An ASCII digit is a code point in the range U+0030 (0) to U+0039 (9),
+ * inclusive.
+ */
+ada_really_inline constexpr bool is_ascii_digit(char c) noexcept;
+
+/**
+ * @private
+ * @details If a char is between U+0000 and U+007F inclusive, then it's an ASCII
+ * character.
+ */
+ada_really_inline constexpr bool is_ascii(char32_t c) noexcept;
+
 /**
  * @private
  * Checks if the input is a C0 control or space character.

include/ada/url.h

@@ -20,6 +20,7 @@
 #include "ada/unicode.h"
 #include "ada/url_base.h"
 #include "ada/url_components.h"
+#include "ada/helpers.h"
 
 namespace ada {
 

include/ada/url_aggregator-inl.h

@@ -7,9 +7,8 @@
 
 #include "ada/character_sets.h"
 #include "ada/character_sets-inl.h"
-#include "ada/checkers-inl.h"
+#include "ada/checkers.h"
 #include "ada/helpers.h"
-#include "ada/unicode.h"
 #include "ada/unicode-inl.h"
 #include "ada/url_aggregator.h"
 #include "ada/url_components.h"
@@ -269,7 +268,6 @@ inline void url_aggregator::update_base_pathname(const std::string_view input) {
 
   const bool begins_with_dashdash = input.starts_with("//");
   if (!begins_with_dashdash && has_dash_dot()) {
-    ada_log("url_aggregator::update_base_pathname has /.: \n", to_diagram());
     // We must delete the ./
     delete_dash_dot();
   }
@@ -292,8 +290,6 @@ inline void url_aggregator::update_base_pathname(const std::string_view input) {
   if (components.hash_start != url_components::omitted) {
     components.hash_start += difference;
   }
-  ada_log("url_aggregator::update_base_pathname end '", input, "' [",
-          input.size(), " bytes] \n", to_diagram());
   ADA_ASSERT_TRUE(validate());
 }
 
@@ -413,7 +409,7 @@ inline void url_aggregator::append_base_username(const std::string_view input) {
 }
 
 constexpr void url_aggregator::clear_password() {
-  ada_log("url_aggregator::clear_password ", to_string(), "\n", to_diagram());
+  ada_log("url_aggregator::clear_password ", to_string());
   ADA_ASSERT_TRUE(validate());
   if (!has_password()) {
     return;