Subversion Repositories DevTools

use FileUtils;

InitFileUtils();

SvnMerge()                             if ( $cmd =~ m/^merge/ );

SvnReintegrate()                       if ( $cmd =~ m/^reintegrate/ );

# Function        : SvnMerge 

#

# Description     : Perform an svn merge 

#                       - with sanity checking

#                       - auto deterine the correct 'head' to merge from

#                  

#

# Inputs          : None

#

# Returns         : 

#

sub SvnMerge

{

    my $opt_path = '.';

    my $opt_info;

    my @mergeOpts;

    my $opt_dryRun;

    #

    #   Parse more options

    #

    Getopt::Long::Configure('pass_through');

    GetOptions (

                "help:+"        => \$opt_help,

                "manual:3"      => \$opt_help,

                "path:s"        => \$opt_path,

                'info'          => \$opt_info,

                'dry-run'       => \$opt_dryRun,

                ) || Error ("Invalid command line" );

    #

    #   Subcommand specific help

    #

    SubCommandHelp( $opt_help, "Sync Merge") if ($opt_help);

    #

    #   Save merge options

    #   Error if a non-option is present

    #

    foreach (@ARGV) {

        if (m~^-~) {

            push @mergeOpts, $_;

        } else {

            Error ("Only options must be passed to Merge: $_");

        }

    }

    #

    #   We intercepted the dry-run option

    #   Put the option back into the stream.

    if ($opt_dryRun) {

        push @mergeOpts, '--dry-run';

    }

    #   Check we are in a workspace

    #   Create an SVN session

    #   

    my $uref = NewSessionByWS($opt_path, 0, 1);

#    DebugDumpData("uref", $uref);

    #

    #   Warn user if the command is being executed from within a subdirectory of the workspace

    #   It might work, but if the directory is deleted it will go badly

    #

    my $ws_root = mustBeWsRoot($uref);

    #

    #   Determine the source of the merge

    #   Get some more workspace information

    # 

    $uref->getWsExtraInfo();

    my $logInfo = $uref->{InfoWsExtra};

#DebugDumpData("getWsExtraInfo", $logInfo);

    # A bit of sanity testing

    Error("Workspace does not appear to be a branch") unless (exists $logInfo->{'copyfrom-path'}); 

    Error("Workspace does not appear to be a branch") unless (exists $logInfo->{'target'}); 

    Error("Workspace is a trunk") if ($logInfo->{'target'} =~ m~/trunk$~);

    Error("Workspace is a raw branch") if ($logInfo->{'target'} =~ m~/branches$~);

    Error("Workspace is a raw tag") if ($logInfo->{'target'} =~ m~/tags$~);

    Error("Workspace is a within a tag") if ($logInfo->{'target'} =~ m~/tags/~);

    #   Ensure the source is a branch and not a trunk

    #   Ensure this workspace is not on the same bit (trunk or branch) 

    #   

    Message ("Merge Info - No merge performed") if $opt_info;

    Message ("RepoRoot: " . $uref->{InfoWs}{'Repository Root'});

    Message ("Parent: " . $logInfo->{'copyfrom-path'});

    Message ("Workspace: " . $logInfo->{'target'});

    unless ($opt_info) {

        #

        #   $logInfo->{'copyfrom-path'} is the parent of the branch in the workspace

        #   use merge ^/<copyfrom-path> to merge the data into this workspace

        #

        #   Perform an interactive command so that the user can accept conflicts - if they want

        my $rv = SvnUserCmd( 'merge',

                @mergeOpts,

                '^' . $logInfo->{'copyfrom-path'},

                $opt_path,

                { 'credentials' => 1 });

        exit $rv;

    }

    $opr_done = 1;

}

#-------------------------------------------------------------------------------

# Function        : SvnReintegrate

#

# Description     : Simulate an svn merge --reintegrate (which is now deprecated)

#                       - Assume the user has the 'trunk' in a workspace

#                       - Ensure there are no uncommitted files

#                       - Ensure it is upto date with thr REpo server

#                       - with much sanity checking

#                       - verify the named branch

#                       - Ensure the named branch is derived from the workspace

#                       - perform a simple merge

#

# Inputs          : None

#

# Returns         : 

#

sub SvnReintegrate

