subversion-1.9.7HEADsubversion-1.9.7master

1 files changed, 619 insertions, 458 deletions

diff --git a/subversion/libsvn_client/diff_local.c b/subversion/libsvn_client/diff_local.c
index 2dd8a1b..df6bc0a 100644
--- a/subversion/libsvn_client/diff_local.c
+++ b/subversion/libsvn_client/diff_local.c
@@ -45,7 +45,9 @@
 #include "svn_subst.h"
 #include "client.h"
 
+#include "private/svn_sorts_private.h"
 #include "private/svn_wc_private.h"
+#include "private/svn_diff_tree.h"
 
 #include "svn_private_config.h"
 
@@ -81,559 +83,718 @@ get_props(apr_hash_t **props,
   return SVN_NO_ERROR;
 }
 
-/* Produce a diff between two arbitrary files at LOCAL_ABSPATH1 and
- * LOCAL_ABSPATH2, using the diff callbacks from CALLBACKS.
- * Use PATH as the name passed to diff callbacks.
- * FILE1_IS_EMPTY and FILE2_IS_EMPTY are used as hints which diff callback
- * function to use to compare the files (added/deleted/changed).
+/* Forward declaration */
+static svn_error_t *
+do_file_diff(const char *left_abspath,
+             const char *right_abspath,
+             const char *left_root_abspath,
+             const char *right_root_abspath,
+             svn_boolean_t left_only,
+             svn_boolean_t right_only,
+             void *parent_baton,
+             const svn_diff_tree_processor_t *diff_processor,
+             svn_client_ctx_t *ctx,
+             apr_pool_t *scratch_pool);
+
+/* Forward declaration */
+static svn_error_t *
+do_dir_diff(const char *left_abspath,
+            const char *right_abspath,
+            const char *left_root_abspath,
+            const char *right_root_abspath,
+            svn_boolean_t left_only,
+            svn_boolean_t right_only,
+            svn_boolean_t left_before_right,
+            svn_depth_t depth,
+            void *parent_baton,
+            const svn_diff_tree_processor_t *diff_processor,
+            svn_client_ctx_t *ctx,
+            apr_pool_t *scratch_pool);
+
+/* Produce a diff of depth DEPTH between two arbitrary directories at
+ * LEFT_ABSPATH1 and RIGHT_ABSPATH2, using the provided diff callbacks
+ * to show file changes and, for versioned nodes, property changes.
+ *
+ * Report paths as relative from LEFT_ROOT_ABSPATH/RIGHT_ROOT_ABSPATH.
  *
- * If ORIGINAL_PROPS_OVERRIDE is not NULL, use it as original properties
- * instead of reading properties from LOCAL_ABSPATH1. This is required when
- * a file replaces a directory, where LOCAL_ABSPATH1 is an empty file that
- * file content must be diffed against, but properties to diff against come
- * from the replaced directory. */
+ * If LEFT_ONLY is TRUE, only the left source exists (= everything will
+ * be reported as deleted). If RIGHT_ONLY is TRUE, only the right source
+ * exists (= everything will be reported as added).
+ *
+ * If LEFT_BEFORE_RIGHT is TRUE and left and right are unrelated, left is
+ * reported first. If false, right is reported first. (This is to allow
+ * producing a proper inverse diff).
+ *
+ * Walk the sources according to depth, and report with parent baton
+ * PARENT_BATON. */
 static svn_error_t *
