subversion/libsvn_client/shelf2.c

/*
 * shelf2.c:  implementation of shelving v2
 *
 * ====================================================================
 *    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_shelf2.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";
  int 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/v2", 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__shelf2_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.d", 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__shelf2_version_t **new_version_p,
                     svn_client__shelf2_t *shelf,
                     int version_number,
                     apr_pool_t *result_pool)
{
  svn_client__shelf2_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;
}

/* Set *ABSPATH to the abspath of the metadata file for SHELF_VERSION
 * node at RELPATH, no matter whether it exists.
 */
static svn_error_t *
get_metadata_abspath(char **abspath,
                     svn_client__shelf2_version_t *shelf_version,
                     const char *wc_relpath,
                     apr_pool_t *result_pool,
                     apr_pool_t *scratch_pool)
{
  wc_relpath = apr_psprintf(scratch_pool, "%s.meta", wc_relpath);
  *abspath = svn_dirent_join(shelf_version->files_dir_abspath, wc_relpath,
                             result_pool);
  return SVN_NO_ERROR;
}

/* Set *ABSPATH to the abspath of the base text file for SHELF_VERSION
 * node at RELPATH, no matter whether it exists.
 */
static svn_error_t *
get_base_file_abspath(char **base_abspath,
                      svn_client__shelf2_version_t *shelf_version,
                      const char *wc_relpath,
                      apr_pool_t *result_pool,
                      apr_pool_t *scratch_pool)
{
  wc_relpath = apr_psprintf(scratch_pool, "%s.base", wc_relpath);
  *base_abspath = svn_dirent_join(shelf_version->files_dir_abspath, wc_relpath,
                                  result_pool);
  return SVN_NO_ERROR;
}

/* Set *ABSPATH to the abspath of the working text file for SHELF_VERSION
 * node at RELPATH, no matter whether it exists.
 */
static svn_error_t *
get_working_file_abspath(char **work_abspath,
                         svn_client__shelf2_version_t *shelf_version,
                         const char *wc_relpath,
                         apr_pool_t *result_pool,
                         apr_pool_t *scratch_pool)
{
  wc_relpath = apr_psprintf(scratch_pool, "%s.work", wc_relpath);
  *work_abspath = svn_dirent_join(shelf_version->files_dir_abspath, wc_relpath,
                                  result_pool);
  return SVN_NO_ERROR;
}

/* Set *ABSPATH to the abspath of the base props file for SHELF_VERSION
 * node at RELPATH, no matter whether it exists.
 */
static svn_error_t *
get_base_props_abspath(char **base_abspath,
                       svn_client__shelf2_version_t *shelf_version,
                       const char *wc_relpath,
                       apr_pool_t *result_pool,
                       apr_pool_t *scratch_pool)
{
  wc_relpath = apr_psprintf(scratch_pool, "%s.base-props", wc_relpath);
  *base_abspath = svn_dirent_join(shelf_version->files_dir_abspath, wc_relpath,
                                  result_pool);
  return SVN_NO_ERROR;
}

/* Set *ABSPATH to the abspath of the working props file for SHELF_VERSION
 * node at RELPATH, no matter whether it exists.
 */
static svn_error_t *
get_working_props_abspath(char **work_abspath,
                          svn_client__shelf2_version_t *shelf_version,
                          const char *wc_relpath,
                          apr_pool_t *result_pool,
                          apr_pool_t *scratch_pool)
{
  wc_relpath = apr_psprintf(scratch_pool, "%s.work-props", wc_relpath);
  *work_abspath = svn_dirent_join(shelf_version->files_dir_abspath, wc_relpath,
                                  result_pool);
  return SVN_NO_ERROR;
}