{

    my $opt_path = '.';

    my $opt_info;

    my @mergeOpts;

    my $opt_reintegrate;

    my $opt_dryRun;

    my $opt_branch;

    #

    #   Parse more options

    #

    Getopt::Long::Configure('pass_through');

    GetOptions (

                "help:+"        => \$opt_help,

                "manual:3"      => \$opt_help,

                "path:s"        => \$opt_path,

                'info'          => \$opt_info,

                'reintegrate!'  => \$opt_reintegrate,

                'dry-run'       => \$opt_dryRun,

                'branch:s'      => \$opt_branch,

                ) || Error ("Invalid command line" );

    #

    #   Subcommand specific help

    #

    SubCommandHelp( $opt_help, "Reintegrate Merge") if ($opt_help);

    #

    #   Save merge options

    #   Extract the named branch ( if not provided via the -branch ) option

    #

    foreach (@ARGV) {

        if (m~^-~) {

            push @mergeOpts, $_;

        } else {

            Error ("Source branh for the merge must only be specified once") if (defined($opt_branch));

            $opt_branch = $_;

        }

    }

    Error("No branch specified") unless defined $opt_branch;

    Error("Branch name looks bad") unless ($opt_branch =~ m~[-/a-zA-Z0-9]~i);

    #

    #   We intercepted the dry-run option,

    #   Put the option back into the stream.

    if ($opt_dryRun) {

        push @mergeOpts, '--dry-run';

    }

    #

    #   Calculate the target name

    #       trunk is special

    #       tags/... is special

    if ( $opt_branch eq 'trunk' ) {

    } elsif ( $opt_branch =~ m~tags/.+~ ) {

    } else {

        $opt_branch = join ('/', 'branches', $opt_branch);

    }

    #

    #   Check we are in a workspace

    #   Create an SVN session

    #

    my $uref = NewSessionByWS($opt_path, 0, 1);

    $uref->{WSURL} =~ m~[^/](/.*)~;

    $uref->{target} = $1;

    #

    #   Warn user if the command is being executed from within a subdirectory of the workspace

    #   It might work, but if the directory is deleted it will go badly

    #

    my $ws_root = mustBeWsRoot($uref);

#DebugDumpData("uref", $uref);

    #

    #   Validate the branch the user has specified - it must exist

    #

    my $ws_url = $uref->Full();

    my $branch_tag = join ('/', $ws_url, $opt_branch);

    $uref->SvnValidateTarget (

                        'cmd'    => 'svn reintegrate',

                        'target' => $branch_tag,

                        'require' => 1,

                        );

    #

    #   Verify the source of the merge

    #   Need to get data about the branch, not the current workspace

    #

    my $branchRef = NewSessionByUrl($branch_tag);

    $branchRef->getWsExtraInfo();

    my $branchLogInfo = $branchRef->{InfoWsExtra};

#DebugDumpData("getWsExtraInfo", $branchLogInfo);

    # A bit of sanity testing

    Error("Branch does not appear to be a branch") unless (exists $branchLogInfo->{'copyfrom-path'}); 

    Error("Branch does not appear to be a branch") unless (exists $branchLogInfo->{'target'}); 

    Warning("Branch is a trunk") if ($branchLogInfo->{'target'} =~ m~/trunk$~);

    Error("Branch is a raw branch") if ($branchLogInfo->{'target'} =~ m~/branches$~);

    Error("Branch is a raw tag") if ($branchLogInfo->{'target'} =~ m~/tags$~);

    Warning("Branch is a within a tag") if ($branchLogInfo->{'target'} =~ m~/tags/~);

    Error ("Merging to myself") if ($uref->{target} eq $branchLogInfo->{'target'});

    Error ("Branch not taken from this trunk", "Workspace: $uref->{'target'}","Branch: $branchLogInfo->{'copyfrom-path'}") unless ($uref->{'target'} eq $branchLogInfo->{'copyfrom-path'});

    Message ("Reintegrate Info - No merge performed") if ($opt_info );

    Message ("RepoRoot: " . $uref->{InfoWs}{'Repository Root'});

    Message ("Source Branch: " . $branchLogInfo->{'target'});

    Message ("Workspace Branch: " . $uref->{'target'} );

    Message ("Reintegrate from $branchLogInfo->{'target'} to $uref->{'target'}");

    #

    #   Examine the workspace and ensure that there are no modified

    #   files - unless they are expected

    #   

    #   Prevent the user from merging into a WS that has not been committed

    #

    $uref->SvnWsModified ( 'cmd' => 'Reintegrate' );

    unless ($opt_info) {

        #

        #   $branchLogInfo->{'target'} is the branch of the specified branch

        #   $uref->{target} - should be the same

        #   

        #   use merge ^/<target> to merge the data into this workspace

        #

        #   Perform an interactive command so that the user can accept conflicts - if they want

        #

        my $rv = SvnUserCmd( 'merge', '--reintegrate',

                @mergeOpts,

                '^' . $branchLogInfo->{'target'},

                '.',

                { 'credentials' => 1 });

    }

    $opr_done = 1;

}

#-------------------------------------------------------------------------------

# Function        : mustBeWsRoot 

#

# Description     : Ensure that the user is not in a subdirectory of a workspace 

#

