<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">package Git::SVN::Editor;
use vars qw/@ISA $_rmdir $_cp_similarity $_find_copies_harder $_rename_limit/;
use strict;
use warnings;
use SVN::Core;
use SVN::Delta;
use Carp qw/croak/;
use Git qw/command command_oneline command_noisy command_output_pipe
           command_input_pipe command_close_pipe
           command_bidi_pipe command_close_bidi_pipe
           get_record/;

BEGIN {
	@ISA = qw(SVN::Delta::Editor);
}

sub new {
	my ($class, $opts) = @_;
	foreach (qw/svn_path r ra tree_a tree_b log editor_cb/) {
		die "$_ required!\n" unless (defined $opts-&gt;{$_});
	}

	my $pool = SVN::Pool-&gt;new;
	my $mods = generate_diff($opts-&gt;{tree_a}, $opts-&gt;{tree_b});
	my $types = check_diff_paths($opts-&gt;{ra}, $opts-&gt;{svn_path},
	                             $opts-&gt;{r}, $mods);

	# $opts-&gt;{ra} functions should not be used after this:
	my @ce  = $opts-&gt;{ra}-&gt;get_commit_editor($opts-&gt;{log},
	                                        $opts-&gt;{editor_cb}, $pool);
	my $self = SVN::Delta::Editor-&gt;new(@ce, $pool);
	bless $self, $class;
	foreach (qw/svn_path r tree_a tree_b/) {
		$self-&gt;{$_} = $opts-&gt;{$_};
	}
	$self-&gt;{url} = $opts-&gt;{ra}-&gt;{url};
	$self-&gt;{mods} = $mods;
	$self-&gt;{types} = $types;
	$self-&gt;{pool} = $pool;
	$self-&gt;{bat} = { '' =&gt; $self-&gt;open_root($self-&gt;{r}, $self-&gt;{pool}) };
	$self-&gt;{rm} = { };
	$self-&gt;{path_prefix} = length $self-&gt;{svn_path} ?
	                       "$self-&gt;{svn_path}/" : '';
	$self-&gt;{config} = $opts-&gt;{config};
	$self-&gt;{mergeinfo} = $opts-&gt;{mergeinfo};
	$self-&gt;{pathnameencoding} = Git::config('svn.pathnameencoding');
	return $self;
}

