/* This function will return a string of pathname
* components from the first directory indicating
* where two directories diverge. For instance:
*
* child: /a/b/c/d/e
* parent: /a/b/d/
*
* Will return: c/d/e
*
* If the directories are not at all similar then
* the full dirname of the child_path effectively
* be returned.
*
* As a special case, child paths that are a URI
* automatically return the full URI path with
* the URI scheme and leading slash stripped out.
*/
static char *
find_diverging_child_components(GFile *child,
GFile *parent)
{
g_object_ref(parent);
GFile *ancestor = parent;
while (ancestor != NULL) {
char *relpath = g_file_get_relative_path(ancestor, child);
if (relpath) {
g_object_unref(ancestor);
return relpath;
}
GFile *new_ancestor = g_file_get_parent(ancestor);
g_object_unref(ancestor);
ancestor = new_ancestor;
}
/* This is a special case of getting the URI below. The difference is that
* this gives you a regular path name; getting it through the URI would
* give a URI-encoded path (%20 for spaces, etc.) */
GFile *root = g_file_new_for_path("/");
char *child_path = g_file_get_relative_path(root, child);
g_object_unref(root);
if (child_path)
return child_path;
char *child_uri = g_file_get_uri(child);
char *stripped_uri = strip_uri_scheme(child_uri);
g_free(child_uri);
return stripped_uri;
}
static gchar *
ensure_dest_path (GFile *file,
gint icon_size)
{
gchar *str, *str2, *size_string, *dest_path;
GFile *dest_file, *dest_dir, *tmp;
str = g_file_get_relative_path (gnome_dir, file);
tmp = g_file_resolve_relative_path (hc_dir, str);
g_free (str);
str = g_file_get_path (tmp);
size_string = g_strdup_printf ("%dx%d", icon_size, icon_size);
str2 = replace_str (str, "-symbolic.svg", ".png");
dest_path = replace_str (str2, "scalable", size_string);
dest_file = g_file_new_for_path (dest_path);
dest_dir = g_file_get_parent (dest_file);
g_file_make_directory_with_parents (dest_dir, NULL, NULL);
g_object_unref (dest_file);
g_object_unref (dest_dir);
g_object_unref (tmp);
g_free (str);
g_free (size_string);
return dest_path;
}
static void
reference_file_scanned (GFile *scanned_file,
GFileInfo *scanned_file_info,
gpointer user_data)
{
ExtractTest *extract_test = user_data;
g_autofree char *relative_path;
GFileInfo *corresponding_file_info;
relative_path = scanned_file == extract_test->reference ?
g_strdup ("") :
g_file_get_relative_path (extract_test->reference,
scanned_file);
corresponding_file_info = g_hash_table_lookup (extract_test->unmatched_files,
relative_path);
g_assert_nonnull (corresponding_file_info);
if (corresponding_file_info != NULL) {
g_assert_cmpuint (g_file_info_get_file_type (scanned_file_info),
==,
g_file_info_get_file_type (corresponding_file_info));
g_hash_table_remove (extract_test->unmatched_files, relative_path);
}
char *
panel_launcher_get_filename (const char *location)
{
GFile *file;
GFile *launchers_dir;
char *launchers_path;
char *retval;
if (!g_path_is_absolute (location) &&
g_ascii_strncasecmp (location, "file:", strlen ("file:")))
/* this is not a local URI */
return NULL;
launchers_path = panel_launcher_get_personal_path ();
launchers_dir = g_file_new_for_path (launchers_path);
g_free (launchers_path);
file = panel_launcher_get_gfile (location);
retval = g_file_get_relative_path (launchers_dir, file);
g_object_unref (file);
g_object_unref (launchers_dir);
return retval;
}
static gboolean
can_delete_directory (RBAndroidSource *source, GFile *dir)
{
GMount *mount;
GFile *root;
char *path;
int i;
int c;
g_object_get (source, "mount", &mount, NULL);
root = g_mount_get_root (mount);
g_object_unref (mount);
/*
* path here will be sdcard/Music/something for anything we want to delete
*/
path = g_file_get_relative_path (root, dir);
c = 0;
for (i = 0; path[i] != '\0'; i++) {
if (path[i] == '/')
c++;
}
g_free (path);
return (c > 1);
}
static gboolean
add_ref_to_set (const char *remote,
GFile *base,
GFile *child,
GHashTable *refs,
GCancellable *cancellable,
GError **error)
{
gboolean ret = FALSE;
char *contents;
char *relpath;
gsize len;
GString *refname;
if (!g_file_load_contents (child, cancellable, &contents, &len, NULL, error))
goto out;
g_strchomp (contents);
refname = g_string_new ("");
if (remote)
{
g_string_append (refname, remote);
g_string_append_c (refname, ':');
}
relpath = g_file_get_relative_path (base, child);
g_string_append (refname, relpath);
g_free (relpath);
g_hash_table_insert (refs, g_string_free (refname, FALSE), contents);
ret = TRUE;
out:
return ret;
}
static IdeProjectFile *
create_file (IdeContext *context,
GFile *file,
GFileType file_type)
{
g_autofree gchar *path = NULL;
g_autofree gchar *name = NULL;
g_autoptr(GFileInfo) file_info = NULL;
IdeVcs *vcs;
GFile *workdir;
g_assert (IDE_IS_CONTEXT (context));
g_assert (G_IS_FILE (file));
g_assert ((file_type == G_FILE_TYPE_DIRECTORY) || (file_type == G_FILE_TYPE_REGULAR));
vcs = ide_context_get_vcs (context);
workdir = ide_vcs_get_working_directory (vcs);
path = g_file_get_relative_path (workdir, file);
name = g_file_get_basename (file);
file_info = g_file_info_new ();
g_file_info_set_file_type (file_info, file_type);
g_file_info_set_name (file_info, name);
g_file_info_set_display_name (file_info, name);
return g_object_new (IDE_TYPE_PROJECT_FILE,
"context", context,
"file", file,
"file-info", file_info,
"path", path,
"parent", NULL,
NULL);
}
static gchar *
normalize_file_name (const gchar *file_name, const gchar *parent_file_name)
{
GFile *parent_file = NULL;
GFile *file;
gchar *result;
file = g_file_new_for_path (file_name);
if (parent_file_name != NULL)
{
parent_file = g_file_new_for_path (parent_file_name);
result = g_file_get_relative_path (parent_file, file);
}
else
{
result = g_file_get_path (file);
}
if (parent_file != NULL)
g_object_unref (parent_file);
g_object_unref (file);
return result;
}
/* Work even if file is not a descendant of parent */
static gchar*
get_relative_path (GFile *parent, GFile *file)
{
gchar *relative;
relative = g_file_get_relative_path (parent, file);
if (relative == NULL)
{
if (g_file_equal (parent, file))
{
relative = g_strdup ("");
}
else
{
GFile *grand_parent = g_file_get_parent (parent);
gint level;
gchar *grand_relative;
gchar *ptr;
gsize len;
for (level = 1; !g_file_has_prefix (file, grand_parent); level++)
{
GFile *next = g_file_get_parent (grand_parent);
g_object_unref (grand_parent);
grand_parent = next;
}
grand_relative = g_file_get_relative_path (grand_parent, file);
g_object_unref (grand_parent);
len = strlen (grand_relative);
relative = g_new (gchar, len + level * 3 + 1);
ptr = relative;
for (; level; level--)
{
memcpy(ptr, ".." G_DIR_SEPARATOR_S, 3);
ptr += 3;
}
memcpy (ptr, grand_relative, len + 1);
g_free (grand_relative);
}
}
return relative;
}
static void
ide_git_vcs_list_status_worker (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
ListStatus *state = task_data;
g_autoptr(GListStore) store = NULL;
g_autoptr(GFile) workdir = NULL;
g_autoptr(GgitRepository) repository = NULL;
g_autoptr(GgitStatusOptions) options = NULL;
g_autoptr(GString) pathspec = NULL;
g_autoptr(GError) error = NULL;
g_autofree gchar *relative = NULL;
gchar *strv[] = { NULL, NULL };
g_assert (G_IS_TASK (task));
g_assert (IDE_IS_GIT_VCS (source_object));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
g_assert (state != NULL);
g_assert (G_IS_FILE (state->repository_location));
if (!(repository = ggit_repository_open (state->repository_location, &error)))
{
g_task_return_error (task, g_steal_pointer (&error));
return;
}
if (!(workdir = ggit_repository_get_workdir (repository)))
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"Failed to locate working directory");
return;
}
g_set_object (&state->workdir, workdir);
if (state->directory_or_file != NULL)
relative = g_file_get_relative_path (workdir, state->directory_or_file);
strv[0] = relative;
options = ggit_status_options_new (GGIT_STATUS_OPTION_DEFAULT,
GGIT_STATUS_SHOW_INDEX_AND_WORKDIR,
(const gchar **)strv);
store = g_list_store_new (IDE_TYPE_VCS_FILE_INFO);
g_set_object (&state->store, store);
if (!ggit_repository_file_status_foreach (repository,
options,
ide_git_vcs_list_status_cb,
state,
&error))
g_task_return_error (task, g_steal_pointer (&error));
else
g_task_return_pointer (task, g_steal_pointer (&store), g_object_unref);
}
void
test_utils_add_test_for_all_files (const gchar *prefix,
GFile *base,
GFile *file,
GTestDataFunc test_func,
AddTestFunc add_test_func)
{
GFileEnumerator *enumerator;
GFileInfo *info;
GList *l, *files;
GError *error = NULL;
if (g_file_query_file_type (file, 0, NULL) != G_FILE_TYPE_DIRECTORY)
{
gchar *test_path;
gchar *relative_path;
if (base)
relative_path = g_file_get_relative_path (base, file);
else
relative_path = g_file_get_path (file);
test_path = g_strconcat (prefix, "/", relative_path, NULL);
g_test_add_data_func_full (test_path, g_object_ref (file), test_func, g_object_unref);
return;
}
enumerator = g_file_enumerate_children (file, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &error);
g_assert_no_error (error);
files = NULL;
while ((info = g_file_enumerator_next_file (enumerator, NULL, &error)))
{
GFile *next_file = g_file_get_child (file, g_file_info_get_name (info));
if (add_test_func == NULL || add_test_func (next_file))
{
files = g_list_prepend (files, g_object_ref (next_file));
}
g_object_unref (next_file);
g_object_unref (info);
}
g_assert_no_error (error);
g_object_unref (enumerator);
files = g_list_sort (files, compare_files);
for (l = files; l; l = l->next)
{
test_utils_add_test_for_all_files (prefix, base, l->data, test_func, add_test_func);
}
g_list_free_full (files, g_object_unref);
}
IdeBufferChangeMonitor *
gbp_git_buffer_change_monitor_new (IdeBuffer *buffer,
IpcGitRepository *repository,
GFile *file,
GCancellable *cancellable,
GError **error)
{
GbpGitBufferChangeMonitor *ret;
g_autoptr(IpcGitChangeMonitor) proxy = NULL;
g_autoptr(IdeContext) context = NULL;
g_autoptr(GFile) workdir = NULL;
g_autofree gchar *relative_path = NULL;
g_autofree gchar *obj_path = NULL;
GDBusConnection *connection;
g_return_val_if_fail (IDE_IS_MAIN_THREAD (), NULL);
g_return_val_if_fail (IDE_IS_BUFFER (buffer), NULL);
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), NULL);
context = ide_buffer_ref_context (buffer);
workdir = ide_context_ref_workdir (context);
if (!g_file_has_prefix (file, workdir))
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_NOT_SUPPORTED,
"Cannot monitor files outside the working directory");
return NULL;
}
relative_path = g_file_get_relative_path (workdir, file);
if (!ipc_git_repository_call_create_change_monitor_sync (repository,
relative_path,
&obj_path,
cancellable,
error))
return NULL;
connection = g_dbus_proxy_get_connection (G_DBUS_PROXY (repository));
if (!(proxy = ipc_git_change_monitor_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
obj_path,
cancellable,
error)))
return NULL;
ret = g_object_new (GBP_TYPE_GIT_BUFFER_CHANGE_MONITOR,
"buffer", buffer,
NULL);
ret->proxy = g_steal_pointer (&proxy);
return IDE_BUFFER_CHANGE_MONITOR (g_steal_pointer (&ret));
}
gboolean
directory_has_makefile_am (BasicAutotoolsPlugin *bb_plugin, GFile *dir)
{
GFile *file;
gboolean exists;
/* We need configure.ac or configure.in too */
if (bb_plugin->project_root_dir == NULL) return FALSE;
exists = TRUE;
file = g_file_get_child (bb_plugin->project_root_dir, "configure.ac");
if (!g_file_query_exists (file, NULL))
{
g_object_unref (file);
file = g_file_get_child (bb_plugin->project_root_dir, "configure.in");
if (!g_file_query_exists (file, NULL))
{
exists = FALSE;
}
}
g_object_unref (file);
/* Check for Makefile.am or GNUmakefile.am */
if (g_file_has_prefix (dir, bb_plugin->project_build_dir))
{
/* Check for Makefile.am in source directory not build directory */
gchar *relative;
GFile *src_dir;
relative = g_file_get_relative_path (bb_plugin->project_build_dir, dir);
src_dir = g_file_get_child (bb_plugin->project_root_dir, relative);
file = g_file_get_child (src_dir, "Makefile.am");
g_object_unref (src_dir);
g_free (relative);
}
else if (g_file_equal (dir, bb_plugin->project_build_dir))
{
file = g_file_get_child (bb_plugin->project_root_dir, "Makefile.am");
}
else
{
file = g_file_get_child (dir, "Makefile.am");
}
if (!g_file_query_exists (file, NULL))
{
g_object_unref (file);
file = g_file_get_child (dir, "GNUmakefile.am");
if (!g_file_query_exists (file, NULL))
{
exists = FALSE;
}
}
g_object_unref (file);
return exists;
}
static GList *
nautilus_directory_moved_internal (GFile *old_location,
GFile *new_location)
{
CollectData collection;
NautilusDirectory *directory;
GList *node, *affected_files;
GFile *new_directory_location;
char *relative_path;
collection.container = old_location;
collection.directories = NULL;
g_hash_table_foreach (directories,
collect_directories_by_container,
&collection);
affected_files = NULL;
for (node = collection.directories; node != NULL; node = node->next) {
directory = NAUTILUS_DIRECTORY (node->data);
new_directory_location = NULL;
if (g_file_equal (directory->details->location, old_location)) {
new_directory_location = g_object_ref (new_location);
} else {
relative_path = g_file_get_relative_path (old_location,
directory->details->location);
if (relative_path != NULL) {
new_directory_location = g_file_resolve_relative_path (new_location, relative_path);
g_free (relative_path);
}
}
if (new_directory_location) {
change_directory_location (directory, new_directory_location);
g_object_unref (new_directory_location);
/* Collect affected files. */
if (directory->details->as_file != NULL) {
affected_files = g_list_prepend
(affected_files,
nautilus_file_ref (directory->details->as_file));
}
affected_files = g_list_concat
(affected_files,
nautilus_file_list_copy (directory->details->file_list));
}
nautilus_directory_unref (directory);
}
g_list_free (collection.directories);
return affected_files;
}
static void
show_completed_file (GFile *hit,
gboolean is_dir,
const char *arg)
{
char *path, *cwd, *display, *t;
GFile *cwd_f;
GFile *home;
if (g_file_is_native (hit))
{
cwd = g_get_current_dir ();
cwd_f = g_file_new_for_path (cwd);
g_free (cwd);
home = g_file_new_for_path (g_get_home_dir ());
if ((g_file_has_prefix (hit, home) ||
g_file_equal (hit, home)) &&
arg[0] == '~')
{
t = g_file_get_relative_path (home, hit);
path = g_strconcat ("~", (t != NULL) ? "/": "", t, NULL);
g_free (t);
}
else if (g_file_has_prefix (hit, cwd_f) &&
!g_path_is_absolute (arg))
path = g_file_get_relative_path (cwd_f, hit);
else
path = g_file_get_path (hit);
g_object_unref (cwd_f);
g_object_unref (home);
display = shell_quote (path);
g_free (path);
}
else
display = g_file_get_uri (hit);
g_print ("%s%s\n", display, (is_dir)?"/":"");
g_free (display);
}
static void
print_diff_item (char prefix,
GFile *base,
GFile *file)
{
if (g_file_is_native (file))
{
g_autofree char *relpath = g_file_get_relative_path (base, file);
g_print ("%c %s\n", prefix, relpath);
}
else
{
g_print ("%c %s\n", prefix, gs_file_get_path_cached (file));
}
}
static void
output_file_scanned (GFile *scanned_file,
GFileInfo *scanned_file_info,
gpointer user_data)
{
ExtractTest *extract_test = user_data;
char *relative_path;
relative_path = scanned_file == extract_test->output ?
g_strdup ("") :
g_file_get_relative_path (extract_test->output,
scanned_file);
g_hash_table_insert (extract_test->unmatched_files, relative_path,
g_object_ref (scanned_file_info));
}
static void
list_source (IAnjutaProject *project, AnjutaProjectNode *root, AnjutaProjectNode *source, gint indent, const gchar *path)
{
GFile *file;
gchar *rel_path;
if (source == NULL) return;
file = anjuta_project_node_get_file (source);
rel_path = g_file_get_relative_path (anjuta_project_node_get_file (root), file);
print ("%*sSOURCE (%s): %s", indent * INDENT, "", no_id ? "" : path, rel_path);
list_property (project, source, indent + 1);
g_free (rel_path);
}
static GInputStream *
tmpl_template_locator_locate_in_path (TmplTemplateLocator *self,
const gchar *path_base,
const gchar *path)
{
GInputStream *ret = NULL;
gchar *full_path;
g_assert (TMPL_IS_TEMPLATE_LOCATOR (self));
g_assert (path_base != NULL);
g_assert (path != NULL);
full_path = g_build_path (path_base, path, NULL);
if (g_str_has_prefix (full_path, "resource://"))
{
/*
* A mediocre attempt to prevent escapes using ../
*/
if (strstr (full_path, "..") == NULL)
ret = g_resources_open_stream (full_path + strlen ("resource://"), 0, NULL);
}
else
{
GFile *parent = g_file_new_for_path (path_base);
GFile *file = g_file_new_for_path (full_path);
gchar *relative;
/*
* If the path tries to escape the search path, using ../../ or
* something clever, we will get an invalid path here.
*/
if ((relative = g_file_get_relative_path (parent, file)))
{
g_free (relative);
ret = (GInputStream *)g_file_read (file, NULL, NULL);
}
g_object_unref (parent);
g_object_unref (file);
}
g_free (full_path);
return ret;
}
static void
list_group (IAnjutaProject *project, AnjutaProjectNode *root, AnjutaProjectNode *group, gint indent, const gchar *path)
{
AnjutaProjectNode *parent;
gchar *rel_path;
GFile *file;
parent = anjuta_project_node_parent (group);
file = anjuta_project_node_get_file (parent);
rel_path = g_file_get_relative_path (file, anjuta_project_node_get_file (group));
print ("%*sGROUP (%s): %s", indent * INDENT, "", no_id ? "" : path, rel_path);
g_free (rel_path);
list_property (project, group, indent + 1);
list_children (project, root, group, indent, path);
}
void
gb_project_tree_reveal (GbProjectTree *self,
GFile *file)
{
g_autofree gchar *relpath = NULL;
g_auto(GStrv) parts = NULL;
IdeContext *context;
IdeTreeNode *node;
IdeVcs *vcs;
GFile *workdir;
guint i;
g_return_if_fail (GB_IS_PROJECT_TREE (self));
g_return_if_fail (G_IS_FILE (file));
context = gb_project_tree_get_context (self);
g_assert (IDE_IS_CONTEXT (context));
if (context == NULL)
return;
vcs = ide_context_get_vcs (context);
workdir = ide_vcs_get_working_directory (vcs);
relpath = g_file_get_relative_path (workdir, file);
if (relpath == NULL)
return;
node = ide_tree_find_child_node (IDE_TREE (self), NULL, find_files_node, NULL);
if (node == NULL)
return;
parts = g_strsplit (relpath, G_DIR_SEPARATOR_S, 0);
for (i = 0; parts [i]; i++)
{
node = ide_tree_find_child_node (IDE_TREE (self), node, find_child_node, parts [i]);
if (node == NULL)
return;
}
ide_tree_expand_to_node (IDE_TREE (self), node);
ide_tree_scroll_to_node (IDE_TREE (self), node);
ide_tree_node_select (node);
}
/**
* gs_file_get_relpath:
* @one: The first #GFile
* @two: The second #GFile
*
* Like gs_file_get_relative_path(), but does not mandate that
* the two files have any parent in common. This function will
* instead insert "../" where appropriate.
*
* Returns: (transfer full): The relative path between the two.
*/
gchar *
gs_file_get_relpath (GFile *one,
GFile *two)
{
gchar *simple_path;
gchar *one_path, *one_suffix;
gchar *two_path, *two_suffix;
GString *path;
int i;
simple_path = g_file_get_relative_path (one, two);
if (simple_path)
return simple_path;
one_path = g_file_get_path (one);
two_path = g_file_get_path (two);
i = path_common_directory (one_path, two_path);
one_suffix = one_path + i;
two_suffix = two_path + i;
path = g_string_new ("");
/* For every leftover path segment one has, append "../" so
* that we reach the same directory. */
while (*one_suffix)
{
g_string_append (path, "../");
one_suffix = strchr (one_suffix, '/');
if (one_suffix == NULL)
break;
one_suffix++;
}
/* And now append the leftover stuff on two's side. */
g_string_append (path, two_suffix);
g_free (one_path);
g_free (two_path);
return g_string_free (path, FALSE);
}
static gboolean
ide_git_vcs_is_ignored (IdeVcs *vcs,
GFile *file,
GError **error)
{
g_autofree gchar *name = NULL;
IdeGitVcs *self = (IdeGitVcs *)vcs;
gboolean ret = FALSE;
g_assert (IDE_IS_GIT_VCS (self));
g_assert (G_IS_FILE (file));
name = g_file_get_relative_path (self->working_directory, file);
if (g_strcmp0 (name, ".git") == 0)
return TRUE;
if (name != NULL)
return ggit_repository_path_is_ignored (self->repository, name, error);
return ret;
}
/**
* ide_project_files_find_file:
* @self: (in): A #IdeProjectFiles.
* @file: A #GFile.
*
* Tries to locate an #IdeProjectFile matching the given file.
* If @file is the working directory, @self is returned.
*
* Returns: (transfer none) (nullable): An #IdeProjectItem or %NULL.
*/
IdeProjectItem *
ide_project_files_find_file (IdeProjectFiles *self,
GFile *file)
{
IdeProjectItem *item;
IdeContext *context;
IdeVcs *vcs;
GFile *workdir;
gchar **parts;
gchar *path;
gsize i;
g_return_val_if_fail (IDE_IS_PROJECT_FILES (self), NULL);
g_return_val_if_fail (G_IS_FILE (file), NULL);
item = IDE_PROJECT_ITEM (self);
context = ide_object_get_context (IDE_OBJECT (self));
vcs = ide_context_get_vcs (context);
workdir = ide_vcs_get_working_directory (vcs);
if (g_file_equal (workdir, file))
return IDE_PROJECT_ITEM (self);
path = g_file_get_relative_path (workdir, file);
if (path == NULL)
return NULL;
parts = g_strsplit (path, G_DIR_SEPARATOR_S, 0);
for (i = 0; parts [i]; i++)
{
if (!(item = ide_project_files_find_child (item, parts [i])))
break;
}
g_strfreev (parts);
g_free (path);
return item;
}
/* utf8 */
gchar *get_relative_path(const gchar *utf8_parent, const gchar *utf8_descendant)
{
GFile *gf_parent, *gf_descendant;
gchar *locale_parent, *locale_descendant;
gchar *locale_ret, *utf8_ret;
locale_parent = utils_get_locale_from_utf8(utf8_parent);
locale_descendant = utils_get_locale_from_utf8(utf8_descendant);
gf_parent = g_file_new_for_path(locale_parent);
gf_descendant = g_file_new_for_path(locale_descendant);
locale_ret = g_file_get_relative_path(gf_parent, gf_descendant);
utf8_ret = utils_get_utf8_from_locale(locale_ret);
g_object_unref(gf_parent);
g_object_unref(gf_descendant);
g_free(locale_parent);
g_free(locale_descendant);
g_free(locale_ret);
return utf8_ret;
}
/**
* ggit_index_entries_get_by_path:
* @entries: a #GgitIndexEntries.
* @file: the path to search.
* @stage: stage to search.
*
* Get a #GgitIndexEntry by index. Note that the returned #GgitIndexEntry is
* _only_ valid as long as:
*
* 1) The associated index has not been closed
* 2) The entry has not been removed (see ggit_index_remove())
* 3) The index has not been refreshed (see ggit_index_read())
*
* Changes to the #GgitIndexEntry will be reflected in the index once written
* back to disk using ggit_index_write().
*
* @stage indicates the stage to search the file for. Stages are used in the
* index when merge conflicts occur, such that multiple versions of the same
* file can be represented in the index. Stage 0 is associated with the working
* tree, while stages 1 to 3 are associated with the various versions of the
* file in a merge conflict. The special value -1 can be used to match the first
* file encountered in any stage.
*
* Returns: (transfer full): a #GgitIndexEntry or %NULL if it was not found.
*
**/
GgitIndexEntry *
ggit_index_entries_get_by_path (GgitIndexEntries *entries,
GFile *file,
gint stage)
{
git_index *gidx;
const git_index_entry *entry;
gchar *path;
GgitRepository *repo;
GFile *wd;
g_return_val_if_fail (entries != NULL, NULL);
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (stage >= 0 && stage <= 3, NULL);
repo = ggit_index_get_owner (entries->owner);
wd = ggit_repository_get_workdir (repo);
path = g_file_get_relative_path (wd, file);
g_object_unref (wd);
g_object_unref (repo);
g_return_val_if_fail (path != NULL, NULL);
gidx = _ggit_index_get_index (entries->owner);
entry = git_index_get_bypath (gidx, path, stage);
g_free (path);
if (entry)
{
return ggit_index_entry_wrap ((git_index_entry *)entry, FALSE);
}
else
{
return NULL;
}
}
static gboolean
ide_git_vcs_is_ignored (IdeVcs *vcs,
GFile *file,
GError **error)
{
g_autofree gchar *name = NULL;
IdeGitVcs *self = (IdeGitVcs *)vcs;
gboolean ret = FALSE;
g_assert (IDE_IS_GIT_VCS (self));
g_assert (G_IS_FILE (file));
/* Note: this function is required to be thread-safe so that workers
* can check if files are ignored from a thread without
* round-tripping to the main thread.
*/
/* self->working_directory is not changed after creation, so safe
* to access it from a thread.
*/
name = g_file_get_relative_path (self->working_directory, file);
if (g_strcmp0 (name, ".git") == 0)
return TRUE;
/*
* If we have a valid name to work with, we want to query the
* repository. But this could be called from a thread, so ensure
* we are the only thread accessing self->repository right now.
*/
if (name != NULL)
{
g_mutex_lock (&self->repository_mutex);
ret = ggit_repository_path_is_ignored (self->repository, name, error);
g_mutex_unlock (&self->repository_mutex);
}
return ret;
}
/* Return build path from a source directory */
static GFile *
build_file_from_directory (BasicAutotoolsPlugin *plugin, GFile *directory)
{
GFile *build_file;
if ((plugin->project_root_dir == NULL) || (plugin->project_build_dir == NULL))
{
/* No change if there is no project or no build directory */
build_file = g_object_ref (directory);
}
else if (g_file_has_prefix (directory, plugin->project_build_dir) || g_file_equal (directory, plugin->project_build_dir))
{
/* No change, already in build directory */
build_file = g_object_ref (directory);
}
else if (g_file_equal (directory, plugin->project_root_dir))
{
/* Use build directory instead of source directory */
build_file = g_object_ref (plugin->project_build_dir);
}
else if (g_file_has_prefix (directory, plugin->project_root_dir))
{
/* Get corresponding file in build directory */
gchar *relative;
relative = g_file_get_relative_path (plugin->project_root_dir, directory);
build_file = g_file_resolve_relative_path (plugin->project_build_dir, relative);
g_free (relative);
}
else
{
/* File outside the project directory */
build_file = g_object_ref (directory);
}
return build_file;
}
void
watcher_event(GFileMonitor *monitor, GFile *file, GFile *other_file,
GFileMonitorEvent event_type, gpointer user_data)
{
GFile *parent, *top, *tmp;
gboolean depth = 1;
watcher_t *watcher;
watcher_event_t *event;
if (!user_data)
return;
watcher = (watcher_t *) user_data;
parent = g_file_new_for_path(watcher->path);
event = (watcher_event_t *) g_new0(watcher_event_t, 1);
event->watcher = watcher;
event->file = g_file_get_path(file);
event->rfile = g_file_get_relative_path(parent, file);
if (!event->rfile)
event->rfile = g_strdup("");
if (watcher->recursive)
{
for (top = g_file_dup(file), depth = 1;
!g_file_equal(top, parent) && !g_file_has_parent(top, parent); top =
tmp, depth++)
{
tmp = g_file_get_parent(top);
g_object_unref(top);
}
g_object_unref(top);
LOG_DEBUG("%s: file depth to watcher path is '%d'", watcher->name, depth);
}
g_object_unref(parent);
LOG_DEBUG("%s: %s (event_type=%d, file=%s)",
watcher->name, N_("watcher event received"), event_type, event->file);
switch (event_type)
{
case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
{
event->event = g_strdup(CONFIG_KEY_WATCHER_EVENT_CHANGING);
break;
}
case G_FILE_MONITOR_EVENT_CHANGED:
{
event->event = g_strdup(CONFIG_KEY_WATCHER_EVENT_CHANGED);
break;
}
case G_FILE_MONITOR_EVENT_CREATED:
{
event->event = g_strdup(CONFIG_KEY_WATCHER_EVENT_CREATED);
break;
}
case G_FILE_MONITOR_EVENT_DELETED:
{
event->event = g_strdup(CONFIG_KEY_WATCHER_EVENT_DELETED);
break;
}
case G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED:
{
event->event = g_strdup(CONFIG_KEY_WATCHER_EVENT_ATTRIBUTECHANGED);
break;
}
default:
{
LOG_DEBUG("%s: %s (event_type=%d)",
watcher->name, N_("unknown event"), event_type);
g_free(event->file);
g_free(event->rfile);
g_free(event);
return;
break;
}
}
if ((event_type == G_FILE_MONITOR_EVENT_DELETED) && watcher->recursive
&& (g_strcmp0(event->file, watcher->path) != 0))
{
watcher_remove_monitor_for_recursive_path(watcher, event->file);
}
if (!watcher_event_test(watcher, event))
{
LOG_DEBUG("%s: %s (event=%s, file=%s)",
watcher->name, N_("event ignored"), event->event, event->file);
g_free(event->event);
g_free(event->file);
g_free(event->rfile);
g_free(event);
return;
}
if (event_type == G_FILE_MONITOR_EVENT_CREATED && watcher->recursive
&& g_file_test(event->file, G_FILE_TEST_IS_DIR)
&& (g_strcmp0(event->file, watcher->path) != 0))
{
watcher_add_monitor_for_recursive_path(watcher, event->file, depth);
}
watcher_event_fired(watcher, event);
g_free(event->event);
g_free(event->file);
g_free(event->rfile);
g_free(event);
}
/* Return build path and target from a GFile */
GFile *
build_file_from_file (BasicAutotoolsPlugin *plugin, GFile *file, gchar **target)
{
if (target != NULL) *target = NULL;
if (file == NULL)
{
/* Use project root directory */
return build_file_from_directory (plugin, plugin->project_root_dir);
}
else if (g_file_query_file_type (file, 0, NULL) == G_FILE_TYPE_DIRECTORY)
{
return build_file_from_directory (plugin, file);
}
else
{
GFile *parent = NULL;
GFile *build_file;
IAnjutaProjectManager* projman;
projman = anjuta_shell_get_interface (ANJUTA_PLUGIN (plugin)->shell,
IAnjutaProjectManager,
NULL);
if (projman != NULL)
{
/* Use the project manager to find the group file */
GFile *child;
for (child = normalize_project_file (file, plugin->project_root_dir); child != NULL;)
{
GFile *group;
AnjutaProjectNodeType type;
type = ianjuta_project_manager_get_target_type (projman, child, NULL);
if (type == ANJUTA_PROJECT_GROUP) break;
group = ianjuta_project_manager_get_parent (projman, child, NULL);
g_object_unref (child);
child = group;
}
parent = child;
}
if (parent == NULL)
{
/* Fallback use parent directory */
parent = g_file_get_parent (file);
}
if (parent != NULL)
{
if (target != NULL) *target = g_file_get_relative_path (parent, file);
build_file = build_file_from_directory (plugin, parent);
g_object_unref (parent);
return build_file;
}
else
{
return NULL;
}
}
}