# Inputs          : $uref   - A Svn session handle

#

# Returns         : Will not return on error

#                   Return the workspace root as provided by SvnLocateWsRoot

#

sub mustBeWsRoot

{

    my ($uref) = @_;

    my $ws_root = $uref->SvnLocateWsRoot(0);

    my $pathToRoot = RelPath($ws_root);

    if ( $pathToRoot =~ m~^..~) {

        Error("This command cannot be executed within a subdirectory of the workspace",

                "It can be executed in the root of the workspace: $pathToRoot",

                "It can be executed externally with the -path option");

    }

    return $ws_root;

}

#-------------------------------------------------------------------------------

    merge                  - Merge head into a feature branch

    reintegrate            - Integrate a feature branch to its head

=head1 Sync Merge

=head2 NAME

Perform a Feature Branch Sync Merge

=head2 SYNOPSIS

jats svn merge [options]

 Options:

    -help[=n]              - Help message, [n=1,2,3]

    -man                   - Full documentation [-help=3]

    -verbose[=n]           - Verbose command operation

    -info                  - Displays merge info only

    -dry-run               - Perform a dry run of the merge

    -path=path             - Target workspace

    ...                    - Other options are passed to the merge

=head2 ARGUMENTS

The command takes no arguments, just options.

=head2 OPTIONS

=over

=item B<-path=path>

This options specifies the path of the target workspace. If not provided the

command will use the current directory.

=item B<-info>

This option will display information about the proposed merge, but it will not do the merge.

This is not the same as a '-dry-run' as it shows information that the command has recovered from

the workspace.

=item B<-dry-run>

This option will perform a dry run of the actual merge. It will not modify the workspace.

=item B<...>

Options that are not processed by this command will be passed through to the underlying

'svn merge' command. Available options include:

=over 8

=item * --accept=mf (mine-full)

=item * --accept=mc (mine-conflict)

=back

=back

=head2 DESCRIPTION

This command implements the common operation of merging the release branch 

head (normally trunk) onto a private development branch in the current working copy. 

The main goal of this command is to avoid situations where developers accidentally merge 

from the wrong branch, or end up with (to them) inexplicable merge failures and thus 

lose confidence in Subversion. 

It will fail if the current working copy is actually on the trunk, and not a branch.

=head1 Reintegrate Merge

=head2 NAME

Reintegrate a Feature Branch

=head2 SYNOPSIS

jats svn reintegrate [options] [branch name]

 Options:

    -help[=n]              - Help message, [n=1,2,3]

    -man                   - Full documentation [-help=3]

    -verbose[=n]           - Verbose command operation

    -path=path             - Target workspace

    -info                  - Displays merge info only

    -dry-run               - Perform a dry run of the merge

    -branch=name           - The branch to be used as the merge source

    ...                    - Other options are passed to the merge

=head2 ARGUMENTS

If an argument is provided then it will be used as the name of the branch to be merged into

the current workspace. This is the same as using the -branch option.

=head2 OPTIONS

=over

=item B<-path=path>

This options specifies the path of the target workspace. If not provided the

command will use the current directory.

=item B<-info>

This option will display information about the proposed merge, but it will not do the merge.

This is not the same as a '--dry-run' as it shows information that the command has recovered from

the workspace.

=item B<-dry-run>

This option will perform a dry run of the actual merge. It will NOT deleted the feature branch. It will

switch the workspace and after the dry run of the merge it will switch it back.

This option implies '-reintegrate'.

=item B<-branch>

This option provides an alternate method for specifying the source of the merge.

=item B<...>

Options that are not processed by this command will be passed through to the underlying

'svn merge' command. Available options include:

=over 8

=item * --accept=mf (mine-full)

=item * --accept=mc (mine-conflict)

=back

=head2 DESCRIPTION

This command implements the common operation of merging a private branch back into the main

development branch (normally the trunk).

The main goal of this command is to avoid situations where developers accidentally merge 

from the wrong branch, or end up with (to them) inexplicable merge failures and thus 

lose confidence in Subversion. 

It will fail if the specified branch was not tacken from the package's trunk.

The command will do the following operations:

=over 8

=item * 

Ensure that the path address a subversion workspace and that the user is not in a sundirectory

of the workspace.

=item * 

Ensure the specified branch exists within the package.

=item * 

Ensure the workspace contains no modified files

=item * 

Ensure that the specified branch was taken from the branch (often the trunk) on which the 

workspace is based. A number of other sanity checks are also performed

=item * 

Perform the reintegration merge.

This is, strictly speaking a 'svn merge --reintegrate' as that operation has been deprecated

and was problematic. The effect is the same.

=back

At the end of the reintegration merge the workspace will conatin modified files. The user should verify 

that the merge has had the desired result and to commit the changes.