PIKApp/libpikaconfig/pikaconfig-path.c

/* LIBPIKA - The PIKA Library
 * Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
 *
 * pikaconfig-path.c
 * Copyright (C) 2001  Sven Neumann <sven@gimp.org>
 *
 * This library is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library.  If not, see
 * <https://www.gnu.org/licenses/>.
 */

#include "config.h"

#include <stdio.h>
#include <string.h>

#include <gio/gio.h>

#include "libpikabase/pikabase.h"

#include "pikaconfig-error.h"
#include "pikaconfig-path.h"

#include "libpika/libpika-intl.h"


/**
 * SECTION: pikaconfig-path
 * @title: PikaConfig-path
 * @short_description: File path utilities for libpikaconfig.
 *
 * File path utilities for libpikaconfig.
 **/


/**
 * pika_config_path_get_type:
 *
 * Reveals the object type
 *
 * Returns: the #GType for a PikaConfigPath string property
 *
 * Since: 2.4
 **/
GType
pika_config_path_get_type (void)
{
  static GType path_type = 0;

  if (! path_type)
    {
      const GTypeInfo type_info = { 0, };

      path_type = g_type_register_static (G_TYPE_STRING, "PikaConfigPath",
                                          &type_info, 0);
    }

  return path_type;
}


/*
 * PIKA_TYPE_PARAM_CONFIG_PATH
 */

#define PIKA_PARAM_SPEC_CONFIG_PATH(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_CONFIG_PATH, PikaParamSpecConfigPath))

typedef struct _PikaParamSpecConfigPath PikaParamSpecConfigPath;

struct _PikaParamSpecConfigPath
{
  GParamSpecString    parent_instance;

  PikaConfigPathType  type;
};

static void  pika_param_config_path_class_init (GParamSpecClass *class);

/**
 * pika_param_config_path_get_type:
 *
 * Reveals the object type
 *
 * Returns: the #GType for a directory path object
 *
 * Since: 2.4
 **/
GType
pika_param_config_path_get_type (void)
{
  static GType spec_type = 0;

  if (! spec_type)
    {
      const GTypeInfo type_info =
      {
        sizeof (GParamSpecClass),
        NULL, NULL,
        (GClassInitFunc) pika_param_config_path_class_init,
        NULL, NULL,
        sizeof (PikaParamSpecConfigPath),
        0, NULL, NULL
      };

      spec_type = g_type_register_static (G_TYPE_PARAM_STRING,
                                          "PikaParamConfigPath",
                                          &type_info, 0);
    }

  return spec_type;
}

static void
pika_param_config_path_class_init (GParamSpecClass *class)
{
  class->value_type = PIKA_TYPE_CONFIG_PATH;
}

/**
 * pika_param_spec_config_path:
 * @name:          Canonical name of the param
 * @nick:          Nickname of the param
 * @blurb:         Brief description of param.
 * @type:          a #PikaConfigPathType value.
 * @default_value: Value to use if none is assigned.
 * @flags:         a combination of #GParamFlags
 *
 * Creates a param spec to hold a filename, dir name,
 * or list of file or dir names.
 * See g_param_spec_internal() for more information.
 *
 * Returns: (transfer full): a newly allocated #GParamSpec instance
 *
 * Since: 2.4
 **/
GParamSpec *
pika_param_spec_config_path (const gchar        *name,
                             const gchar        *nick,
                             const gchar        *blurb,
                             PikaConfigPathType  type,
                             const gchar        *default_value,
                             GParamFlags         flags)
{
  GParamSpecString *pspec;

  pspec = g_param_spec_internal (PIKA_TYPE_PARAM_CONFIG_PATH,
                                 name, nick, blurb, flags);

  pspec->default_value = g_strdup (default_value);

  PIKA_PARAM_SPEC_CONFIG_PATH (pspec)->type = type;

  return G_PARAM_SPEC (pspec);
}