/* Delete the storage for SHELF:VERSION. */
static svn_error_t *
shelf_version_delete(svn_client__shelf2_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__shelf2_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__shelf2_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__shelf2_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__shelf2_revprop_set(svn_client__shelf2_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__shelf2_revprop_set_all(svn_client__shelf2_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__shelf2_revprop_get(svn_string_t **prop_val,
                               svn_client__shelf2_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__shelf2_revprop_list(apr_hash_t **props,
                                svn_client__shelf2_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__shelf2_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__shelf2_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__shelf2_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 */

/* Create a status struct with all fields initialized to valid values
 * representing 'uninteresting' or 'unknown' status.
 */
static svn_wc_status3_t *
status_create(apr_pool_t *result_pool)
{
  svn_wc_status3_t *s = apr_pcalloc(result_pool, sizeof(*s));

  s->filesize = SVN_INVALID_FILESIZE;
  s->versioned = TRUE;
  s->node_status = svn_wc_status_none;
  s->text_status = svn_wc_status_none;
  s->prop_status = svn_wc_status_none;
  s->revision = SVN_INVALID_REVNUM;
  s->changed_rev = SVN_INVALID_REVNUM;
  s->repos_node_status = svn_wc_status_none;
  s->repos_text_status = svn_wc_status_none;
  s->repos_prop_status = svn_wc_status_none;
  s->ood_changed_rev = SVN_INVALID_REVNUM;
  return s;
}

/* Convert from svn_node_kind_t to a single character representation. */
static char
kind_to_char(svn_node_kind_t kind)
{
  return (kind == svn_node_dir ? 'd'
            : kind == svn_node_file ? 'f'
                : kind == svn_node_symlink ? 'l'
                    : '?');
}

/* Convert to svn_node_kind_t from a single character representation. */
static svn_node_kind_t
char_to_kind(char kind)
{
  return (kind == 'd' ? svn_node_dir
            : kind == 'f' ? svn_node_file
                : kind == 'l' ? svn_node_symlink
                    : svn_node_unknown);
}

/* Return the single character representation of STATUS.
 * (Similar to subversion/svn/status.c:generate_status_code()
 * and subversion/tests/libsvn_client/client-test.c:status_to_char().) */
static char
status_to_char(enum svn_wc_status_kind status)
{
  switch (status)
    {
    case svn_wc_status_none:        return '.';
    case svn_wc_status_unversioned: return '?';
    case svn_wc_status_normal:      return ' ';
    case svn_wc_status_added:       return 'A';
    case svn_wc_status_missing:     return '!';
    case svn_wc_status_deleted:     return 'D';
    case svn_wc_status_replaced:    return 'R';
    case svn_wc_status_modified:    return 'M';
    case svn_wc_status_merged:      return 'G';
    case svn_wc_status_conflicted:  return 'C';
    case svn_wc_status_ignored:     return 'I';
    case svn_wc_status_obstructed:  return '~';
    case svn_wc_status_external:    return 'X';
    case svn_wc_status_incomplete:  return ':';
    default:                        return '*';
    }
}

static enum svn_wc_status_kind
char_to_status(char status)
{
  switch (status)
    {
    case '.': return svn_wc_status_none;
    case '?': return svn_wc_status_unversioned;
    case ' ': return svn_wc_status_normal;
    case 'A': return svn_wc_status_added;
    case '!': return svn_wc_status_missing;
    case 'D': return svn_wc_status_deleted;
    case 'R': return svn_wc_status_replaced;
    case 'M': return svn_wc_status_modified;
    case 'G': return svn_wc_status_merged;
    case 'C': return svn_wc_status_conflicted;
    case 'I': return svn_wc_status_ignored;
    case '~': return svn_wc_status_obstructed;
    case 'X': return svn_wc_status_external;
    case ':': return svn_wc_status_incomplete;
    default:  return (enum svn_wc_status_kind)0;
    }
}

/* Write a serial representation of (some fields of) STATUS to STREAM.
 */
static svn_error_t *
wc_status_serialize(svn_stream_t *stream,
                    const svn_wc_status3_t *status,
                    apr_pool_t *scratch_pool)
{
  SVN_ERR(svn_stream_printf(stream, scratch_pool, "%c %c%c%c %ld",
                            kind_to_char(status->kind),
                            status_to_char(status->node_status),
                            status_to_char(status->text_status),
                            status_to_char(status->prop_status),
                            status->revision));
  return SVN_NO_ERROR;
}

/* Read a serial representation of (some fields of) STATUS from STREAM.
 */
static svn_error_t *
wc_status_unserialize(svn_wc_status3_t *status,
                      svn_stream_t *stream,
                      apr_pool_t *result_pool)
{
  svn_stringbuf_t *sb;
  char *string;

  SVN_ERR(svn_stringbuf_from_stream(&sb, stream, 100, result_pool));
  string = sb->data;
  status->kind = char_to_kind(string[0]);
  status->node_status = char_to_status(string[2]);
  status->text_status = char_to_status(string[3]);
  status->prop_status = char_to_status(string[4]);
  sscanf(string + 6, "%ld", &status->revision);
  return SVN_NO_ERROR;
}

/* Write status to shelf storage.
 */
static svn_error_t *
status_write(svn_client__shelf2_version_t *shelf_version,
             const char *relpath,
             const svn_wc_status3_t *status,
             apr_pool_t *scratch_pool)
{
  char *file_abspath;
  svn_stream_t *stream;

  SVN_ERR(get_metadata_abspath(&file_abspath, shelf_version, relpath,
                               scratch_pool, scratch_pool));
  SVN_ERR(svn_stream_open_writable(&stream, file_abspath,
                                   scratch_pool, scratch_pool));
  SVN_ERR(wc_status_serialize(stream, status, scratch_pool));
  SVN_ERR(svn_stream_close(stream));
  return SVN_NO_ERROR;
}

/* Read status from shelf storage.
 */
static svn_error_t *
status_read(svn_wc_status3_t **status,
            svn_client__shelf2_version_t *shelf_version,
            const char *relpath,
            apr_pool_t *result_pool,
            apr_pool_t *scratch_pool)
{
  svn_wc_status3_t *s = status_create(result_pool);
  char *file_abspath;
  svn_stream_t *stream;

  SVN_ERR(get_metadata_abspath(&file_abspath, shelf_version, relpath,
                               scratch_pool, scratch_pool));
  SVN_ERR(svn_stream_open_readonly(&stream, file_abspath,
                                   scratch_pool, scratch_pool));
  SVN_ERR(wc_status_unserialize(s, stream, result_pool));
  SVN_ERR(svn_stream_close(stream));

  s->changelist = apr_psprintf(result_pool, "svn:shelf:%s",
                               shelf_version->shelf->name);
  *status = s;
  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.
 * Only some fields in STATUS are available.
 */
typedef svn_error_t *(*shelf_status_visitor_t)(void *baton,
                                               const char *relpath,
                                               svn_wc_status3_t *status,
                                               apr_pool_t *scratch_pool);

/* Baton for shelved_files_walk_visitor(). */
struct shelf_status_baton_t
{
  svn_client__shelf2_version_t *shelf_version;
  const char *top_relpath;
  const char *walk_root_abspath;
  shelf_status_visitor_t walk_func;
  void *walk_baton;
};

/* Call BATON->walk_func(BATON->walk_baton, relpath, ...) for the shelved
 * 'binary' file stored at ABSPATH.
 * Implements svn_io_walk_func_t. */
static svn_error_t *
shelf_status_visitor(void *baton,
                     const char *abspath,
                     const apr_finfo_t *finfo,
                     apr_pool_t *scratch_pool)
{
  struct shelf_status_baton_t *b = baton;
  const char *relpath;

  relpath = svn_dirent_skip_ancestor(b->walk_root_abspath, abspath);
  if (finfo->filetype == APR_REG
      && (strlen(relpath) >= 5 && strcmp(relpath+strlen(relpath)-5, ".meta") == 0))
    {
      svn_wc_status3_t *s;

      relpath = apr_pstrndup(scratch_pool, relpath, strlen(relpath) - 5);
      if (!svn_relpath_skip_ancestor(b->top_relpath, relpath))
        return SVN_NO_ERROR;

      SVN_ERR(status_read(&s, b->shelf_version, relpath,
                          scratch_pool, scratch_pool));
      SVN_ERR(b->walk_func(b->walk_baton, relpath, s, 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__shelf2_version_t *shelf_version,
                        const char *wc_relpath,
                        shelf_status_visitor_t walk_func,
                        void *walk_baton,
                        apr_pool_t *scratch_pool)
{
  struct shelf_status_baton_t baton;
  char *abspath;
  apr_finfo_t finfo;

  baton.shelf_version = shelf_version;
  baton.top_relpath = wc_relpath;
  baton.walk_root_abspath = shelf_version->files_dir_abspath;
  baton.walk_func = walk_func;
  baton.walk_baton = walk_baton;
  SVN_ERR(get_metadata_abspath(&abspath, shelf_version, wc_relpath,
                               scratch_pool, scratch_pool));
  SVN_ERR(svn_io_stat(&finfo, abspath, APR_FINFO_TYPE, scratch_pool));
  SVN_ERR(shelf_status_visitor(&baton, abspath, &finfo, scratch_pool));
  return SVN_NO_ERROR;
}

/* Report the shelved status of all the shelved paths in SHELF_VERSION
 * via WALK_FUNC(WALK_BATON, ...).
 */
static svn_error_t *
shelf_status_walk(svn_client__shelf2_version_t *shelf_version,
                  const char *wc_relpath,
                  shelf_status_visitor_t walk_func,
                  void *walk_baton,
                  apr_pool_t *scratch_pool)
{
  struct shelf_status_baton_t baton;
  svn_error_t *err;

  baton.shelf_version = shelf_version;
  baton.top_relpath = wc_relpath;
  baton.walk_root_abspath = shelf_version->files_dir_abspath;
  baton.walk_func = walk_func;
  baton.walk_baton = walk_baton;
  err = svn_io_dir_walk2(baton.walk_root_abspath, 0 /*wanted*/,
                         shelf_status_visitor, &baton,
                         scratch_pool);
  if (err && APR_STATUS_IS_ENOENT(err->apr_err))
    svn_error_clear(err);
  else
    SVN_ERR(err);

  return SVN_NO_ERROR;
}

typedef struct wc_status_baton_t
{
  svn_client__shelf2_version_t *shelf_version;
  svn_wc_status_func4_t walk_func;
  void *walk_baton;
} wc_status_baton_t;

static svn_error_t *
wc_status_visitor(void *baton,
                      const char *relpath,
                      svn_wc_status3_t *status,
                      apr_pool_t *scratch_pool)
{
  struct wc_status_baton_t *b = baton;
  svn_client__shelf2_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__shelf2_version_status_walk(svn_client__shelf2_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 */

/* A baton for use with write_changes_visitor(). */
typedef struct write_changes_baton_t {
  const char *wc_root_abspath;
  svn_client__shelf2_version_t *shelf_version;
  svn_client_ctx_t *ctx;
  svn_boolean_t any_shelved;  /* were any paths successfully shelved? */
  svn_client_status_func_t was_shelved_func;
  void *was_shelved_baton;
  svn_client_status_func_t was_not_shelved_func;
  void *was_not_shelved_baton;
  apr_pool_t *pool;  /* pool for data in 'unshelvable', etc. */
} write_changes_baton_t;

/*  */
static svn_error_t *
notify_shelved(write_changes_baton_t *wb,
               const char *wc_relpath,
               const char *local_abspath,
               const svn_wc_status3_t *wc_status,
               apr_pool_t *scratch_pool)
{
  if (wb->was_shelved_func)
    {
      svn_client_status_t *cst;

      SVN_ERR(svn_client__create_status(&cst, wb->ctx->wc_ctx, local_abspath,
                                        wc_status,
                                        scratch_pool, scratch_pool));
      SVN_ERR(wb->was_shelved_func(wb->was_shelved_baton,
                                   wc_relpath, cst, scratch_pool));
    }

  wb->any_shelved = TRUE;
  return SVN_NO_ERROR;
}

/*  */
static svn_error_t *
notify_not_shelved(write_changes_baton_t *wb,
                   const char *wc_relpath,
                   const char *local_abspath,
                   const svn_wc_status3_t *wc_status,
                   apr_pool_t *scratch_pool)
{
  if (wb->was_not_shelved_func)
    {
      svn_client_status_t *cst;

      SVN_ERR(svn_client__create_status(&cst, wb->ctx->wc_ctx, local_abspath,
                                        wc_status,
                                        scratch_pool, scratch_pool));
      SVN_ERR(wb->was_not_shelved_func(wb->was_not_shelved_baton,
                                       wc_relpath, cst, scratch_pool));
    }

  return SVN_NO_ERROR;
}

/* Read BASE_PROPS and WORK_PROPS from the WC, setting each to null if
 * the node has no base or working version (respectively).
 */
static svn_error_t *
read_props_from_wc(apr_hash_t **base_props,
                   apr_hash_t **work_props,
                   enum svn_wc_status_kind node_status,
                   const char *from_wc_abspath,
                   svn_client_ctx_t *ctx,
                   apr_pool_t *result_pool,
                   apr_pool_t *scratch_pool)
{
  if (node_status != svn_wc_status_added)
    SVN_ERR(svn_wc_get_pristine_props(base_props, ctx->wc_ctx, from_wc_abspath,
                                      result_pool, scratch_pool));
  else
    *base_props = NULL;
  if (node_status != svn_wc_status_deleted)
    SVN_ERR(svn_wc_prop_list2(work_props, ctx->wc_ctx, from_wc_abspath,
                              result_pool, scratch_pool));
  else
    *work_props = NULL;
  return SVN_NO_ERROR;
}

/* Write BASE_PROPS and WORK_PROPS to storage in SHELF_VERSION:WC_RELPATH.
 */
static svn_error_t *
write_props_to_shelf(svn_client__shelf2_version_t *shelf_version,
                     const char *wc_relpath,
                     apr_hash_t *base_props,
                     apr_hash_t *work_props,
                     apr_pool_t *scratch_pool)
{
  char *stored_props_abspath;
  svn_stream_t *stream;

  if (base_props)
    {
      SVN_ERR(get_base_props_abspath(&stored_props_abspath,
                                     shelf_version, wc_relpath,
                                     scratch_pool, scratch_pool));
      SVN_ERR(svn_stream_open_writable(&stream, stored_props_abspath,
                                       scratch_pool, scratch_pool));
      SVN_ERR(svn_hash_write2(base_props, stream, NULL, scratch_pool));
      SVN_ERR(svn_stream_close(stream));
    }

  if (work_props)
    {
      SVN_ERR(get_working_props_abspath(&stored_props_abspath,
                                        shelf_version, wc_relpath,
                                        scratch_pool, scratch_pool));
      SVN_ERR(svn_stream_open_writable(&stream, stored_props_abspath,
                                       scratch_pool, scratch_pool));
      SVN_ERR(svn_hash_write2(work_props, stream, NULL, scratch_pool));
      SVN_ERR(svn_stream_close(stream));
    }

  return SVN_NO_ERROR;
}

/* Read BASE_PROPS and WORK_PROPS from storage in SHELF_VERSION:WC_RELPATH.
 */
static svn_error_t *
read_props_from_shelf(apr_hash_t **base_props,
                      apr_hash_t **work_props,
                      enum svn_wc_status_kind node_status,
                      svn_client__shelf2_version_t *shelf_version,
                      const char *wc_relpath,
                      apr_pool_t *result_pool,
                      apr_pool_t *scratch_pool)
{
  char *stored_props_abspath;
  svn_stream_t *stream;

  if (node_status != svn_wc_status_added)
    {
      *base_props = apr_hash_make(result_pool);
      SVN_ERR(get_base_props_abspath(&stored_props_abspath,
                                     shelf_version, wc_relpath,
                                     scratch_pool, scratch_pool));
      SVN_ERR(svn_stream_open_readonly(&stream, stored_props_abspath,
                                       scratch_pool, scratch_pool));
      SVN_ERR(svn_hash_read2(*base_props, stream, NULL, scratch_pool));
      SVN_ERR(svn_stream_close(stream));
    }
  else
    *base_props = NULL;

  if (node_status != svn_wc_status_deleted)
    {
      *work_props = apr_hash_make(result_pool);
      SVN_ERR(get_working_props_abspath(&stored_props_abspath,
                                        shelf_version, wc_relpath,
                                        scratch_pool, scratch_pool));
      SVN_ERR(svn_stream_open_readonly(&stream, stored_props_abspath,
                                       scratch_pool, scratch_pool));
      SVN_ERR(svn_hash_read2(*work_props, stream, NULL, scratch_pool));
      SVN_ERR(svn_stream_close(stream));
    }
  else
    *work_props = NULL;

  return SVN_NO_ERROR;
}

/* Store metadata for any node, and base and working files if it's a file.
 *
 * Copy the WC base and working files at FROM_WC_ABSPATH to the storage
 * area in SHELF_VERSION.
 */
static svn_error_t *
store_file(const char *from_wc_abspath,
           const char *wc_relpath,
           svn_client__shelf2_version_t *shelf_version,
           const svn_wc_status3_t *status,
           svn_client_ctx_t *ctx,
           apr_pool_t *scratch_pool)
{
  char *stored_abspath;
  apr_hash_t *base_props, *work_props;

  SVN_ERR(get_working_file_abspath(&stored_abspath,
                                   shelf_version, wc_relpath,
                                   scratch_pool, scratch_pool));
  SVN_ERR(svn_io_make_dir_recursively(svn_dirent_dirname(stored_abspath,
                                                         scratch_pool),
                                      scratch_pool));
  SVN_ERR(status_write(shelf_version, wc_relpath,
                       status, scratch_pool));

  /* properties */
  SVN_ERR(read_props_from_wc(&base_props, &work_props,
                             status->node_status,
                             from_wc_abspath, ctx,
                             scratch_pool, scratch_pool));
  SVN_ERR(write_props_to_shelf(shelf_version, wc_relpath,
                               base_props, work_props,
                               scratch_pool));

  /* file text */
  if (status->kind == svn_node_file)
    {
      svn_stream_t *wc_base_stream;
      svn_node_kind_t work_kind;

      /* Copy the base file (copy-from base, if copied/moved), if present */
      SVN_ERR(svn_wc_get_pristine_contents2(&wc_base_stream,
                                            ctx->wc_ctx, from_wc_abspath,
                                            scratch_pool, scratch_pool));
      if (wc_base_stream)
        {
          char *stored_base_abspath;
          svn_stream_t *stored_base_stream;

          SVN_ERR(get_base_file_abspath(&stored_base_abspath,
                                        shelf_version, wc_relpath,
                                        scratch_pool, scratch_pool));
          SVN_ERR(svn_stream_open_writable(&stored_base_stream,
                                           stored_base_abspath,
                                           scratch_pool, scratch_pool));
          SVN_ERR(svn_stream_copy3(wc_base_stream, stored_base_stream,
                                   NULL, NULL, scratch_pool));
        }

      /* Copy the working file, if present */
      SVN_ERR(svn_io_check_path(from_wc_abspath, &work_kind, scratch_pool));
      if (work_kind == svn_node_file)
        {
          SVN_ERR(svn_io_copy_file(from_wc_abspath, stored_abspath,
                                   TRUE /*copy_perms*/, scratch_pool));
        }
    }
  return SVN_NO_ERROR;
}

/* An implementation of svn_wc_status_func4_t. */
static svn_error_t *
write_changes_visitor(void *baton,
                      const char *local_abspath,
                      const svn_wc_status3_t *status,
                      apr_pool_t *scratch_pool)
{
  write_changes_baton_t *wb = baton;
  const char *wc_relpath = svn_dirent_skip_ancestor(wb->wc_root_abspath,
                                                    local_abspath);

  /* Catch any conflict, even a tree conflict on a path that has
     node-status 'unversioned'. */
  if (status->conflicted)
    {
      SVN_ERR(notify_not_shelved(wb, wc_relpath, local_abspath,
                                 status, scratch_pool));
    }
  else switch (status->node_status)
    {
      case svn_wc_status_deleted:
      case svn_wc_status_added:
      case svn_wc_status_replaced:
        if (status->kind != svn_node_file
            || status->copied)
          {
            SVN_ERR(notify_not_shelved(wb, wc_relpath, local_abspath,
                                       status, scratch_pool));
            break;
          }
        /* fall through */
      case svn_wc_status_modified:
      {
        /* Store metadata, and base and working versions if it's a file */
        SVN_ERR(store_file(local_abspath, wc_relpath, wb->shelf_version,
                           status, wb->ctx, scratch_pool));
        SVN_ERR(notify_shelved(wb, wc_relpath, local_abspath,
                               status, scratch_pool));
        break;
      }

      case svn_wc_status_incomplete:
        if ((status->text_status != svn_wc_status_normal
             && status->text_status != svn_wc_status_none)
            || (status->prop_status != svn_wc_status_normal
                && status->prop_status != svn_wc_status_none))
          {
            /* Incomplete, but local modifications */
            SVN_ERR(notify_not_shelved(wb, wc_relpath, local_abspath,
                                       status, scratch_pool));
          }
        break;

      case svn_wc_status_conflicted:
      case svn_wc_status_missing:
      case svn_wc_status_obstructed:
        SVN_ERR(notify_not_shelved(wb, wc_relpath, local_abspath,
                                   status, scratch_pool));
        break;

      case svn_wc_status_normal:
      case svn_wc_status_ignored:
      case svn_wc_status_none:
      case svn_wc_status_external:
      case svn_wc_status_unversioned:
      default:
        break;
    }

  return SVN_NO_ERROR;
}

/* A baton for use with changelist_filter_func(). */
struct changelist_filter_baton_t {
  apr_hash_t *changelist_hash;
  svn_wc_status_func4_t status_func;
  void *status_baton;
};

/* Filter out paths that are not in the requested changelist(s).
 * Implements svn_wc_status_func4_t. */
static svn_error_t *
changelist_filter_func(void *baton,
                       const char *local_abspath,
                       const svn_wc_status3_t *status,
                       apr_pool_t *scratch_pool)
{
  struct changelist_filter_baton_t *b = baton;

  if (b->changelist_hash
      && (! status->changelist
          || ! svn_hash_gets(b->changelist_hash, status->changelist)))
    {
      return SVN_NO_ERROR;
    }

  SVN_ERR(b->status_func(b->status_baton, local_abspath, status,
                         scratch_pool));
  return SVN_NO_ERROR;
}

/*
 * Walk the WC tree(s) rooted at PATHS, to depth DEPTH, omitting paths that
 * are not in one of the CHANGELISTS (if not null).
 *
 * Call STATUS_FUNC(STATUS_BATON, ...) for each visited path.
 *
 * PATHS are absolute, or relative to CWD.
 */
static svn_error_t *
wc_walk_status_multi(const apr_array_header_t *paths,
                     svn_depth_t depth,
                     const apr_array_header_t *changelists,
                     svn_wc_status_func4_t status_func,
                     void *status_baton,
                     svn_client_ctx_t *ctx,
                     apr_pool_t *scratch_pool)
{
  struct changelist_filter_baton_t cb = {0};
  int i;

  if (changelists && changelists->nelts)
    SVN_ERR(svn_hash_from_cstring_keys(&cb.changelist_hash,
                                       changelists, scratch_pool));
  cb.status_func = status_func;
  cb.status_baton = status_baton;

  for (i = 0; i < paths->nelts; i++)
    {
      const char *path = APR_ARRAY_IDX(paths, i, const char *);

      if (svn_path_is_url(path))
        return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
                                 _("'%s' is not a local path"), path);
      SVN_ERR(svn_dirent_get_absolute(&path, path, scratch_pool));

      SVN_ERR(svn_wc_walk_status(ctx->wc_ctx, path, depth,
                                 FALSE /*get_all*/, FALSE /*no_ignore*/,
                                 FALSE /*ignore_text_mods*/,
                                 NULL /*ignore_patterns*/,
                                 changelist_filter_func, &cb,
                                 ctx->cancel_func, ctx->cancel_baton,
                                 scratch_pool));
    }

  return SVN_NO_ERROR;
}

/** Write local changes to the shelf storage.
 *
 * @a paths, @a depth, @a changelists: The selection of local paths to diff.
 *
 * @a paths are relative to CWD (or absolute).
 */
static svn_error_t *
shelf_write_changes(svn_boolean_t *any_shelved,
                    svn_client__shelf2_version_t *shelf_version,
                    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,
                    const char *wc_root_abspath,
                    svn_client_ctx_t *ctx,
                    apr_pool_t *result_pool,
                    apr_pool_t *scratch_pool)
{
  write_changes_baton_t wb = { 0 };

  wb.wc_root_abspath = wc_root_abspath;
  wb.shelf_version = shelf_version;
  wb.ctx = ctx;
  wb.any_shelved = FALSE;
  wb.was_shelved_func = shelved_func;
  wb.was_shelved_baton = shelved_baton;
  wb.was_not_shelved_func = not_shelved_func;
  wb.was_not_shelved_baton = not_shelved_baton;
  wb.pool = result_pool;

  /* Walk the WC */
  SVN_ERR(wc_walk_status_multi(paths, depth, changelists,
                               write_changes_visitor, &wb,
                               ctx, scratch_pool));

  *any_shelved = wb.any_shelved;
  return SVN_NO_ERROR;
}

/* 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__shelf2_t **shelf_p,
                const char *name,
                const char *local_abspath,
                svn_client_ctx_t *ctx,
                apr_pool_t *result_pool)
{
  svn_client__shelf2_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__shelf2_open_existing(svn_client__shelf2_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__shelf2_open_or_create(svn_client__shelf2_t **shelf_p,
                                  const char *name,
                                  const char *local_abspath,
                                  svn_client_ctx_t *ctx,
                                  apr_pool_t *result_pool)
{
  svn_client__shelf2_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__shelf2_close(svn_client__shelf2_t *shelf,
                         apr_pool_t *scratch_pool)
{
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf2_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__shelf2_t *shelf;
  int i;
  char *abspath;

  SVN_ERR(svn_client__shelf2_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__shelf2_close(shelf, scratch_pool));
  return SVN_NO_ERROR;
}

/* Baton for paths_changed_visitor(). */
struct paths_changed_walk_baton_t
{
  apr_hash_t *paths_hash;
  svn_boolean_t as_abspath;
  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,
                      svn_wc_status3_t *s,
                      apr_pool_t *scratch_pool)
{
  struct paths_changed_walk_baton_t *b = baton;

  relpath = (b->as_abspath
             ? svn_dirent_join(b->wc_root_abspath, relpath, b->pool)
             : 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__shelf2_version_t *shelf_version,
                    svn_boolean_t as_abspath,
                    apr_pool_t *result_pool,
                    apr_pool_t *scratch_pool)
{
  svn_client__shelf2_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.as_abspath = as_abspath;
  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__shelf2_paths_changed(apr_hash_t **affected_paths,
                                 svn_client__shelf2_version_t *shelf_version,
                                 apr_pool_t *result_pool,
                                 apr_pool_t *scratch_pool)
{
  SVN_ERR(shelf_paths_changed(affected_paths, NULL, shelf_version,
                              FALSE /*as_abspath*/,
                              result_pool, scratch_pool));
  return SVN_NO_ERROR;
}

/* Send a notification */
static svn_error_t *
send_notification(const char *local_abspath,
                  svn_wc_notify_action_t action,
                  svn_node_kind_t kind,
                  svn_wc_notify_state_t content_state,
                  svn_wc_notify_state_t prop_state,
                  svn_wc_notify_func2_t notify_func,
                  void *notify_baton,
                  apr_pool_t *scratch_pool)
{
  if (notify_func)
    {
      svn_wc_notify_t *notify
        = svn_wc_create_notify(local_abspath, action, scratch_pool);

      notify->kind = kind;
      notify->content_state = content_state;
      notify->prop_state = prop_state;
      notify_func(notify_baton, notify, scratch_pool);
    }

  return SVN_NO_ERROR;
}

/* Merge a shelved change into WC_ABSPATH.
 */
static svn_error_t *
wc_file_merge(const char *wc_abspath,
              const char *left_file,
              const char *right_file,
              /*const*/ apr_hash_t *left_props,
              /*const*/ apr_hash_t *right_props,
              svn_client_ctx_t *ctx,
              apr_pool_t *scratch_pool)
{
  svn_wc_notify_state_t property_state;
  svn_boolean_t has_local_mods;
  enum svn_wc_merge_outcome_t content_outcome;
  const char *target_label, *left_label, *right_label;
  apr_array_header_t *prop_changes;

  /* xgettext: the '.working', '.merge-left' and '.merge-right' strings
     are used to tag onto a file name in case of a merge conflict */
  target_label = apr_psprintf(scratch_pool, _(".working"));
  left_label = apr_psprintf(scratch_pool, _(".merge-left"));
  right_label = apr_psprintf(scratch_pool, _(".merge-right"));

  SVN_ERR(svn_prop_diffs(&prop_changes, right_props, left_props, scratch_pool));
  SVN_ERR(svn_wc_text_modified_p2(&has_local_mods, ctx->wc_ctx,
                                  wc_abspath, FALSE, scratch_pool));

  /* Do property merge and text merge in one step so that keyword expansion
     takes into account the new property values. */
  SVN_WC__CALL_WITH_WRITE_LOCK(
    svn_wc_merge5(&content_outcome, &property_state, ctx->wc_ctx,
                  left_file, right_file, wc_abspath,
                  left_label, right_label, target_label,
                  NULL, NULL, /*left, right conflict-versions*/
                  FALSE /*dry_run*/, NULL /*diff3_cmd*/,
                  NULL /*merge_options*/,
                  left_props, prop_changes,
                  NULL, NULL,
                  ctx->cancel_func, ctx->cancel_baton,
                  scratch_pool),
    ctx->wc_ctx, wc_abspath,
    FALSE /*lock_anchor*/, scratch_pool);

  return SVN_NO_ERROR;
}

/* Merge a shelved change (of properties) into the dir at WC_ABSPATH.
 */
static svn_error_t *
wc_dir_props_merge(const char *wc_abspath,
                   /*const*/ apr_hash_t *left_props,
                   /*const*/ apr_hash_t *right_props,
                   svn_client_ctx_t *ctx,
                   apr_pool_t *result_pool,
                   apr_pool_t *scratch_pool)
{
  apr_array_header_t *prop_changes;
  svn_wc_notify_state_t property_state;

  SVN_ERR(svn_prop_diffs(&prop_changes, right_props, left_props, scratch_pool));
  SVN_WC__CALL_WITH_WRITE_LOCK(
    svn_wc_merge_props3(&property_state, ctx->wc_ctx,
                        wc_abspath,
                        NULL, NULL, /*left, right conflict-versions*/
                        left_props, prop_changes,
                        FALSE /*dry_run*/,
                        NULL, NULL,
                        ctx->cancel_func, ctx->cancel_baton,
                        scratch_pool),
    ctx->wc_ctx, wc_abspath,
    FALSE /*lock_anchor*/, scratch_pool);

  return SVN_NO_ERROR;
}

/* Apply a shelved "delete" to TO_WC_ABSPATH.
 */
static svn_error_t *
wc_node_delete(const char *to_wc_abspath,
               svn_client_ctx_t *ctx,
               apr_pool_t *scratch_pool)
{
  SVN_WC__CALL_WITH_WRITE_LOCK(
    svn_wc_delete4(ctx->wc_ctx,
                   to_wc_abspath,
                   FALSE /*keep_local*/,
                   TRUE /*delete_unversioned_target*/,
                   NULL, NULL, NULL, NULL, /*cancel, notify*/
                   scratch_pool),
    ctx->wc_ctx, to_wc_abspath,
    TRUE /*lock_anchor*/, scratch_pool);
  return SVN_NO_ERROR;
}

/* Apply a shelved "add" to TO_WC_ABSPATH.
 * The node must already exist on disk, in a versioned parent dir.
 */
static svn_error_t *
wc_node_add(const char *to_wc_abspath,
            apr_hash_t *work_props,
            svn_client_ctx_t *ctx,
            apr_pool_t *scratch_pool)
{
  /* If it was not already versioned, schedule the node for addition.
     (Do not apply autoprops, because this isn't a user-facing "add" but
     restoring a previously saved state.) */
  SVN_WC__CALL_WITH_WRITE_LOCK(
    svn_wc_add_from_disk3(ctx->wc_ctx,
                          to_wc_abspath, work_props,
                          FALSE /* skip checks */,
                          NULL, NULL, scratch_pool),
    ctx->wc_ctx, to_wc_abspath,
    TRUE /*lock_anchor*/, scratch_pool);
  return SVN_NO_ERROR;
}

/* Baton for apply_file_visitor(). */
struct apply_files_baton_t
{
  svn_client__shelf2_version_t *shelf_version;
  svn_boolean_t test_only;  /* only check whether it would conflict */
  svn_boolean_t conflict;  /* would it conflict? */
  svn_client_ctx_t *ctx;
};

/* Copy the file RELPATH from shelf binary file storage to the WC.
 *
 * If it is not already versioned, schedule the file for addition.
 *
 * Make any missing parent directories.
 *
 * In test mode (BATON->test_only): set BATON->conflict if we can't apply
 * the 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 *
apply_file_visitor(void *baton,
                   const char *relpath,
                   svn_wc_status3_t *s,
                   apr_pool_t *scratch_pool)
{
  struct apply_files_baton_t *b = baton;
  const char *wc_root_abspath = b->shelf_version->shelf->wc_root_abspath;
  char *stored_base_abspath, *stored_work_abspath;
  apr_hash_t *base_props, *work_props;
  const char *to_wc_abspath = svn_dirent_join(wc_root_abspath, relpath,
                                              scratch_pool);
  const char *to_dir_abspath = svn_dirent_dirname(to_wc_abspath, scratch_pool);

  SVN_ERR(get_base_file_abspath(&stored_base_abspath,
                                b->shelf_version, relpath,
                                scratch_pool, scratch_pool));
  SVN_ERR(get_working_file_abspath(&stored_work_abspath,
                                   b->shelf_version, relpath,
                                   scratch_pool, scratch_pool));
  SVN_ERR(read_props_from_shelf(&base_props, &work_props,
                                s->node_status,
                                b->shelf_version, relpath,
                                scratch_pool, scratch_pool));

  if (b->test_only)
    {
      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;
    }

  /* Handle 'delete' and the delete half of 'replace' */
  if (s->node_status == svn_wc_status_deleted
      || s->node_status == svn_wc_status_replaced)
    {
      SVN_ERR(wc_node_delete(to_wc_abspath, b->ctx, scratch_pool));
      if (s->node_status != svn_wc_status_replaced)
        {
          SVN_ERR(send_notification(to_wc_abspath, svn_wc_notify_update_delete,
                                    s->kind,
                                    svn_wc_notify_state_inapplicable,
                                    svn_wc_notify_state_inapplicable,
                                    b->ctx->notify_func2, b->ctx->notify_baton2,
                                    scratch_pool));
        }
    }

  /* If we can merge a file, do so. */
  if (s->node_status == svn_wc_status_modified)
    {
      if (s->kind == svn_node_dir)
        {
          SVN_ERR(wc_dir_props_merge(to_wc_abspath,
                                     base_props, work_props,
                                     b->ctx, scratch_pool, scratch_pool));
        }
      else if (s->kind == svn_node_file)
        {
          SVN_ERR(wc_file_merge(to_wc_abspath,
                                stored_base_abspath, stored_work_abspath,
                                base_props, work_props,
                                b->ctx, scratch_pool));
        }
      SVN_ERR(send_notification(to_wc_abspath, svn_wc_notify_update_update,
                                s->kind,
                                (s->kind == svn_node_dir)
                                  ? svn_wc_notify_state_inapplicable
                                  : svn_wc_notify_state_merged,
                                (s->kind == svn_node_dir)
                                  ? svn_wc_notify_state_merged
                                  : svn_wc_notify_state_unknown,
                                b->ctx->notify_func2, b->ctx->notify_baton2,
                                scratch_pool));
    }

  /* For an added file, copy it into the WC and ensure it's versioned. */
  if (s->node_status == svn_wc_status_added
      || s->node_status == svn_wc_status_replaced)
    {
      if (s->kind == svn_node_dir)
        {
          SVN_ERR(svn_io_make_dir_recursively(to_wc_abspath, scratch_pool));
        }
      else if (s->kind == svn_node_file)
        {
          SVN_ERR(svn_io_make_dir_recursively(to_dir_abspath, scratch_pool));
          SVN_ERR(svn_io_copy_file(stored_work_abspath, to_wc_abspath,
                                   TRUE /*copy_perms*/, scratch_pool));
        }
      SVN_ERR(wc_node_add(to_wc_abspath, work_props, b->ctx, scratch_pool));
      SVN_ERR(send_notification(to_wc_abspath,
                                (s->node_status == svn_wc_status_replaced)
                                  ? svn_wc_notify_update_replace
                                  : svn_wc_notify_update_add,
                                s->kind,
                                svn_wc_notify_state_inapplicable,
                                svn_wc_notify_state_inapplicable,
                                b->ctx->notify_func2, b->ctx->notify_baton2,
                                scratch_pool));
    }

  return SVN_NO_ERROR;
}

/*-------------------------------------------------------------------------*/
/* Diff */

/*  */
static svn_error_t *
file_changed(svn_client__shelf2_version_t *shelf_version,
             const char *relpath,
             svn_wc_status3_t *s,
             const svn_diff_tree_processor_t *diff_processor,
             svn_diff_source_t *left_source,
             svn_diff_source_t *right_source,
             const char *left_stored_abspath,
             const char *right_stored_abspath,
             void *dir_baton,
             apr_pool_t *scratch_pool)
{
  void *fb;
  svn_boolean_t skip = FALSE;

  SVN_ERR(diff_processor->file_opened(&fb, &skip, relpath,
                                      left_source, right_source,
                                      NULL /*copyfrom*/,
                                      dir_baton, diff_processor,
                                      scratch_pool, scratch_pool));
  if (!skip)
    {
      apr_hash_t *left_props, *right_props;
      apr_array_header_t *prop_changes;

      SVN_ERR(read_props_from_shelf(&left_props, &right_props,
                                    s->node_status, shelf_version, relpath,
                                    scratch_pool, scratch_pool));
      SVN_ERR(svn_prop_diffs(&prop_changes, right_props, left_props,
                             scratch_pool));
      SVN_ERR(diff_processor->file_changed(
                relpath,
                left_source, right_source,
                left_stored_abspath, right_stored_abspath,
                left_props, right_props,
                TRUE /*file_modified*/, prop_changes,
                fb, diff_processor, scratch_pool));
    }

  return SVN_NO_ERROR;
}

/*  */
static svn_error_t *
file_deleted(svn_client__shelf2_version_t *shelf_version,
             const char *relpath,
             svn_wc_status3_t *s,
             const svn_diff_tree_processor_t *diff_processor,
             svn_diff_source_t *left_source,
             const char *left_stored_abspath,
             void *dir_baton,
             apr_pool_t *scratch_pool)
{
  void *fb;
  svn_boolean_t skip = FALSE;

  SVN_ERR(diff_processor->file_opened(&fb, &skip, relpath,
                                      left_source, NULL, NULL /*copyfrom*/,
                                      dir_baton, diff_processor,
                                      scratch_pool, scratch_pool));
  if (!skip)
    {
      apr_hash_t *left_props, *right_props;

      SVN_ERR(read_props_from_shelf(&left_props, &right_props,
                                    s->node_status, shelf_version, relpath,
                                    scratch_pool, scratch_pool));
      SVN_ERR(diff_processor->file_deleted(relpath,
                                           left_source,
                                           left_stored_abspath,
                                           left_props,
                                           fb, diff_processor,
                                           scratch_pool));
    }

  return SVN_NO_ERROR;
}

/*  */
static svn_error_t *
file_added(svn_client__shelf2_version_t *shelf_version,
           const char *relpath,
           svn_wc_status3_t *s,
           const svn_diff_tree_processor_t *diff_processor,
           svn_diff_source_t *right_source,
           const char *right_stored_abspath,
           void *dir_baton,
           apr_pool_t *scratch_pool)
{
  void *fb;
  svn_boolean_t skip = FALSE;

  SVN_ERR(diff_processor->file_opened(&fb, &skip, relpath,
                                      NULL, right_source, NULL /*copyfrom*/,
                                      dir_baton, diff_processor,
                                      scratch_pool, scratch_pool));
  if (!skip)
    {
      apr_hash_t *left_props, *right_props;

      SVN_ERR(read_props_from_shelf(&left_props, &right_props,
                                    s->node_status, shelf_version, relpath,
                                    scratch_pool, scratch_pool));
      SVN_ERR(diff_processor->file_added(
                relpath,
                NULL /*copyfrom_source*/, right_source,
                NULL /*copyfrom_abspath*/, right_stored_abspath,
                NULL /*copyfrom_props*/, right_props,
                fb, diff_processor, scratch_pool));
    }

  return SVN_NO_ERROR;
}

/* Baton for diff_visitor(). */
struct diff_baton_t
{
  svn_client__shelf2_version_t *shelf_version;
  const char *top_relpath;  /* top of diff, relative to shelf */
  const char *walk_root_abspath;
  const svn_diff_tree_processor_t *diff_processor;
};

/* Drive BATON->diff_processor.
 * Implements svn_io_walk_func_t. */
static svn_error_t *
diff_visitor(void *baton,
             const char *abspath,
             const apr_finfo_t *finfo,
             apr_pool_t *scratch_pool)
{
  struct diff_baton_t *b = baton;
  const char *relpath;

  relpath = svn_dirent_skip_ancestor(b->walk_root_abspath, abspath);
  if (finfo->filetype == APR_REG
           && (strlen(relpath) >= 5 && strcmp(relpath+strlen(relpath)-5, ".meta") == 0))
    {
      svn_wc_status3_t *s;
      void *db = NULL;
      svn_diff_source_t *left_source;
      svn_diff_source_t *right_source;
      char *left_stored_abspath, *right_stored_abspath;

      relpath = apr_pstrndup(scratch_pool, relpath, strlen(relpath) - 5);
      if (!svn_relpath_skip_ancestor(b->top_relpath, relpath))
        return SVN_NO_ERROR;

      SVN_ERR(status_read(&s, b->shelf_version, relpath,
                          scratch_pool, scratch_pool));

      left_source = svn_diff__source_create(s->revision, scratch_pool);
      right_source = svn_diff__source_create(SVN_INVALID_REVNUM, scratch_pool);
      SVN_ERR(get_base_file_abspath(&left_stored_abspath,
                                    b->shelf_version, relpath,
                                    scratch_pool, scratch_pool));
      SVN_ERR(get_working_file_abspath(&right_stored_abspath,
                                       b->shelf_version, relpath,
                                       scratch_pool, scratch_pool));

      switch (s->node_status)
        {
        case svn_wc_status_modified:
          SVN_ERR(file_changed(b->shelf_version, relpath, s,
                               b->diff_processor,
                               left_source, right_source,
                               left_stored_abspath, right_stored_abspath,
                               db, scratch_pool));
          break;
        case svn_wc_status_added:
          SVN_ERR(file_added(b->shelf_version, relpath, s,
                             b->diff_processor,
                             right_source, right_stored_abspath,
                             db, scratch_pool));
          break;
        case svn_wc_status_deleted:
          SVN_ERR(file_deleted(b->shelf_version, relpath, s,
                               b->diff_processor,
                               left_source, left_stored_abspath,
                               db, scratch_pool));
          break;
        case svn_wc_status_replaced:
          SVN_ERR(file_deleted(b->shelf_version, relpath, s,
                               b->diff_processor,
                               left_source, left_stored_abspath,
                               db, scratch_pool));
          SVN_ERR(file_added(b->shelf_version, relpath, s,
                             b->diff_processor,
                             right_source, right_stored_abspath,
                             db, scratch_pool));
        default:
          break;
        }
    }
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf2_test_apply_file(svn_boolean_t *conflict_p,
                                   svn_client__shelf2_version_t *shelf_version,
                                   const char *file_relpath,
                                   apr_pool_t *scratch_pool)
{
  struct apply_files_baton_t baton = {0};

  baton.shelf_version = shelf_version;
  baton.test_only = TRUE;
  baton.conflict = FALSE;
  baton.ctx = shelf_version->shelf->ctx;
  SVN_ERR(shelf_status_visit_path(shelf_version, file_relpath,
                           apply_file_visitor, &baton,
                           scratch_pool));
  *conflict_p = baton.conflict;

  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf2_apply(svn_client__shelf2_version_t *shelf_version,
                         svn_boolean_t dry_run,
                         apr_pool_t *scratch_pool)
{
  struct apply_files_baton_t baton = {0};

  baton.shelf_version = shelf_version;
  baton.ctx = shelf_version->shelf->ctx;
  SVN_ERR(shelf_status_walk(shelf_version, "",
                            apply_file_visitor, &baton,
                            scratch_pool));

  svn_io_sleep_for_timestamps(shelf_version->shelf->wc_root_abspath,
                              scratch_pool);
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf2_unapply(svn_client__shelf2_version_t *shelf_version,
                           svn_boolean_t dry_run,
                           apr_pool_t *scratch_pool)
{
  apr_array_header_t *targets;

  SVN_ERR(shelf_paths_changed(NULL, &targets, shelf_version,
                              TRUE /*as_abspath*/,
                              scratch_pool, scratch_pool));
  if (!dry_run)
    {
      SVN_ERR(svn_client_revert4(targets, svn_depth_empty,
                                 NULL /*changelists*/,
                                 FALSE /*clear_changelists*/,
                                 FALSE /*metadata_only*/,
                                 FALSE /*added_keep_local*/,
                                 shelf_version->shelf->ctx, scratch_pool));
    }
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf2_delete_newer_versions(svn_client__shelf2_t *shelf,
                                         svn_client__shelf2_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__shelf2_diff(svn_client__shelf2_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)
{
  struct diff_baton_t baton;

  if (shelf_version->version_number == 0)
    return SVN_NO_ERROR;

  baton.shelf_version = shelf_version;
  baton.top_relpath = shelf_relpath;
  baton.walk_root_abspath = shelf_version->files_dir_abspath;
  baton.diff_processor = diff_processor;
  SVN_ERR(svn_io_dir_walk2(baton.walk_root_abspath, 0 /*wanted*/,
                           diff_visitor, &baton,
                           scratch_pool));

  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf2_save_new_version3(svn_client__shelf2_version_t **new_version_p,
                                     svn_client__shelf2_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)
{
  int next_version = shelf->max_version + 1;
  svn_client__shelf2_version_t *new_shelf_version;
  svn_boolean_t any_shelved;

  SVN_ERR(shelf_version_create(&new_shelf_version,
                               shelf, next_version, scratch_pool));
  SVN_ERR(shelf_write_changes(&any_shelved,
                              new_shelf_version,
                              paths, depth, changelists,
                              shelved_func, shelved_baton,
                              not_shelved_func, not_shelved_baton,
                              shelf->wc_root_abspath,
                              shelf->ctx, scratch_pool, scratch_pool));

  if (any_shelved)
    {
      shelf->max_version = next_version;
      SVN_ERR(shelf_write_current(shelf, scratch_pool));

      if (new_version_p)
        SVN_ERR(svn_client__shelf2_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__shelf2_get_log_message(char **log_message,
                                   svn_client__shelf2_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__shelf2_set_log_message(svn_client__shelf2_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__shelf2_revprop_set(shelf, SVN_PROP_REVISION_LOG, propval,
                                         scratch_pool));
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf2_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__shelf2_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__shelf2_version_open(svn_client__shelf2_version_t **shelf_version_p,
                                svn_client__shelf2_t *shelf,
                                int version_number,
                                apr_pool_t *result_pool,
                                apr_pool_t *scratch_pool)
{
  svn_client__shelf2_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__shelf2_get_newest_version(svn_client__shelf2_version_t **shelf_version_p,
                                      svn_client__shelf2_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__shelf2_version_open(shelf_version_p,
                                          shelf, shelf->max_version,
                                          result_pool, scratch_pool));
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf2_get_all_versions(apr_array_header_t **versions_p,
                                    svn_client__shelf2_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__shelf2_version_t *));

  for (i = 1; i <= shelf->max_version; i++)
    {
      svn_client__shelf2_version_t *shelf_version;

      SVN_ERR(svn_client__shelf2_version_open(&shelf_version,
                                              shelf, i,
                                              result_pool, scratch_pool));
      APR_ARRAY_PUSH(*versions_p, svn_client__shelf2_version_t *) = shelf_version;
    }
  return SVN_NO_ERROR;
}