Extract shared IsUriScheme helper; use std::ranges::replace (#341)

Author: yadavay-amzn

src/iceberg/arrow/arrow_io.cc

@@ -18,7 +18,6 @@
  */
 
 #include <algorithm>
-#include <cctype>
 #include <chrono>
 #include <limits>
 #include <mutex>
@@ -37,6 +36,7 @@
 #include "iceberg/arrow/arrow_io_util.h"
 #include "iceberg/arrow/arrow_status_internal.h"
 #include "iceberg/util/macros.h"
+#include "iceberg/util/uri.h"
 
 namespace iceberg::arrow {
 
@@ -486,26 +486,15 @@ class ArrowOutputFile : public OutputFile {
 
 Result<std::string> ArrowFileSystemFileIO::ResolvePath(const std::string& file_location) {
   // Detect whether the location is a URI by looking for a scheme component.
-  // A URI scheme (RFC 3986 §3.1) starts with a letter and is followed by any
-  // combination of letters, digits, '+', '-', or '.', ending at the first ':'.
-  // A single character before ':' is a Windows drive letter (e.g., "C:\..."),
-  // not a URI scheme.
-  auto colon_pos = file_location.find(':');
-  bool is_uri =
-      colon_pos != std::string::npos && colon_pos > 1 &&
-      std::isalpha(static_cast<unsigned char>(file_location[0])) &&
-      std::all_of(file_location.begin(),
-                  file_location.begin() + static_cast<std::ptrdiff_t>(colon_pos),
-                  [](char c) {
-                    return std::isalpha(static_cast<unsigned char>(c)) ||
-                           std::isdigit(static_cast<unsigned char>(c)) || c == '+' ||
-                           c == '-' || c == '.';
-                  });
+  // See iceberg/util/uri.h for the RFC 3986 scheme grammar.
+  bool is_uri = IsUriScheme(file_location);
 
   if (!is_uri) {
     return file_location;  // Bare local path (Unix or Windows drive letter)
   }
 
+  auto colon_pos = file_location.find(':');
+
   // Normalize authority-less file: URI short forms to the canonical three-slash
   // form so that Arrow's PathFromUri can parse them.  Java Iceberg may write
   // "file:/path" (one slash) which lacks the "://" that Arrow expects.

src/iceberg/catalog/rest/rest_file_io.cc

@@ -19,8 +19,6 @@
 
 #include "iceberg/catalog/rest/rest_file_io.h"
 
-#include <algorithm>
-#include <cctype>
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ -30,6 +28,7 @@
 #include "iceberg/file_io.h"
 #include "iceberg/file_io_registry.h"
 #include "iceberg/util/macros.h"
+#include "iceberg/util/uri.h"
 
 namespace iceberg::rest {
 
@@ -53,24 +52,15 @@ std::unordered_map<std::string, std::string> MergeFileIOProperties(
 }  // namespace
 
 Result<BuiltinFileIOKind> DetectBuiltinFileIO(std::string_view location) {
-  // Detect URI scheme using RFC 3986 rules: a scheme is 2+ chars starting with
-  // a letter, followed by letters/digits/+/-/., ending at ':'.
-  // A single char before ':' is a Windows drive letter, not a scheme.
-  auto colon_pos = location.find(':');
-  bool is_uri =
-      colon_pos != std::string_view::npos && colon_pos > 1 &&
-      std::isalpha(static_cast<unsigned char>(location[0])) &&
-      std::all_of(location.begin(),
-                  location.begin() + static_cast<std::ptrdiff_t>(colon_pos), [](char c) {
-                    return std::isalpha(static_cast<unsigned char>(c)) ||
-                           std::isdigit(static_cast<unsigned char>(c)) || c == '+' ||
-                           c == '-' || c == '.';
-                  });
+  // Detect URI scheme using RFC 3986 rules.
+  // See iceberg/util/uri.h for the scheme grammar.
+  bool is_uri = IsUriScheme(location);
 
   if (!is_uri) {
     return BuiltinFileIOKind::kArrowLocal;
   }
 
+  const auto colon_pos = location.find(':');
   const auto scheme = location.substr(0, colon_pos);
   if (scheme == "file") {
     return BuiltinFileIOKind::kArrowLocal;

src/iceberg/test/arrow_io_test.cc

@@ -451,7 +451,7 @@ TEST_F(LocalFileIOTest, ResolvesFileUriSingleSlash) {
   // Build a cross-platform file:/path URI: normalize backslashes to forward slashes
   // and ensure a leading '/' (Linux paths already have one; Windows drive letters don't).
   std::string p = temp_filepath_;
-  std::replace(p.begin(), p.end(), '\\', '/');
+  std::ranges::replace(p, '\\', '/');
   std::string single_slash_uri = "file:" + (p.front() == '/' ? p : "/" + p);
   auto read_res = file_io_->ReadFile(single_slash_uri, std::nullopt);
   EXPECT_THAT(read_res, IsOk());
@@ -465,7 +465,7 @@ TEST_F(LocalFileIOTest, ResolvesFileUriTripleSlash) {
   // that "file://" + "/" + path produces the canonical triple-slash form on all
   // platforms. Linux: file:///tmp/...  Windows: file:///C:/Users/...
   std::string p = temp_filepath_;
-  std::replace(p.begin(), p.end(), '\\', '/');
+  std::ranges::replace(p, '\\', '/');
   std::string triple_slash_uri = "file://" + (p.front() == '/' ? p : "/" + p);
   auto read_res = file_io_->ReadFile(triple_slash_uri, std::nullopt);
   EXPECT_THAT(read_res, IsOk());

src/iceberg/util/uri.h

@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <cctype>
+#include <string_view>
+
+/// \file iceberg/util/uri.h
+/// \brief URI scheme detection utilities per RFC 3986.
+
+namespace iceberg {
+
+/// \brief Check whether a string begins with a valid RFC 3986 URI scheme
+/// followed by ':'.
+///
+/// A scheme (RFC 3986 §3.1) is defined as:
+///   scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
+///
+/// A single character before ':' is treated as a Windows drive letter, not a
+/// scheme (e.g., "C:\path").
+///
+/// \param value The string to inspect.
+/// \return true if \p value starts with a valid URI scheme followed by ':'.
+inline bool IsUriScheme(std::string_view value) {
+  auto colon_pos = value.find(':');
+  if (colon_pos == std::string_view::npos || colon_pos <= 1) {
+    return false;
+  }
+  if (!std::isalpha(static_cast<unsigned char>(value[0]))) {
+    return false;
+  }
+  return std::ranges::all_of(value.substr(1, colon_pos - 1), [](char c) {
+    return std::isalpha(static_cast<unsigned char>(c)) ||
+           std::isdigit(static_cast<unsigned char>(c)) || c == '+' || c == '-' ||
+           c == '.';
+  });
+}
+
+}  // namespace iceberg