/**
 * pika_param_spec_config_path_type:
 * @pspec:         A #GParamSpec for a path param
 *
 * Tells whether the path param encodes a filename,
 * dir name, or list of file or dir names.
 *
 * Returns: a #PikaConfigPathType value
 *
 * Since: 2.4
 **/
PikaConfigPathType
pika_param_spec_config_path_type (GParamSpec *pspec)
{
  g_return_val_if_fail (PIKA_IS_PARAM_SPEC_CONFIG_PATH (pspec), 0);

  return PIKA_PARAM_SPEC_CONFIG_PATH (pspec)->type;
}


/*
 * PikaConfig path utilities
 */

static gchar        * pika_config_path_expand_only   (const gchar  *path,
                                                      GError      **error) G_GNUC_MALLOC;
static inline gchar * pika_config_path_extract_token (const gchar **str);
static gchar        * pika_config_path_unexpand_only (const gchar  *path) G_GNUC_MALLOC;


/**
 * pika_config_build_data_path:
 * @name: directory name (in UTF-8 encoding)
 *
 * Creates a search path as it is used in the pikarc file.  The path
 * returned by pika_config_build_data_path() includes a directory
 * below the user's pika directory and one in the system-wide data
 * directory.
 *
 * Note that you cannot use this path directly with pika_path_parse().
 * As it is in the pikarc notation, you first need to expand and
 * recode it using pika_config_path_expand().
 *
 * Returns: a newly allocated string
 *
 * Since: 2.4
 **/
gchar *
pika_config_build_data_path (const gchar *name)
{
  return g_strconcat ("${pika_dir}", G_DIR_SEPARATOR_S, name,
                      G_SEARCHPATH_SEPARATOR_S,
                      "${pika_data_dir}", G_DIR_SEPARATOR_S, name,
                      NULL);
}

/**
 * pika_config_build_plug_in_path:
 * @name: directory name (in UTF-8 encoding)
 *
 * Creates a search path as it is used in the pikarc file.  The path
 * returned by pika_config_build_plug_in_path() includes a directory
 * below the user's pika directory and one in the system-wide plug-in
 * directory.
 *
 * Note that you cannot use this path directly with pika_path_parse().
 * As it is in the pikarc notation, you first need to expand and
 * recode it using pika_config_path_expand().
 *
 * Returns: a newly allocated string
 *
 * Since: 2.4
 **/
gchar *
pika_config_build_plug_in_path (const gchar *name)
{
  return g_strconcat ("${pika_dir}", G_DIR_SEPARATOR_S, name,
                      G_SEARCHPATH_SEPARATOR_S,
                      "${pika_plug_in_dir}", G_DIR_SEPARATOR_S, name,
                      NULL);
}

/**
 * pika_config_build_writable_path:
 * @name: directory name (in UTF-8 encoding)
 *
 * Creates a search path as it is used in the pikarc file.  The path
 * returned by pika_config_build_writable_path() is just the writable
 * parts of the search path constructed by pika_config_build_data_path().
 *
 * Note that you cannot use this path directly with pika_path_parse().
 * As it is in the pikarc notation, you first need to expand and
 * recode it using pika_config_path_expand().
 *
 * Returns: a newly allocated string
 *
 * Since: 2.4
 **/
gchar *
pika_config_build_writable_path (const gchar *name)
{
  return g_strconcat ("${pika_dir}", G_DIR_SEPARATOR_S, name, NULL);
}

/**
 * pika_config_build_system_path:
 * @name: directory name (in UTF-8 encoding)
 *
 * Creates a search path as it is used in the pikarc file.  The path
 * returned by pika_config_build_system_path() is just the read-only
 * parts of the search path constructed by pika_config_build_plug_in_path().
 *
 * Note that you cannot use this path directly with pika_path_parse().
 * As it is in the pikarc notation, you first need to expand and
 * recode it using pika_config_path_expand().
 *
 * Returns: a newly allocated string
 *
 * Since: 2.10.6
 **/