sub generate_diff {
	my ($tree_a, $tree_b) = @_;
	my @diff_tree = qw(diff-tree -z -r);
	if ($_cp_similarity) {
		push @diff_tree, "-C$_cp_similarity";
	} else {
		push @diff_tree, '-C';
	}
	push @diff_tree, '--find-copies-harder' if $_find_copies_harder;
	push @diff_tree, "-l$_rename_limit" if defined $_rename_limit;
	push @diff_tree, $tree_a, $tree_b;
	my ($diff_fh, $ctx) = command_output_pipe(@diff_tree);
	my $state = 'meta';
	my @mods;
	while (defined($_ = get_record($diff_fh, "\0"))) {
		if ($state eq 'meta' &amp;&amp; /^:(\d{6})\s(\d{6})\s
					($::sha1)\s($::sha1)\s
					([MTCRAD])\d*$/xo) {
			push @mods, {	mode_a =&gt; $1, mode_b =&gt; $2,
					sha1_a =&gt; $3, sha1_b =&gt; $4,
					chg =&gt; $5 };
			if ($5 =~ /^(?:C|R)$/) {
				$state = 'file_a';
			} else {
				$state = 'file_b';
			}
		} elsif ($state eq 'file_a') {
			my $x = $mods[$#mods] or croak "Empty array\n";
			if ($x-&gt;{chg} !~ /^(?:C|R)$/) {
				croak "Error parsing $_, $x-&gt;{chg}\n";
			}
			$x-&gt;{file_a} = $_;
			$state = 'file_b';
		} elsif ($state eq 'file_b') {
			my $x = $mods[$#mods] or croak "Empty array\n";
			if (exists $x-&gt;{file_a} &amp;&amp; $x-&gt;{chg} !~ /^(?:C|R)$/) {
				croak "Error parsing $_, $x-&gt;{chg}\n";
			}
			if (!exists $x-&gt;{file_a} &amp;&amp; $x-&gt;{chg} =~ /^(?:C|R)$/) {
				croak "Error parsing $_, $x-&gt;{chg}\n";
			}
			$x-&gt;{file_b} = $_;
			$state = 'meta';
		} else {
			croak "Error parsing $_\n";
		}
	}
	command_close_pipe($diff_fh, $ctx);
	\@mods;
}

sub check_diff_paths {
	my ($ra, $pfx, $rev, $mods) = @_;
	my %types;
	$pfx .= '/' if length $pfx;

	sub type_diff_paths {
		my ($ra, $types, $path, $rev) = @_;
		my @p = split m#/+#, $path;
		my $c = shift @p;
		unless (defined $types-&gt;{$c}) {
			$types-&gt;{$c} = $ra-&gt;check_path($c, $rev);
		}
		while (@p) {
			$c .= '/' . shift @p;
			next if defined $types-&gt;{$c};
			$types-&gt;{$c} = $ra-&gt;check_path($c, $rev);
		}
	}

	foreach my $m (@$mods) {
		foreach my $f (qw/file_a file_b/) {
			next unless defined $m-&gt;{$f};
			my ($dir) = ($m-&gt;{$f} =~ m#^(.*?)/?(?:[^/]+)$#);
			if (length $pfx.$dir &amp;&amp; ! defined $types{$dir}) {
				type_diff_paths($ra, \%types, $pfx.$dir, $rev);
			}
		}
	}
	\%types;
}

sub split_path {
	return ($_[0] =~ m#^(.*?)/?([^/]+)$#);
}

sub repo_path {
	my ($self, $path) = @_;
	if (my $enc = $self-&gt;{pathnameencoding}) {
		require Encode;
		Encode::from_to($path, $enc, 'UTF-8');
	}
	$self-&gt;{path_prefix}.(defined $path ? $path : '');
}

sub url_path {
	my ($self, $path) = @_;
	$path = $self-&gt;repo_path($path);
	if ($self-&gt;{url} =~ m#^https?://#) {
		# characters are taken from subversion/libsvn_subr/path.c
		$path =~ s#([^~a-zA-Z0-9_./!$&amp;'()*+,-])#sprintf("%%%02X",ord($1))#eg;
	}
	$self-&gt;{url} . '/' . $path;
}

sub rmdirs {
	my ($self) = @_;
	my $rm = $self-&gt;{rm};
	delete $rm-&gt;{''}; # we never delete the url we're tracking
	return unless %$rm;

	foreach (keys %$rm) {
		my @d = split m#/#, $_;
		my $c = shift @d;
		$rm-&gt;{$c} = 1;
		while (@d) {
			$c .= '/' . shift @d;
			$rm-&gt;{$c} = 1;
		}
	}
	delete $rm-&gt;{$self-&gt;{svn_path}};
	delete $rm-&gt;{''}; # we never delete the url we're tracking
	return unless %$rm;

	my ($fh, $ctx) = command_output_pipe(qw/ls-tree --name-only -r -z/,
	                                     $self-&gt;{tree_b});
	while (defined($_ = get_record($fh, "\0"))) {
		my @dn = split m#/#, $_;
		while (pop @dn) {
			delete $rm-&gt;{join '/', @dn};
		}
		unless (%$rm) {
			close $fh;
			return;
		}
	}
	command_close_pipe($fh, $ctx);

	my ($r, $p, $bat) = ($self-&gt;{r}, $self-&gt;{pool}, $self-&gt;{bat});
	foreach my $d (sort { $b =~ tr#/#/# &lt;=&gt; $a =~ tr#/#/# } keys %$rm) {
		$self-&gt;close_directory($bat-&gt;{$d}, $p);
		my ($dn) = ($d =~ m#^(.*?)/?(?:[^/]+)$#);
		print "\tD+\t$d/\n" unless $::_q;
		$self-&gt;SUPER::delete_entry($d, $r, $bat-&gt;{$dn}, $p);
		delete $bat-&gt;{$d};
	}
}

sub open_or_add_dir {
	my ($self, $full_path, $baton, $deletions) = @_;
	my $t = $self-&gt;{types}-&gt;{$full_path};
	if (!defined $t) {
		die "$full_path not known in r$self-&gt;{r} or we have a bug!\n";
	}
	{
		no warnings 'once';
		# SVN::Node::none and SVN::Node::file are used only once,
		# so we're shutting up Perl's warnings about them.
		if ($t == $SVN::Node::none || defined($deletions-&gt;{$full_path})) {
			return $self-&gt;add_directory($full_path, $baton,
			    undef, -1, $self-&gt;{pool});
		} elsif ($t == $SVN::Node::dir) {
			return $self-&gt;open_directory($full_path, $baton,
			    $self-&gt;{r}, $self-&gt;{pool});
		} # no warnings 'once'
		print STDERR "$full_path already exists in repository at ",
		    "r$self-&gt;{r} and it is not a directory (",
		    ($t == $SVN::Node::file ? 'file' : 'unknown'),"/$t)\n";
	} # no warnings 'once'
	exit 1;
}

sub ensure_path {
	my ($self, $path, $deletions) = @_;
	my $bat = $self-&gt;{bat};
	my $repo_path = $self-&gt;repo_path($path);
	return $bat-&gt;{''} unless (length $repo_path);

	my @p = split m#/+#, $repo_path;
	my $c = shift @p;
	$bat-&gt;{$c} ||= $self-&gt;open_or_add_dir($c, $bat-&gt;{''}, $deletions);
	while (@p) {
		my $c0 = $c;
		$c .= '/' . shift @p;
		$bat-&gt;{$c} ||= $self-&gt;open_or_add_dir($c, $bat-&gt;{$c0}, $deletions);
	}
	return $bat-&gt;{$c};
}

# Subroutine to convert a globbing pattern to a regular expression.
# From perl cookbook.
sub glob2pat {
	my $globstr = shift;
	my %patmap = ('*' =&gt; '.*', '?' =&gt; '.', '[' =&gt; '[', ']' =&gt; ']');
	$globstr =~ s{(.)} { $patmap{$1} || "\Q$1" }ge;
	return '^' . $globstr . '$';
}

sub check_autoprop {
	my ($self, $pattern, $properties, $file, $fbat) = @_;
	# Convert the globbing pattern to a regular expression.
	my $regex = glob2pat($pattern);
	# Check if the pattern matches the file name.
	if($file =~ m/($regex)/) {
		# Parse the list of properties to set.
		my @props = split(/;/, $properties);
		foreach my $prop (@props) {
			# Parse 'name=value' syntax and set the property.
			if ($prop =~ /([^=]+)=(.*)/) {
				my ($n,$v) = ($1,$2);
				for ($n, $v) {
					s/^\s+//; s/\s+$//;
				}
				$self-&gt;change_file_prop($fbat, $n, $v);
			}
		}
	}
}

sub apply_autoprops {
	my ($self, $file, $fbat) = @_;
	my $conf_t = ${$self-&gt;{config}}{'config'};
	no warnings 'once';
	# Check [miscellany]/enable-auto-props in svn configuration.
	if (SVN::_Core::svn_config_get_bool(
		$conf_t,
		$SVN::_Core::SVN_CONFIG_SECTION_MISCELLANY,
		$SVN::_Core::SVN_CONFIG_OPTION_ENABLE_AUTO_PROPS,
		0)) {
		# Auto-props are enabled.  Enumerate them to look for matches.
		my $callback = sub {
			$self-&gt;check_autoprop($_[0], $_[1], $file, $fbat);
		};
		SVN::_Core::svn_config_enumerate(
			$conf_t,
			$SVN::_Core::SVN_CONFIG_SECTION_AUTO_PROPS,
			$callback);
	}
}

sub check_attr {
	my ($attr,$path) = @_;
	my $val = command_oneline("check-attr", $attr, "--", $path);
	if ($val) { $val =~ s/^[^:]*:\s*[^:]*:\s*(.*)\s*$/$1/; }
	return $val;
}

sub apply_manualprops {
	my ($self, $file, $fbat) = @_;
	my $pending_properties = check_attr( "svn-properties", $file );
	if ($pending_properties eq "") { return; }
	# Parse the list of properties to set.
	my @props = split(/;/, $pending_properties);
	# TODO: get existing properties to compare to
	# - this fails for add so currently not done
	# my $existing_props = ::get_svnprops($file);
	my $existing_props = {};
	# TODO: caching svn properties or storing them in .gitattributes
	# would make that faster
	foreach my $prop (@props) {
		# Parse 'name=value' syntax and set the property.
		if ($prop =~ /([^=]+)=(.*)/) {
			my ($n,$v) = ($1,$2);
			for ($n, $v) {
				s/^\s+//; s/\s+$//;
			}
			my $existing = $existing_props-&gt;{$n};
			if (!defined($existing) || $existing ne $v) {
			    $self-&gt;change_file_prop($fbat, $n, $v);
			}
		}
	}
}

sub A {
	my ($self, $m, $deletions) = @_;
	my ($dir, $file) = split_path($m-&gt;{file_b});
	my $pbat = $self-&gt;ensure_path($dir, $deletions);
	my $fbat = $self-&gt;add_file($self-&gt;repo_path($m-&gt;{file_b}), $pbat,
					undef, -1);
	print "\tA\t$m-&gt;{file_b}\n" unless $::_q;
	$self-&gt;apply_autoprops($file, $fbat);
	$self-&gt;apply_manualprops($m-&gt;{file_b}, $fbat);
	$self-&gt;chg_file($fbat, $m);
	$self-&gt;close_file($fbat,undef,$self-&gt;{pool});
}

sub C {
	my ($self, $m, $deletions) = @_;
	my ($dir, $file) = split_path($m-&gt;{file_b});
	my $pbat = $self-&gt;ensure_path($dir, $deletions);
	# workaround for a bug in svn serf backend (v1.8.5 and below):
	# store third argument to -&gt;add_file() in a local variable, to make it
	# have the same lifetime as $fbat
	my $upa = $self-&gt;url_path($m-&gt;{file_a});
	my $fbat = $self-&gt;add_file($self-&gt;repo_path($m-&gt;{file_b}), $pbat,
				$upa, $self-&gt;{r});
	print "\tC\t$m-&gt;{file_a} =&gt; $m-&gt;{file_b}\n" unless $::_q;
	$self-&gt;apply_manualprops($m-&gt;{file_b}, $fbat);
	$self-&gt;chg_file($fbat, $m);
	$self-&gt;close_file($fbat,undef,$self-&gt;{pool});
}

sub delete_entry {
	my ($self, $path, $pbat) = @_;
	my $rpath = $self-&gt;repo_path($path);
	my ($dir, $file) = split_path($rpath);
	$self-&gt;{rm}-&gt;{$dir} = 1;
	$self-&gt;SUPER::delete_entry($rpath, $self-&gt;{r}, $pbat, $self-&gt;{pool});
}

sub R {
	my ($self, $m, $deletions) = @_;
	my ($dir, $file) = split_path($m-&gt;{file_b});
	my $pbat = $self-&gt;ensure_path($dir, $deletions);
	# workaround for a bug in svn serf backend, see comment in C() above
	my $upa = $self-&gt;url_path($m-&gt;{file_a});
	my $fbat = $self-&gt;add_file($self-&gt;repo_path($m-&gt;{file_b}), $pbat,
				$upa, $self-&gt;{r});
	print "\tR\t$m-&gt;{file_a} =&gt; $m-&gt;{file_b}\n" unless $::_q;
	$self-&gt;apply_autoprops($file, $fbat);
	$self-&gt;apply_manualprops($m-&gt;{file_b}, $fbat);
	$self-&gt;chg_file($fbat, $m);
	$self-&gt;close_file($fbat,undef,$self-&gt;{pool});

	($dir, $file) = split_path($m-&gt;{file_a});
	$pbat = $self-&gt;ensure_path($dir, $deletions);
	$self-&gt;delete_entry($m-&gt;{file_a}, $pbat);
}

sub M {
	my ($self, $m, $deletions) = @_;
	my ($dir, $file) = split_path($m-&gt;{file_b});
	my $pbat = $self-&gt;ensure_path($dir, $deletions);
	my $fbat = $self-&gt;open_file($self-&gt;repo_path($m-&gt;{file_b}),
				$pbat,$self-&gt;{r},$self-&gt;{pool});
	print "\t$m-&gt;{chg}\t$m-&gt;{file_b}\n" unless $::_q;
	$self-&gt;apply_manualprops($m-&gt;{file_b}, $fbat);
	$self-&gt;chg_file($fbat, $m);
	$self-&gt;close_file($fbat,undef,$self-&gt;{pool});
}

sub T {
	my ($self, $m, $deletions) = @_;

	# Work around subversion issue 4091: toggling the "is a
	# symlink" property requires removing and re-adding a
	# file or else "svn up" on affected clients trips an
	# assertion and aborts.
	if (($m-&gt;{mode_b} =~ /^120/ &amp;&amp; $m-&gt;{mode_a} !~ /^120/) ||
	    ($m-&gt;{mode_b} !~ /^120/ &amp;&amp; $m-&gt;{mode_a} =~ /^120/)) {
		$self-&gt;D({
			mode_a =&gt; $m-&gt;{mode_a}, mode_b =&gt; '000000',
			sha1_a =&gt; $m-&gt;{sha1_a}, sha1_b =&gt; '0' x 40,
			chg =&gt; 'D', file_b =&gt; $m-&gt;{file_b}
		}, $deletions);
		$self-&gt;A({
			mode_a =&gt; '000000', mode_b =&gt; $m-&gt;{mode_b},
			sha1_a =&gt; '0' x 40, sha1_b =&gt; $m-&gt;{sha1_b},
			chg =&gt; 'A', file_b =&gt; $m-&gt;{file_b}
		}, $deletions);
		return;
	}

	$self-&gt;M($m, $deletions);
}

sub change_file_prop {
	my ($self, $fbat, $pname, $pval) = @_;
	$self-&gt;SUPER::change_file_prop($fbat, $pname, $pval, $self-&gt;{pool});
}

sub change_dir_prop {
	my ($self, $pbat, $pname, $pval) = @_;
	$self-&gt;SUPER::change_dir_prop($pbat, $pname, $pval, $self-&gt;{pool});
}

sub _chg_file_get_blob ($$$$) {
	my ($self, $fbat, $m, $which) = @_;
	my $fh = $::_repository-&gt;temp_acquire("git_blob_$which");
	if ($m-&gt;{"mode_$which"} =~ /^120/) {
		print $fh 'link ' or croak $!;
		$self-&gt;change_file_prop($fbat,'svn:special','*');
	} elsif ($m-&gt;{mode_a} =~ /^120/ &amp;&amp; $m-&gt;{"mode_$which"} !~ /^120/) {
		$self-&gt;change_file_prop($fbat,'svn:special',undef);
	}
	my $blob = $m-&gt;{"sha1_$which"};
	return ($fh,) if ($blob =~ /^0{40}$/);
	my $size = $::_repository-&gt;cat_blob($blob, $fh);
	croak "Failed to read object $blob" if ($size &lt; 0);
	$fh-&gt;flush == 0 or croak $!;
	seek $fh, 0, 0 or croak $!;

	my $exp = ::md5sum($fh);
	seek $fh, 0, 0 or croak $!;
	return ($fh, $exp);
}

sub chg_file {
	my ($self, $fbat, $m) = @_;
	if ($m-&gt;{mode_b} =~ /755$/ &amp;&amp; $m-&gt;{mode_a} !~ /755$/) {
		$self-&gt;change_file_prop($fbat,'svn:executable','*');
	} elsif ($m-&gt;{mode_b} !~ /755$/ &amp;&amp; $m-&gt;{mode_a} =~ /755$/) {
		$self-&gt;change_file_prop($fbat,'svn:executable',undef);
	}
	my ($fh_a, $exp_a) = _chg_file_get_blob $self, $fbat, $m, 'a';
	my ($fh_b, $exp_b) = _chg_file_get_blob $self, $fbat, $m, 'b';
	my $pool = SVN::Pool-&gt;new;
	my $atd = $self-&gt;apply_textdelta($fbat, $exp_a, $pool);
	if (-s $fh_a) {
		my $txstream = SVN::TxDelta::new ($fh_a, $fh_b, $pool);
		my $res = SVN::TxDelta::send_txstream($txstream, @$atd, $pool);
		if (defined $res) {
			die "Unexpected result from send_txstream: $res\n",
			    "(SVN::Core::VERSION: $SVN::Core::VERSION)\n";
		}
	} else {
		my $got = SVN::TxDelta::send_stream($fh_b, @$atd, $pool);
		die "Checksum mismatch\nexpected: $exp_b\ngot: $got\n"
		    if ($got ne $exp_b);
	}
	Git::temp_release($fh_b, 1);
	Git::temp_release($fh_a, 1);
	$pool-&gt;clear;
}

sub D {
	my ($self, $m, $deletions) = @_;
	my ($dir, $file) = split_path($m-&gt;{file_b});
	my $pbat = $self-&gt;ensure_path($dir, $deletions);
	print "\tD\t$m-&gt;{file_b}\n" unless $::_q;
	$self-&gt;delete_entry($m-&gt;{file_b}, $pbat);
}

sub close_edit {
	my ($self) = @_;
	my ($p,$bat) = ($self-&gt;{pool}, $self-&gt;{bat});
	foreach (sort { $b =~ tr#/#/# &lt;=&gt; $a =~ tr#/#/# } keys %$bat) {
		next if $_ eq '';
		$self-&gt;close_directory($bat-&gt;{$_}, $p);
	}
	$self-&gt;close_directory($bat-&gt;{''}, $p);
	$self-&gt;SUPER::close_edit($p);
	$p-&gt;clear;
}

sub abort_edit {
	my ($self) = @_;
	$self-&gt;SUPER::abort_edit($self-&gt;{pool});
}

sub DESTROY {
	my $self = shift;
	$self-&gt;SUPER::DESTROY(@_);
	$self-&gt;{pool}-&gt;clear;
}

# this drives the editor
sub apply_diff {
	my ($self) = @_;
	my $mods = $self-&gt;{mods};
	my %o = ( D =&gt; 0, C =&gt; 1, R =&gt; 2, A =&gt; 3, M =&gt; 4, T =&gt; 5 );
	my %deletions;

	foreach my $m (@$mods) {
		if ($m-&gt;{chg} eq "D") {
			$deletions{$m-&gt;{file_b}} = 1;
		}
	}

	foreach my $m (sort { $o{$a-&gt;{chg}} &lt;=&gt; $o{$b-&gt;{chg}} } @$mods) {
		my $f = $m-&gt;{chg};
		if (defined $o{$f}) {
			$self-&gt;$f($m, \%deletions);
		} else {
			fatal("Invalid change type: $f");
		}
	}

	if (defined($self-&gt;{mergeinfo})) {
		$self-&gt;change_dir_prop($self-&gt;{bat}{''}, "svn:mergeinfo",
			               $self-&gt;{mergeinfo});
	}
	$self-&gt;rmdirs if $_rmdir;
	if (@$mods == 0 &amp;&amp; !defined($self-&gt;{mergeinfo})) {
		$self-&gt;abort_edit;
	} else {
		$self-&gt;close_edit;
	}
	return scalar @$mods;
}

1;
__END__

=head1 NAME

Git::SVN::Editor - commit driver for "git svn set-tree" and dcommit

=head1 SYNOPSIS

	use Git::SVN::Editor;
	use Git::SVN::Ra;

	my $ra = Git::SVN::Ra-&gt;new($url);
	my %opts = (
		r =&gt; 19,
		log =&gt; "log message",
		ra =&gt; $ra,
		config =&gt; SVN::Core::config_get_config($svn_config_dir),
		tree_a =&gt; "$commit^",
		tree_b =&gt; "$commit",
		editor_cb =&gt; sub { print "Committed r$_[0]\n"; },
		mergeinfo =&gt; "/branches/foo:1-10",
		svn_path =&gt; "trunk"
	);
	Git::SVN::Editor-&gt;new(\%opts)-&gt;apply_diff or print "No changes\n";

	my $re = Git::SVN::Editor::glob2pat("trunk/*");
	if ($branchname =~ /$re/) {
		print "matched!\n";
	}

=head1 DESCRIPTION

This module is an implementation detail of the "git svn" command.
Do not use it unless you are developing git-svn.

This module adapts the C&lt;SVN::Delta::Editor&gt; object returned by
C&lt;SVN::Delta::get_commit_editor&gt; and drives it to convey the
difference between two git tree objects to a remote Subversion
repository.

The interface will change as git-svn evolves.

=head1 DEPENDENCIES

Subversion perl bindings,
the core L&lt;Carp&gt; module,
and git's L&lt;Git&gt; helper module.

C&lt;Git::SVN::Editor&gt; has not been tested using callers other than
B&lt;git-svn&gt; itself.

=head1 SEE ALSO

L&lt;SVN::Delta&gt;,
L&lt;Git::SVN::Fetcher&gt;.

=head1 INCOMPATIBILITIES

None reported.

=head1 BUGS

None.
</pre></body></html>