rugged 1.9.0 → 1.9.4

data/vendor/libgit2/src/util/str.h

@@ -268,21 +268,23 @@ int git_str_splice(
  * @param str String buffer to append data to
  * @param string String to escape and append
  * @param esc_chars Characters to be escaped
- * @param esc_with String to insert in from of each found character
+ * @param esc_prefix String to insert as prefix of each found character
+ * @param esc_suffix String to insert as suffix of each found character
  * @return 0 on success, <0 on failure (probably allocation problem)
  */
 extern int git_str_puts_escaped(
 	git_str *str,
 	const char *string,
 	const char *esc_chars,
-	const char *esc_with);
+	const char *esc_prefix,
+	const char *esc_suffix);
 
 /**
  * Append string escaping characters that are regex special
  */
 GIT_INLINE(int) git_str_puts_escape_regex(git_str *str, const char *string)
 {
-	return git_str_puts_escaped(str, string, "^.[]$()|*+?{}\\", "\\");
+	return git_str_puts_escaped(str, string, "^.[]$()|*+?{}\\", "\\", NULL);
 }
 
 /**

data/vendor/libgit2/src/util/unix/process.c

@@ -12,6 +12,7 @@
 
 #include "git2_util.h"
 #include "vector.h"
+#include "futils.h"
 #include "process.h"
 #include "strlist.h"
 
@@ -28,7 +29,8 @@ struct git_process {
 
 	char *cwd;
 
-	unsigned int capture_in  : 1,
+	unsigned int use_shell   : 1,
+	             capture_in  : 1,
 	             capture_out : 1,
 	             capture_err : 1;
 
@@ -42,7 +44,7 @@ struct git_process {
 
 GIT_INLINE(bool) is_delete_env(const char *env)
 {
-	char *c = strchr(env, '=');
+	const char *c = strchr(env, '=');
 
 	if (c == NULL)
 		return false;
@@ -50,6 +52,53 @@ GIT_INLINE(bool) is_delete_env(const char *env)
 	return *(c+1) == '\0';
 }
 
+GIT_INLINE(int) insert_dup(git_vector *v, const char *s)
+{
+	char *dup = git__strdup(s);
+
+	GIT_ERROR_CHECK_ALLOC(dup);
+
+	return git_vector_insert(v, dup);
+}
+
+static int setup_args(
+	char ***out,
+	const char **args,
+	size_t args_len,
+	bool use_shell)
+{
+	git_vector prefixed = GIT_VECTOR_INIT;
+	git_str first = GIT_STR_INIT;
+	size_t cnt;
+
+	GIT_ASSERT(args && args_len);
+
+	if (use_shell) {
+		if (git_str_puts(&first, args[0]) < 0 ||
+		    git_str_puts(&first, " \"$@\"") < 0 ||
+		    insert_dup(&prefixed, "/bin/sh") < 0 ||
+		    insert_dup(&prefixed, "-c") < 0 ||
+		    git_vector_insert(&prefixed, git_str_detach(&first)) < 0)
+			goto on_error;
+	}
+
+	for (cnt = 0; args && cnt < args_len; cnt++) {
+		if (insert_dup(&prefixed, args[cnt]) < 0)
+			goto on_error;
+	}
+
+	git_vector_insert(&prefixed, NULL);
+
+	*out = (char **)prefixed.contents;
+
+	return 0;
+
+on_error:
+	git_str_dispose(&first);
+	git_vector_dispose_deep(&prefixed);
+	return -1;
+}
+
 static int merge_env(
 	char ***out,
 	const char **env,
@@ -57,7 +106,7 @@ static int merge_env(
 	bool exclude_env)
 {
 	git_vector merged = GIT_VECTOR_INIT;
-	char **kv, *dup;
+	char **kv;
 	size_t max, cnt;
 	int error = 0;
 
@@ -71,10 +120,7 @@ static int merge_env(
 		if (is_delete_env(env[cnt]))
 			continue;
 
-		dup = git__strdup(env[cnt]);
-		GIT_ERROR_CHECK_ALLOC(dup);
-
-		if ((error = git_vector_insert(&merged, dup)) < 0)
+		if (insert_dup(&merged, env[cnt]) < 0)
 			goto on_error;
 	}
 
@@ -83,10 +129,7 @@ static int merge_env(
 			if (env && git_strlist_contains_key(env, env_len, *kv, '='))
 				continue;
 
-			dup = git__strdup(*kv);
-			GIT_ERROR_CHECK_ALLOC(dup);
-
-			if ((error = git_vector_insert(&merged, dup)) < 0)
+			if (insert_dup(&merged, *kv) < 0)
 				goto on_error;
 		}
 	}
@@ -125,13 +168,14 @@ int git_process_new(
 	process = git__calloc(sizeof(git_process), 1);
 	GIT_ERROR_CHECK_ALLOC(process);
 
-	if (git_strlist_copy_with_null(&process->args, args, args_len) < 0 ||
+	if (setup_args(&process->args, args, args_len, opts ? opts->use_shell : false) < 0 ||
 	    merge_env(&process->env, env, env_len, opts ? opts->exclude_env : false) < 0) {
 		git_process_free(process);
 		return -1;
 	}
 
 	if (opts) {
+		process->use_shell = opts->use_shell;
 		process->capture_in = opts->capture_in;
 		process->capture_out = opts->capture_out;
 		process->capture_err = opts->capture_err;
@@ -158,10 +202,12 @@ extern int git_process_new_from_cmdline(
 	size_t env_len,
 	git_process_options *opts)
 {
-	const char *args[] = { "/bin/sh", "-c", cmdline };
+	git_process_options merged_opts = {0};
 
-	return git_process_new(out,
-		args, ARRAY_SIZE(args), env, env_len, opts);
+	memcpy(&merged_opts, opts, sizeof(git_process_options));
+	merged_opts.use_shell = 1;
+
+	return git_process_new(out, &cmdline, 1, env, env_len, &merged_opts);
 }
 
 #define CLOSE_FD(fd) \
@@ -271,6 +317,33 @@ static void write_status(int fd, const char *fn, int error, int os_error)
 		try_write_status(fd, fn, fn_len);
 }
 
+static int resolve_path(git_process *process)
+{
+	git_str full_path = GIT_STR_INIT;
+	int error = 0;
+
+	/* The shell will resolve the path for us */
+	if (process->use_shell)
+		goto done;
+
+	error = git_fs_path_find_executable(&full_path, process->args[0]);
+
+	if (error == GIT_ENOTFOUND) {
+		git_error_set(GIT_ERROR_SSH, "cannot run %s: No such file or directory", process->args[0]);
+		error = -1;
+	}
+
+	if (error)
+		goto done;
+
+	git__free(process->args[0]);
+	process->args[0] = git_str_detach(&full_path);
+
+done:
+	git_str_dispose(&full_path);
+	return error;
+}
+
 int git_process_start(git_process *process)
 {
 	int in[2] = { -1, -1 }, out[2] = { -1, -1 },
@@ -278,6 +351,10 @@ int git_process_start(git_process *process)
 	int fdflags, state, error;
 	pid_t pid;
 
+	/* Locate the path (unless we're letting the shell do it for us) */
+	if ((error = resolve_path(process)) < 0)
+		goto on_error;
+
 	/* Set up the pipes to read from/write to the process */
 	if ((process->capture_in && pipe(in) < 0) ||
 	    (process->capture_out && pipe(out) < 0) ||

data/vendor/libgit2/src/util/util.c

@@ -269,13 +269,26 @@ int git__prefixncmp_icase(const char *str, size_t str_n, const char *prefix)
 	return prefixcmp(str, str_n, prefix, true);
 }
 
-int git__suffixcmp(const char *str, const char *suffix)
+static int suffixcmp(const char *str, const char *suffix, bool icase)
 {
 	size_t a = strlen(str);
 	size_t b = strlen(suffix);
+
 	if (a < b)
 		return -1;
-	return strcmp(str + (a - b), suffix);
+
+	return icase ? strcasecmp(str + (a - b), suffix) :
+	               strcmp(str + (a - b), suffix);
+}
+
+int git__suffixcmp(const char *str, const char *suffix)
+{
+	return suffixcmp(str, suffix, false);
+}
+
+int git__suffixcmp_icase(const char *str, const char *suffix)
+{
+	return suffixcmp(str, suffix, true);
 }
 
 char *git__strtok(char **end, const char *sep)
@@ -323,7 +336,7 @@ char *git__strsep(char **end, const char *sep)
 
 size_t git__linenlen(const char *buffer, size_t buffer_len)
 {
-	char *nl = memchr(buffer, '\n', buffer_len);
+	const char *nl = memchr(buffer, '\n', buffer_len);
 	return nl ? (size_t)(nl - buffer) + 1 : buffer_len;
 }
 

data/vendor/libgit2/src/util/util.h

@@ -57,6 +57,7 @@ extern int git__prefixcmp_icase(const char *str, const char *prefix);
 extern int git__prefixncmp(const char *str, size_t str_n, const char *prefix);
 extern int git__prefixncmp_icase(const char *str, size_t str_n, const char *prefix);
 extern int git__suffixcmp(const char *str, const char *suffix);
+extern int git__suffixcmp_icase(const char *str, const char *suffix);
 
 GIT_INLINE(int) git__signum(int val)
 {

data/vendor/libgit2/src/util/win32/path_w32.c

@@ -153,6 +153,7 @@ int git_win32_path_canonicalize(git_win32_path path)
 
 static int git_win32_path_join(
 	git_win32_path dest,
+	size_t *dest_len,
 	const wchar_t *one,
 	size_t one_len,
 	const wchar_t *two,
@@ -176,6 +177,9 @@ static int git_win32_path_join(
 	memcpy(dest + one_len + backslash, two, two_len * sizeof(wchar_t));
 	dest[one_len + backslash + two_len] = L'\0';
 
+	if (dest_len)
+		*dest_len = one_len + backslash + two_len;
+
 	return 0;
 }
 
@@ -253,21 +257,92 @@ static void win32_path_iter_dispose(struct win32_path_iter *iter)
 	iter->current_dir = NULL;
 }
 
+struct executable_suffix {
+	const wchar_t *suffix;
+	size_t len;
+};
+
+static struct executable_suffix suffixes[] = { { NULL, 0 }, { L".exe", 4 }, { L".cmd", 4 } };
+
+static bool has_executable_suffix(wchar_t *exe, size_t exe_len)
+{
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(suffixes); i++) {
+		struct executable_suffix *suffix = &suffixes[i];
+
+		if (!suffix->len)
+			continue;
+
+		if (exe_len < suffix->len)
+			continue;
+
+		if (memcmp(&exe[exe_len - suffix->len], suffix->suffix, suffix->len) == 0)
+			return true;
+	}
+
+	return false;
+}
+
+static int is_executable(git_win32_path path, size_t path_len, bool suffixed)
+{
+	size_t i;
+
+	/*
+	 * if the given name has an executable suffix, then try looking for it
+	 * directly. in all cases, append executable extensions
+	 * (".exe", ".cmd"...)
+	 */
+	for (i = suffixed ? 0 : 1; i < ARRAY_SIZE(suffixes); i++) {
+		struct executable_suffix *suffix = &suffixes[i];
+
+		if (suffix->len) {
+			if (path_len + suffix->len > MAX_PATH)
+				continue;
+
+			wcscat(path, suffix->suffix);
+		}
+
+		if (_waccess(path, 0) == 0)
+			return true;
+
+		path[path_len] = L'\0';
+	}
+
+	return false;
+}
+
 int git_win32_path_find_executable(git_win32_path fullpath, wchar_t *exe)
 {
 	struct win32_path_iter path_iter;
 	const wchar_t *dir;
-	size_t dir_len, exe_len = wcslen(exe);
-	bool found = false;
+	size_t dir_len, exe_len, fullpath_len;
+	bool suffixed = false, found = false;
+
+	if ((exe_len = wcslen(exe)) > MAX_PATH)
+		goto done;
+
+	/* see if the given executable has an executable suffix; if so we will
+	 * look for the explicit name directly, as well as with added suffixes.
+	 */
+	suffixed = has_executable_suffix(exe, exe_len);
+
+	/* For fully-qualified paths we do not look in PATH */
+	if (wcschr(exe, L'\\') != NULL || wcschr(exe, L'/') != NULL) {
+		if ((found = is_executable(exe, exe_len, suffixed)))
+			wcscpy(fullpath, exe);
+
+		goto done;
+	}
 
 	if (win32_path_iter_init(&path_iter) < 0)
 		return -1;
 
-	while (win32_path_iter_next(&dir, &dir_len, &path_iter) != GIT_ITEROVER) {
-		if (git_win32_path_join(fullpath, dir, dir_len, exe, exe_len) < 0)
+	while (win32_path_iter_next(&dir, &dir_len, &path_iter) != GIT_ITEROVER && !found) {
+		if (git_win32_path_join(fullpath, &fullpath_len, dir, dir_len, exe, exe_len) < 0)
 			continue;
 
-		if (_waccess(fullpath, 0) == 0) {
+		if (is_executable(fullpath, fullpath_len, suffixed)) {
 			found = true;
 			break;
 		}
@@ -275,6 +350,7 @@ int git_win32_path_find_executable(git_win32_path fullpath, wchar_t *exe)
 
 	win32_path_iter_dispose(&path_iter);
 
+done:
 	if (found)
 		return 0;
 

data/vendor/libgit2/src/util/win32/process.c

@@ -11,6 +11,7 @@
 #include "git2_util.h"
 #include "process.h"
 #include "strlist.h"
+#include "fs_path.h"
 
 #ifndef DWORD_MAX
 # define DWORD_MAX INT32_MAX
@@ -19,7 +20,8 @@
 #define ENV_MAX 32767
 
 struct git_process {
-	wchar_t *appname;
+	char *app_name;
+	wchar_t *app_path;
 	wchar_t *cmdline;
 	wchar_t *env;
 
@@ -178,8 +180,7 @@ static int process_new(
 	process = git__calloc(1, sizeof(git_process));
 	GIT_ERROR_CHECK_ALLOC(process);
 
-	if (appname &&
-	    git_utf8_to_16_alloc(&process->appname, appname) < 0) {
+	if (appname && (process->app_name = git__strdup(appname)) == NULL) {
 		error = -1;
 		goto done;
 	}
@@ -233,7 +234,7 @@ int git_process_new(
 	size_t env_len,
 	git_process_options *opts)
 {
-	git_str cmdline = GIT_STR_INIT;
+	git_str cmd_path = GIT_STR_INIT, cmdline = GIT_STR_INIT;
 	int error;
 
 	GIT_ASSERT_ARG(out && args && args_len > 0);
@@ -244,6 +245,7 @@ int git_process_new(
 	error = process_new(out, args[0], cmdline.ptr, env, env_len, opts);
 
 done:
+	git_str_dispose(&cmd_path);
 	git_str_dispose(&cmdline);
 	return error;
 }
@@ -259,6 +261,19 @@ int git_process_start(git_process *process)
 	       out[2] = { NULL, NULL },
 	       err[2] = { NULL, NULL };
 
+	if (process->app_name) {
+		git_str cmd_path = GIT_STR_INIT;
+		int error;
+
+		if ((error = git_fs_path_find_executable(&cmd_path, process->app_name)) == 0)
+			error = git_utf8_to_16_alloc(&process->app_path, cmd_path.ptr);
+
+		git_str_dispose(&cmd_path);
+
+		if (error < 0)
+			goto on_error;
+	}
+
 	memset(&security_attrs, 0, sizeof(SECURITY_ATTRIBUTES));
 	security_attrs.bInheritHandle = TRUE;
 
@@ -303,7 +318,7 @@ int git_process_start(git_process *process)
 
 	memset(&process->process_info, 0, sizeof(PROCESS_INFORMATION));
 
-	if (!CreateProcessW(process->appname, process->cmdline,
+	if (!CreateProcessW(process->app_path, process->cmdline,
 	                    NULL, NULL, TRUE, flags, process->env,
 	                    process->cwd,
 	                    &startup_info,
@@ -501,6 +516,7 @@ void git_process_free(git_process *process)
 	git__free(process->env);
 	git__free(process->cwd);
 	git__free(process->cmdline);
-	git__free(process->appname);
+	git__free(process->app_path);
+	git__free(process->app_name);
 	git__free(process);
 }

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rugged
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.9.4
 platform: ruby
 authors:
 - Scott Chacon
 - Vicent Marti
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-03 00:00:00.000000000 Z
+date: 2026-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -53,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
   Rugged is a Ruby bindings to the libgit2 linkable C Git library. This is
   for testing and using the libgit2 library in a language that is awesome.
@@ -751,7 +764,6 @@ licenses:
 - MIT
 metadata:
   msys2_mingw_dependencies: libssh2 cmake
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -766,8 +778,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Rugged is a Ruby binding to the libgit2 linkable library
 test_files: []