aboutsummaryrefslogtreecommitdiffstats
path: root/subversion/libsvn_client/shelf.c
diff options
context:
space:
mode:
Diffstat (limited to 'subversion/libsvn_client/shelf.c')
-rw-r--r--subversion/libsvn_client/shelf.c1274
1 files changed, 1274 insertions, 0 deletions
diff --git a/subversion/libsvn_client/shelf.c b/subversion/libsvn_client/shelf.c
new file mode 100644
index 000000000000..2bba1935384a
--- /dev/null
+++ b/subversion/libsvn_client/shelf.c
@@ -0,0 +1,1274 @@
+/*
+ * shelf.c: implementation of shelving
+ *
+ * ====================================================================
+ * 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.
+ * ====================================================================
+ */
+
+/* ==================================================================== */
+
+/* We define this here to remove any further warnings about the usage of
+ experimental functions in this file. */
+#define SVN_EXPERIMENTAL
+
+#include "svn_client.h"
+#include "svn_wc.h"
+#include "svn_pools.h"
+#include "svn_dirent_uri.h"
+#include "svn_path.h"
+#include "svn_hash.h"
+#include "svn_utf.h"
+#include "svn_ctype.h"
+#include "svn_props.h"
+
+#include "client.h"
+#include "private/svn_client_shelf.h"
+#include "private/svn_client_private.h"
+#include "private/svn_wc_private.h"
+#include "private/svn_sorts_private.h"
+#include "svn_private_config.h"
+
+
+static svn_error_t *
+shelf_name_encode(char **encoded_name_p,
+ const char *name,
+ apr_pool_t *result_pool)
+{
+ char *encoded_name
+ = apr_palloc(result_pool, strlen(name) * 2 + 1);
+ char *out_pos = encoded_name;
+
+ if (name[0] == '\0')
+ return svn_error_create(SVN_ERR_BAD_CHANGELIST_NAME, NULL,
+ _("Shelf name cannot be the empty string"));
+
+ while (*name)
+ {
+ apr_snprintf(out_pos, 3, "%02x", (unsigned char)(*name++));
+ out_pos += 2;
+ }
+ *encoded_name_p = encoded_name;
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+shelf_name_decode(char **decoded_name_p,
+ const char *codename,
+ apr_pool_t *result_pool)
+{
+ svn_stringbuf_t *sb
+ = svn_stringbuf_create_ensure(strlen(codename) / 2, result_pool);
+ const char *input = codename;
+
+ while (*input)
+ {
+ int c;
+ int nchars;
+ int nitems = sscanf(input, "%02x%n", &c, &nchars);
+
+ if (nitems != 1 || nchars != 2)
+ return svn_error_createf(SVN_ERR_BAD_CHANGELIST_NAME, NULL,
+ _("Shelve: Bad encoded name '%s'"), codename);
+ svn_stringbuf_appendbyte(sb, c);
+ input += 2;
+ }
+ *decoded_name_p = sb->data;
+ return SVN_NO_ERROR;
+}
+
+/* Set *NAME to the shelf name from FILENAME, if FILENAME names a '.current'
+ * file, else to NULL. */
+static svn_error_t *
+shelf_name_from_filename(char **name,
+ const char *filename,
+ apr_pool_t *result_pool)
+{
+ size_t len = strlen(filename);
+ static const char suffix[] = ".current";
+ size_t suffix_len = sizeof(suffix) - 1;
+
+ if (len > suffix_len && strcmp(filename + len - suffix_len, suffix) == 0)
+ {
+ char *codename = apr_pstrndup(result_pool, filename, len - suffix_len);
+ SVN_ERR(shelf_name_decode(name, codename, result_pool));
+ }
+ else
+ {
+ *name = NULL;
+ }
+ return SVN_NO_ERROR;
+}
+
+/* Set *DIR to the shelf storage directory inside the WC's administrative
+ * area. Ensure the directory exists. */
+static svn_error_t *
+get_shelves_dir(char **dir,
+ svn_wc_context_t *wc_ctx,
+ const char *local_abspath,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ char *experimental_abspath;
+
+ SVN_ERR(svn_wc__get_experimental_dir(&experimental_abspath,
+ wc_ctx, local_abspath,
+ scratch_pool, scratch_pool));
+ *dir = svn_dirent_join(experimental_abspath, "shelves/v3", result_pool);
+
+ /* Ensure the directory exists. (Other versions of svn don't create it.) */
+ SVN_ERR(svn_io_make_dir_recursively(*dir, scratch_pool));
+
+ return SVN_NO_ERROR;
+}
+
+/* Set *ABSPATH to the abspath of the file storage dir for SHELF
+ * version VERSION, no matter whether it exists.
+ */
+static svn_error_t *
+shelf_version_files_dir_abspath(const char **abspath,
+ svn_client__shelf_t *shelf,
+ int version,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ char *codename;
+ char *filename;
+
+ SVN_ERR(shelf_name_encode(&codename, shelf->name, result_pool));
+ filename = apr_psprintf(scratch_pool, "%s-%03d.wc", codename, version);
+ *abspath = svn_dirent_join(shelf->shelves_dir, filename, result_pool);
+ return SVN_NO_ERROR;
+}
+
+/* Create a shelf-version object for a version that may or may not already
+ * exist on disk.
+ */
+static svn_error_t *
+shelf_version_create(svn_client__shelf_version_t **new_version_p,
+ svn_client__shelf_t *shelf,
+ int version_number,
+ apr_pool_t *result_pool)
+{
+ svn_client__shelf_version_t *shelf_version
+ = apr_pcalloc(result_pool, sizeof(*shelf_version));
+
+ shelf_version->shelf = shelf;
+ shelf_version->version_number = version_number;
+ SVN_ERR(shelf_version_files_dir_abspath(&shelf_version->files_dir_abspath,
+ shelf, version_number,
+ result_pool, result_pool));
+ *new_version_p = shelf_version;
+ return SVN_NO_ERROR;
+}
+
+/* Delete the storage for SHELF:VERSION. */
+static svn_error_t *
+shelf_version_delete(svn_client__shelf_t *shelf,
+ int version,
+ apr_pool_t *scratch_pool)
+{
+ const char *files_dir_abspath;
+
+ SVN_ERR(shelf_version_files_dir_abspath(&files_dir_abspath,
+ shelf, version,
+ scratch_pool, scratch_pool));
+ SVN_ERR(svn_io_remove_dir2(files_dir_abspath, TRUE /*ignore_enoent*/,
+ NULL, NULL, /*cancel*/
+ scratch_pool));
+ return SVN_NO_ERROR;
+}
+
+/* */
+static svn_error_t *
+get_log_abspath(char **log_abspath,
+ svn_client__shelf_t *shelf,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ char *codename;
+ const char *filename;
+
+ SVN_ERR(shelf_name_encode(&codename, shelf->name, result_pool));
+ filename = apr_pstrcat(scratch_pool, codename, ".log", SVN_VA_NULL);
+ *log_abspath = svn_dirent_join(shelf->shelves_dir, filename, result_pool);
+ return SVN_NO_ERROR;
+}
+
+/* Set SHELF->revprops by reading from its storage (the '.log' file).
+ * Set SHELF->revprops to empty if the storage file does not exist; this
+ * is not an error.
+ */
+static svn_error_t *
+shelf_read_revprops(svn_client__shelf_t *shelf,
+ apr_pool_t *scratch_pool)
+{
+ char *log_abspath;
+ svn_error_t *err;
+ svn_stream_t *stream;
+
+ SVN_ERR(get_log_abspath(&log_abspath, shelf, scratch_pool, scratch_pool));
+
+ shelf->revprops = apr_hash_make(shelf->pool);
+ err = svn_stream_open_readonly(&stream, log_abspath,
+ scratch_pool, scratch_pool);
+ if (err && APR_STATUS_IS_ENOENT(err->apr_err))
+ {
+ svn_error_clear(err);
+ return SVN_NO_ERROR;
+ }
+ else
+ SVN_ERR(err);
+ SVN_ERR(svn_hash_read2(shelf->revprops, stream, "PROPS-END", shelf->pool));
+ SVN_ERR(svn_stream_close(stream));
+ return SVN_NO_ERROR;
+}
+
+/* Write SHELF's revprops to its file storage.
+ */
+static svn_error_t *
+shelf_write_revprops(svn_client__shelf_t *shelf,
+ apr_pool_t *scratch_pool)
+{
+ char *log_abspath;
+ apr_file_t *file;
+ svn_stream_t *stream;
+
+ SVN_ERR(get_log_abspath(&log_abspath, shelf, scratch_pool, scratch_pool));
+
+ SVN_ERR(svn_io_file_open(&file, log_abspath,
+ APR_FOPEN_WRITE | APR_FOPEN_CREATE | APR_FOPEN_TRUNCATE,
+ APR_FPROT_OS_DEFAULT, scratch_pool));
+ stream = svn_stream_from_aprfile2(file, FALSE /*disown*/, scratch_pool);
+
+ SVN_ERR(svn_hash_write2(shelf->revprops, stream, "PROPS-END", scratch_pool));
+ SVN_ERR(svn_stream_close(stream));
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_revprop_set(svn_client__shelf_t *shelf,
+ const char *prop_name,
+ const svn_string_t *prop_val,
+ apr_pool_t *scratch_pool)
+{
+ svn_hash_sets(shelf->revprops, apr_pstrdup(shelf->pool, prop_name),
+ svn_string_dup(prop_val, shelf->pool));
+ SVN_ERR(shelf_write_revprops(shelf, scratch_pool));
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_revprop_set_all(svn_client__shelf_t *shelf,
+ apr_hash_t *revprop_table,
+ apr_pool_t *scratch_pool)
+{
+ if (revprop_table)
+ shelf->revprops = svn_prop_hash_dup(revprop_table, shelf->pool);
+ else
+ shelf->revprops = apr_hash_make(shelf->pool);
+
+ SVN_ERR(shelf_write_revprops(shelf, scratch_pool));
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_revprop_get(svn_string_t **prop_val,
+ svn_client__shelf_t *shelf,
+ const char *prop_name,
+ apr_pool_t *result_pool)
+{
+ *prop_val = svn_hash_gets(shelf->revprops, prop_name);
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_revprop_list(apr_hash_t **props,
+ svn_client__shelf_t *shelf,
+ apr_pool_t *result_pool)
+{
+ *props = shelf->revprops;
+ return SVN_NO_ERROR;
+}
+
+/* */
+static svn_error_t *
+get_current_abspath(char **current_abspath,
+ svn_client__shelf_t *shelf,
+ apr_pool_t *result_pool)
+{
+ char *codename;
+ char *filename;
+
+ SVN_ERR(shelf_name_encode(&codename, shelf->name, result_pool));
+ filename = apr_psprintf(result_pool, "%s.current", codename);
+ *current_abspath = svn_dirent_join(shelf->shelves_dir, filename, result_pool);
+ return SVN_NO_ERROR;
+}
+
+/* Read SHELF->max_version from its storage (the '.current' file).
+ * Set SHELF->max_version to -1 if that file does not exist.
+ */
+static svn_error_t *
+shelf_read_current(svn_client__shelf_t *shelf,
+ apr_pool_t *scratch_pool)
+{
+ char *current_abspath;
+ svn_error_t *err;
+
+ SVN_ERR(get_current_abspath(&current_abspath, shelf, scratch_pool));
+ err = svn_io_read_version_file(&shelf->max_version,
+ current_abspath, scratch_pool);
+ if (err)
+ {
+ shelf->max_version = -1;
+ svn_error_clear(err);
+ return SVN_NO_ERROR;
+ }
+ return SVN_NO_ERROR;
+}
+
+/* */
+static svn_error_t *
+shelf_write_current(svn_client__shelf_t *shelf,
+ apr_pool_t *scratch_pool)
+{
+ char *current_abspath;
+
+ SVN_ERR(get_current_abspath(&current_abspath, shelf, scratch_pool));
+ SVN_ERR(svn_io_write_version_file(current_abspath, shelf->max_version,
+ scratch_pool));
+ return SVN_NO_ERROR;
+}
+
+/*-------------------------------------------------------------------------*/
+/* Status Reporting */
+
+/* Adjust a status STATUS_IN obtained from the shelf storage WC, to add
+ * shelf-related metadata:
+ * - changelist: 'svn:shelf:SHELFNAME'
+ */
+static svn_error_t *
+status_augment(svn_wc_status3_t **status_p,
+ const svn_wc_status3_t *status_in,
+ svn_client__shelf_version_t *shelf_version,
+ apr_pool_t *result_pool)
+{
+ *status_p = svn_wc_dup_status3(status_in, result_pool);
+ (*status_p)->changelist = apr_psprintf(result_pool, "svn:shelf:%s",
+ shelf_version->shelf->name);
+ return SVN_NO_ERROR;
+}
+
+/* Read status from shelf storage.
+ */
+static svn_error_t *
+status_read(svn_wc_status3_t **status,
+ svn_client__shelf_version_t *shelf_version,
+ const char *relpath,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ svn_client_ctx_t *ctx = shelf_version->shelf->ctx;
+ char *abspath
+ = svn_dirent_join(shelf_version->files_dir_abspath, relpath,
+ scratch_pool);
+
+ SVN_ERR(svn_wc_status3(status, ctx->wc_ctx, abspath,
+ result_pool, scratch_pool));
+ SVN_ERR(status_augment(status, *status, shelf_version, result_pool));
+ return SVN_NO_ERROR;
+}
+
+/* A visitor function type for use with shelf_status_walk().
+ * The same as svn_wc_status_func4_t except relpath instead of abspath.
+ */
+typedef svn_error_t *(*shelf_status_visitor_t)(void *baton,
+ const char *relpath,
+ const svn_wc_status3_t *status,
+ apr_pool_t *scratch_pool);
+
+/* Baton for shelved_files_walk_visitor(). */
+struct shelf_status_baton_t
+{
+ svn_client__shelf_version_t *shelf_version;
+ shelf_status_visitor_t walk_func;
+ void *walk_baton;
+};
+
+/* Convert a svn_wc_status_func4_t callback invocation to call a
+ * shelf_status_visitor_t callback.
+ *
+ * Call BATON->walk_func(BATON->walk_baton, relpath, ...) for the shelved
+ * storage path ABSPATH, converting ABSPATH to a WC-relative path, and
+ * augmenting the STATUS.
+ *
+ * The opposite of wc_status_visitor().
+ *
+ * Implements svn_wc_status_func4_t. */
+static svn_error_t *
+shelf_status_visitor(void *baton,
+ const char *abspath,
+ const svn_wc_status3_t *status,
+ apr_pool_t *scratch_pool)
+{
+ struct shelf_status_baton_t *b = baton;
+ const char *relpath;
+ svn_wc_status3_t *new_status;
+
+ relpath = svn_dirent_skip_ancestor(b->shelf_version->files_dir_abspath,
+ abspath);
+ SVN_ERR(status_augment(&new_status, status, b->shelf_version, scratch_pool));
+ SVN_ERR(b->walk_func(b->walk_baton, relpath, new_status, scratch_pool));
+ return SVN_NO_ERROR;
+}
+
+/* Report the shelved status of the path SHELF_VERSION:WC_RELPATH
+ * via WALK_FUNC(WALK_BATON, ...).
+ */
+static svn_error_t *
+shelf_status_visit_path(svn_client__shelf_version_t *shelf_version,
+ const char *wc_relpath,
+ shelf_status_visitor_t walk_func,
+ void *walk_baton,
+ apr_pool_t *scratch_pool)
+{
+ svn_wc_status3_t *status;
+
+ SVN_ERR(status_read(&status, shelf_version, wc_relpath,
+ scratch_pool, scratch_pool));
+ SVN_ERR(walk_func(walk_baton, wc_relpath, status, scratch_pool));
+ return SVN_NO_ERROR;
+}
+
+/* Report the shelved status of all the shelved paths in SHELF_VERSION
+ * at and under WC_RELPATH, via WALK_FUNC(WALK_BATON, ...).
+ */
+static svn_error_t *
+shelf_status_walk(svn_client__shelf_version_t *shelf_version,
+ const char *wc_relpath,
+ shelf_status_visitor_t walk_func,
+ void *walk_baton,
+ apr_pool_t *scratch_pool)
+{
+ svn_client_ctx_t *ctx = shelf_version->shelf->ctx;
+ char *walk_root_abspath
+ = svn_dirent_join(shelf_version->files_dir_abspath, wc_relpath,
+ scratch_pool);
+ struct shelf_status_baton_t baton;
+ svn_error_t *err;
+
+ baton.shelf_version = shelf_version;
+ baton.walk_func = walk_func;
+ baton.walk_baton = walk_baton;
+ err = svn_wc_walk_status(ctx->wc_ctx, walk_root_abspath,
+ svn_depth_infinity,
+ FALSE /*get_all*/,
+ TRUE /*no_ignore*/,
+ FALSE /*ignore_text_mods*/,
+ NULL /*ignore_patterns: use the defaults*/,
+ shelf_status_visitor, &baton,
+ NULL, NULL, /*cancellation*/
+ scratch_pool);
+ if (err && APR_STATUS_IS_ENOENT(err->apr_err))
+ svn_error_clear(err);
+ else
+ SVN_ERR(err);
+
+ return SVN_NO_ERROR;
+}
+
+/* Baton for wc_status_visitor(). */
+typedef struct wc_status_baton_t
+{
+ svn_client__shelf_version_t *shelf_version;
+ svn_wc_status_func4_t walk_func;
+ void *walk_baton;
+} wc_status_baton_t;
+
+/* Convert a shelf_status_visitor_t callback invocation to call a
+ * svn_wc_status_func4_t callback.
+ *
+ * Call BATON->walk_func(BATON->walk_baton, abspath, ...) for the WC-
+ * relative path RELPATH, converting RELPATH to an abspath in the user's WC.
+ *
+ * The opposite of shelf_status_visitor().
+ *
+ * Implements shelf_status_visitor_t. */
+static svn_error_t *
+wc_status_visitor(void *baton,
+ const char *relpath,
+ const svn_wc_status3_t *status,
+ apr_pool_t *scratch_pool)
+{
+ struct wc_status_baton_t *b = baton;
+ svn_client__shelf_t *shelf = b->shelf_version->shelf;
+ const char *abspath = svn_dirent_join(shelf->wc_root_abspath, relpath,
+ scratch_pool);
+ SVN_ERR(b->walk_func(b->walk_baton, abspath, status, scratch_pool));
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_version_status_walk(svn_client__shelf_version_t *shelf_version,
+ const char *wc_relpath,
+ svn_wc_status_func4_t walk_func,
+ void *walk_baton,
+ apr_pool_t *scratch_pool)
+{
+ wc_status_baton_t baton;
+
+ baton.shelf_version = shelf_version;
+ baton.walk_func = walk_func;
+ baton.walk_baton = walk_baton;
+ SVN_ERR(shelf_status_walk(shelf_version, wc_relpath,
+ wc_status_visitor, &baton,
+ scratch_pool));
+ return SVN_NO_ERROR;
+}
+
+/*-------------------------------------------------------------------------*/
+/* Shelf Storage */
+
+/* Construct a shelf object representing an empty shelf: no versions,
+ * no revprops, no looking to see if such a shelf exists on disk.
+ */
+static svn_error_t *
+shelf_construct(svn_client__shelf_t **shelf_p,
+ const char *name,
+ const char *local_abspath,
+ svn_client_ctx_t *ctx,
+ apr_pool_t *result_pool)
+{
+ svn_client__shelf_t *shelf = apr_palloc(result_pool, sizeof(*shelf));
+ char *shelves_dir;
+
+ SVN_ERR(svn_client_get_wc_root(&shelf->wc_root_abspath,
+ local_abspath, ctx,
+ result_pool, result_pool));
+ SVN_ERR(get_shelves_dir(&shelves_dir, ctx->wc_ctx, local_abspath,
+ result_pool, result_pool));
+ shelf->shelves_dir = shelves_dir;
+ shelf->ctx = ctx;
+ shelf->pool = result_pool;
+
+ shelf->name = apr_pstrdup(result_pool, name);
+ shelf->revprops = apr_hash_make(result_pool);
+ shelf->max_version = 0;
+
+ *shelf_p = shelf;
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_open_existing(svn_client__shelf_t **shelf_p,
+ const char *name,
+ const char *local_abspath,
+ svn_client_ctx_t *ctx,
+ apr_pool_t *result_pool)
+{
+ SVN_ERR(shelf_construct(shelf_p, name,
+ local_abspath, ctx, result_pool));
+ SVN_ERR(shelf_read_revprops(*shelf_p, result_pool));
+ SVN_ERR(shelf_read_current(*shelf_p, result_pool));
+ if ((*shelf_p)->max_version < 0)
+ {
+ return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
+ _("Shelf '%s' not found"),
+ name);
+ }
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_open_or_create(svn_client__shelf_t **shelf_p,
+ const char *name,
+ const char *local_abspath,
+ svn_client_ctx_t *ctx,
+ apr_pool_t *result_pool)
+{
+ svn_client__shelf_t *shelf;
+
+ SVN_ERR(shelf_construct(&shelf, name,
+ local_abspath, ctx, result_pool));
+ SVN_ERR(shelf_read_revprops(shelf, result_pool));
+ SVN_ERR(shelf_read_current(shelf, result_pool));
+ if (shelf->max_version < 0)
+ {
+ shelf->max_version = 0;
+ SVN_ERR(shelf_write_current(shelf, result_pool));
+ }
+ *shelf_p = shelf;
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_close(svn_client__shelf_t *shelf,
+ apr_pool_t *scratch_pool)
+{
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_delete(const char *name,
+ const char *local_abspath,
+ svn_boolean_t dry_run,
+ svn_client_ctx_t *ctx,
+ apr_pool_t *scratch_pool)
+{
+ svn_client__shelf_t *shelf;
+ int i;
+ char *abspath;
+
+ SVN_ERR(svn_client__shelf_open_existing(&shelf, name,
+ local_abspath, ctx, scratch_pool));
+
+ /* Remove the versions. */
+ for (i = shelf->max_version; i > 0; i--)
+ {
+ SVN_ERR(shelf_version_delete(shelf, i, scratch_pool));
+ }
+
+ /* Remove the other files */
+ SVN_ERR(get_log_abspath(&abspath, shelf, scratch_pool, scratch_pool));
+ SVN_ERR(svn_io_remove_file2(abspath, TRUE /*ignore_enoent*/, scratch_pool));
+ SVN_ERR(get_current_abspath(&abspath, shelf, scratch_pool));
+ SVN_ERR(svn_io_remove_file2(abspath, TRUE /*ignore_enoent*/, scratch_pool));
+
+ SVN_ERR(svn_client__shelf_close(shelf, scratch_pool));
+ return SVN_NO_ERROR;
+}
+
+/* Baton for paths_changed_visitor(). */
+struct paths_changed_walk_baton_t
+{
+ apr_hash_t *paths_hash;
+ const char *wc_root_abspath;
+ apr_pool_t *pool;
+};
+
+/* Add to the list(s) in BATON, the RELPATH of a shelved 'binary' file.
+ * Implements shelved_files_walk_func_t. */
+static svn_error_t *
+paths_changed_visitor(void *baton,
+ const char *relpath,
+ const svn_wc_status3_t *s,
+ apr_pool_t *scratch_pool)
+{
+ struct paths_changed_walk_baton_t *b = baton;
+
+ relpath = apr_pstrdup(b->pool, relpath);
+ svn_hash_sets(b->paths_hash, relpath, relpath);
+ return SVN_NO_ERROR;
+}
+
+/* Get the paths changed, relative to WC root or as abspaths, as a hash
+ * and/or an array (in no particular order).
+ */
+static svn_error_t *
+shelf_paths_changed(apr_hash_t **paths_hash_p,
+ apr_array_header_t **paths_array_p,
+ svn_client__shelf_version_t *shelf_version,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ svn_client__shelf_t *shelf = shelf_version->shelf;
+ apr_hash_t *paths_hash = apr_hash_make(result_pool);
+ struct paths_changed_walk_baton_t baton;
+
+ baton.paths_hash = paths_hash;
+ baton.wc_root_abspath = shelf->wc_root_abspath;
+ baton.pool = result_pool;
+ SVN_ERR(shelf_status_walk(shelf_version, "",
+ paths_changed_visitor, &baton,
+ scratch_pool));
+
+ if (paths_hash_p)
+ *paths_hash_p = paths_hash;
+ if (paths_array_p)
+ SVN_ERR(svn_hash_keys(paths_array_p, paths_hash, result_pool));
+
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_paths_changed(apr_hash_t **affected_paths,
+ svn_client__shelf_version_t *shelf_version,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ SVN_ERR(shelf_paths_changed(affected_paths, NULL, shelf_version,
+ result_pool, scratch_pool));
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_replay(svn_client__shelf_version_t *shelf_version,
+ const char *top_relpath,
+ const svn_delta_editor_t *editor,
+ void *edit_baton,
+ svn_wc_notify_func2_t notify_func,
+ void *notify_baton,
+ apr_pool_t *scratch_pool)
+{
+ svn_client_ctx_t *ctx = shelf_version->shelf->ctx;
+ apr_array_header_t *src_targets = apr_array_make(scratch_pool, 1,
+ sizeof(char *));
+ const char *src_wc_abspath
+ = svn_dirent_join(shelf_version->files_dir_abspath, top_relpath, scratch_pool);
+
+ APR_ARRAY_PUSH(src_targets, const char *) = src_wc_abspath;
+ SVN_ERR(svn_client__wc_replay(src_wc_abspath,
+ src_targets, svn_depth_infinity, NULL,
+ editor, edit_baton,
+ notify_func, notify_baton,
+ ctx, scratch_pool));
+ return SVN_NO_ERROR;
+}
+
+/* Baton for test_apply_file_visitor(). */
+struct test_apply_files_baton_t
+{
+ svn_client__shelf_version_t *shelf_version;
+ svn_boolean_t conflict; /* would it conflict? */
+ svn_client_ctx_t *ctx;
+};
+
+/* Ideally, set BATON->conflict if we can't apply a change to WC
+ * at RELPATH without conflict. But in fact, just check
+ * if WC at RELPATH is locally modified.
+ *
+ * Implements shelved_files_walk_func_t. */
+static svn_error_t *
+test_apply_file_visitor(void *baton,
+ const char *relpath,
+ const svn_wc_status3_t *s,
+ apr_pool_t *scratch_pool)
+{
+ struct test_apply_files_baton_t *b = baton;
+ const char *wc_root_abspath = b->shelf_version->shelf->wc_root_abspath;
+ const char *to_wc_abspath = svn_dirent_join(wc_root_abspath, relpath,
+ scratch_pool);
+ svn_wc_status3_t *status;
+
+ SVN_ERR(svn_wc_status3(&status, b->ctx->wc_ctx, to_wc_abspath,
+ scratch_pool, scratch_pool));
+ switch (status->node_status)
+ {
+ case svn_wc_status_normal:
+ case svn_wc_status_none:
+ break;
+ default:
+ b->conflict = TRUE;
+ }
+
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_test_apply_file(svn_boolean_t *conflict_p,
+ svn_client__shelf_version_t *shelf_version,
+ const char *file_relpath,
+ apr_pool_t *scratch_pool)
+{
+ struct test_apply_files_baton_t baton = {0};
+
+ baton.shelf_version = shelf_version;
+ baton.conflict = FALSE;
+ baton.ctx = shelf_version->shelf->ctx;
+ SVN_ERR(shelf_status_visit_path(shelf_version, file_relpath,
+ test_apply_file_visitor, &baton,
+ scratch_pool));
+ *conflict_p = baton.conflict;
+
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+wc_mods_editor(const svn_delta_editor_t **editor_p,
+ void **edit_baton_p,
+ const char *dst_wc_abspath,
+ svn_wc_notify_func2_t notify_func,
+ void *notify_baton,
+ svn_client_ctx_t *ctx,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ svn_client__pathrev_t *base;
+ const char *dst_wc_url;
+ svn_ra_session_t *ra_session;
+
+ /* We'll need an RA session to obtain the base of any copies */
+ SVN_ERR(svn_client__wc_node_get_base(&base,
+ dst_wc_abspath, ctx->wc_ctx,
+ scratch_pool, scratch_pool));
+ dst_wc_url = base->url;
+ SVN_ERR(svn_client_open_ra_session2(&ra_session,
+ dst_wc_url, dst_wc_abspath,
+ ctx, result_pool, scratch_pool));
+ SVN_ERR(svn_client__wc_editor(editor_p, edit_baton_p,
+ dst_wc_abspath,
+ notify_func, notify_baton,
+ ra_session, ctx, result_pool));
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_mods_editor(const svn_delta_editor_t **editor_p,
+ void **edit_baton_p,
+ svn_client__shelf_version_t *shelf_version,
+ svn_wc_notify_func2_t notify_func,
+ void *notify_baton,
+ svn_client_ctx_t *ctx,
+ apr_pool_t *result_pool)
+{
+ SVN_ERR(wc_mods_editor(editor_p, edit_baton_p,
+ shelf_version->files_dir_abspath,
+ notify_func, notify_baton,
+ ctx, result_pool, result_pool));
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_apply(svn_client__shelf_version_t *shelf_version,
+ svn_boolean_t dry_run,
+ apr_pool_t *scratch_pool)
+{
+ svn_client__shelf_t *shelf = shelf_version->shelf;
+ const svn_delta_editor_t *editor;
+ void *edit_baton;
+
+ SVN_ERR(wc_mods_editor(&editor, &edit_baton,
+ shelf->wc_root_abspath,
+ NULL, NULL, /*notification*/
+ shelf->ctx, scratch_pool, scratch_pool));
+
+ SVN_ERR(svn_client__shelf_replay(shelf_version, "",
+ editor, edit_baton,
+ shelf->ctx->notify_func2, shelf->ctx->notify_baton2,
+ scratch_pool));
+
+ svn_io_sleep_for_timestamps(shelf->wc_root_abspath,
+ scratch_pool);
+ return SVN_NO_ERROR;
+}
+
+/* Baton for paths_changed_visitor(). */
+struct unapply_walk_baton_t
+{
+ const char *wc_root_abspath;
+ svn_boolean_t dry_run;
+ svn_boolean_t use_commit_times;
+ svn_client_ctx_t *ctx;
+ apr_pool_t *pool;
+};
+
+/* Revert the change at RELPATH in the user's WC.
+ * Implements shelved_files_walk_func_t. */
+static svn_error_t *
+unapply_visitor(void *baton,
+ const char *relpath,
+ const svn_wc_status3_t *s,
+ apr_pool_t *scratch_pool)
+{
+ struct unapply_walk_baton_t *b = baton;
+ const char *abspath = svn_dirent_join(b->wc_root_abspath, relpath,
+ scratch_pool);
+
+ if (!b->dry_run)
+ {
+ apr_array_header_t *targets
+ = apr_array_make(scratch_pool, 1, sizeof(char *));
+ svn_depth_t depth;
+
+ APR_ARRAY_PUSH(targets, const char *) = abspath;
+
+ /* If the local modification is a "delete" then revert it all
+ (recursively). Otherwise we'd have to walk paths in
+ top-down order to revert a delete, whereas we need bottom-up
+ order to revert children of an added directory. */
+ if (s->node_status == svn_wc_status_deleted
+ || s->node_status == svn_wc_status_replaced
+ || s->node_status == svn_wc_status_added)
+ depth = svn_depth_infinity;
+ else
+ depth = svn_depth_empty;
+ SVN_ERR(svn_wc_revert6(b->ctx->wc_ctx,
+ abspath,
+ depth,
+ b->use_commit_times,
+ NULL /*changelists*/,
+ FALSE /*clear_changelists*/,
+ FALSE /*metadata_only*/,
+ FALSE /*added_keep_local*/,
+ b->ctx->cancel_func, b->ctx->cancel_baton,
+ NULL, NULL, /*notification*/
+ scratch_pool));
+ }
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_unapply(svn_client__shelf_version_t *shelf_version,
+ svn_boolean_t dry_run,
+ apr_pool_t *scratch_pool)
+{
+ svn_client_ctx_t *ctx = shelf_version->shelf->ctx;
+ svn_client__shelf_t *shelf = shelf_version->shelf;
+ struct unapply_walk_baton_t baton;
+ svn_config_t *cfg;
+
+ baton.wc_root_abspath = shelf->wc_root_abspath;
+ baton.dry_run = dry_run;
+ baton.ctx = ctx;
+ baton.pool = scratch_pool;
+
+ cfg = ctx->config ? svn_hash_gets(ctx->config, SVN_CONFIG_CATEGORY_CONFIG)
+ : NULL;
+ SVN_ERR(svn_config_get_bool(cfg, &baton.use_commit_times,
+ SVN_CONFIG_SECTION_MISCELLANY,
+ SVN_CONFIG_OPTION_USE_COMMIT_TIMES, FALSE));
+
+ SVN_WC__CALL_WITH_WRITE_LOCK(
+ shelf_status_walk(shelf_version, "",
+ unapply_visitor, &baton,
+ scratch_pool),
+ ctx->wc_ctx, shelf_version->shelf->wc_root_abspath,
+ FALSE /*lock_anchor*/, scratch_pool);
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_delete_newer_versions(svn_client__shelf_t *shelf,
+ svn_client__shelf_version_t *shelf_version,
+ apr_pool_t *scratch_pool)
+{
+ int previous_version = shelf_version ? shelf_version->version_number : 0;
+ int i;
+
+ /* Delete any newer checkpoints */
+ for (i = shelf->max_version; i > previous_version; i--)
+ {
+ SVN_ERR(shelf_version_delete(shelf, i, scratch_pool));
+ }
+
+ shelf->max_version = previous_version;
+ SVN_ERR(shelf_write_current(shelf, scratch_pool));
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_diff(svn_client__shelf_version_t *shelf_version,
+ const char *shelf_relpath,
+ svn_depth_t depth,
+ svn_boolean_t ignore_ancestry,
+ const svn_diff_tree_processor_t *diff_processor,
+ apr_pool_t *scratch_pool)
+{
+ svn_client_ctx_t *ctx = shelf_version->shelf->ctx;
+ char *local_abspath
+ = svn_dirent_join(shelf_version->files_dir_abspath, shelf_relpath,
+ scratch_pool);
+
+ if (shelf_version->version_number == 0)
+ return SVN_NO_ERROR;
+
+ SVN_ERR(svn_wc__diff7(FALSE /*anchor_at_given_paths*/,
+ ctx->wc_ctx, local_abspath,
+ depth,
+ ignore_ancestry,
+ NULL /*changelists*/,
+ diff_processor,
+ NULL, NULL, /*cancellation*/
+ scratch_pool, scratch_pool));
+ return SVN_NO_ERROR;
+}
+
+/* Populate the storage a new shelf-version object NEW_SHELF_VERSION,
+ * by creating a shelf storage WC with its base state copied from the
+ * 'real' WC.
+ */
+static svn_error_t *
+shelf_copy_base(svn_client__shelf_version_t *new_shelf_version,
+ apr_pool_t *scratch_pool)
+{
+ svn_client_ctx_t *ctx = new_shelf_version->shelf->ctx;
+ const char *users_wc_abspath = new_shelf_version->shelf->wc_root_abspath;
+ svn_client__pathrev_t *users_wc_root_base;
+ svn_opt_revision_t users_wc_root_rev;
+ svn_ra_session_t *ra_session = NULL;
+ svn_boolean_t sleep_here = FALSE;
+
+ SVN_ERR(svn_client__wc_node_get_base(&users_wc_root_base,
+ users_wc_abspath, ctx->wc_ctx,
+ scratch_pool, scratch_pool));
+
+ /* ### We need to read and recreate the mixed-rev, switched-URL,
+ mixed-depth WC state; but for a rough start we'll just use
+ HEAD, unswitched, depth-infinity. */
+ users_wc_root_rev.kind = svn_opt_revision_head;
+
+ /* ### TODO: Create an RA session that reads from the user's WC.
+ For a rough start, we'll just let 'checkout' read from the repo. */
+
+ SVN_ERR(svn_client__checkout_internal(NULL /*result_rev*/, &sleep_here,
+ users_wc_root_base->url,
+ new_shelf_version->files_dir_abspath,
+ &users_wc_root_rev, &users_wc_root_rev,
+ svn_depth_infinity,
+ TRUE /*ignore_externals*/,
+ FALSE /*allow_unver_obstructions*/,
+ ra_session,
+ ctx, scratch_pool));
+ /* ### hopefully we won't eventually need to sleep_here... */
+ if (sleep_here)
+ svn_io_sleep_for_timestamps(new_shelf_version->files_dir_abspath,
+ scratch_pool);
+ return SVN_NO_ERROR;
+}
+
+/* */
+struct shelf_save_notifer_baton_t
+{
+ svn_client__shelf_version_t *shelf_version;
+ svn_wc_notify_func2_t notify_func;
+ void *notify_baton;
+ svn_client_status_func_t shelved_func;
+ void *shelved_baton;
+ svn_boolean_t any_shelved;
+};
+
+/* */
+static void
+shelf_save_notifier(void *baton,
+ const svn_wc_notify_t *notify,
+ apr_pool_t *pool)
+{
+ struct shelf_save_notifer_baton_t *nb = baton;
+ const char *wc_relpath
+ = svn_dirent_skip_ancestor(nb->shelf_version->shelf->wc_root_abspath,
+ notify->path);
+ svn_client_status_t *cst = NULL;
+#if 0
+ svn_wc_status3_t *wc_status;
+
+ svn_error_clear(status_read(&wc_status, nb->shelf_version, wc_relpath,
+ pool, pool));
+ svn_error_clear(svn_client__create_status(
+ &cst, nb->shelf_version->shelf->ctx->wc_ctx,
+ notify->path, wc_status, pool, pool));
+#endif
+ svn_error_clear(nb->shelved_func(nb->shelved_baton, wc_relpath, cst, pool));
+ nb->any_shelved = TRUE;
+
+ nb->notify_func(nb->notify_baton, notify, pool);
+}
+
+svn_error_t *
+svn_client__shelf_save_new_version3(svn_client__shelf_version_t **new_version_p,
+ svn_client__shelf_t *shelf,
+ const apr_array_header_t *paths,
+ svn_depth_t depth,
+ const apr_array_header_t *changelists,
+ svn_client_status_func_t shelved_func,
+ void *shelved_baton,
+ svn_client_status_func_t not_shelved_func,
+ void *not_shelved_baton,
+ apr_pool_t *scratch_pool)
+{
+ svn_client_ctx_t *ctx = shelf->ctx;
+ int next_version = shelf->max_version + 1;
+ svn_client__shelf_version_t *new_shelf_version;
+ struct shelf_save_notifer_baton_t nb;
+ const svn_delta_editor_t *editor;
+ void *edit_baton;
+
+ SVN_ERR(shelf_version_create(&new_shelf_version,
+ shelf, next_version, scratch_pool));
+ SVN_ERR(shelf_copy_base(new_shelf_version, scratch_pool));
+
+ nb.shelf_version = new_shelf_version;
+ nb.notify_func = ctx->notify_func2;
+ nb.notify_baton = ctx->notify_baton2;
+ nb.shelved_func = shelved_func;
+ nb.shelved_baton = shelved_baton;
+ nb.any_shelved = FALSE;
+ SVN_ERR(svn_client__shelf_mods_editor(&editor, &edit_baton,
+ new_shelf_version,
+ NULL, NULL, /*notification*/
+ ctx, scratch_pool));
+ SVN_ERR(svn_client__wc_replay(shelf->wc_root_abspath,
+ paths, depth, changelists,
+ editor, edit_baton,
+ shelf_save_notifier, &nb,
+ ctx, scratch_pool));
+
+ if (nb.any_shelved)
+ {
+ shelf->max_version = next_version;
+ SVN_ERR(shelf_write_current(shelf, scratch_pool));
+
+ if (new_version_p)
+ SVN_ERR(svn_client__shelf_version_open(new_version_p, shelf, next_version,
+ scratch_pool, scratch_pool));
+ }
+ else
+ {
+ if (new_version_p)
+ *new_version_p = NULL;
+ }
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_get_log_message(char **log_message,
+ svn_client__shelf_t *shelf,
+ apr_pool_t *result_pool)
+{
+ svn_string_t *propval = svn_hash_gets(shelf->revprops, SVN_PROP_REVISION_LOG);
+
+ if (propval)
+ *log_message = apr_pstrdup(result_pool, propval->data);
+ else
+ *log_message = NULL;
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_set_log_message(svn_client__shelf_t *shelf,
+ const char *message,
+ apr_pool_t *scratch_pool)
+{
+ svn_string_t *propval
+ = message ? svn_string_create(message, shelf->pool) : NULL;
+
+ SVN_ERR(svn_client__shelf_revprop_set(shelf, SVN_PROP_REVISION_LOG, propval,
+ scratch_pool));
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_list(apr_hash_t **shelf_infos,
+ const char *local_abspath,
+ svn_client_ctx_t *ctx,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ const char *wc_root_abspath;
+ char *shelves_dir;
+ apr_hash_t *dirents;
+ apr_hash_index_t *hi;
+
+ SVN_ERR(svn_wc__get_wcroot(&wc_root_abspath, ctx->wc_ctx, local_abspath,
+ scratch_pool, scratch_pool));
+ SVN_ERR(get_shelves_dir(&shelves_dir, ctx->wc_ctx, local_abspath,
+ scratch_pool, scratch_pool));
+ SVN_ERR(svn_io_get_dirents3(&dirents, shelves_dir, FALSE /*only_check_type*/,
+ result_pool, scratch_pool));
+
+ *shelf_infos = apr_hash_make(result_pool);
+
+ /* Remove non-shelves */
+ for (hi = apr_hash_first(scratch_pool, dirents); hi; hi = apr_hash_next(hi))
+ {
+ const char *filename = apr_hash_this_key(hi);
+ svn_io_dirent2_t *dirent = apr_hash_this_val(hi);
+ char *name = NULL;
+
+ svn_error_clear(shelf_name_from_filename(&name, filename, result_pool));
+ if (name && dirent->kind == svn_node_file)
+ {
+ svn_client__shelf_info_t *info
+ = apr_palloc(result_pool, sizeof(*info));
+
+ info->mtime = dirent->mtime;
+ svn_hash_sets(*shelf_infos, name, info);
+ }
+ }
+
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_version_open(svn_client__shelf_version_t **shelf_version_p,
+ svn_client__shelf_t *shelf,
+ int version_number,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ svn_client__shelf_version_t *shelf_version;
+ const svn_io_dirent2_t *dirent;
+
+ SVN_ERR(shelf_version_create(&shelf_version,
+ shelf, version_number, result_pool));
+ SVN_ERR(svn_io_stat_dirent2(&dirent,
+ shelf_version->files_dir_abspath,
+ FALSE /*verify_truename*/,
+ TRUE /*ignore_enoent*/,
+ result_pool, scratch_pool));
+ if (dirent->kind == svn_node_none)
+ {
+ return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
+ _("Shelf '%s' version %d not found"),
+ shelf->name, version_number);
+ }
+ shelf_version->mtime = dirent->mtime;
+ *shelf_version_p = shelf_version;
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_get_newest_version(svn_client__shelf_version_t **shelf_version_p,
+ svn_client__shelf_t *shelf,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ if (shelf->max_version == 0)
+ {
+ *shelf_version_p = NULL;
+ return SVN_NO_ERROR;
+ }
+
+ SVN_ERR(svn_client__shelf_version_open(shelf_version_p,
+ shelf, shelf->max_version,
+ result_pool, scratch_pool));
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_client__shelf_get_all_versions(apr_array_header_t **versions_p,
+ svn_client__shelf_t *shelf,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ int i;
+
+ *versions_p = apr_array_make(result_pool, shelf->max_version - 1,
+ sizeof(svn_client__shelf_version_t *));
+
+ for (i = 1; i <= shelf->max_version; i++)
+ {
+ svn_client__shelf_version_t *shelf_version;
+
+ SVN_ERR(svn_client__shelf_version_open(&shelf_version,
+ shelf, i,
+ result_pool, scratch_pool));
+ APR_ARRAY_PUSH(*versions_p, svn_client__shelf_version_t *) = shelf_version;
+ }
+ return SVN_NO_ERROR;
+}