gchar *
pika_config_build_system_path (const gchar *name)
{
  return g_strconcat ("${pika_plug_in_dir}", G_DIR_SEPARATOR_S, name, NULL);
}

/**
 * pika_config_path_expand:
 * @path:   a NUL-terminated string in UTF-8 encoding
 * @recode: whether to convert to the filesystem's encoding
 * @error:  return location for errors
 *
 * Paths as stored in pikarc and other config files have to be treated
 * special.  The string may contain special identifiers such as for
 * example ${pika_dir} that have to be substituted before use. Also
 * the user's filesystem may be in a different encoding than UTF-8
 * (which is what is used for the pikarc). This function does the
 * variable substitution for you and can also attempt to convert to
 * the filesystem encoding.
 *
 * To reverse the expansion, use pika_config_path_unexpand().
 *
 * Returns: a newly allocated NUL-terminated string
 *
 * Since: 2.4
 **/
gchar *
pika_config_path_expand (const gchar  *path,
                         gboolean      recode,
                         GError      **error)
{
  g_return_val_if_fail (path != NULL, NULL);
  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  if (recode)
    {
      gchar *retval;
      gchar *expanded = pika_config_path_expand_only (path, error);

      if (! expanded)
        return NULL;

      retval = g_filename_from_utf8 (expanded, -1, NULL, NULL, error);

      g_free (expanded);

      return retval;
    }

  return pika_config_path_expand_only (path, error);
}

/**
 * pika_config_path_expand_to_files:
 * @path:  a NUL-terminated string in UTF-8 encoding
 * @error: return location for errors
 *
 * Paths as stored in the pikarc have to be treated special. The
 * string may contain special identifiers such as for example
 * ${pika_dir} that have to be substituted before use. Also the user's
 * filesystem may be in a different encoding than UTF-8 (which is what
 * is used for the pikarc).
 *
 * This function runs @path through pika_config_path_expand() and
 * pika_path_parse(), then turns the filenames returned by
 * pika_path_parse() into GFile using g_file_new_for_path().
 *
 * Returns: (element-type GFile) (transfer full):
                 a #GList of newly allocated #GFile objects.
 *
 * Since: 2.10
 **/
GList *
pika_config_path_expand_to_files (const gchar  *path,
                                  GError      **error)
{
  GList *files;
  GList *list;
  gchar *expanded;

  g_return_val_if_fail (path != NULL, NULL);
  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  expanded = pika_config_path_expand (path, TRUE, error);

  if (! expanded)
    return NULL;

  files = pika_path_parse (expanded, 256, FALSE, NULL);

  g_free (expanded);

  for (list = files; list; list = g_list_next (list))
    {
      gchar *dir = list->data;

      list->data = g_file_new_for_path (dir);
      g_free (dir);
    }

  return files;
}

/**
 * pika_config_path_unexpand:
 * @path:   a NUL-terminated string
 * @recode: whether @path is in filesystem encoding or UTF-8
 * @error:  return location for errors
 *
 * The inverse operation of pika_config_path_expand()
 *
 * This function takes a @path and tries to substitute the first
 * elements by well-known special identifiers such as for example
 * ${pika_dir}. The unexpanded path can then be stored in pikarc and
 * other config files.
 *
 * If @recode is %TRUE then @path is in local filesystem encoding,
 * if @recode is %FALSE then @path is assumed to be UTF-8.
 *
 * Returns: a newly allocated NUL-terminated UTF-8 string
 *
 * Since: 2.10
 **/
gchar *
pika_config_path_unexpand (const gchar  *path,
                           gboolean      recode,
                           GError      **error)
{
  g_return_val_if_fail (path != NULL, NULL);
  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  if (recode)
    {
      gchar *retval;
      gchar *utf8 = g_filename_to_utf8 (path, -1, NULL, NULL, error);

      if (! utf8)
        return NULL;

      retval = pika_config_path_unexpand_only (utf8);

      g_free (utf8);

      return retval;
    }

  return pika_config_path_unexpand_only (path);
}

