Skip to content
Permalink

Comparing changes

Choose two branches to see what’s changed or to start a new pull request. If you need to, you can also or learn more about diff comparisons.

Open a pull request

Create a new pull request by comparing changes across two branches. If you need to, you can also . Learn more about diff comparisons here.
base repository: ada-url/ada-python
Failed to load repositories. Confirm that selected base ref is valid, then try again.
Loading
base: v1.17.0
Choose a base ref
...
head repository: ada-url/ada-python
Failed to load repositories. Confirm that selected head ref is valid, then try again.
Loading
compare: v1.18.0
Choose a head ref
  • 1 commit
  • 3 files changed
  • 1 contributor

Commits on Feb 24, 2025

  1. Updates for ada 3.1.1 / version 1.18.0

    @bbayles @anonrig
    bbayles authored and anonrig committed Feb 24, 2025
    Loading
    Loading status checks…
    Copy the full SHA
    c3b9793 View commit details
Showing with 201 additions and 158 deletions.
  1. +35 −36 ada_url/ada.cpp
  2. +165 −121 ada_url/ada.h
  3. +1 −1 pyproject.toml
71 changes: 35 additions & 36 deletions ada_url/ada.cpp
View file
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
/* auto-generated on 2025-02-11 09:47:50 -0500. Do not edit! */
/* auto-generated on 2025-02-23 20:08:55 -0500. Do not edit! */
/* begin file src/ada.cpp */
#include "ada.h"
/* begin file src/checkers.cpp */
@@ -15225,7 +15225,7 @@ inline void url_aggregator::consume_prepared_path(std::string_view input) {
namespace ada {

tl::expected<url_pattern_init, errors> url_pattern_init::process(
url_pattern_init init, std::string_view type,
url_pattern_init init, url_pattern_init::process_type type,
std::optional<std::string_view> protocol,
std::optional<std::string_view> username,
std::optional<std::string_view> password,
@@ -15287,8 +15287,8 @@ tl::expected<url_pattern_init, errors> url_pattern_init::process(
// If type is not "pattern" and init contains none of "protocol",
// "hostname", "port" and "username", then set result["username"] to the
// result of processing a base URL string given baseURL’s username and type.
if (type != "pattern" && !init.protocol && !init.hostname && !init.port &&
!init.username) {
if (type != process_type::pattern && !init.protocol && !init.hostname &&
!init.port && !init.username) {
result.username = url_pattern_helpers::process_base_url_string(
base_url->get_username(), type);
}
@@ -15298,8 +15298,8 @@ tl::expected<url_pattern_init, errors> url_pattern_init::process(
// "hostname", "port", "username" and "password", then set
// result["password"] to the result of processing a base URL string given
// baseURL’s password and type.
if (type != "pattern" && !init.protocol && !init.hostname && !init.port &&
!init.username && !init.password) {
if (type != process_type::pattern && !init.protocol && !init.hostname &&
!init.port && !init.username && !init.password) {
result.password = url_pattern_helpers::process_base_url_string(
base_url->get_password(), type);
}
@@ -15418,6 +15418,8 @@ tl::expected<url_pattern_init, errors> url_pattern_init::process(
!url_pattern_helpers::is_absolute_pathname(*result.pathname, type)) {
// Let baseURLPath be the result of running process a base URL string
// given the result of URL path serializing baseURL and type.
// TODO: Optimization opportunity: Avoid returning a string if no slash
// exist.
std::string base_url_path = url_pattern_helpers::process_base_url_string(
base_url->get_pathname(), type);

@@ -15430,12 +15432,12 @@ tl::expected<url_pattern_init, errors> url_pattern_init::process(
if (slash_index != std::string::npos) {
// Let new pathname be the code point substring from 0 to slash index +
// 1 within baseURLPath.
std::string new_pathname = base_url_path.substr(0, slash_index + 1);
base_url_path.resize(slash_index + 1);
// Append result["pathname"] to the end of new pathname.
ADA_ASSERT_TRUE(result.pathname.has_value());
new_pathname.append(result.pathname.value());
base_url_path.append(std::move(*result.pathname));
// Set result["pathname"] to new pathname.
result.pathname = std::move(new_pathname);
result.pathname = std::move(base_url_path);
}
}

@@ -15473,56 +15475,56 @@ tl::expected<url_pattern_init, errors> url_pattern_init::process(
}

tl::expected<std::string, errors> url_pattern_init::process_protocol(
std::string_view value, std::string_view type) {
std::string_view value, process_type type) {
ada_log("process_protocol=", value, " [", type, "]");
// Let strippedValue be the given value with a single trailing U+003A (:)
// removed, if any.
if (value.ends_with(":")) {
value.remove_suffix(1);
}
// If type is "pattern" then return strippedValue.
if (type == "pattern") {
if (type == process_type::pattern) {
return std::string(value);
}
// Return the result of running canonicalize a protocol given strippedValue.
return url_pattern_helpers::canonicalize_protocol(value);
}

tl::expected<std::string, errors> url_pattern_init::process_username(
std::string_view value, std::string_view type) {
std::string_view value, process_type type) {
// If type is "pattern" then return value.
if (type == "pattern") {
if (type == process_type::pattern) {
return std::string(value);
}
// Return the result of running canonicalize a username given value.
return url_pattern_helpers::canonicalize_username(value);
}

tl::expected<std::string, errors> url_pattern_init::process_password(
std::string_view value, std::string_view type) {
std::string_view value, process_type type) {
// If type is "pattern" then return value.
if (type == "pattern") {
if (type == process_type::pattern) {
return std::string(value);
}
// Return the result of running canonicalize a password given value.
return url_pattern_helpers::canonicalize_password(value);
}

tl::expected<std::string, errors> url_pattern_init::process_hostname(
std::string_view value, std::string_view type) {
std::string_view value, process_type type) {
ada_log("process_hostname value=", value, " type=", type);
// If type is "pattern" then return value.
if (type == "pattern") {
if (type == process_type::pattern) {
return std::string(value);
}
// Return the result of running canonicalize a hostname given value.
return url_pattern_helpers::canonicalize_hostname(value);
}

tl::expected<std::string, errors> url_pattern_init::process_port(
std::string_view port, std::string_view protocol, std::string_view type) {
std::string_view port, std::string_view protocol, process_type type) {
// If type is "pattern" then return portValue.
if (type == "pattern") {
if (type == process_type::pattern) {
return std::string(port);
}
// Return the result of running canonicalize a port given portValue and
@@ -15531,9 +15533,9 @@ tl::expected<std::string, errors> url_pattern_init::process_port(
}

tl::expected<std::string, errors> url_pattern_init::process_pathname(
std::string_view value, std::string_view protocol, std::string_view type) {
std::string_view value, std::string_view protocol, process_type type) {
// If type is "pattern" then return pathnameValue.
if (type == "pattern") {
if (type == process_type::pattern) {
return std::string(value);
}

@@ -15549,31 +15551,31 @@ tl::expected<std::string, errors> url_pattern_init::process_pathname(
}

tl::expected<std::string, errors> url_pattern_init::process_search(
std::string_view value, std::string_view type) {
std::string_view value, process_type type) {
// Let strippedValue be the given value with a single leading U+003F (?)
// removed, if any.
if (value.starts_with("?")) {
value.remove_prefix(1);
}
ADA_ASSERT_TRUE(!value.starts_with("?"));
// If type is "pattern" then return strippedValue.
if (type == "pattern") {
if (type == process_type::pattern) {
return std::string(value);
}
// Return the result of running canonicalize a search given strippedValue.
return url_pattern_helpers::canonicalize_search(value);
}

tl::expected<std::string, errors> url_pattern_init::process_hash(
std::string_view value, std::string_view type) {
std::string_view value, process_type type) {
// Let strippedValue be the given value with a single leading U+0023 (#)
// removed, if any.
if (value.starts_with("#")) {
value.remove_prefix(1);
}
ADA_ASSERT_TRUE(!value.starts_with("#"));
// If type is "pattern" then return strippedValue.
if (type == "pattern") {
if (type == process_type::pattern) {
return std::string(value);
}
// Return the result of running canonicalize a hash given strippedValue.
@@ -15599,7 +15601,6 @@ generate_regular_expression_and_name_list(

// Let name list be a new list
std::vector<std::string> name_list{};
const std::string full_wildcard_regexp_value = ".*";

// For each part of part list:
for (const url_pattern_part& part : part_list) {
@@ -15645,7 +15646,7 @@ generate_regular_expression_and_name_list(
// Otherwise if part's type is "full-wildcard"
else if (part.type == url_pattern_part_type::FULL_WILDCARD) {
// then set regexp value to full wildcard regexp value.
regexp_value = full_wildcard_regexp_value;
regexp_value = ".*";
}

// If part's prefix is the empty string and part's suffix is the empty
@@ -15724,7 +15725,7 @@ generate_regular_expression_and_name_list(
result += "$";

// Return (result, name list)
return {result, name_list};
return {std::move(result), std::move(name_list)};
}

bool is_ipv6_address(std::string_view input) noexcept {
@@ -16387,33 +16388,31 @@ std::string escape_regexp_string(std::string_view input) {
}

std::string process_base_url_string(std::string_view input,
std::string_view type) {
url_pattern_init::process_type type) {
// If type is not "pattern" return input.
if (type != "pattern") {
if (type != url_pattern_init::process_type::pattern) {
return std::string(input);
}
// Return the result of escaping a pattern string given input.
return escape_pattern_string(input);
}

constexpr bool is_absolute_pathname(std::string_view input,
std::string_view type) noexcept {
constexpr bool is_absolute_pathname(
std::string_view input, url_pattern_init::process_type type) noexcept {
// If input is the empty string, then return false.
if (input.empty()) [[unlikely]] {
return false;
}
// If input[0] is U+002F (/), then return true.
if (input.starts_with("/")) return true;
// If type is "url", then return false.
if (type == "url") return false;
if (type == url_pattern_init::process_type::url) return false;
// If input’s code point length is less than 2, then return false.
if (input.size() < 2) return false;
// If input[0] is U+005C (\) and input[1] is U+002F (/), then return true.
if (input.starts_with("\\/")) return true;
// If input[0] is U+007B ({) and input[1] is U+002F (/), then return true.
if (input.starts_with("{/")) return true;
// Return false.
return false;
return input[1] == '/' && (input[0] == '\\' || input[0] == '{');
}

std::string generate_pattern_string(
Loading