Alien-SVN
view release on metacpan or search on metacpan
src/subversion/build/generator/extractor.py view on Meta::CPAN
_funcs = re.compile(r'^(?:(?:(?:\w+|\*) )+\*?)?((?:svn|apr)_[a-z_0-9]+)\s*\(', re.M)
def extract_funcs(fname):
funcs = [ ]
for name in _funcs.findall(open(fname).read()):
if name not in _filter_names:
funcs.append(name)
return funcs
_filter_names = [
'svn_boolean_t', # svn_config_enumerator_t looks like (to our regex) a
# function declaration for svn_boolean_t
# Not available on Windows
'svn_auth_get_keychain_simple_provider',
'svn_auth_get_keychain_ssl_client_cert_pw_provider',
'svn_auth_get_gnome_keyring_simple_provider',
'svn_auth_get_gnome_keyring_ssl_client_cert_pw_provider',
'svn_auth_get_kwallet_simple_provider',
'svn_auth_get_kwallet_ssl_client_cert_pw_provider',
'svn_auth_gnome_keyring_version',
src/subversion/build/libtool.m4 view on Meta::CPAN
# Let DOS variable expansion print the short 8.3 style file name.
lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
done
IFS=$lt_save_ifs
# Convert to MSYS style.
sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([[a-zA-Z]]\\):| /\\1|g' -e 's|^ ||'`
;;
cygwin*)
# Convert to unix form, then to dos form, then back to unix form
# but this time dos style (no spaces!) so that the unix form looks
# like /cygdrive/c/PROGRA~1:/cygdr...
sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
;;
*)
sys_lib_search_path_spec=$LIB
if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then
# It is most probably a Windows format PATH.
sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
src/subversion/build/libtool.m4 view on Meta::CPAN
_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
;;
tcc*)
# Fabrice Bellard et al's Tiny C Compiler
_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
;;
pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
# Portland Group compilers (*not* the Pentium gcc compiler,
# which looks to be a dead project)
_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
;;
ccc*)
_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
# All Alpha code is PIC.
_LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
;;
xl* | bgxl* | bgf* | mpixl*)
src/subversion/configure view on Meta::CPAN
# certainly right.
break;;
*.* )
if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
then :; else
ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
fi
# We set ac_cv_exeext here because the later test for it is not
# safe: cross compilers may not add the suffix if given an `-o'
# argument, so we may need to know it at that point already.
# Even if this section looks crufty: it has the advantage of
# actually working.
break;;
* )
break;;
esac
done
test "$ac_cv_exeext" = no && ac_cv_exeext=
else
ac_file=''
src/subversion/configure view on Meta::CPAN
lt_prog_compiler_static='-Bstatic'
;;
tcc*)
# Fabrice Bellard et al's Tiny C Compiler
lt_prog_compiler_wl='-Wl,'
lt_prog_compiler_pic='-fPIC'
lt_prog_compiler_static='-static'
;;
pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
# Portland Group compilers (*not* the Pentium gcc compiler,
# which looks to be a dead project)
lt_prog_compiler_wl='-Wl,'
lt_prog_compiler_pic='-fpic'
lt_prog_compiler_static='-Bstatic'
;;
ccc*)
lt_prog_compiler_wl='-Wl,'
# All Alpha code is PIC.
lt_prog_compiler_static='-non_shared'
;;
xl* | bgxl* | bgf* | mpixl*)
src/subversion/configure view on Meta::CPAN
# Let DOS variable expansion print the short 8.3 style file name.
lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
done
IFS=$lt_save_ifs
# Convert to MSYS style.
sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
;;
cygwin*)
# Convert to unix form, then to dos form, then back to unix form
# but this time dos style (no spaces!) so that the unix form looks
# like /cygdrive/c/PROGRA~1:/cygdr...
sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
;;
*)
sys_lib_search_path_spec=$LIB
if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then
# It is most probably a Windows format PATH.
sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
src/subversion/configure view on Meta::CPAN
# Let DOS variable expansion print the short 8.3 style file name.
lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
done
IFS=$lt_save_ifs
# Convert to MSYS style.
sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
;;
cygwin*)
# Convert to unix form, then to dos form, then back to unix form
# but this time dos style (no spaces!) so that the unix form looks
# like /cygdrive/c/PROGRA~1:/cygdr...
sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
;;
*)
sys_lib_search_path_spec=$LIB
if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then
# It is most probably a Windows format PATH.
sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
src/subversion/subversion/bindings/swig/INSTALL view on Meta::CPAN
from the top of the Subversion build tree. This will copy
your new Python libraries into the appropriate system location.
Note: If you don't have access to install to Python's site-packages
directory, you can have the Python modules install to your home
directory. You can do this by running
'make install-swig-py swig_pydir=~'.
Note: If you want to install to an alternate prefix (usually only
if you are building packages), you can supply the prefix here. An
example of doing this for building rpms looks like
'make install-swig-py DESTDIR=$RPM_BUILD_ROOT/usr'.
4. Make sure that whatever directory the bindings got installed in
is in your Python search path. That directory depends on how you
installed; a typical location is /usr/local/lib/svn-python/.
There are several ways to do this. See Python's documentation for
'sys.path' and 'PYTHONPATH'. A nice way to do this is:
$ echo /usr/local/lib/svn-python \
> /usr/lib/python2.x/site-packages/subversion.pth
src/subversion/subversion/bindings/swig/include/proxy.swg view on Meta::CPAN
if "_is_valid" in self.__dict__:
assert self.__dict__["_is_valid"](), "Variable has already been deleted"
def __getattr__(self, name):
"""Get an attribute from this object"""
self.assert_valid()
value = _swig_getattr(self, self.__class__, name)
# If we got back a different object than we have, we need to copy all our
# metadata into it, so that it looks identical
members = self.__dict__.get("_members")
if members is not None:
_copy_metadata_deep(value, members.get(name))
# Verify that the new object is good
_assert_valid_deep(value)
return value
def __setattr__(self, name, value):
src/subversion/subversion/bindings/swig/perl/libsvn_swig_perl/swigutil_pl.c view on Meta::CPAN
#define maybe_croak(argv) do { if (croak_on_error) croak argv; \
else return NULL; } while (0)
if (source == NULL || source == &PL_sv_undef || !SvOK(source)) {
rev->kind = svn_opt_revision_unspecified;
}
else if (sv_isobject(source) && sv_derived_from(source, "_p_svn_opt_revision_t")) {
/* this will assign to rev */
SWIG_ConvertPtr(source, (void **)&rev, _SWIG_TYPE("svn_opt_revision_t *"), 0);
}
else if (looks_like_number(source)) {
rev->kind = svn_opt_revision_number;
rev->value.number = SvIV(source);
}
else if (SvPOK(source)) {
char *input = SvPV_nolen(source);
if (svn_cstring_casecmp(input, "BASE") == 0)
rev->kind = svn_opt_revision_base;
else if (svn_cstring_casecmp(input, "HEAD") == 0)
rev->kind = svn_opt_revision_head;
else if (svn_cstring_casecmp(input, "WORKING") == 0)
src/subversion/subversion/bindings/swig/perl/native/Repos.pm view on Meta::CPAN
=item $repos-E<gt>dump_fs($dump_fh, $feedback_fh, $start_rev, $end_rev, $incremental, $cancel_func, $cancel_baton)
=item $repos-E<gt>dump_fs2($dump_fh, $feedback_fh, $start_rev, $end_rev, $incremental, $deltify, $cancel_func, $cancel_baton)
Create a dump file of the repository from revision C<$start_rev> to C<$end_rev>
, store it into the filehandle C<$dump_fh>, and write feedback on the progress
of the operation to filehandle C<$feedback_fh>.
If C<$incremental> is TRUE, the first revision dumped will be a diff
against the previous revision (usually it looks like a full dump of
the tree).
If C<$use_deltas> is TRUE, output only node properties which have
changed relative to the previous contents, and output text contents
as svndiff data against the previous contents. Regardless of how
this flag is set, the first revision of a non-incremental dump will
be done with full plain text. A dump with @a use_deltas set cannot
be loaded by Subversion 1.0.x.
According to svn_repos.h, the C<$cancel_func> is a function that is called
src/subversion/subversion/bindings/swig/ruby/test/test_fs.rb view on Meta::CPAN
start_time = Time.now
txn1 = @fs.transaction
assert_equal([Svn::Core::PROP_REVISION_DATE], txn1.proplist.keys)
assert_instance_of(Time, txn1.proplist[Svn::Core::PROP_REVISION_DATE])
date = txn1.prop(Svn::Core::PROP_REVISION_DATE)
# Subversion's clock is more precise than Ruby's on
# Windows. So this test can fail intermittently because
# the begin and end of the range are the same (to 3
# decimal places), but the time from Subversion has 6
# decimal places so it looks like it's not in the range.
# So we just add a smidgen to the end of the Range.
assert_operator(start_time..(Time.now + 0.001), :include?, date)
txn1.set_prop(Svn::Core::PROP_REVISION_DATE, nil)
assert_equal([], txn1.proplist.keys)
assert_equal(youngest_rev, txn1.base_revision)
assert(txn1.root.txn_root?)
assert(!txn1.root.revision_root?)
assert_equal(txn1.name, txn1.root.name)
assert_equal(txn1.base_revision, txn1.root.base_revision)
src/subversion/subversion/include/private/svn_ra_svn_private.h view on Meta::CPAN
svn_ra_svn__write_tuple(svn_ra_svn_conn_t *conn,
apr_pool_t *pool,
const char *fmt, ...);
/** Read an item from the network into @a *item. */
svn_error_t *
svn_ra_svn__read_item(svn_ra_svn_conn_t *conn,
apr_pool_t *pool,
svn_ra_svn_item_t **item);
/** Scan data on @a conn until we find something which looks like the
* beginning of an svn server greeting (an open paren followed by a
* whitespace character). This function is appropriate for beginning
* a client connection opened in tunnel mode, since people's dotfiles
* sometimes write output to stdout. It may only be called at the
* beginning of a client connection.
*/
svn_error_t *
svn_ra_svn__skip_leading_garbage(svn_ra_svn_conn_t *conn,
apr_pool_t *pool);
src/subversion/subversion/include/svn_auth.h view on Meta::CPAN
* - can retry the fetch (or try to fetch something different)
* - can store the credentials for future use
*
* For any given type of credentials, there can exist any number of
* separate providers -- each provider has a different method of
* fetching. (i.e. from a disk store, by prompting the user, etc.)
*
* The application begins by creating an auth baton object, and
* "registers" some number of providers with the auth baton, in a
* specific order. (For example, it may first register a
* username/password provider that looks in disk store, then register
* a username/password provider that prompts the user.)
*
* Later on, when any svn library is challenged, it asks the auth
* baton for the specific credentials. If the initial credentials
* fail to authenticate, the caller keeps requesting new credentials.
* Under the hood, libsvn_auth effectively "walks" over each provider
* (in order of registry), one at a time, until all the providers have
* exhausted all their retry options.
*
* This system allows an application to flexibly define authentication
src/subversion/subversion/include/svn_dirent_uri.h view on Meta::CPAN
*/
const char *
svn_uri_canonicalize(const char *uri,
apr_pool_t *result_pool);
/** Return @c TRUE iff @a dirent is canonical.
*
* Use @a scratch_pool for temporary allocations.
*
* @note The test for canonicalization is currently defined as
* "looks exactly the same as @c svn_dirent_canonicalize() would make
* it look".
*
* @see svn_dirent_canonicalize()
* @since New in 1.6.
*/
svn_boolean_t
svn_dirent_is_canonical(const char *dirent,
apr_pool_t *scratch_pool);
/** Return @c TRUE iff @a relpath is canonical.
src/subversion/subversion/include/svn_path.h view on Meta::CPAN
svn_error_t *
svn_path_check_valid(const char *path, apr_pool_t *pool);
/** URI/URL stuff
*
* @defgroup svn_path_uri_stuff URI/URL conversion
* @{
*/
/** Return TRUE iff @a path looks like a valid absolute URL. */
svn_boolean_t
svn_path_is_url(const char *path);
/** Return @c TRUE iff @a path is URI-safe, @c FALSE otherwise. */
svn_boolean_t
svn_path_is_uri_safe(const char *path);
/** Return a URI-encoded copy of @a path, allocated in @a pool. (@a
path can be an arbitrary UTF-8 string and does not have to be a
canonical path.) */
src/subversion/subversion/include/svn_ra_svn.h view on Meta::CPAN
*
* @deprecated Provided for backward compatibility with the 1.7 API.
* RA_SVN low-level functions are no longer considered public.
*/
SVN_DEPRECATED
svn_error_t *
svn_ra_svn_read_item(svn_ra_svn_conn_t *conn,
apr_pool_t *pool,
svn_ra_svn_item_t **item);
/** Scan data on @a conn until we find something which looks like the
* beginning of an svn server greeting (an open paren followed by a
* whitespace character). This function is appropriate for beginning
* a client connection opened in tunnel mode, since people's dotfiles
* sometimes write output to stdout. It may only be called at the
* beginning of a client connection.
*
* @deprecated Provided for backward compatibility with the 1.7 API.
* RA_SVN low-level functions are no longer considered public.
*/
SVN_DEPRECATED
src/subversion/subversion/include/svn_repos.h view on Meta::CPAN
* @note If someday we want more sophisticated authorization states
* than just yes/no, @a allowed can become an enum type.
*/
typedef svn_error_t *(*svn_repos_authz_func_t)(svn_boolean_t *allowed,
svn_fs_root_t *root,
const char *path,
void *baton,
apr_pool_t *pool);
/** An enum defining the kinds of access authz looks up.
*
* @since New in 1.3.
*/
typedef enum svn_repos_authz_access_t
{
/** No access. */
svn_authz_none = 0,
/** Path can be read. */
svn_authz_read = 1,
src/subversion/subversion/include/svn_repos.h view on Meta::CPAN
* revision up through @a end_rev. Use @a pool for all allocation. If
* non-@c NULL, send feedback to @a feedback_stream. If @a dumpstream is
* @c NULL, this is effectively a primitive verify. It is not complete,
* however; svn_repos_verify_fs2() and svn_fs_verify().
*
* If @a start_rev is #SVN_INVALID_REVNUM, then start dumping at revision
* 0. If @a end_rev is #SVN_INVALID_REVNUM, then dump through the @c HEAD
* revision.
*
* If @a incremental is @c TRUE, the first revision dumped will be a diff
* against the previous revision (usually it looks like a full dump of
* the tree).
*
* If @a use_deltas is @c TRUE, output only node properties which have
* changed relative to the previous contents, and output text contents
* as svndiff data against the previous contents. Regardless of how
* this flag is set, the first revision of a non-incremental dump will
* be done with full plain text. A dump with @a use_deltas set cannot
* be loaded by Subversion 1.0.x.
*
* If @a notify_func is not @c NULL, then for every dumped revision call
src/subversion/subversion/libsvn_client/copy.c view on Meta::CPAN
iterpool = svn_pool_create(scratch_pool);
/* Determine the longest common ancestor for the destinations, and open an RA
session to that location. */
/* ### But why start by getting the _parent_ of the first one? */
/* --- That works because multiple destinations always point to the same
* directory. I'm rather wondering why we need to find a common
* destination parent here at all, instead of simply getting
* top_dst_url from get_copy_pair_ancestors() above?
* It looks like the entire block of code hanging off this comment
* is redundant. */
first_pair = APR_ARRAY_IDX(copy_pairs, 0, svn_client__copy_pair_t *);
top_dst_url = svn_uri_dirname(first_pair->dst_abspath_or_url, scratch_pool);
for (i = 1; i < copy_pairs->nelts; i++)
{
svn_client__copy_pair_t *pair = APR_ARRAY_IDX(copy_pairs, i,
svn_client__copy_pair_t *);
top_dst_url = svn_uri_get_longest_ancestor(top_dst_url,
pair->dst_abspath_or_url,
scratch_pool);
src/subversion/subversion/libsvn_client/deprecated.c view on Meta::CPAN
err = svn_client_log2(targets, start, end, 0, discover_changed_paths,
strict_node_history, receiver, receiver_baton, ctx,
pool);
/* Special case: If there have been no commits, we'll get an error
* for requesting log of a revision higher than 0. But the
* default behavior of "svn log" is to give revisions HEAD through
* 1, on the assumption that HEAD >= 1.
*
* So if we got that error for that reason, and it looks like the
* user was just depending on the defaults (rather than explicitly
* requesting the log for revision 1), then we don't error. Instead
* we just invoke the receiver manually on a hand-constructed log
* message for revision 0.
*
* See also http://subversion.tigris.org/issues/show_bug.cgi?id=692.
*/
if (err && (err->apr_err == SVN_ERR_FS_NO_SUCH_REVISION)
&& (start->kind == svn_opt_revision_head)
&& ((end->kind == svn_opt_revision_number)
src/subversion/subversion/libsvn_client/diff.c view on Meta::CPAN
With only one distinct revision the working copy provides the
other. When path is a URL there is no working copy. Thus
1: compare repository versions for URL coresponding to working copy
2: compare working copy against repository version
3: compare repository versions for URL
4: nothing to do.
5: compare working copy against text-base
Case 4 is not as stupid as it looks, for example it may occur if
the user specifies two dates that resolve to the same revision. */
/** Check if paths PATH_OR_URL1 and PATH_OR_URL2 are urls and if the
* revisions REVISION1 and REVISION2 are local. If PEG_REVISION is not
* unspecified, ensure that at least one of the two revisions is not
* BASE or WORKING.
* If PATH_OR_URL1 can only be found in the repository, set *IS_REPOS1
* to TRUE. If PATH_OR_URL2 can only be found in the repository, set
* *IS_REPOS2 to TRUE. */
src/subversion/subversion/libsvn_client/export.c view on Meta::CPAN
*
* [2] DIR onto DIR case. If the 'FORCE' flag is true then copy the
* source's children inside the target dir, else error out. When
* copying the children, apply the same set of rules, except in the
* FILE onto DIR case error out like in note [1].
*
* [3] If the 'FORCE' flag is true then overwrite the destination file
* else error out.
*
* The reality (apparently, looking at the code) is somewhat different.
* For a start, to detect the source kind, it looks at what is on disk
* rather than the versioned working or base node.
*/
if (kind == svn_node_file)
SVN_ERR(append_basename_if_dir(&to_path, from_path_or_url, FALSE,
pool));
eib.to_path = to_path;
eib.revision = revision;
eib.overwrite = overwrite;
eib.ignore_keywords = ignore_keywords;
src/subversion/subversion/libsvn_client/merge.c view on Meta::CPAN
primary_url, peg_rev,
younger_rev, older_rev, ctx,
scratch_pool);
/* If PRIMARY_URL@peg_rev doesn't exist then
svn_client__repos_location_segments() typically returns an
SVN_ERR_FS_NOT_FOUND error, but if it doesn't exist for a
forward merge over ra_neon then we get SVN_ERR_RA_DAV_REQUEST_FAILED.
http://subversion.tigris.org/issues/show_bug.cgi?id=3137 fixed some of
the cases where different RA layers returned different error codes to
signal the "path not found"...but it looks like there is more to do.
### Do we still need to special case for ra_neon (since it no longer
exists)? */
if (err)
{
if (err->apr_err == SVN_ERR_FS_NOT_FOUND
|| err->apr_err == SVN_ERR_RA_DAV_REQUEST_FAILED)
{
/* PRIMARY_URL@peg_rev doesn't exist. Check if PRIMARY_URL@older_rev
exists, if neither exist then the editor can simply ignore this
src/subversion/subversion/libsvn_client/patch.c view on Meta::CPAN
apr_file_t *file = (apr_file_t *)baton;
SVN_ERR(svn_io_file_write_full(file, buf, len, &len, scratch_pool));
return SVN_NO_ERROR;
}
/* Handling symbolic links:
*
* In Subversion, symlinks can be represented on disk in two distinct ways.
* On systems which support symlinks, a symlink is created on disk.
* On systems which do not support symlink, a file is created on disk
* which contains the "normal form" of the symlink, which looks like:
* link TARGET
* where TARGET is the file the symlink points to.
*
* When reading symlinks (i.e. the link itself, not the file the symlink
* is pointing to) through the svn_subst_create_specialfile() function
* into a buffer, the buffer always contains the "normal form" of the symlink.
* Due to this representation symlinks always contain a single line of text.
*
* The functions below are needed to deal with the case where a patch
* wants to change the TARGET that a symlink points to.
src/subversion/subversion/libsvn_fs_base/notes/fs-history view on Meta::CPAN
(a love song for libsvn_fs, by C. Michael Pilato)
The Subversion filesystem can be your best friend, or your worst
enemy, usually depending on which side of the public API you are
working on. Callers of the libsvn_fs interfaces do their work in a
world pleasantly addressed by roots (the name given to a revision or
transaction snapshot of the versioned directory tree) and paths under
those roots. But once you swim beneath the surface, you quickly
realize that there is a beast both beautiful and dangerous lying in
wait. What looks to the outside world as a sort of coordinate system
with axes for "Time" and "Location" is, in fact, a complicated DAG
subsystem, with nodes that represent revisions of versioned locations
all interconnected in various relationships with each other.
The goal of this document is straightforward: to relay knowledge about
how to untangle that DAG subsystem -- knowledge which likely lives
only in the minds of a few developers -- so that the Few might become
the Many.
src/subversion/subversion/libsvn_fs_base/notes/fs-history view on Meta::CPAN
query.
Seems pretty easy, doesn't it? Keep reading.
All About Node-Revision IDs
As previously mentioned, each node-revision in the filesystem has a
unique key, referred to as the node-revision ID. This key is
typically represented as a string which looks like a period-separated
list of its three components:
1. node ID: This key is unique to the members of a single
historical lineage. Differing versions of the same versioned
resource, irrespective of the paths and revision in which those
versions are located, all share this ID. If two node-revisions
have different node IDs, their are historically unrelated.
2. copy ID: This key uniquely identifies a copy operation, and is
sometimes referred to (or at least thought of) as a "branch ID."
src/subversion/subversion/libsvn_fs_base/notes/structure view on Meta::CPAN
(("fulltext" TXN CHECKSUM) "1001")
while the entry for key "1729" in `strings' is:
<some unprintable glob of svndiff data>
which, when applied to the fulltext at key "1001" in strings, results
in this new fulltext:
"((some text) (that looks) (deceptively like) (directory entries))"
Et voila! Subversion knew enough, via the `representations' and
`strings' tables, to undeltify and get that fulltext; and knew enough,
because of the node revision's "file" type, to interpret the result as
file contents, not as a directory entry list.
(Note that the `strings' table stores multiple DB values per key.
That is, although it's accurate to say there is one string per key,
the string may be divided into multiple consecutive blocks, all
sharing that key. You use a Berkeley DB cursor to find the desired
src/subversion/subversion/libsvn_ra/deprecated.c view on Meta::CPAN
#include "deprecated.h"
#include "svn_private_config.h"
/*** From ra_loader.c ***/
/*** Compatibility Wrappers ***/
/* Wrap @c svn_ra_reporter3_t in an interface that looks like
@c svn_ra_reporter2_t, for compatibility with functions that take
the latter. This shields the ra-specific implementations from
worrying about what kind of reporter they're dealing with.
This code does not live in wrapper_template.h because that file is
about the big changeover from a vtable-style to function-style
interface, and does not contain the post-changeover interfaces
that we are compatiblizing here.
This code looks like it duplicates code in libsvn_wc/adm_crawler.c,
but in fact it does not. That code makes old things look like new
things; this code makes a new thing look like an old thing. */
/* Baton for abovementioned wrapping. */
struct reporter_3in2_baton {
const svn_ra_reporter3_t *reporter3;
void *reporter3_baton;
};
/* Wrap the corresponding svn_ra_reporter3_t field in an
src/subversion/subversion/libsvn_ra_serf/ra_serf.h view on Meta::CPAN
apr_size_t len,
apr_pool_t *scratch_pool);
/* State transition table.
When the XML Context is constructed, it is in state 0. User states are
positive integers.
In a list of transitions, use { 0 } to indicate the end. Specifically,
the code looks for NS == NULL.
### more docco
*/
typedef struct svn_ra_serf__xml_transition_t {
/* This transition applies when in this state */
int from_state;
/* And when this tag is observed */
const char *ns;
const char *name;
src/subversion/subversion/libsvn_ra_serf/update.c view on Meta::CPAN
}
report->done_dir_propfinds = NULL;
/* If the parser is paused, and the number of active requests has
dropped far enough, then resume parsing. */
if (parser_ctx->paused
&& (report->num_active_fetches + report->num_active_propfinds
< REQUEST_COUNT_TO_RESUME))
parser_ctx->paused = FALSE;
/* If we have not paused the parser and it looks like data MAY be
present (we can't know for sure because of the private structure),
then go process the pending content. */
if (!parser_ctx->paused && parser_ctx->pending != NULL)
SVN_ERR(svn_ra_serf__process_pending(parser_ctx,
&report->report_received,
iterpool_inner));
/* Debugging purposes only! */
for (i = 0; i < sess->num_conns; i++)
{
src/subversion/subversion/libsvn_repos/dump.c view on Meta::CPAN
return svn_error_createf(SVN_ERR_REPOS_BAD_ARGS, NULL,
_("Start revision %ld"
" is greater than end revision %ld"),
start_rev, end_rev);
if (end_rev > youngest)
return svn_error_createf(SVN_ERR_REPOS_BAD_ARGS, NULL,
_("End revision %ld is invalid "
"(youngest revision is %ld)"),
end_rev, youngest);
if ((start_rev == 0) && incremental)
incremental = FALSE; /* revision 0 looks the same regardless of
whether or not this is an incremental
dump, so just simplify things. */
/* Write out the UUID. */
SVN_ERR(svn_fs_get_uuid(fs, &uuid, pool));
/* If we're not using deltas, use the previous version, for
compatibility with svn 1.0.x. */
version = SVN_REPOS_DUMPFILE_FORMAT_VERSION;
if (!use_deltas)
src/subversion/subversion/libsvn_subr/cmdline.c view on Meta::CPAN
/* Get information about the temporary file after the assumed editing. */
apr_err = apr_stat(&finfo_after, tmpfile_apr,
APR_FINFO_MTIME | APR_FINFO_SIZE, pool);
if (apr_err)
{
err = svn_error_wrap_apr(apr_err, _("Can't stat '%s'"), tmpfile_name);
goto cleanup;
}
/* If the file looks changed... */
if ((finfo_before.mtime != finfo_after.mtime) ||
(finfo_before.size != finfo_after.size))
{
svn_stringbuf_t *edited_contents_s;
err = svn_stringbuf_from_file2(&edited_contents_s, tmpfile_name, pool);
if (err)
goto cleanup;
*edited_contents = svn_stringbuf__morph_into_string(edited_contents_s);
src/subversion/subversion/libsvn_subr/dirent_uri.c view on Meta::CPAN
#ifdef SVN_USE_DOS_PATHS
/* On Windows, we'll typically have to skip the leading / if the
path starts with a drive letter. Like most Web browsers, We
support two variants of this scheme:
file:///X:/path and
file:///X|/path
Note that, at least on WinNT and above, file:////./X:/path will
also work, so we must make sure the transformation doesn't break
that, and file:///path (that looks within the current drive
only) should also keep working.
If we got a non-empty hostname other than localhost, we convert this
into an UNC path. In this case, we obviously don't strip the slash
even if the path looks like it starts with a drive letter.
*/
{
static const char valid_drive_letters[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
/* Casting away const! */
char *dup_path = (char *)svn_path_uri_decode(path, pool);
/* This check assumes ':' and '|' are already decoded! */
if (!hostname && dup_path[1] && strchr(valid_drive_letters, dup_path[1])
&& (dup_path[2] == ':' || dup_path[2] == '|'))
src/subversion/subversion/libsvn_subr/time.c view on Meta::CPAN
* first part, and then in parentheses comes everything else required
* to completely fill in an apr_time_exp_t: tm_yday, tm_isdst,
* and tm_gmtoff.
*
* This format is still recognized on input, for backward
* compatibility, but no longer generated.
*/
#define OLD_TIMESTAMP_FORMAT \
"%3s %d %3s %d %02d:%02d:%02d.%06d (day %03d, dst %d, gmt_off %06d)"
/* Our human representation of dates looks like this:
*
* "2002-06-23 11:13:02 +0300 (Sun, 23 Jun 2002)"
*
* This format is used whenever time is shown to the user. It consists
* of a machine parseable, almost ISO-8601, part in the beginning -
* and a human explanatory part at the end. The machine parseable part
* is generated strictly by APR and our code, with a apr_snprintf. The
* human explanatory part is generated by apr_strftime, which means
* that its generation can be affected by locale, it can fail and it
* doesn't need to be constant in size. In other words, perfect to be
src/subversion/subversion/libsvn_subr/time.c view on Meta::CPAN
svn_error_t *
svn_time_from_cstring(apr_time_t *when, const char *data, apr_pool_t *pool)
{
apr_time_exp_t exploded_time;
apr_status_t apr_err;
char wday[4], month[4];
char *c;
/* Open-code parsing of the new timestamp format, as this
is a hot path for reading the entries file. This format looks
like: "2001-08-31T04:24:14.966996Z" */
exploded_time.tm_year = (apr_int32_t) strtol(data, &c, 10);
if (*c++ != '-') goto fail;
exploded_time.tm_mon = (apr_int32_t) strtol(c, &c, 10);
if (*c++ != '-') goto fail;
exploded_time.tm_mday = (apr_int32_t) strtol(c, &c, 10);
if (*c++ != 'T') goto fail;
exploded_time.tm_hour = (apr_int32_t) strtol(c, &c, 10);
if (*c++ != ':') goto fail;
exploded_time.tm_min = (apr_int32_t) strtol(c, &c, 10);
src/subversion/subversion/libsvn_wc/ambient_depth_filter_editor.c view on Meta::CPAN
In the 'svn up', the requested depth is unspecified, meaning that
the ambient depth(s) of the working copy should be preserved.
Since there's only one directory, and its depth is 'empty',
clearly we should filter out or render no-ops all editor calls
after open_root(), except maybe for change_dir_prop() on the
top-level directory. (Note that the server will have stuff to
send down, because we checked out at an old revision in the first
place, to set up this scenario.)
The depth-filtering editor won't help us here. It only filters
based on the requested depth, it never looks in the working copy
to get ambient depths. So the update editor itself will have to
filter out the unwanted calls -- or better yet, it will have to
be wrapped in a filtering editor that does the job.
This is that filtering editor.
Most of the work is done at the moment of baton construction.
When a file or dir is opened, we create its baton with the
appropriate ambient depth, either taking the depth directly from
the corresponding working copy object (if available), or from its
( run in 0.667 second using v1.01-cache-2.11-cpan-64827b87656 )