/**
 * pika_file_new_for_config_path:
 * @path:   a NUL-terminated string in UTF-8 encoding
 * @error:  return location for errors
 *
 * Expands @path using pika_config_path_expand() and returns a #GFile
 * for the expanded path.
 *
 * To reverse the expansion, use pika_file_get_config_path().
 *
 * Returns: (nullable) (transfer full): a newly allocated #GFile,
 *          or %NULL if the expansion failed.
 *
 * Since: 2.10
 **/
GFile *
pika_file_new_for_config_path (const gchar  *path,
                               GError      **error)
{
  GFile *file = NULL;
  gchar *expanded;

  g_return_val_if_fail (path != NULL, NULL);
  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  expanded = pika_config_path_expand (path, TRUE, error);

  if (expanded)
    {
      file = g_file_new_for_path (expanded);
      g_free (expanded);
    }

  return file;
}

/**
 * pika_file_get_config_path:
 * @file:   a #GFile
 * @error:  return location for errors
 *
 * Unexpands @file's path using pika_config_path_unexpand() and
 * returns the unexpanded path.
 *
 * The inverse operation of pika_file_new_for_config_path().
 *
 * Returns: a newly allocated NUL-terminated UTF-8 string, or %NULL if
 *               unexpanding failed.
 *
 * Since: 2.10
 **/
gchar *
pika_file_get_config_path (GFile   *file,
                           GError **error)
{
  gchar *unexpanded = NULL;
  gchar *path;

  g_return_val_if_fail (G_IS_FILE (file), NULL);
  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  path = g_file_get_path (file);

  if (path)
    {
      unexpanded = pika_config_path_unexpand (path, TRUE, error);
      g_free (path);
    }
  else
    {
      g_set_error_literal (error, 0, 0,
                           _("File has no path representation"));
    }

  return unexpanded;
}


/*  private functions  */

#define SUBSTS_ALLOC 4

