| /* log.c --- retrieving log messages |
| * |
| * ==================================================================== |
| * Copyright (c) 2000-2002 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/. |
| * ==================================================================== |
| */ |
| |
| |
| #define APR_WANT_STRFUNC |
| #include <apr_want.h> |
| |
| #include "svn_pools.h" |
| #include "svn_error.h" |
| #include "svn_path.h" |
| #include "svn_fs.h" |
| #include "svn_repos.h" |
| #include "svn_string.h" |
| #include "svn_time.h" |
| #include "repos.h" |
| |
| |
| |
| |
| /* Store as keys in CHANGED the paths of all nodes at or below NODE |
| * that show a significant change. "Significant" means that the text |
| * or properties of the node were changed, or that the node was added |
| * or deleted. |
| * |
| * The key is allocated in POOL; the value is (void *) 'A', 'D', or |
| * 'R', for added, deleted, or opened, respectively. |
| * |
| * Standard practice is to call this on the root node of delta tree |
| * generated from svn_repos_dir_delta() and its node accessor, |
| * svn_repos_node_from_baton(), with PATH representing "/". |
| */ |
| static void |
| detect_changed (apr_hash_t *changed, |
| svn_repos_node_t *node, |
| svn_stringbuf_t *path, |
| apr_pool_t *pool) |
| { |
| /* Recurse sideways first. */ |
| if (node->sibling) |
| detect_changed (changed, node->sibling, path, pool); |
| |
| /* Then "enter" this node; but if its name is the empty string, then |
| there's no need to extend path (and indeed, the behavior |
| svn_path_add_component_nts is to strip the trailing slash even |
| when the new path is "/", so we'd end up with "", which would |
| screw everything up anyway). */ |
| if (node->name && *(node->name)) |
| { |
| svn_path_add_component_nts (path, node->name); |
| } |
| |
| /* Recurse downward before processing this node. */ |
| if (node->child) |
| detect_changed (changed, node->child, path, pool); |
| |
| /* Process this node. |
| We register all differences except for directory opens that don't |
| involve any prop mods, because those are the result from |
| bubble-up and don't belong in a change list. */ |
| if (! ((node->kind == svn_node_dir) |
| && (node->action == 'R') |
| && (! node->prop_mod))) |
| { |
| apr_hash_set (changed, |
| apr_pstrdup (pool, path->data), path->len, |
| (void *) ((int) node->action)); |
| } |
| |
| /* "Leave" this node. */ |
| svn_path_remove_component (path); |
| |
| /* ### todo: See issue #559. This workaround is slated for |
| demolition in the next ten microseconds. */ |
| if (path->len == 0) |
| svn_stringbuf_appendcstr (path, "/"); |
| } |
| |
| |
| svn_error_t * |
| svn_repos_get_logs (svn_repos_t *repos, |
| const apr_array_header_t *paths, |
| svn_revnum_t start, |
| svn_revnum_t end, |
| svn_boolean_t discover_changed_paths, |
| svn_log_message_receiver_t receiver, |
| void *receiver_baton, |
| apr_pool_t *pool) |
| { |
| svn_revnum_t this_rev, head = SVN_INVALID_REVNUM; |
| apr_pool_t *subpool = svn_pool_create (pool); |
| apr_hash_t *changed_paths = NULL; |
| svn_fs_t *fs = repos->fs; |
| apr_array_header_t *revs = NULL; |
| |
| /* If no START revision was given, use HEAD. */ |
| if (! SVN_IS_VALID_REVNUM (start)) |
| { |
| SVN_ERR (svn_fs_youngest_rev (&head, fs, pool)); |
| start = head; |
| } |
| |
| /* If no END revision was given, use HEAD (note that we might have |
| already calculate HEAD in the step above). */ |
| if (! SVN_IS_VALID_REVNUM (end)) |
| { |
| if (! SVN_IS_VALID_REVNUM (head)) |
| SVN_ERR (svn_fs_youngest_rev (&head, fs, pool)); |
| end = head; |
| } |
| |
| /* If paths were specified, then we only really care about revisions |
| in which those paths were changed. So we ask the filesystem for |
| all the revisions in which any of the paths was changed. */ |
| if (paths && paths->nelts) |
| { |
| int i; |
| svn_fs_root_t *rev_root; |
| apr_array_header_t *cpaths = |
| apr_array_make (pool, paths->nelts, sizeof (const char *)); |
| |
| /* Build an array of const char's from our stringbuf stuff. */ |
| for (i = 0; i < paths->nelts; i++) |
| (*(const char **)apr_array_push (cpaths)) = |
| (APR_ARRAY_IDX (paths, i, svn_stringbuf_t *))->data; |
| |
| /* Set the revision root to the newer of the revisions we are |
| searching for. */ |
| SVN_ERR (svn_fs_revision_root (&rev_root, fs, |
| (start > end) ? start : end, pool)); |
| |
| /* And the search is on... */ |
| SVN_ERR (svn_fs_revisions_changed (&revs, rev_root, cpaths, pool)); |
| |
| /* If no revisions were found for these entries, we have nothing |
| to show. Just return now before we break a sweat. */ |
| if (! (revs && revs->nelts)) |
| return SVN_NO_ERROR; |
| } |
| |
| for (this_rev = start; |
| ((start >= end) ? (this_rev >= end) : (this_rev <= end)); |
| ((start >= end) ? this_rev-- : this_rev++)) |
| { |
| svn_string_t *author, *date, *message; |
| |
| /* If we have a list of revs for use, check to make sure this is |
| one of them. */ |
| if (revs) |
| { |
| int i, matched = 0; |
| for (i = 0; ((i < revs->nelts) && (! matched)); i++) |
| { |
| if (this_rev == ((svn_revnum_t *)(revs->elts))[i]) |
| matched = 1; |
| } |
| |
| if (! matched) |
| continue; |
| } |
| |
| SVN_ERR (svn_fs_revision_prop |
| (&author, fs, this_rev, SVN_PROP_REVISION_AUTHOR, subpool)); |
| SVN_ERR (svn_fs_revision_prop |
| (&date, fs, this_rev, SVN_PROP_REVISION_DATE, subpool)); |
| SVN_ERR (svn_fs_revision_prop |
| (&message, fs, this_rev, SVN_PROP_REVISION_LOG, subpool)); |
| |
| /* ### Below, we discover changed paths if the user requested |
| them (i.e., "svn log -v" means `discover_changed_paths' will |
| be non-zero here). */ |
| |
| #ifndef SVN_REPOS_ALLOW_LOG_WITH_PATHS |
| discover_changed_paths = FALSE; |
| #else |
| if ((this_rev > 0) && |
| (discover_changed_paths || (paths && paths->nelts > 0))) |
| { |
| const svn_delta_edit_fns_t *editor; |
| svn_fs_root_t *oldroot, *newroot; |
| void *edit_baton; |
| |
| changed_paths = apr_hash_make (subpool); |
| |
| /* Use a dir_deltas run with the node editor between the |
| current revision and its immediate predecessor to see |
| what changed in this revision. |
| |
| ### todo: not sure this needs an editor and dir_deltas. |
| Might be easier to just walk the one revision tree, |
| looking at created-rev fields... */ |
| SVN_ERR (svn_fs_revision_root (&oldroot, fs, this_rev - 1, subpool)); |
| SVN_ERR (svn_fs_revision_root (&newroot, fs, this_rev, subpool)); |
| SVN_ERR (svn_repos_node_editor (&editor, &edit_baton, fs, |
| oldroot, newroot, subpool, subpool)); |
| SVN_ERR (svn_repos_dir_delta (oldroot, "", NULL, NULL, |
| newroot, "", |
| editor, edit_baton, |
| FALSE, TRUE, FALSE, subpool)); |
| detect_changed (changed_paths, |
| svn_repos_node_from_baton (edit_baton), |
| svn_stringbuf_create ("/", subpool), |
| subpool); |
| |
| /* ### Feels slightly bogus to assume "/" as the right start |
| for repository style. */ |
| } |
| |
| #endif /* SVN_REPOS_ALLOW_LOG_WITH_PATHS */ |
| |
| SVN_ERR ((*receiver) (receiver_baton, |
| (discover_changed_paths ? changed_paths : NULL), |
| this_rev, |
| author ? author->data : "", |
| date ? date->data : "", |
| message ? message->data : "")); |
| |
| svn_pool_clear (subpool); |
| } |
| |
| svn_pool_destroy (subpool); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| /* |
| * local variables: |
| * eval: (load-file "../../tools/dev/svn-dev.el") |
| * end: |
| */ |
