/*
* svn_tests_editor.c: a `dummy' editor implementation for testing
*
* ====================================================================
* Copyright (c) 2000-2004 CollabNet. All rights reserved.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
* are also available at http://subversion.tigris.org/license-1.html.
* If newer versions of this license are posted there, you may use a
* newer version instead, at your option.
*
* This software consists of voluntary contributions made by many
* individuals. For exact contribution history, see the revision
* history and logs, available at http://subversion.tigris.org/.
* ====================================================================
*/
/* ==================================================================== */
#include <stdio.h>
#include <string.h>
#include <apr_pools.h>
#include <apr_file_io.h>
#include "svn_types.h"
#include "svn_test.h"
#include "svn_error.h"
#include "svn_path.h"
#include "svn_delta.h"
struct edit_baton
{
const char *root_path;
const char *editor_name;
svn_stream_t *out_stream;
apr_pool_t *pool;
int indentation;
svn_boolean_t verbose;
};
struct node_baton
{
struct edit_baton *edit_baton;
struct node_baton *parent_baton;
int indent_level;
const char *path;
};
/* Print newline character to EB->outstream. */
static svn_error_t *
newline(struct edit_baton *eb)
{
apr_size_t len = 1;
return svn_stream_write(eb->out_stream, "\n", &len);
}
/* Print EB->indentation * LEVEL spaces, followed by STR,
to EB->out_stream. */
static svn_error_t *
print(struct edit_baton *eb, int level, svn_stringbuf_t *str)
{
apr_size_t len;
int i;
len = 1;
for (i = 0; i < (eb->indentation * level); i++)
SVN_ERR(svn_stream_write(eb->out_stream, " ", &len));
len = str->len;
SVN_ERR(svn_stream_write(eb->out_stream, str->data, &len));
return SVN_NO_ERROR;
}
/* A dummy routine designed to consume windows of vcdiff data, (of
type svn_text_delta_window_handler_t). This will be called by the
vcdiff parser everytime it has a window ready to go. */
static svn_error_t *
my_vcdiff_windoweater(svn_txdelta_window_t *window, void *baton)
{
int i;
struct node_baton *nb = baton;
struct edit_baton *eb = nb->edit_baton;
apr_pool_t *pool = eb->pool;
svn_stringbuf_t *str;
/* We're done if non-verbose */
if (! eb->verbose)
return SVN_NO_ERROR;
if (window)
str = svn_stringbuf_createf(pool,
"[%s] window_handler (%d ops)\n",
eb->editor_name,
window->num_ops);
else
str = svn_stringbuf_createf(pool,
"[%s] window_handler (EOT)\n",
eb->editor_name);
SVN_ERR(print(eb, nb->indent_level + 2, str));
if (window)
{
/* Delve into the vcdiff window and print the data. */
for (i = 1; i <= window->num_ops; i++)
{
switch (window->ops[i].action_code)
{
case svn_txdelta_new:
str = svn_stringbuf_createf
(pool,
"(%d) new text: length %" APR_SIZE_T_FMT "\n",
i, (window->ops[i].length));
break;
case svn_txdelta_source:
str = svn_stringbuf_createf
(pool,
"(%d) source text: offset %" APR_SIZE_T_FMT
", length %" APR_SIZE_T_FMT "\n",
i, window->ops[i].offset, window->ops[i].length);
break;
case svn_txdelta_target:
str = svn_stringbuf_createf
(pool,
"(%d) target text: offset %" APR_SIZE_T_FMT
", length %" APR_SIZE_T_FMT "\n",
i, window->ops[i].offset, window->ops[i].length);
break;
default:
str = svn_stringbuf_createf(pool,
"(%d) unknown window type\n", i);
break;
}
SVN_ERR(print(eb, nb->indent_level + 2, str));
}
}
SVN_ERR(newline(eb));
return SVN_NO_ERROR;
}
static svn_error_t *
test_delete_entry(const char *path,
svn_revnum_t revision,
void *parent_baton,
apr_pool_t *pool)
{
struct node_baton *nb = parent_baton;
struct edit_baton *eb = nb->edit_baton;
const char *full_path;
svn_stringbuf_t *str;
full_path = svn_path_join(eb->root_path, path, pool);
str = svn_stringbuf_createf(pool,
"[%s] delete_entry (%s)\n",
eb->editor_name, full_path);
SVN_ERR(print(eb, nb->indent_level + 1, str));
if (eb->verbose)
SVN_ERR(newline(eb));
return SVN_NO_ERROR;
}
static svn_error_t *
test_set_target_revision(void *edit_baton,
svn_revnum_t target_revision,
apr_pool_t *pool)
{
struct edit_baton *eb = edit_baton;
svn_stringbuf_t *str;
str = svn_stringbuf_createf(pool,
"[%s] set_target_revision (%ld)\n",
eb->editor_name,
target_revision);
SVN_ERR(print(eb, 0, str));
if (eb->verbose)
SVN_ERR(newline(eb));
return SVN_NO_ERROR;
}
static svn_error_t *
test_open_root(void *edit_baton,
svn_revnum_t base_revision,
apr_pool_t *pool,
void **root_baton)
{
struct edit_baton *eb = edit_baton;
struct node_baton *nb = apr_pcalloc(pool, sizeof(*nb));
svn_stringbuf_t *str;
nb->path = apr_pstrdup(pool, eb->root_path);
nb->edit_baton = eb;
nb->indent_level = 0;
*root_baton = nb;
str = svn_stringbuf_createf(pool,
"[%s] open_root (%s)\n",
eb->editor_name,
nb->path);
SVN_ERR(print(eb, nb->indent_level, str));
/* We're done if non-verbose */
if (! eb->verbose)
return SVN_NO_ERROR;
str = svn_stringbuf_createf(pool,
"base_revision: %ld\n",
base_revision);
SVN_ERR(print(eb, nb->indent_level, str));
SVN_ERR(newline(eb));
return SVN_NO_ERROR;
}
static svn_error_t *
add_or_open(const char *path,
void *parent_baton,
const char *base_path,
svn_revnum_t base_revision,
apr_pool_t *pool,
void **child_baton,
svn_boolean_t is_dir,
const char *pivot_string)
{
struct node_baton *pb = parent_baton;
struct edit_baton *eb = pb->edit_baton;
struct node_baton *nb = apr_pcalloc(pool, sizeof(*nb));
svn_stringbuf_t *str;
/* Set child_baton to a new dir baton. */
nb->path = svn_path_join(eb->root_path, path, pool);
nb->edit_baton = pb->edit_baton;
nb->parent_baton = pb;
nb->indent_level = (pb->indent_level + 1);
*child_baton = nb;
str = svn_stringbuf_createf(pool, "[%s] %s_%s (%s)\n",
eb->editor_name, pivot_string,
is_dir ? "directory" : "file", nb->path);
SVN_ERR(print(eb, nb->indent_level, str));
/* We're done if non-verbose */
if (! eb->verbose)
return SVN_NO_ERROR;
str = svn_stringbuf_createf(pool, "parent: %s\n", pb->path);
SVN_ERR(print(eb, nb->indent_level, str));
if (strcmp(pivot_string, "add") == 0)
{
str = svn_stringbuf_createf(pool, "copyfrom_path: %s\n",
base_path ? base_path : "");
SVN_ERR(print(eb, nb->indent_level, str));
str = svn_stringbuf_createf(pool, "copyfrom_revision: %ld\n",
base_revision);
SVN_ERR(print(eb, nb->indent_level, str));
}
else
{
str = svn_stringbuf_createf(pool, "base_revision: %ld\n",
base_revision);
SVN_ERR(print(eb, nb->indent_level, str));
}
SVN_ERR(newline(eb));
return SVN_NO_ERROR;
}
static svn_error_t *
close_file_or_dir(void *baton,
svn_boolean_t is_dir,
apr_pool_t *pool)
{
struct node_baton *nb = baton;
struct edit_baton *eb = nb->edit_baton;
svn_stringbuf_t *str;
str = svn_stringbuf_createf(pool,
"[%s] close_%s (%s)\n",
eb->editor_name,
is_dir ? "directory" : "file",
nb->path);
SVN_ERR(print(eb, nb->indent_level, str));
if (eb->verbose)
SVN_ERR(newline(eb));
return SVN_NO_ERROR;
}
static svn_error_t *
test_add_directory(const char *path,
void *parent_baton,
const char *copyfrom_path,
svn_revnum_t copyfrom_revision,
apr_pool_t *pool,
void **child_baton)
{
return add_or_open(path, parent_baton, copyfrom_path, copyfrom_revision,
pool, child_baton, TRUE, "add");
}
static svn_error_t *
test_open_directory(const char *path,
void *parent_baton,
svn_revnum_t base_revision,
apr_pool_t *pool,
void **child_baton)
{
return add_or_open(path, parent_baton, NULL, base_revision,
pool, child_baton, TRUE, "open");
}
static svn_error_t *
test_add_file(const char *path,
void *parent_baton,
const char *copyfrom_path,
svn_revnum_t copyfrom_revision,
apr_pool_t *pool,
void **file_baton)
{
return add_or_open(path, parent_baton, copyfrom_path, copyfrom_revision,
pool, file_baton, FALSE, "add");
}
static svn_error_t *
test_open_file(const char *path,
void *parent_baton,
svn_revnum_t base_revision,
apr_pool_t *pool,
void **file_baton)
{
return add_or_open(path, parent_baton, NULL, base_revision,
pool, file_baton, FALSE, "open");
}
static svn_error_t *
test_close_directory(void *dir_baton,
apr_pool_t *pool)
{
return close_file_or_dir(dir_baton, TRUE, pool);
}
static svn_error_t *
absent_file_or_dir(const char *path,
void *baton,
svn_boolean_t is_dir,
apr_pool_t *pool)
{
struct node_baton *nb = baton;
struct edit_baton *eb = nb->edit_baton;
svn_stringbuf_t *str;
str = svn_stringbuf_createf(pool,
"[%s] absent_%s (%s)\n",
eb->editor_name,
is_dir ? "directory" : "file",
nb->path);
SVN_ERR(print(eb, nb->indent_level, str));
if (eb->verbose)
SVN_ERR(newline(eb));
return SVN_NO_ERROR;
}
static svn_error_t *
test_absent_directory(const char *path,
void *baton,
apr_pool_t *pool)
{
return absent_file_or_dir(path, baton, TRUE, pool);
}
static svn_error_t *
test_close_file(void *file_baton,
const char *text_checksum,
apr_pool_t *pool)
{
return close_file_or_dir(file_baton, FALSE, pool);
}
static svn_error_t *
test_absent_file(const char *path,
void *baton,
apr_pool_t *pool)
{
return absent_file_or_dir(path, baton, FALSE, pool);
}
static svn_error_t *
test_close_edit(void *edit_baton,
apr_pool_t *pool)
{
struct edit_baton *eb = edit_baton;
svn_stringbuf_t *str;
str = svn_stringbuf_createf(pool, "[%s] close_edit\n", eb->editor_name);
SVN_ERR(print(eb, 0, str));
if (eb->verbose)
SVN_ERR(newline(eb));
return SVN_NO_ERROR;
}
static svn_error_t *
test_abort_edit(void *edit_baton,
apr_pool_t *pool)
{
struct edit_baton *eb = edit_baton;
svn_stringbuf_t *str;
str = svn_stringbuf_createf(pool, "[%s] ***ABORT_EDIT***\n",
eb->editor_name);
SVN_ERR(print(eb, 0, str));
if (eb->verbose)
SVN_ERR(newline(eb));
return SVN_NO_ERROR;
}
static svn_error_t *
test_apply_textdelta(void *file_baton,
const char *base_checksum,
apr_pool_t *pool,
svn_txdelta_window_handler_t *handler,
void **handler_baton)
{
struct node_baton *nb = file_baton;
struct edit_baton *eb = nb->edit_baton;
svn_stringbuf_t *str;
/* Set the value of HANDLER and HANDLER_BATON here */
*handler = my_vcdiff_windoweater;
*handler_baton = nb;
str = svn_stringbuf_createf(pool, "[%s] apply_textdelta (%s)\n",
eb->editor_name, nb->path);
SVN_ERR(print(eb, nb->indent_level + 1, str));
if (eb->verbose)
SVN_ERR(newline(eb));
return SVN_NO_ERROR;
}
static svn_error_t *
change_prop(void *baton,
const char *name,
const svn_string_t *value,
apr_pool_t *pool,
svn_boolean_t is_dir)
{
struct node_baton *nb = baton;
struct edit_baton *eb = nb->edit_baton;
svn_stringbuf_t *str;
str = svn_stringbuf_createf(pool, "[%s] change_%s_prop (%s)\n",
eb->editor_name,
is_dir ? "directory" : "file", nb->path);
SVN_ERR(print(eb, nb->indent_level + 1, str));
/* We're done if non-verbose */
if (! eb->verbose)
return SVN_NO_ERROR;
str = svn_stringbuf_createf(pool, "name: %s\n", name);
SVN_ERR(print(eb, nb->indent_level + 1, str));
str = svn_stringbuf_createf(pool, "value: %s\n",
value ? value->data : "(null)");
SVN_ERR(print(eb, nb->indent_level + 1, str));
SVN_ERR(newline(eb));
return SVN_NO_ERROR;
}
static svn_error_t *
test_change_file_prop(void *file_baton,
const char *name,
const svn_string_t *value,
apr_pool_t *pool)
{
return change_prop(file_baton, name, value, pool, FALSE);
}
static svn_error_t *
test_change_dir_prop(void *parent_baton,
const char *name,
const svn_string_t *value,
apr_pool_t *pool)
{
return change_prop(parent_baton, name, value, pool, TRUE);
}
/*---------------------------------------------------------------*/
/** Public interface: svn_test_get_editor() **/
svn_error_t *
svn_test_get_editor(const svn_delta_editor_t **editor,
void **edit_baton,
const char *editor_name,
svn_stream_t *out_stream,
int indentation,
svn_boolean_t verbose,
const char *path,
apr_pool_t *pool)
{
svn_delta_editor_t *my_editor;
struct edit_baton *my_edit_baton;
/* Set up the editor. */
my_editor = svn_delta_default_editor(pool);
my_editor->set_target_revision = test_set_target_revision;
my_editor->open_root = test_open_root;
my_editor->delete_entry = test_delete_entry;
my_editor->add_directory = test_add_directory;
my_editor->open_directory = test_open_directory;
my_editor->close_directory = test_close_directory;
my_editor->absent_directory = test_absent_directory;
my_editor->add_file = test_add_file;
my_editor->open_file = test_open_file;
my_editor->close_file = test_close_file;
my_editor->absent_file = test_absent_file;
my_editor->apply_textdelta = test_apply_textdelta;
my_editor->change_file_prop = test_change_file_prop;
my_editor->change_dir_prop = test_change_dir_prop;
my_editor->close_edit = test_close_edit;
my_editor->abort_edit = test_abort_edit;
/* Set up the edit baton. */
my_edit_baton = apr_pcalloc(pool, sizeof(*my_edit_baton));
my_edit_baton->root_path = apr_pstrdup(pool, path);
my_edit_baton->editor_name = apr_pstrdup(pool, editor_name);
my_edit_baton->pool = pool;
my_edit_baton->indentation = indentation;
my_edit_baton->verbose = verbose;
my_edit_baton->out_stream = out_stream;
*editor = my_editor;
*edit_baton = my_edit_baton;
return SVN_NO_ERROR;
}