-do_arbitrary_files_diff(const char *local_abspath1,
-                        const char *local_abspath2,
-                        const char *path,
-                        svn_boolean_t file1_is_empty,
-                        svn_boolean_t file2_is_empty,
-                        apr_hash_t *original_props_override,
-                        const svn_wc_diff_callbacks4_t *callbacks,
-                        void *diff_baton,
-                        svn_client_ctx_t *ctx,
-                        apr_pool_t *scratch_pool)
+inner_dir_diff(const char *left_abspath,
+               const char *right_abspath,
+               const char *left_root_abspath,
+               const char *right_root_abspath,
+               svn_boolean_t left_only,
+               svn_boolean_t right_only,
+               svn_boolean_t left_before_right,
+               svn_depth_t depth,
+               void *parent_baton,
+               const svn_diff_tree_processor_t *diff_processor,
+               svn_client_ctx_t *ctx,
+               apr_pool_t *scratch_pool)
 {
-  apr_hash_t *original_props;
-  apr_hash_t *modified_props;
-  apr_array_header_t *prop_changes;
-  svn_string_t *original_mime_type = NULL;
-  svn_string_t *modified_mime_type = NULL;
-
-  if (ctx->cancel_func)
-    SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
-
-  /* Try to get properties from either file. It's OK if the files do not
-   * have properties, or if they are unversioned. */
-  if (original_props_override)
-    original_props = original_props_override;
-  else
-    SVN_ERR(get_props(&original_props, local_abspath1, ctx->wc_ctx,
-                      scratch_pool, scratch_pool));
-  SVN_ERR(get_props(&modified_props, local_abspath2, ctx->wc_ctx,
-                    scratch_pool, scratch_pool));
+  apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+  apr_hash_t *left_dirents;
+  apr_hash_t *right_dirents;
+  apr_array_header_t *sorted_dirents;
+  svn_error_t *err;
+  svn_depth_t depth_below_here;
+  int i;
 
-  SVN_ERR(svn_prop_diffs(&prop_changes, modified_props, original_props,
-                         scratch_pool));
+  SVN_ERR_ASSERT(depth >= svn_depth_files && depth <= svn_depth_infinity);
 
-  /* Try to determine the mime-type of each file. */
-  original_mime_type = svn_hash_gets(original_props, SVN_PROP_MIME_TYPE);
-  if (!file1_is_empty && !original_mime_type)
+  if (!right_only)
     {
-      const char *mime_type;
-      SVN_ERR(svn_io_detect_mimetype2(&mime_type, local_abspath1,
-                                      ctx->mimetypes_map, scratch_pool));
+      err = svn_io_get_dirents3(&left_dirents, left_abspath, FALSE,
+                                scratch_pool, iterpool);
 
-      if (mime_type)
-        original_mime_type = svn_string_create(mime_type, scratch_pool);
+      if (err && (APR_STATUS_IS_ENOENT(err->apr_err)
+                  || SVN__APR_STATUS_IS_ENOTDIR(err->apr_err)))
+        {
+          svn_error_clear(err);
+          left_dirents = apr_hash_make(scratch_pool);
+          right_only = TRUE;
+        }
+      else
+        SVN_ERR(err);
     }
+  else
+    left_dirents = apr_hash_make(scratch_pool);
 
-  modified_mime_type = svn_hash_gets(modified_props, SVN_PROP_MIME_TYPE);
-  if (!file2_is_empty && !modified_mime_type)
+  if (!left_only)
     {
-      const char *mime_type;
-      SVN_ERR(svn_io_detect_mimetype2(&mime_type, local_abspath1,
-                                      ctx->mimetypes_map, scratch_pool));
+      err = svn_io_get_dirents3(&right_dirents, right_abspath, FALSE,
+                                scratch_pool, iterpool);
 
-      if (mime_type)
-        modified_mime_type = svn_string_create(mime_type, scratch_pool);
+      if (err && (APR_STATUS_IS_ENOENT(err->apr_err)
+                  || SVN__APR_STATUS_IS_ENOTDIR(err->apr_err)))
+        {
+          svn_error_clear(err);
+          right_dirents = apr_hash_make(scratch_pool);
+          right_only = TRUE;
+        }
+      else
+        SVN_ERR(err);
     }
+  else
+    right_dirents = apr_hash_make(scratch_pool);
+
+  if (left_only && right_only)
+    return SVN_NO_ERROR; /* Somebody deleted the directory?? */
 
-  /* Produce the diff. */
-  if (file1_is_empty && !file2_is_empty)
-    SVN_ERR(callbacks->file_added(NULL, NULL, NULL, path,
-                                  local_abspath1, local_abspath2,
-                                  /* ### TODO get real revision info
-                                   * for versioned files? */
-                                  SVN_INVALID_REVNUM, SVN_INVALID_REVNUM,
-                                  original_mime_type ?
-                                    original_mime_type->data : NULL,
-                                  modified_mime_type ?
-                                    modified_mime_type->data : NULL,
-                                  /* ### TODO get copyfrom? */
-                                  NULL, SVN_INVALID_REVNUM,
-                                  prop_changes, original_props,
-                                  diff_baton, scratch_pool));
-  else if (!file1_is_empty && file2_is_empty)
-    SVN_ERR(callbacks->file_deleted(NULL, NULL, path,
-                                    local_abspath1, local_abspath2,
-                                    original_mime_type ?
-                                      original_mime_type->data : NULL,
-                                    modified_mime_type ?
-                                      modified_mime_type->data : NULL,
-                                    original_props,
-                                    diff_baton, scratch_pool));
+  if (depth != svn_depth_infinity)
+    depth_below_here = svn_depth_empty;
   else
+    depth_below_here = svn_depth_infinity;
+
+  sorted_dirents = svn_sort__hash(apr_hash_merge(iterpool, left_dirents,
+                                                 right_dirents, NULL, NULL),
+                                  svn_sort_compare_items_as_paths,
+                                  scratch_pool);
+
+  for (i = 0; i < sorted_dirents->nelts; i++)
     {
-      svn_stream_t *file1;
-      svn_stream_t *file2;
-      svn_boolean_t same;
-      svn_string_t *val;
-      /* We have two files, which may or may not be the same.
+      svn_sort__item_t* elt = &APR_ARRAY_IDX(sorted_dirents, i, svn_sort__item_t);
+      svn_io_dirent2_t *left_dirent;
+      svn_io_dirent2_t *right_dirent;
+      const char *child_left_abspath;
+      const char *child_right_abspath;
 
-         ### Our caller assumes that we should ignore symlinks here and
-             handle them as normal paths. Perhaps that should change?
-      */
-      SVN_ERR(svn_stream_open_readonly(&file1, local_abspath1, scratch_pool,
-                                       scratch_pool));
+      svn_pool_clear(iterpool);
 
-      SVN_ERR(svn_stream_open_readonly(&file2, local_abspath2, scratch_pool,
-                                       scratch_pool));
+      if (ctx->cancel_func)
+        SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
 
-      /* Wrap with normalization, etc. if necessary */
-      if (original_props)
-        {
-          val = svn_hash_gets(original_props, SVN_PROP_EOL_STYLE);
+      if (svn_wc_is_adm_dir(elt->key, iterpool))
+        continue;
 
-          if (val)
+      left_dirent = right_only ? NULL : svn_hash_gets(left_dirents, elt->key);
+      right_dirent = left_only ? NULL : svn_hash_gets(right_dirents, elt->key);
+
+      child_left_abspath = svn_dirent_join(left_abspath, elt->key, iterpool);
+      child_right_abspath = svn_dirent_join(right_abspath, elt->key, iterpool);
+
+      if (((left_dirent == NULL) != (right_dirent == NULL))
+          || (left_dirent->kind != right_dirent->kind))
+        {
+          /* Report delete and/or add */
+          if (left_dirent && left_before_right)
             {
-              svn_subst_eol_style_t style;
-              const char *eol;
-              svn_subst_eol_style_from_value(&style, &eol, val->data);
-
-              /* ### Ignoring keywords */
-              if (eol)
-                file1 = svn_subst_stream_translated(file1, eol, TRUE,
-                                                    NULL, FALSE,
-                                                    scratch_pool);
+              if (left_dirent->kind == svn_node_file)
+                SVN_ERR(do_file_diff(child_left_abspath, child_right_abspath,
+                                     left_root_abspath, right_root_abspath,
+                                     TRUE, FALSE, parent_baton,
+                                     diff_processor, ctx, iterpool));
+              else if (depth >= svn_depth_immediates)
+                SVN_ERR(do_dir_diff(child_left_abspath, child_right_abspath,
+                                    left_root_abspath, right_root_abspath,
+                                    TRUE, FALSE, left_before_right,
+                                    depth_below_here, parent_baton,
+                                    diff_processor, ctx, iterpool));
             }
-        }
 
-      if (modified_props)
-        {
-          val = svn_hash_gets(modified_props, SVN_PROP_EOL_STYLE);
+          if (right_dirent)
+            {
+              if (right_dirent->kind == svn_node_file)
+                SVN_ERR(do_file_diff(child_left_abspath, child_right_abspath,
+                                     left_root_abspath, right_root_abspath,
+                                     FALSE, TRUE, parent_baton,
+                                     diff_processor, ctx, iterpool));
+              else if (depth >= svn_depth_immediates)
+                SVN_ERR(do_dir_diff(child_left_abspath, child_right_abspath,
+                                    left_root_abspath, right_root_abspath,
+                                    FALSE, TRUE,  left_before_right,
+                                    depth_below_here, parent_baton,
+                                    diff_processor, ctx, iterpool));
+            }
 
-          if (val)
+          if (left_dirent && !left_before_right)
             {
-              svn_subst_eol_style_t style;
-              const char *eol;
-              svn_subst_eol_style_from_value(&style, &eol, val->data);
-
-              /* ### Ignoring keywords */
-              if (eol)
-                file2 = svn_subst_stream_translated(file2, eol, TRUE,
-                                                    NULL, FALSE,
-                                                    scratch_pool);
+              if (left_dirent->kind == svn_node_file)
+                SVN_ERR(do_file_diff(child_left_abspath, child_right_abspath,
+                                     left_root_abspath, right_root_abspath,
+                                     TRUE, FALSE, parent_baton,
+                                     diff_processor, ctx, iterpool));
+              else if (depth >= svn_depth_immediates)
+                SVN_ERR(do_dir_diff(child_left_abspath, child_right_abspath,
+                                    left_root_abspath, right_root_abspath,
+                                    TRUE, FALSE,  left_before_right,
+                                    depth_below_here, parent_baton,
+                                    diff_processor, ctx, iterpool));
             }
         }
-
-      SVN_ERR(svn_stream_contents_same2(&same, file1, file2, scratch_pool));
-
-      if (! same || prop_changes->nelts > 0)
+      else if (left_dirent->kind == svn_node_file)
         {
-          /* ### We should probably pass the normalized data we created using
-                 the subst streams as that is what diff users expect */
-          SVN_ERR(callbacks->file_changed(NULL, NULL, NULL, path,
-                                          same ? NULL : local_abspath1,
-                                          same ? NULL : local_abspath2,
-                                          /* ### TODO get real revision info
-                                           * for versioned files? */
-                                          SVN_INVALID_REVNUM /* rev1 */,
-                                          SVN_INVALID_REVNUM /* rev2 */,
-                                          original_mime_type ?
-                                            original_mime_type->data : NULL,
-                                          modified_mime_type ?
-                                            modified_mime_type->data : NULL,
-                                          prop_changes, original_props,
-                                          diff_baton, scratch_pool));
+          /* Perform file-file diff */
+          SVN_ERR(do_file_diff(child_left_abspath, child_right_abspath,
+                               left_root_abspath, right_root_abspath,
+                               FALSE, FALSE, parent_baton,
+                               diff_processor, ctx, iterpool));
+        }
+      else if (depth >= svn_depth_immediates)
+        {
+          /* Perform dir-dir diff */
+          SVN_ERR(do_dir_diff(child_left_abspath, child_right_abspath,
+                              left_root_abspath, right_root_abspath,
+                              FALSE, FALSE,  left_before_right,
+                              depth_below_here, parent_baton,
+                              diff_processor, ctx, iterpool));
         }
     }
 
   return SVN_NO_ERROR;
 }
 
-struct arbitrary_diff_walker_baton {
-  /* The root directories of the trees being compared. */
-  const char *root1_abspath;
-  const char *root2_abspath;
-
-  /* TRUE if recursing within an added subtree of root2_abspath that
-   * does not exist in root1_abspath. */
-  svn_boolean_t recursing_within_added_subtree;
+/* Translates *LEFT_ABSPATH to a temporary file if PROPS specify that the
+   file needs translation. *LEFT_ABSPATH is updated to point to a file that
+   lives at least as long as RESULT_POOL when translation is necessary.
+   Otherwise the value is not updated */
+static svn_error_t *
+translate_if_necessary(const char **local_abspath,
+                       apr_hash_t *props,
+                       svn_cancel_func_t cancel_func,
+                       void *cancel_baton,
+                       apr_pool_t *result_pool,
+                       apr_pool_t *scratch_pool)
+{
+  const svn_string_t *eol_style_val;
+  const svn_string_t *keywords_val;
+  svn_subst_eol_style_t eol_style;
+  const char *eol;
+  apr_hash_t *keywords;
+  svn_stream_t *contents;
+  svn_stream_t *dst;
+
+  /* if (svn_hash_gets(props, SVN_PROP_SPECIAL))
+      ### TODO: Implement */
+
+  eol_style_val = svn_hash_gets(props, SVN_PROP_EOL_STYLE);
+  keywords_val = svn_hash_gets(props, SVN_PROP_KEYWORDS);
+
+  if (eol_style_val)
+    svn_subst_eol_style_from_value(&eol_style, &eol, eol_style_val->data);
+  else
+    {
+      eol = NULL;
+      eol_style = svn_subst_eol_style_none;
+    }
 
-  /* TRUE if recursing within an administrative (.i.e. .svn) directory. */
-  svn_boolean_t recursing_within_adm_dir;
+  if (keywords_val)
+    SVN_ERR(svn_subst_build_keywords3(&keywords, keywords_val->data,
+                                      APR_STRINGIFY(SVN_INVALID_REVNUM),
+                                      "", "", 0, "", scratch_pool));
+  else
+    keywords = NULL;
 
-  /* The absolute path of the adm dir if RECURSING_WITHIN_ADM_DIR is TRUE.
-   * Else this is NULL.*/
-  const char *adm_dir_abspath;
+  if (!svn_subst_translation_required(eol_style, eol, keywords, FALSE, FALSE))
+    return SVN_NO_ERROR;
 
-  /* A path to an empty file used for diffs that add/delete files. */
-  const char *empty_file_abspath;
+  SVN_ERR(svn_stream_open_readonly(&contents, *local_abspath,
+                                    scratch_pool, scratch_pool));
 
-  const svn_wc_diff_callbacks4_t *callbacks;
-  void *diff_baton;
-  svn_client_ctx_t *ctx;
-  apr_pool_t *pool;
-} arbitrary_diff_walker_baton;
+  SVN_ERR(svn_stream_open_unique(&dst, local_abspath, NULL,
+                                  svn_io_file_del_on_pool_cleanup,
+                                  result_pool, scratch_pool));
 
-/* Forward declaration needed because this function has a cyclic
- * dependency with do_arbitrary_dirs_diff(). */
-static svn_error_t *
-arbitrary_diff_walker(void *baton, const char *local_abspath,
-                      const apr_finfo_t *finfo,
-                      apr_pool_t *scratch_pool);
+  dst = svn_subst_stream_translated(dst, eol, TRUE /* repair */,
+                                    keywords, FALSE /* expand */,
+                                    scratch_pool);
 
-/* Another forward declaration. */
-static svn_error_t *
-arbitrary_diff_this_dir(struct arbitrary_diff_walker_baton *b,
-                        const char *local_abspath,
-                        svn_depth_t depth,
-                        apr_pool_t *scratch_pool);
+  SVN_ERR(svn_stream_copy3(contents, dst, cancel_func, cancel_baton,
+                           scratch_pool));
 
-/* Produce a diff of depth DEPTH between two arbitrary directories at
- * LOCAL_ABSPATH1 and LOCAL_ABSPATH2, using the provided diff callbacks
- * to show file changes and, for versioned nodes, property changes.
- *
- * If ROOT_ABSPATH1 and ROOT_ABSPATH2 are not NULL, show paths in diffs
- * relative to these roots, rather than relative to LOCAL_ABSPATH1 and
- * LOCAL_ABSPATH2. This is needed when crawling a subtree that exists
- * only within LOCAL_ABSPATH2. */
-static svn_error_t *
-do_arbitrary_dirs_diff(const char *local_abspath1,
-                       const char *local_abspath2,
-                       const char *root_abspath1,
-                       const char *root_abspath2,
-                       svn_depth_t depth,
-                       const svn_wc_diff_callbacks4_t *callbacks,
-                       void *diff_baton,
-                       svn_client_ctx_t *ctx,
-                       apr_pool_t *scratch_pool)
-{
-  apr_file_t *empty_file;
-  svn_node_kind_t kind1;
-
-  struct arbitrary_diff_walker_baton b;
-
-  /* If LOCAL_ABSPATH1 is not a directory, crawl LOCAL_ABSPATH2 instead
-   * and compare it to LOCAL_ABSPATH1, showing only additions.
-   * This case can only happen during recursion from arbitrary_diff_walker(),
-   * because do_arbitrary_nodes_diff() prevents this from happening at
-   * the root of the comparison. */
-  SVN_ERR(svn_io_check_resolved_path(local_abspath1, &kind1, scratch_pool));
-  b.recursing_within_added_subtree = (kind1 != svn_node_dir);
-
-  b.root1_abspath = root_abspath1 ? root_abspath1 : local_abspath1;
-  b.root2_abspath = root_abspath2 ? root_abspath2 : local_abspath2;
-  b.recursing_within_adm_dir = FALSE;
-  b.adm_dir_abspath = NULL;
-  b.callbacks = callbacks;
-  b.diff_baton = diff_baton;
-  b.ctx = ctx;
-  b.pool = scratch_pool;
-
-  SVN_ERR(svn_io_open_unique_file3(&empty_file, &b.empty_file_abspath,
-                                   NULL, svn_io_file_del_on_pool_cleanup,
-                                   scratch_pool, scratch_pool));
-
-  if (depth <= svn_depth_immediates)
-    SVN_ERR(arbitrary_diff_this_dir(&b, local_abspath1, depth, scratch_pool));
-  else if (depth == svn_depth_infinity)
-    SVN_ERR(svn_io_dir_walk2(b.recursing_within_added_subtree ? local_abspath2
-                                                              : local_abspath1,
-                             0, arbitrary_diff_walker, &b, scratch_pool));
   return SVN_NO_ERROR;
 }
 
-/* Produce a diff of depth DEPTH for the directory at LOCAL_ABSPATH,
- * using information from the arbitrary_diff_walker_baton B.
- * LOCAL_ABSPATH is the path being crawled and can be on either side
- * of the diff depending on baton->recursing_within_added_subtree. */
+/* Handles reporting of a file for inner_dir_diff */
 static svn_error_t *
-arbitrary_diff_this_dir(struct arbitrary_diff_walker_baton *b,
-                        const char *local_abspath,
-                        svn_depth_t depth,
-                        apr_pool_t *scratch_pool)
+do_file_diff(const char *left_abspath,
+             const char *right_abspath,
+             const char *left_root_abspath,
+             const char *right_root_abspath,
+             svn_boolean_t left_only,
+             svn_boolean_t right_only,
+             void *parent_baton,
+             const svn_diff_tree_processor_t *diff_processor,
+             svn_client_ctx_t *ctx,
+             apr_pool_t *scratch_pool)
 {
-  const char *local_abspath1;
-  const char *local_abspath2;
-  svn_node_kind_t kind1;
-  svn_node_kind_t kind2;
-  const char *child_relpath;
-  apr_hash_t *dirents1;
-  apr_hash_t *dirents2;
-  apr_hash_t *merged_dirents;
-  apr_array_header_t *sorted_dirents;
-  int i;
-  apr_pool_t *iterpool;
-
-  if (b->recursing_within_adm_dir)
-    {
-      if (svn_dirent_skip_ancestor(b->adm_dir_abspath, local_abspath))
-        return SVN_NO_ERROR;
-      else
-        {
-          b->recursing_within_adm_dir = FALSE;
-          b->adm_dir_abspath = NULL;
-        }
-    }
-  else if (svn_wc_is_adm_dir(svn_dirent_basename(local_abspath, NULL),
-                             scratch_pool))
-    {
-      b->recursing_within_adm_dir = TRUE;
-      b->adm_dir_abspath = apr_pstrdup(b->pool, local_abspath);
-      return SVN_NO_ERROR;
-    }
+  const char *relpath;
+  svn_diff_source_t *left_source;
+  svn_diff_source_t *right_source;
+  svn_boolean_t skip = FALSE;
+  apr_hash_t *left_props;
+  apr_hash_t *right_props;
+  void *file_baton;
+
+  relpath = svn_dirent_skip_ancestor(left_root_abspath, left_abspath);
+
+ if (! right_only)
+    left_source = svn_diff__source_create(SVN_INVALID_REVNUM, scratch_pool);
+  else
+    left_source = NULL;
 
-  if (b->recursing_within_added_subtree)
-    child_relpath = svn_dirent_skip_ancestor(b->root2_abspath, local_abspath);
+  if (! left_only)
+    right_source = svn_diff__source_create(SVN_INVALID_REVNUM, scratch_pool);
   else
-    child_relpath = svn_dirent_skip_ancestor(b->root1_abspath, local_abspath);
-  if (!child_relpath)
+    right_source = NULL;
+
+  SVN_ERR(diff_processor->file_opened(&file_baton, &skip,
+                                      relpath,
+                                      left_source,
+                                      right_source,
+                                      NULL /* copyfrom_source */,
+                                      parent_baton,
+                                      diff_processor,
+                                      scratch_pool,
+                                      scratch_pool));
+
+  if (skip)
     return SVN_NO_ERROR;
 
-  local_abspath1 = svn_dirent_join(b->root1_abspath, child_relpath,
-                                   scratch_pool);
-  SVN_ERR(svn_io_check_resolved_path(local_abspath1, &kind1, scratch_pool));
+   if (! right_only)
+    {
+      SVN_ERR(get_props(&left_props, left_abspath, ctx->wc_ctx,
+                        scratch_pool, scratch_pool));
 
-  local_abspath2 = svn_dirent_join(b->root2_abspath, child_relpath,
-                                   scratch_pool);
-  SVN_ERR(svn_io_check_resolved_path(local_abspath2, &kind2, scratch_pool));
+      /* We perform a mimetype detection to avoid diffing binary files
+         for textual changes.*/
+      if (! svn_hash_gets(left_props, SVN_PROP_MIME_TYPE))
+        {
+          const char *mime_type;
 
-  if (depth > svn_depth_empty)
-    {
-      if (kind1 == svn_node_dir)
-        SVN_ERR(svn_io_get_dirents3(&dirents1, local_abspath1,
-                                    TRUE, /* only_check_type */
-                                    scratch_pool, scratch_pool));
-      else
-        dirents1 = apr_hash_make(scratch_pool);
+          /* ### Use libmagic magic? */
+          SVN_ERR(svn_io_detect_mimetype2(&mime_type, left_abspath,
+                                          ctx->mimetypes_map, scratch_pool));
+
+          if (mime_type)
+            svn_hash_sets(left_props, SVN_PROP_MIME_TYPE,
+                          svn_string_create(mime_type, scratch_pool));
+        }
+
+      SVN_ERR(translate_if_necessary(&left_abspath, left_props,
+                                     ctx->cancel_func, ctx->cancel_baton,
+                                     scratch_pool, scratch_pool));
     }
+  else
+    left_props = NULL;
 
-  if (kind2 == svn_node_dir)
+  if (! left_only)
     {
-      apr_hash_t *original_props;
-      apr_hash_t *modified_props;
-      apr_array_header_t *prop_changes;
-
-      /* Show any property changes for this directory. */
-      SVN_ERR(get_props(&original_props, local_abspath1, b->ctx->wc_ctx,
-                        scratch_pool, scratch_pool));
-      SVN_ERR(get_props(&modified_props, local_abspath2, b->ctx->wc_ctx,
+      SVN_ERR(get_props(&right_props, right_abspath, ctx->wc_ctx,
                         scratch_pool, scratch_pool));
-      SVN_ERR(svn_prop_diffs(&prop_changes, modified_props, original_props,
-                             scratch_pool));
-      if (prop_changes->nelts > 0)
-        SVN_ERR(b->callbacks->dir_props_changed(NULL, NULL, child_relpath,
-                                                FALSE /* was_added */,
-                                                prop_changes, original_props,
-                                                b->diff_baton,
-                                                scratch_pool));
-
-      if (depth > svn_depth_empty)
-        {
-          /* Read directory entries. */
-          SVN_ERR(svn_io_get_dirents3(&dirents2, local_abspath2,
-                                      TRUE, /* only_check_type */
-                                      scratch_pool, scratch_pool));
-        }
-    }
-  else if (depth > svn_depth_empty)
-    dirents2 = apr_hash_make(scratch_pool);
 
-  if (depth <= svn_depth_empty)
-    return SVN_NO_ERROR;
+      /* We perform a mimetype detection to avoid diffing binary files
+         for textual changes.*/
+      if (! svn_hash_gets(right_props, SVN_PROP_MIME_TYPE))
+        {
+          const char *mime_type;
 
-  /* Compare dirents1 to dirents2 and show added/deleted/changed files. */
-  merged_dirents = apr_hash_merge(scratch_pool, dirents1, dirents2,
-                                  NULL, NULL);
-  sorted_dirents = svn_sort__hash(merged_dirents,
-                                  svn_sort_compare_items_as_paths,
-                                  scratch_pool);
-  iterpool = svn_pool_create(scratch_pool);
-  for (i = 0; i < sorted_dirents->nelts; i++)
-    {
-      svn_sort__item_t elt = APR_ARRAY_IDX(sorted_dirents, i, svn_sort__item_t);
-      const char *name = elt.key;
-      svn_io_dirent2_t *dirent1;
-      svn_io_dirent2_t *dirent2;
-      const char *child1_abspath;
-      const char *child2_abspath;
+          /* ### Use libmagic magic? */
+          SVN_ERR(svn_io_detect_mimetype2(&mime_type, right_abspath,
+                                          ctx->mimetypes_map, scratch_pool));
 
-      svn_pool_clear(iterpool);
+          if (mime_type)
+            svn_hash_sets(right_props, SVN_PROP_MIME_TYPE,
+                          svn_string_create(mime_type, scratch_pool));
+        }
 
-      if (b->ctx->cancel_func)
-        SVN_ERR(b->ctx->cancel_func(b->ctx->cancel_baton));
+      SVN_ERR(translate_if_necessary(&right_abspath, right_props,
+                                     ctx->cancel_func, ctx->cancel_baton,
+                                     scratch_pool, scratch_pool));
 
-      if (strcmp(name, SVN_WC_ADM_DIR_NAME) == 0)
-        continue;
+    }
+  else
+    right_props = NULL;
 
-      dirent1 = svn_hash_gets(dirents1, name);
-      if (!dirent1)
-        {
-          dirent1 = svn_io_dirent2_create(iterpool);
-          dirent1->kind = svn_node_none;
-        }
-      dirent2 = svn_hash_gets(dirents2, name);
-      if (!dirent2)
-        {
-          dirent2 = svn_io_dirent2_create(iterpool);
-          dirent2->kind = svn_node_none;
-        }
+  if (left_only)
+    {
+      SVN_ERR(diff_processor->file_deleted(relpath,
+                                           left_source,
+                                           left_abspath,
+                                           left_props,
+                                           file_baton,
+                                           diff_processor,
+                                           scratch_pool));
+    }
+  else if (right_only)
+    {
+      SVN_ERR(diff_processor->file_added(relpath,
+                                         NULL /* copyfrom_source */,
+                                         right_source,
+                                         NULL /* copyfrom_file */,
+                                         right_abspath,
+                                         NULL /* copyfrom_props */,
+                                         right_props,
+                                         file_baton,
+                                         diff_processor,
+                                         scratch_pool));
+    }
+  else
+    {
+      /* ### Perform diff -> close/changed */
+      svn_boolean_t same;
+      apr_array_header_t *prop_changes;
 
-      child1_abspath = svn_dirent_join(local_abspath1, name, iterpool);
-      child2_abspath = svn_dirent_join(local_abspath2, name, iterpool);
+      SVN_ERR(svn_io_files_contents_same_p(&same, left_abspath, right_abspath,
+                                           scratch_pool));
 
-      if (dirent1->special)
-        SVN_ERR(svn_io_check_resolved_path(child1_abspath, &dirent1->kind,
-                                           iterpool));
-      if (dirent2->special)
-        SVN_ERR(svn_io_check_resolved_path(child1_abspath, &dirent2->kind,
-                                           iterpool));
+      SVN_ERR(svn_prop_diffs(&prop_changes, right_props, left_props,
+                             scratch_pool));
 
-      if (dirent1->kind == svn_node_dir &&
-          dirent2->kind == svn_node_dir)
+      if (!same || prop_changes->nelts > 0)
         {
-          if (depth == svn_depth_immediates)
-            {
-              /* Not using the walker, so show property diffs on these dirs. */
-              SVN_ERR(do_arbitrary_dirs_diff(child1_abspath, child2_abspath,
-                                             b->root1_abspath, b->root2_abspath,
-                                             svn_depth_empty,
-                                             b->callbacks, b->diff_baton,
-                                             b->ctx, iterpool));
-            }
-          else
-            {
-              /* Either the walker will visit these directories (with
-               * depth=infinity) and they will be processed as 'this dir'
-               * later, or we're showing file children only (depth=files). */
-              continue;
-            }
-
+          SVN_ERR(diff_processor->file_changed(relpath,
+                                               left_source,
+                                               right_source,
+                                               same ? NULL : left_abspath,
+                                               same ? NULL : right_abspath,
+                                               left_props,
+                                               right_props,
+                                               !same,
+                                               prop_changes,
+                                               file_baton,
+                                               diff_processor,
+                                               scratch_pool));
         }
-
-      /* Files that exist only in dirents1. */
-      if (dirent1->kind == svn_node_file &&
-          (dirent2->kind == svn_node_dir || dirent2->kind == svn_node_none))
-        SVN_ERR(do_arbitrary_files_diff(child1_abspath, b->empty_file_abspath,
-                                        svn_relpath_join(child_relpath, name,
-                                                         iterpool),
-                                        FALSE, TRUE, NULL,
-                                        b->callbacks, b->diff_baton,
-                                        b->ctx, iterpool));
-
-      /* Files that exist only in dirents2. */
-      if (dirent2->kind == svn_node_file &&
-          (dirent1->kind == svn_node_dir || dirent1->kind == svn_node_none))
+      else
         {
-          apr_hash_t *original_props;
-
-          SVN_ERR(get_props(&original_props, child1_abspath, b->ctx->wc_ctx,
-                            scratch_pool, scratch_pool));
-          SVN_ERR(do_arbitrary_files_diff(b->empty_file_abspath, child2_abspath,
-                                          svn_relpath_join(child_relpath, name,
-                                                           iterpool),
-                                          TRUE, FALSE, original_props,
-                                          b->callbacks, b->diff_baton,
-                                          b->ctx, iterpool));
+          SVN_ERR(diff_processor->file_closed(relpath,
+                                            left_source,
+                                            right_source,
+                                            file_baton,
+                                            diff_processor,
+                                            scratch_pool));
         }
-
-      /* Files that exist in dirents1 and dirents2. */
-      if (dirent1->kind == svn_node_file && dirent2->kind == svn_node_file)
-        SVN_ERR(do_arbitrary_files_diff(child1_abspath, child2_abspath,
-                                        svn_relpath_join(child_relpath, name,
-                                                         iterpool),
-                                        FALSE, FALSE, NULL,
-                                        b->callbacks, b->diff_baton,
-                                        b->ctx, scratch_pool));
-
-      /* Directories that only exist in dirents2. These aren't crawled
-       * by this walker so we have to crawl them separately. */
-      if (depth > svn_depth_files &&
-          dirent2->kind == svn_node_dir &&
-          (dirent1->kind == svn_node_file || dirent1->kind == svn_node_none))
-        SVN_ERR(do_arbitrary_dirs_diff(child1_abspath, child2_abspath,
-                                       b->root1_abspath, b->root2_abspath,
-                                       depth <= svn_depth_immediates
-                                         ? svn_depth_empty
-                                         : svn_depth_infinity ,
-                                       b->callbacks, b->diff_baton,
-                                       b->ctx, iterpool));
     }
-
-  svn_pool_destroy(iterpool);
-
   return SVN_NO_ERROR;
 }
 
-/* An implementation of svn_io_walk_func_t.
- * Note: LOCAL_ABSPATH is the path being crawled and can be on either side
- * of the diff depending on baton->recursing_within_added_subtree. */
+
+/* Handles reporting of a directory and its children for inner_dir_diff */
 static svn_error_t *
-arbitrary_diff_walker(void *baton, const char *local_abspath,
-                      const apr_finfo_t *finfo,
-                      apr_pool_t *scratch_pool)
+do_dir_diff(const char *left_abspath,
+            const char *right_abspath,
+            const char *left_root_abspath,
+            const char *right_root_abspath,
+            svn_boolean_t left_only,
+            svn_boolean_t right_only,
+            svn_boolean_t left_before_right,
+            svn_depth_t depth,
+            void *parent_baton,
+            const svn_diff_tree_processor_t *diff_processor,
+            svn_client_ctx_t *ctx,
+            apr_pool_t *scratch_pool)
 {
-  struct arbitrary_diff_walker_baton *b = baton;
+  const char *relpath;
+  svn_diff_source_t *left_source;
+  svn_diff_source_t *right_source;
+  svn_boolean_t skip = FALSE;
+  svn_boolean_t skip_children = FALSE;
+  void *dir_baton;
+  apr_hash_t *left_props;
+  apr_hash_t *right_props;
+
+  relpath = svn_dirent_skip_ancestor(left_root_abspath, left_abspath);
+
+  if (! right_only)
+    {
+      left_source = svn_diff__source_create(SVN_INVALID_REVNUM, scratch_pool);
+      SVN_ERR(get_props(&left_props, left_abspath, ctx->wc_ctx,
+                        scratch_pool, scratch_pool));
+    }
+  else
+    {
+      left_source = NULL;
+      left_props = NULL;
+    }
+
+  if (! left_only)
+    {
+      right_source = svn_diff__source_create(SVN_INVALID_REVNUM, scratch_pool);
+      SVN_ERR(get_props(&right_props, right_abspath, ctx->wc_ctx,
+                        scratch_pool, scratch_pool));
+    }
+  else
+    {
+      right_source = NULL;
+      right_props = NULL;
+    }
 
-  if (b->ctx->cancel_func)
-    SVN_ERR(b->ctx->cancel_func(b->ctx->cancel_baton));
+  SVN_ERR(diff_processor->dir_opened(&dir_baton, &skip, &skip_children,
+                                     relpath,
+                                     left_source,
+                                     right_source,
+                                     NULL /* copyfrom_source */,
+                                     parent_baton,
+                                     diff_processor,
+                                     scratch_pool, scratch_pool));
 
-  if (finfo->filetype != APR_DIR)
+  if (!skip_children)
+    {
+      if (depth >= svn_depth_files)
+        SVN_ERR(inner_dir_diff(left_abspath, right_abspath,
+                               left_root_abspath, right_root_abspath,
+                               left_only, right_only,
+                               left_before_right, depth,
+                               dir_baton,
+                               diff_processor, ctx, scratch_pool));
+    }
+  else if (skip)
     return SVN_NO_ERROR;
 
-  SVN_ERR(arbitrary_diff_this_dir(b, local_abspath, svn_depth_infinity,
-                                  scratch_pool));
+  if (left_props && right_props)
+    {
+      apr_array_header_t *prop_diffs;
+
+      SVN_ERR(svn_prop_diffs(&prop_diffs, right_props, left_props,
+                             scratch_pool));
+
+      if (prop_diffs->nelts)
+        {
+          SVN_ERR(diff_processor->dir_changed(relpath,
+                                              left_source,
+                                              right_source,
+                                              left_props,
+                                              right_props,
+                                              prop_diffs,
+                                              dir_baton,
+                                              diff_processor,
+                                              scratch_pool));
+          return SVN_NO_ERROR;
+        }
+    }
+
+  if (left_source && right_source)
+    {
+      SVN_ERR(diff_processor->dir_closed(relpath,
+                                         left_source,
+                                         right_source,
+                                         dir_baton,
+                                         diff_processor,
+                                         scratch_pool));
+    }
+  else if (left_source)
+    {
+      SVN_ERR(diff_processor->dir_deleted(relpath,
+                                          left_source,
+                                          left_props,
+                                          dir_baton,
+                                          diff_processor,
+                                          scratch_pool));
+    }
+  else
+    {
+      SVN_ERR(diff_processor->dir_added(relpath,
+                                        NULL /* copyfrom_source */,
+                                        right_source,
+                                        NULL /* copyfrom_props */,
+                                        right_props,
+                                        dir_baton,
+                                        diff_processor,
+                                        scratch_pool));
+    }
 
   return SVN_NO_ERROR;
 }
 
 svn_error_t *
-svn_client__arbitrary_nodes_diff(const char *local_abspath1,
-                                 const char *local_abspath2,
+svn_client__arbitrary_nodes_diff(const char **root_relpath,
+                                 svn_boolean_t *root_is_dir,
+                                 const char *left_abspath,
+                                 const char *right_abspath,
                                  svn_depth_t depth,
-                                 const svn_wc_diff_callbacks4_t *callbacks,
-                                 void *diff_baton,
+                                 const svn_diff_tree_processor_t *diff_processor,
                                  svn_client_ctx_t *ctx,
+                                 apr_pool_t *result_pool,
                                  apr_pool_t *scratch_pool)
 {
-  svn_node_kind_t kind1;
-  svn_node_kind_t kind2;
+  svn_node_kind_t left_kind;
+  svn_node_kind_t right_kind;
+  const char *left_root_abspath;
+  const char *right_root_abspath;
+  svn_boolean_t left_before_right = TRUE; /* Future argument? */
 
-  SVN_ERR(svn_io_check_resolved_path(local_abspath1, &kind1, scratch_pool));
-  SVN_ERR(svn_io_check_resolved_path(local_abspath2, &kind2, scratch_pool));
+  if (depth == svn_depth_unknown)
+    depth = svn_depth_infinity;
 
-  if (kind1 != kind2)
-    return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
-                             _("'%s' is not the same node kind as '%s'"),
-                             svn_dirent_local_style(local_abspath1,
-                                                    scratch_pool),
-                             svn_dirent_local_style(local_abspath2,
-                                                    scratch_pool));
+  SVN_ERR(svn_io_check_resolved_path(left_abspath, &left_kind, scratch_pool));
+  SVN_ERR(svn_io_check_resolved_path(right_abspath, &right_kind, scratch_pool));
 
   if (depth == svn_depth_unknown)
     depth = svn_depth_infinity;
 
-  if (kind1 == svn_node_file)
-    SVN_ERR(do_arbitrary_files_diff(local_abspath1, local_abspath2,
-                                    svn_dirent_basename(local_abspath1,
-                                                        scratch_pool),
-                                    FALSE, FALSE, NULL,
-                                    callbacks, diff_baton,
-                                    ctx, scratch_pool));
-  else if (kind1 == svn_node_dir)
-    SVN_ERR(do_arbitrary_dirs_diff(local_abspath1, local_abspath2,
-                                   NULL, NULL, depth,
-                                   callbacks, diff_baton,
-                                   ctx, scratch_pool));
+  if (left_kind == svn_node_dir && right_kind == svn_node_dir)
+    {
+      left_root_abspath = left_abspath;
+      right_root_abspath = right_abspath;
+
+      if (root_relpath)
+        *root_relpath = "";
+      if (root_is_dir)
+        *root_is_dir = TRUE;
+    }
+  else
+    {
+      svn_dirent_split(&left_root_abspath, root_relpath, left_abspath,
+                       scratch_pool);
+      right_root_abspath = svn_dirent_dirname(right_abspath, scratch_pool);
+
+      if (root_relpath)
+        *root_relpath = apr_pstrdup(result_pool, *root_relpath);
+      if (root_is_dir)
+        *root_is_dir = FALSE;
+    }
+
+  if (left_kind == svn_node_dir && right_kind == svn_node_dir)
+    {
+      SVN_ERR(do_dir_diff(left_abspath, right_abspath,
+                          left_root_abspath, right_root_abspath,
+                          FALSE, FALSE, left_before_right,
+                          depth, NULL /* parent_baton */,
+                          diff_processor, ctx, scratch_pool));
+    }
+  else if (left_kind == svn_node_file && right_kind == svn_node_file)
+    {
+      SVN_ERR(do_file_diff(left_abspath, right_abspath,
+                           left_root_abspath, right_root_abspath,
+                           FALSE, FALSE,
+                           NULL /* parent_baton */,
+                           diff_processor, ctx, scratch_pool));
+    }
+  else if (left_kind == svn_node_file || left_kind == svn_node_dir
+           || right_kind == svn_node_file || right_kind == svn_node_dir)
+    {
+      void *dir_baton;
+      svn_boolean_t skip = FALSE;
+      svn_boolean_t skip_children = FALSE;
+      svn_diff_source_t *left_src;
+      svn_diff_source_t *right_src;
+
+      left_src = svn_diff__source_create(SVN_INVALID_REVNUM, scratch_pool);
+      right_src = svn_diff__source_create(SVN_INVALID_REVNUM, scratch_pool);
+
+      /* The root is replaced... */
+      /* Report delete and/or add */
+
+      SVN_ERR(diff_processor->dir_opened(&dir_baton, &skip, &skip_children, "",
+                                         left_src,
+                                         right_src,
+                                         NULL /* copyfrom_src */,
+                                         NULL,
+                                         diff_processor,
+                                         scratch_pool, scratch_pool));
+
+      if (skip)
+        return SVN_NO_ERROR;
+      else if (!skip_children)
+        {
+          if (left_before_right)
+            {
+              if (left_kind == svn_node_file)
+                SVN_ERR(do_file_diff(left_abspath, right_abspath,
+                                     left_root_abspath, right_root_abspath,
+                                     TRUE, FALSE, NULL /* parent_baton */,
+                                     diff_processor, ctx, scratch_pool));
+              else if (left_kind == svn_node_dir)
+                SVN_ERR(do_dir_diff(left_abspath, right_abspath,
+                                    left_root_abspath, right_root_abspath,
+                                    TRUE, FALSE, left_before_right,
+                                    depth, NULL /* parent_baton */,
+                                    diff_processor, ctx, scratch_pool));
+            }
+
+          if (right_kind == svn_node_file)
+            SVN_ERR(do_file_diff(left_abspath, right_abspath,
+                                 left_root_abspath, right_root_abspath,
+                                 FALSE, TRUE, NULL /* parent_baton */,
+                                 diff_processor, ctx, scratch_pool));
+          else if (right_kind == svn_node_dir)
+            SVN_ERR(do_dir_diff(left_abspath, right_abspath,
+                                left_root_abspath, right_root_abspath,
+                                FALSE, TRUE,  left_before_right,
+                                depth, NULL /* parent_baton */,
+                                diff_processor, ctx, scratch_pool));
+
+          if (! left_before_right)
+            {
+              if (left_kind == svn_node_file)
+                SVN_ERR(do_file_diff(left_abspath, right_abspath,
+                                     left_root_abspath, right_root_abspath,
+                                     TRUE, FALSE, NULL /* parent_baton */,
+                                     diff_processor, ctx, scratch_pool));
+              else if (left_kind == svn_node_dir)
+                SVN_ERR(do_dir_diff(left_abspath, right_abspath,
+                                    left_root_abspath, right_root_abspath,
+                                    TRUE, FALSE,  left_before_right,
+                                    depth, NULL /* parent_baton */,
+                                    diff_processor, ctx, scratch_pool));
+            }
+        }
+
+      SVN_ERR(diff_processor->dir_closed("",
+                                         left_src,
+                                         right_src,
+                                         dir_baton,
+                                         diff_processor,
+                                         scratch_pool));
+    }
   else
     return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
                              _("'%s' is not a file or directory"),
-                             kind1 == svn_node_none
-                               ? svn_dirent_local_style(local_abspath1,
-                                                        scratch_pool)
-                               : svn_dirent_local_style(local_abspath2,
-                                                        scratch_pool));
+                             svn_dirent_local_style(
+                                    (left_kind == svn_node_none)
+                                        ? left_abspath
+                                        : right_abspath,
+                                    scratch_pool));
+
   return SVN_NO_ERROR;
 }