view release on metacpan or  search on metacpan

src/subversion/subversion/bindings/swig/perl/native/Client.pm  view on Meta::CPAN

        }
    } else {
        $self->config(SVN::Core::config_get_config(undef));
    }

    if (defined($args{'notify'}))
    {
        $self->notify($args{'notify'});
    }

    if (defined($args{'log_msg'}))
    {
        $self->log_msg($args{'log_msg'});
    }

    if (defined($args{'cancel'}))
    {
        $self->cancel($args{'cancel'});
    }

    return $self;
}

=item $client-E<gt>add($path, $recursive, $pool);

Similar to $client-E<gt>add2(), but with $force always set to FALSE.

=item $client-E<gt>add2($path, $recursive, $force, $pool);

Similar to $client-E<gt>add3(), but with $no_ignore always set to FALSE.

=item $client-E<gt>add3($path, $recursive, $force, $no_ignore, $pool);

Similar to $client-E<gt>add4(), but with $add_parents always set to FALSE and
$depth set according to $recursive; if TRUE, then depth is
$SVN::Depth::infinity, if FALSE, then $SVN::Depth::empty.

=item $client-E<gt>add4($path, $depth, $force, $no_ignore, $add_parents, $pool);

Schedule a working copy $path for addition to the repository.

If $depth is $SVN::Depth::empty, add just $path and nothing below it.  If
$SVN::Depth::files, add $path and any file children of $path.  If 
$SVN::Depth::immediates, add $path, any file children, and any immediate
subdirectories (but nothing underneath those subdirectories).  If 
$SVN::Depth::infinity, add $path and everything under it fully recursively.

$path's parent must be under revision control already (unless $add_parents is
TRUE), but $path is not.

Unless $force is TRUE and $path is already under version control, returns an
$SVN::Error::ENTRY_EXISTS object.  If $force is set, do not error on
already-versioned items.  When used with $depth set to $SVN::Depth::infinity
it will enter versioned directories; scheduling unversioned children. 

Calls the notify callback for each added item.

If $no_ignore is FALSE, don't add any file or directory (or recurse into any
directory) that is unversioned and found by recursion (as opposed to being the
explicit target $path) and whose name matches the svn:ignore property on its
parent directory or the global-ignores list in $client->config.  If $no_ignore is
TRUE, do include such files and directories.  (Note that an svn:ignore property
can influence this behaviour only when recursing into an already versioned
directory with $force).

If $add_parents is TRUE, recurse up $path's directory and look for a versioned
directory.  If found, add all intermediate paths between it and $path.  If not
found return $SVN::Error::NO_VERSIONED_PARENT.

Important: this is a B<scheduling> operation.  No changes will happen
to the repository until a commit occurs.  This scheduling can be
removed with $client-E<gt>revert().

No return.

=item $client-E<gt>blame($target, $start, $end, \&receiver, $pool);

Invoke \&receiver subroutine on each line-blame item associated with revision
$end of $target, using $start as the default source of all blame.

An Error will be raised if either $start or $end is undef.

No return.

The blame receiver subroutine receives the following arguments:
$line_no, $revision, $author, $date, $line, $pool

$line_no is the line number of the file (starting with 0).
The line was last changed in revision number $revision
by $author on $date and the contents were $line.

The blame receiver subroutine can return an svn_error_t object
to return an error.  All other returns will be ignored.
You can create an svn_error_t object with SVN::Error::create().

=item $client-E<gt>cat(\*FILEHANDLE, $target, $revision, $pool);

Outputs the content of the file identified by $target and $revision to the
FILEHANDLE.  FILEHANDLE is a reference to a filehandle.

If $target is not a local path and if $revision is 'PREV' (or some
other kind that requires a local path), then an error will be raised,
because the desired revision can not be determined.

=item $client-E<gt>checkout($url, $path, $revision, $recursive, $pool);

Similar to $client-E<gt>checkout2(), but with $peg_revision always set to undef (unspecified) and $ignore_externals always set to FALSE.

=item $client-E<gt>checkout2($url, $path, $peg_revision, $revision, $recursive, $ignore_externals, $pool);

Similar to $client-E<gt>checkout3(), but with $allow_unver_obstructions always set
to FALSE, and $depth set according to $recurse: if $recurse is TRUE, $depth is
$SVN::Depth::infinity, if $recurse is FALSE, set $depth to $SVN::Depth::files.

=item $client-E<gt>checkout3($url, $path, $preg_revision, $revision, $depth, $ignore_externals, $allow_unver_obstructions, $pool);

Checkout a working copy of $url at $revision using $path as the root directory
of the newly checked out working copy.

The $peg_revision sets the revision at which the path in the $url is treated as representing.