static gchar *
pika_config_path_expand_only (const gchar  *path,
                              GError      **error)
{
  const gchar *home;
  const gchar *p;
  const gchar *s;
  gchar       *n;
  gchar       *token;
  gchar       *filename = NULL;
  gchar       *expanded = NULL;
  gchar      **substs   = NULL;
  guint        n_substs = 0;
  gint         length   = 0;
  guint        i;

  home = g_get_home_dir ();
  if (home)
    home = pika_filename_to_utf8 (home);

  p = path;

  while (*p)
    {
      if (*p == '~' && home)
        {
          length += strlen (home);
          p += 1;
        }
      else if ((token = pika_config_path_extract_token (&p)) != NULL)
        {
          for (i = 0; i < n_substs; i++)
            if (strcmp (substs[2*i], token) == 0)
              break;

          if (i < n_substs)
            {
              s = substs[2*i+1];
            }
          else
            {
              s = NULL;

              if (strcmp (token, "pika_dir") == 0)
                s = pika_directory ();
              else if (strcmp (token, "pika_data_dir") == 0)
                s = pika_data_directory ();
              else if (strcmp (token, "pika_plug_in_dir") == 0 ||
                       strcmp (token, "pika_plugin_dir") == 0)
                s = pika_plug_in_directory ();
              else if (strcmp (token, "pika_sysconf_dir") == 0)
                s = pika_sysconf_directory ();
              else if (strcmp (token, "pika_installation_dir") == 0)
                s = pika_installation_directory ();
              else if (strcmp (token, "pika_cache_dir") == 0)
                s = pika_cache_directory ();
              else if (strcmp (token, "pika_temp_dir") == 0)
                s = pika_temp_directory ();

              if (!s)
                s = g_getenv (token);

#ifdef G_OS_WIN32
              /* The default user pikarc on Windows references
               * ${TEMP}, but not all Windows installations have that
               * environment variable, even if it should be kinda
               * standard. So special-case it.
               */
              if (!s && strcmp (token, "TEMP") == 0)
                s = g_get_tmp_dir ();
#endif  /* G_OS_WIN32 */
            }

          if (!s)
            {
              g_set_error (error, PIKA_CONFIG_ERROR, PIKA_CONFIG_ERROR_PARSE,
                           _("Cannot expand ${%s}"), token);
              g_free (token);
              goto cleanup;
            }

          if (n_substs % SUBSTS_ALLOC == 0)
            substs = g_renew (gchar *, substs, 2 * (n_substs + SUBSTS_ALLOC));

          substs[2*n_substs]     = token;
          substs[2*n_substs + 1] = (gchar *) pika_filename_to_utf8 (s);

          length += strlen (substs[2*n_substs + 1]);

          n_substs++;
        }
      else
        {
          length += g_utf8_skip[(const guchar) *p];
          p = g_utf8_next_char (p);
        }
    }

  if (n_substs == 0)
    return g_strdup (path);

  expanded = g_new (gchar, length + 1);

  p = path;
  n = expanded;

  while (*p)
    {
      if (*p == '~' && home)
        {
          *n = '\0';
          strcat (n, home);
          n += strlen (home);
          p += 1;
        }
      else if ((token = pika_config_path_extract_token (&p)) != NULL)
        {
          for (i = 0; i < n_substs; i++)
            {
              if (strcmp (substs[2*i], token) == 0)
                {
                  s = substs[2*i+1];

                  *n = '\0';
                  strcat (n, s);
                  n += strlen (s);

                  break;
                }
            }

          g_free (token);
        }
      else
        {
          *n++ = *p++;
        }
    }

  *n = '\0';

 cleanup:
  for (i = 0; i < n_substs; i++)
    g_free (substs[2*i]);

  g_free (substs);
  g_free (filename);

  return expanded;
}

static inline gchar *
pika_config_path_extract_token (const gchar **str)
{
  const gchar *p;
  gchar       *token;

  if (strncmp (*str, "${", 2))
    return NULL;

  p = *str + 2;

  while (*p && (*p != '}'))
    p = g_utf8_next_char (p);

  if (! *p)
    return NULL;

  token = g_strndup (*str + 2, g_utf8_pointer_to_offset (*str + 2, p));

  *str = p + 1; /* after the closing bracket */

  return token;
}

static gchar *
pika_config_path_unexpand_only (const gchar *path)
{
  const struct
  {
    const gchar *id;
    const gchar *prefix;
  }
  identifiers[] =
  {
    { "${pika_plug_in_dir}",      pika_plug_in_directory () },
    { "${pika_data_dir}",         pika_data_directory () },
    { "${pika_sysconf_dir}",      pika_sysconf_directory () },
    { "${pika_installation_dir}", pika_installation_directory () },
    { "${pika_cache_dir}",        pika_cache_directory () },
    { "${pika_temp_dir}",         pika_temp_directory () },
    { "${pika_dir}",              pika_directory () }
  };

  GList *files;
  GList *list;
  gchar *unexpanded;

  files = pika_path_parse (path, 256, FALSE, NULL);

  for (list = files; list; list = g_list_next (list))
    {
      gchar *dir = list->data;
      gint   i;

      for (i = 0; i < G_N_ELEMENTS (identifiers); i++)
        {
          if (g_str_has_prefix (dir, identifiers[i].prefix))
            {
              gchar *tmp = g_strconcat (identifiers[i].id,
                                        dir + strlen (identifiers[i].prefix),
                                        NULL);

              g_free (dir);
              list->data = tmp;

              break;
            }
        }
    }

  unexpanded = pika_path_to_str (files);

  pika_path_free (files);

  return unexpanded;
}