1native::Client(3)     User Contributed Perl Documentation    native::Client(3)
2
3
4

NAME

6       SVN::Client - Subversion client functions
7

SYNOPSIS

9           use SVN::Client;
10           my $client = new SVN::Client();
11
12           # setup to handle authentication the same as the command line client
13           my $config_dir = undef; # use default location
14           my $config = SVN:Core::config_get_config($config_dir);
15           my $config_category = $cfg->{SVN::Core::CONFIG_CATEGORY_CONFIG};
16           $client->auth(
17             SVN::Core::cmdline_create_auth_baton(0,           #non_interactive
18                                                  undef,       #username
19                                                  undef,       #password
20                                                  $config_dir,
21                                                  0,           #no_auth_cache
22                                                  0,           #trust_server_cert
23                                                  $config_category,
24                                                  undef)       #cancel_callback
25           );
26
27           # Use first argument as target and canonicalize it before using
28           my $target;
29           if (SVN::Core::path_is_url($ARGV[0])) {
30             $target = SVN::Core::uri_canonicalize($ARGV[0]);
31           } else {
32             $target = SVN::Core::dirent_canonicalize($ARGV[0]);
33           }
34
35           # fetch the head revision of the target
36           $client->cat(\*STDOUT, $target, 'HEAD');
37

DESCRIPTION

39       SVN::Client wraps the highest level of functions provided by subversion
40       to accomplish specific tasks in an object oriented API.  Methods are
41       similar to the functions provided by the C API and as such the
42       documentation for it may be helpful in understanding this interface.
43
44       There are a few notable differences from the C API.  Most C function
45       calls take a svn_client_ctx_t pointer as the next to last parameter.
46       The Perl method calls take a SVN::Client object as the first parameter.
47       This allows method call invocation of the methods to be possible.  For
48       example, the following are equivalent:
49
50         SVN::Client::add($client,$path, $recursive, $pool);
51         $client->add($path, $recursive, $pool);
52
53       Many of the C API calls also take a apr_pool_t pointer as their last
54       argument.  The Perl bindings generally deal with this for you and you
55       do not need to pass a pool parameter.  However, you may still pass a
56       pool parameter as the last parameter to override the automatic handling
57       of this for you.
58
59       Users of this interface should not directly manipulate the underlying
60       hash values but should use the respective attribute methods.  Many of
61       these attribute methods do other things, especially when setting an
62       attribute, besides simply manipulating the value in the hash.
63

PARAMETER NOTES

65       The client methods described below take a variety of parameters.  Many
66       of them are similar.  Methods accepting parameters named below will
67       follow the rules below or will be noted otherwise in the method
68       description.
69
70       $client
71           An SVN::Client object that you get from the constructor.
72
73       $url
74           This is a URL to a subversion repository.
75
76       $path
77           This is a path to a file or directory on the local file system.
78           Paths need to be canonicalized before being passed into the
79           Subversion APIs.  Paths on the local file system are called dirents
80           and can be canonicalized by calling
81           "SVN::Core::dirent_canonicalize".
82
83       $paths
84           This argument can either be a single $path (as defined above) or a
85           reference to an array of them.
86
87       $target
88           This is a path to a file or directory in a working copy or a URL to
89           a file or directory in a subversion repository.  Both paths and
90           URLs need to be canonicalized before being passed into the
91           Subversion APIs.  Paths on the local file system are called dirents
92           and can be canonicalized by calling
93           "SVN::Core::dirent_canonicalize".  URLs can be canonicalized by
94           calling "SVN::Core::uri_canonicalize".
95
96       $targets
97           This argument can either be a single $target (as defined above) or
98           a reference to an array of them.
99
100       $revision
101           This specifies a revision in the Subversion repository.  You can
102           specify a revision in several ways.  The easiest and most obvious
103           is to directly provide the revision number.  You may also use the
104           strings (aka revision keywords) 'HEAD', 'BASE', 'COMMITTED', and
105           'PREV' which have the same meanings as in the command line client.
106           When referencing a working copy you can use the string 'WORKING" to
107           reference the BASE plus any local modifications.  "undef" may be
108           used to specify an unspecified revision.  You may also pass a date
109           by specifying the date inside curly braces '{}'.  The date formats
110           accepted are the same as the command line client accepts. Finally a
111           "_p_svn_opt_revision_t" object is accepted (which may have been
112           returned by some Subversion function).
113
114       $recursive $nonrecursive.
115           A boolean parameter that specifies if the action should follow
116           directories.  It should only be 1 or 0.  $recursive means, 1 means
117           to descend into directories, 0 means not to.  $nonrecursive has the
118           inverse meaning.
119
120       $pool
121           Pool is always an option parameter.  If you wish to pass a pool
122           parameter it should be a SVN::Pool or an apr_pool_t object.
123

METHODS

125       The following methods are available:
126
127       $client = SVN::Client->new( %options );
128           This class method constructs a new "SVN::Client" object and returns
129           a reference to it.
130
131           Key/value pair arguments may be provided to set up the initial
132           state of the user agent.  The following methods correspond to
133           attribute methods described below:
134
135               KEY                    DEFAULT
136               ----------             ----------------------------------------
137               auth                   auth_baton initiated with providers that
138                                      read cached authentication options from
139                                      the subversion config only.
140
141               cancel                 undef
142
143               config                 Hash containing the config from the
144                                      default subversion config file location.
145
146               log_msg                undef
147
148               notify                 undef
149
150               pool                   A new pool is created for the context.
151
152       $client->add($path, $recursive, $pool);
153           Similar to $client->add2(), but with $force always set to FALSE.
154
155       $client->add2($path, $recursive, $force, $pool);
156           Similar to $client->add3(), but with $no_ignore always set to
157           FALSE.
158
159       $client->add3($path, $recursive, $force, $no_ignore, $pool);
160           Similar to $client->add4(), but with $add_parents always set to
161           FALSE and $depth set according to $recursive; if TRUE, then depth
162           is $SVN::Depth::infinity, if FALSE, then $SVN::Depth::empty.
163
164       $client->add4($path, $depth, $force, $no_ignore, $add_parents, $pool);
165           Schedule a working copy $path for addition to the repository.
166
167           If $depth is $SVN::Depth::empty, add just $path and nothing below
168           it.  If $SVN::Depth::files, add $path and any file children of
169           $path.  If $SVN::Depth::immediates, add $path, any file children,
170           and any immediate subdirectories (but nothing underneath those
171           subdirectories).  If $SVN::Depth::infinity, add $path and
172           everything under it fully recursively.
173
174           $path's parent must be under revision control already (unless
175           $add_parents is TRUE), but $path is not.
176
177           Unless $force is TRUE and $path is already under version control,
178           returns an $SVN::Error::ENTRY_EXISTS object.  If $force is set, do
179           not error on already-versioned items.  When used with $depth set to
180           $SVN::Depth::infinity it will enter versioned directories;
181           scheduling unversioned children.
182
183           Calls the notify callback for each added item.
184
185           If $no_ignore is FALSE, don't add any file or directory (or recurse
186           into any directory) that is unversioned and found by recursion (as
187           opposed to being the explicit target $path) and whose name matches
188           the svn:ignore property on its parent directory or the global-
189           ignores list in $client->config.  If $no_ignore is TRUE, do include
190           such files and directories.  (Note that an svn:ignore property can
191           influence this behaviour only when recursing into an already
192           versioned directory with $force).
193
194           If $add_parents is TRUE, recurse up $path's directory and look for
195           a versioned directory.  If found, add all intermediate paths
196           between it and $path.  If not found return
197           $SVN::Error::NO_VERSIONED_PARENT.
198
199           Important: this is a scheduling operation.  No changes will happen
200           to the repository until a commit occurs.  This scheduling can be
201           removed with $client->revert().
202
203           No return.
204
205       $client->blame($target, $start, $end, \&receiver, $pool);
206           Invoke \&receiver subroutine on each line-blame item associated
207           with revision $end of $target, using $start as the default source
208           of all blame.
209
210           An Error will be raised if either $start or $end is undef.
211
212           No return.
213
214           The blame receiver subroutine receives the following arguments:
215           $line_no, $revision, $author, $date, $line, $pool
216
217           $line_no is the line number of the file (starting with 0).  The
218           line was last changed in revision number $revision by $author on
219           $date and the contents were $line.
220
221           The blame receiver subroutine can return an svn_error_t object to
222           return an error.  All other returns will be ignored.  You can
223           create an svn_error_t object with SVN::Error::create().
224
225       $client->cat(\*FILEHANDLE, $target, $revision, $pool);
226           Outputs the content of the file identified by $target and $revision
227           to the FILEHANDLE.  FILEHANDLE is a reference to a filehandle.
228
229           If $target is not a local path and if $revision is 'PREV' (or some
230           other kind that requires a local path), then an error will be
231           raised, because the desired revision can not be determined.
232
233       $client->checkout($url, $path, $revision, $recursive, $pool);
234           Similar to $client->checkout2(), but with $peg_revision always set
235           to undef (unspecified) and $ignore_externals always set to FALSE.
236
237       $client->checkout2($url, $path, $peg_revision, $revision, $recursive,
238       $ignore_externals, $pool);
239           Similar to $client->checkout3(), but with $allow_unver_obstructions
240           always set to FALSE, and $depth set according to $recurse: if
241           $recurse is TRUE, $depth is $SVN::Depth::infinity, if $recurse is
242           FALSE, set $depth to $SVN::Depth::files.
243
244       $client->checkout3($url, $path, $preg_revision, $revision, $depth,
245       $ignore_externals, $allow_unver_obstructions, $pool);
246           Checkout a working copy of $url at $revision using $path as the
247           root directory of the newly checked out working copy.
248
249           The $peg_revision sets the revision at which the path in the $url
250           is treated as representing.
251
252           $revision must be a number, 'HEAD', or a date.  If $revision does
253           not meet these requirements the $SVN::Error::CLIENT_BAD_REVISION is
254           raised.
255
256           $depth is one of the constants in SVN::Depth and specifies the
257           depth of the operation.  If set to $SVN::Depth::unknown, then
258           behave as if for $SVN::Depth::infinity, except in the case of
259           resuming a previous checkout of $path (i.e. updating) in which case
260           use the depth of the existing working copy.
261
262           $ignore_exteranls if set to TRUE the operation will ignore external
263           definitions.
264
265           $allow_unver_obstructions if set to TRUE the operation will
266           tolerate existing unversioned items that obstruct incoming paths.
267           Only obstructions of the same type (file or dir) as the added item
268           are tolerated.  The text of obstructing files is left as-is,
269           effectively treating it as a user modification after the checkout.
270           Working properties of obstructing items are set equal to the base
271           properties.  If set to FALSE, then abort if there are any
272           unversioned obstructing items.
273
274           Returns the value of the revision actually checked out of the
275           repository.
276
277       $client->cleanup($dir, $pool);
278           Recursively cleanup a working copy directory, $dir, finishing any
279           incomplete operations, removing lockfiles, etc.
280
281       $client->commit($targets, $nonrecursive, $pool);
282           Commit files or directories referenced by target.  Will use the
283           log_msg callback to obtain the log message for the commit.
284
285           If $targets contains no paths (zero elements), then does nothing
286           and immediately returns without error.
287
288           Calls the notify callback as the commit progresses with any of the
289           following actions: $SVN::Wc::Notify::Action::commit_modified,
290           $SVN::Wc::Notify::Action::commit_added,
291           $SVN::Wc::Notify::Action::commit_deleted,
292           $SVN::Wc::Notify::Action::commit_replaced,
293           $SVN::Wc::Notify::Action::commit_postfix_txdelta.
294
295           Use $nonrecursive to indicate that subdirectories of directory
296           targets should be ignored.
297
298           Returns a svn_client_commit_info_t object.  If the revision member
299           of the commit information object is $SVN::Core::INVALID_REVNUM and
300           no error was raised, then the commit was a no-op; nothing needed to
301           be committed.
302
303       $client->copy($src_target, $src_revision, $dst_target, $pool);
304           Copies $src_target to $dst_target.
305
306           $src_target must be a file or directory under version control, or
307           the URL of a versioned item in the repository.  If $src_target is a
308           URL, $src_revision is used to choose the revision from which to
309           copy the $src_target.  $dst_path must be a file or directory under
310           version control, or a repository URL, existing or not.
311
312           If $dst_target is a URL, immediately attempt to commit the copy
313           action to the repository.  The log_msg callback will be called to
314           query for a commit log message.  If the commit succeeds, return a
315           svn_client_commit_info_t object.
316
317           If $dst_target is not a URL, then this is just a variant of
318           $client->add(), where the $dst_path items are scheduled for
319           addition as copies.  No changes will happen to the repository until
320           a commit occurs.  This scheduling can be removed with
321           $client->revert().  undef will be returned in this case.
322
323           Calls the notify callback for each item added at the new location,
324           passing the new, relative path of the added item.
325
326       $client->delete($targets, $force, $pool);
327           Delete items from a repository or working copy.
328
329           If the paths in $targets are URLs, immediately attempt to commit a
330           deletion of the URLs from the repository.  The log_msg callback
331           will be called to query for a commit log message.  If the commit
332           succeeds, return a svn_client_commit_info_t object.  Every path
333           must belong to the same repository.
334
335           Else, schedule the working copy paths in $targets for removal from
336           the repository.  Each path's parent must be under revision control.
337           This is just a scheduling operation.  No changes will happen to the
338           repository until a commit occurs.  This scheduling can be removed
339           with $client->revert().  If a path is a file it is immediately
340           removed from the working copy.  If the path is a directory it will
341           remain in the working copy but all the files, and all unversioned
342           items it contains will be removed.  If $force is not set then this
343           operation will fail if any path contains locally modified and/or
344           unversioned items.  If $force is set such items will be deleted.
345
346           The notify callback is called for each item deleted with the path
347           of the deleted item.
348
349           Has no return.
350
351       $client->diff($diff_options, $target1, $revision1, $target2,
352       $revision2, $recursive, $ignore_ancestry, $no_diff_deleted, $outfile,
353       $errfile, $pool);
354           Produces diff output which describes the delta between $target1 at
355           $revision1 and $target2 at $revision2.  They both must represent
356           the same node type (i.e. they most both be directories or files).
357           The revisions must not be undef.
358
359           Prints the output of the diff to the filename or filehandle passed
360           as $outfile, and any errors to the filename or filehandle passed as
361           $errfile.
362
363           Use $ignore_ancestry to control whether or not items being diffed
364           will be checked for relatedness first.  Unrelated items are
365           typically transmitted to the editor as a deletion of one thing and
366           the addition of another, but if this flag is true, unrelated items
367           will be diffed as if they were related.
368
369           If $no_diff_deleted is true, then no diff output will be generated
370           on deleted files.
371
372           $diff_options is a reference to an array of additional arguments to
373           pass to diff process invoked to compare files.  You'll usually just
374           want to use [] to pass an empty array to return a unified context
375           diff (like `diff -u`).
376
377           Has no return.
378
379       $client->diff_summarize($target1, $revision1, $target2, $revision2,
380       $recursive, $ignore_ancestry, \&summarize_func, $pool);
381           Produce a diff summary which lists the changed items between
382           $target1 at $revision1 and $target2 at $revision2 without creating
383           text deltas.  $target1 and $target2 can be either working-copy
384           paths or URLs.
385
386           The function may report false positives if $ignore_ancestry is
387           false, since a file might have been modified between two revisions,
388           but still have the same contents.
389
390           Calls \&summarize_func with with a svn_client_diff_summarize_t
391           structure describing the difference.
392
393           See diff() for a description of the other parameters.
394
395           Has no return.
396
397       $client->export($from, $to, $revision, $force, $pool);
398           Export the contents of either a subversion repository or a
399           subversion working copy into a 'clean' directory (meaning a
400           directory with no administrative directories).
401
402           $from is either the path to the working copy on disk, or a URL to
403           the repository you wish to export.
404
405           $to is the path to the directory where you wish to create the
406           exported tree.
407
408           $revision is the revision that should be exported, which is only
409           used when exporting from a repository.  It may be undef otherwise.
410
411           The notify callback will be called for the items exported.
412
413           Returns the value of the revision actually exported or
414           $SVN::Core::INVALID_REVNUM for local exports.
415
416       $client->import($path, $url, $nonrecursive, $pool);
417           Import file or directory $path into repository directory $url at
418           head.
419
420           If some components of $url do not exist then create parent
421           directories as necessary.
422
423           If $path is a directory, the contents of that directory are
424           imported directly into the directory identified by $url.  Note that
425           the directory $path itself is not imported; that is, the basename
426           of $path is not part of the import.
427
428           If $path is a file, then the dirname of $url is the directory
429           receiving the import.  The basename of $url is the filename in the
430           repository.  In this case if $url already exists, raise an error.
431
432           The notify callback (if defined) will be called as the import
433           progresses, with any of the following actions:
434           $SVN::Wc::Notify::Action::commit_added,
435           $SVN::Wc::Notify::Action::commit_postfix_txdelta.
436
437           Use $nonrecursive to indicate that imported directories should not
438           recurse into any subdirectories they may have.
439
440           Uses the log_msg callback to determine the log message for the
441           commit when one is needed.
442
443           Returns a svn_client_commit_info_t object.
444
445       $client->info($path_or_url, $peg_revision, $revision, \&receiver,
446       $recurse);
447           Invokes \&receiver passing it information about $path_or_url for
448           $revision.  The information returned is system-generated metadata,
449           not the sort of "property" metadata created by users.  For methods
450           available on the object passed to \&receiver, see svn_info_t.
451
452           If both revision arguments are either svn_opt_revision_unspecified
453           or NULL, then information will be pulled solely from the working
454           copy; no network connections will be made.
455
456           Otherwise, information will be pulled from a repository.  The
457           actual node revision selected is determined by the $path_or_url as
458           it exists in $peg_revision.  If $peg_revision is undef, then it
459           defaults to HEAD for URLs or WORKING for WC targets.
460
461           If $path_or_url is not a local path, then if $revision is PREV (or
462           some other kind that requires a local path), an error will be
463           returned, because the desired revision cannot be determined.
464
465           Uses the authentication baton cached in ctx to authenticate against
466           the repository.
467
468           If $recurse is true (and $path_or_url is a directory) this will be
469           a recursive operation, invoking $receiver on each child.
470
471            my $receiver = sub {
472                my( $path, $info, $pool ) = @_;
473                print "Current revision of $path is ", $info->rev, "\n";
474            };
475            $client->info( 'foo/bar.c', undef, 'WORKING', $receiver, 0 );
476
477       $client->log5($targets, $peg_revision, $revision_ranges, $limit,
478       $discover_changed_paths, $strict_node_history,
479       $include_merged_revisions, $revprops, \&log_entry_receiver, $pool);
480           Invoke "log_entry_receiver" on each log message from each revision
481           range in $revision_ranges in turn, inclusive (but never invoke
482           "log_entry_receiver" on a given log message more than once).
483
484           $targets is a reference to an array of either a URL followed by
485           zero or more relative paths, or 1 working copy path, for which log
486           messages are desired. If the array contains only a single element
487           you may set $targets to this element instead.  "log_entry_receiver"
488           is invoked only on messages whose revisions involved a change to
489           some path in $targets.
490
491           $peg_revision indicates in which revision $targets are valid.  If
492           $peg_revision is "undef", it defaults to 'HEAD' for URLs or
493           'WORKING' for WC paths.
494
495           $revision_ranges is either a single revision range or a reference
496           to an array of them. A revision range may be specified as a
497           reference to a two-element array "[$start, $end]" of $revisions or
498           a SVN::Core::svn_opt_revision_range_t object. Examples:
499
500             $revision_ranges = ['HEAD', 1];
501             $revision_ranges = [[2, 3], [5, 8], [13, 21]];
502
503           If $limit is non-zero only invoke "log_entry_receiver" on the first
504           $limit logs.
505
506           If $discover_changed_paths is true, then the changed_paths2 field
507           in the $log_entry argument to "log_entry_receiver" will be
508           populated on each invocation.  Note: The text_modified and
509           props_modified fields of the changed_paths2 structure may have the
510           value $SVN::Tristate::unknown if the repository does not report
511           that information.
512
513           If $strict_node_history is true, copy history (if any exists) will
514           not be traversed while harvesting revision logs for each target.
515
516           If $include_merged_revisions is true, log information for revisions
517           which have been merged to $targets will also be returned.
518
519           If $revprops is "undef", retrieve all revision properties.
520           Otherwise $revpros should be a reference to an array of property
521           names and only these properties will be retrieved (i.e. none if the
522           array is empty).
523
524           Use $pool for any temporary allocation.
525
526           Calls the notify subroutine with a $SVN::Wc::Notify::Action::skip
527           signal on any unversioned $targets.
528
529           The "log_entry_receiver" takes the following arguments:
530           "$log_entry, $pool".  $log_entry is a SVN::Core::svn_log_entry_t
531           object.
532
533       $client->log4($targets, $peg_revision, $start, $end, $limit,
534       $discover_changed_paths, $strict_node_history,
535       $include_merged_revisions, $revprops, \&log_entry_receiver, $pool);
536           Similar to "$client->log5()", but takes explicit $start and $end
537           parameters instead of $revision_ranges.
538
539           Deprecated.
540
541       $client->log3($targets, $peg_revision, $start, $end, $limit,
542       $discover_changed_paths, $strict_node_history, \&log_message_receiver,
543       $pool);
544           Similar to "$client->log4()", but using "log_message_receiver"
545           instead of "log_entry_receiver".  Also, $include_merged_revisions
546           is false and $revprops is [qw( svn:author svn:date and svn:log )].
547
548           The "log_message_receiver" takes the following arguments:
549           "$changed_paths, $revision, $author, $date, $message, $pool".  It
550           is called once for each log $message from the $revision on $date by
551           $author.  $author, $date or $message may be "undef".
552
553           If $changed_paths is defined it references a hash with the keys
554           every path committed in $revision; the values are
555           SVN::Core::svn_log_changed_path_t objects.
556
557           Deprecated.
558
559       $client->log2($targets, $start, $end, $limit, $discover_changed_paths,
560       $strict_node_history, \&log_message_receiver, $pool);
561           Similar to "$client->log3()", but with $peg_revision set to
562           "undef".
563
564           Deprecated.
565
566       $client->log($targets, $start, $end, $discover_changed_paths,
567       $strict_node_history, \&log_message_receiver, $pool);
568           Similar to "$client->log2()", but with $limit set to 0.
569
570           Special case for repositories at revision 0: If $start is 'HEAD'
571           and $end is 1, then handle an empty (no revisions) repository
572           specially: instead of erroring because requested revision 1 when
573           the highest revision is 0, just invoke "log_message_receiver" on
574           revision 0, passing "undef" to $changed_paths and empty strings for
575           the author and date.  This is because that particular combination
576           of $start and $end usually indicates the common case of log
577           invocation; the user wants to see all log messages from youngest to
578           oldest, where the oldest commit is revision 1.  That works fine,
579           except there are no commits in the repository, hence this special
580           case.
581
582           Deprecated.
583
584       $client->ls($target, $revision, $recursive, $pool);
585           Returns a hash of svn_dirent_t objects for $target at $revision.
586
587           If $target is a directory, returns entries for all of the
588           directories' contents.  If $recursive is true, it will recurse
589           subdirectories in $target.
590
591           If $target is a file only return an entry for the file.
592
593           If $target is non-existent, raises the $SVN::Error::FS_NOT_FOUND
594           error.
595
596       $client->merge($src1, $rev1, $src2, $rev2, $target_wcpath, $recursive,
597       $ignore_ancestry, $force, $dry_run, $pool);
598           Merge changes from $src1/$rev1 to $src2/$rev2 into the working-copy
599           path $target_wcpath.
600
601           $src1 and $src2 are either URLs that refer to entries in the
602           repository, or paths to entries in the working copy.
603
604           By 'merging', we mean: apply file differences and schedule
605           additions & deletions when appropriate.
606
607           $src1 and $src2 must both represent the same node kind; that is, if
608           $src1 is a directory, $src2 must also be, and if $src1 is a file,
609           $src2 must also be.
610
611           If either $rev1 or $rev2 is undef raises the
612           $SVN::Error::CLIENT_BAD_REVISION error.
613
614           If $recursive is true (and the URLs are directories), apply changes
615           recursively; otherwise, only apply changes in the current
616           directory.
617
618           Use $ignore_ancestry to control whether or not items being diffed
619           will be checked for relatedness first.  Unrelated items are
620           typically transmitted to the editor as a deletion of one thing and
621           the addition of another, but if this flag is true, unrelated items
622           will be diffed as if they were related.
623
624           If $force is not set and the merge involves deleting locally
625           modified or unversioned items the operation will raise an error.
626           If $force is set such items will be deleted.
627
628           Calls the notify callback once for each merged target, passing the
629           targets local path.
630
631           If $dry_run is true the merge is carried out, and the full
632           notification feedback is provided, but the working copy is not
633           modified.
634
635           Has no return.
636
637       $client->mkdir($targets, $pool);
638           Similar to $client->mkdir2() except it returns an
639           svn_client_commit_info_t object instead of a svn_commit_info_t
640           object.
641
642       $client->mkdir2($targets, $pool);
643           Similar to $client->mkdir3(), but with $make_parents always FALSE,
644           and $revprop_hash always undef.
645
646       $client->mkdir3($targets, $make_parents, $revprop_hash, $pool);
647           Similar to $client->mkdir4(), but returns a svn_commit_info_t
648           object rather than through a callback function.
649
650       $client->mkdir4($targets, $make_parents, $revprop_hash,
651       \&commit_callback, $pool);
652           Create a directory, either in a repository or a working copy.
653
654           If $targets contains URLs, immediately attempts to commit the
655           creation of the directories in $targets in the repository.  Returns
656           a svn_client_commit_info_t object.
657
658           Else, create the directories on disk, and attempt to schedule them
659           for addition.  In this case returns undef.
660
661           If $make_parents is TRUE, create any non-existent parent
662           directories also.
663
664           If not undef, $revprop_hash is a reference to a hash table holding
665           additional custom revision properites (property names mapped to
666           strings) to be set on the new revision in the event that this is a
667           committing operation.  This hash cannot contain any standard
668           Subversion properties.
669
670           Calls the log message callback to query for a commit log message
671           when one is needed.
672
673           Calls the notify callback when the directory has been created
674           (successfully) in the working copy, with the path of the new
675           directory.  Note this is only called for items added to the working
676           copy.
677
678           If \&commit_callback is not undef, then for each successful commit,
679           call \&commit_callback with the svn_commit_info_t object for the
680           commit.
681
682       $client->move($src_path, $src_revision, $dst_path, $force, $pool);
683           Move $src_path to $dst_path.
684
685           $src_path must be a file or directory under version control, or the
686           URL of a versioned item in the repository.
687
688           If $src_path is a repository URL:
689
690           * $dst_path must also be a repository URL (existent or not).
691
692           * $src_revision is used to choose the revision from which to copy
693           the $src_path.
694
695           * The log_msg callback will be called for the commit log message.
696
697           * The move operation will be immediately committed.  If the commit
698           succeeds, returns a svn_client_commit_info_t object.
699
700           If $src_path is a working copy path
701
702           * $dst_path must also be a working copy path (existent or not).
703
704           * $src_revision is ignored and may be undef.  The log_msg callback
705           will not be called.
706
707           * This is a scheduling operation.  No changes will happen to the
708           repository until a commit occurs.  This scheduling can be removed
709           with $client->revert().  If $src_path is a file it is removed from
710           the working copy immediately.  If $src_path is a directory it will
711           remain in the working copy but all files, and unversioned items, it
712           contains will be removed.
713
714           * If $src_path contains locally modified and/or unversioned items
715           and $force is not set, the copy will raise an error.  If $force is
716           set such items will be removed.
717
718           The notify callback will be called twice for each item moved, once
719           to indicate the deletion of the moved node, and once to indicate
720           the addition of the new location of the node.
721
722       $client->propget($propname, $target, $revision, $recursive, $pool);
723           Returns a reference to a hash containing paths or URLs, prefixed by
724           $target (a working copy or URL), of items for which the property
725           $propname is set, and whose values represent the property value for
726           $propname at that path.
727
728       $client->proplist($target, $revision, $recursive, $pool);
729           Returns a reference to an array of svn_client_proplist_item_t
730           objects.
731
732           For each item the node_name member of the proplist_item object
733           contains the name relative to the same base as $target.
734
735           If $revision is undef, then get properties from the working copy,
736           if $target is a working copy, or from the repository head if
737           $target is a URL.  Else get the properties as of $revision.
738
739           If $recursive is false, or $target is a file, the returned array
740           will only contain a single element.  Otherwise, it will contain one
741           entry for each versioned entry below (and including) $target.
742
743           If $target is not found, raises the $SVN::Error::ENTRY_NOT_FOUND
744           error.
745
746       $client->propset($propname, $propval, $target, $recursive, $pool);
747           Set $propname to $propval on $target (a working copy or URL path).
748
749           If $recursive is true, then $propname will be set recursively on
750           $target and all children.  If $recursive is false, and $target is a
751           directory, $propname will be set on only $target.
752
753           A $propval of undef will delete the property.
754
755           If $propname is an svn-controlled property (i.e. prefixed with
756           svn:), then the caller is responsible for ensuring that $propval is
757           UTF8-encoded and uses LF line-endings.
758
759       $client->relocate($dir, $from, $to, $recursive, $pool);
760           Modify a working copy directory $dir, changing any repository URLs
761           that begin with $from to begin with $to instead, recursing into
762           subdirectories if $recursive is true.
763
764           Has no return.
765
766       $client->resolved($path, $recursive, $pool);
767           Removed the 'conflicted' state on a working copy path.
768
769           This will not semantically resolve conflicts; it just allows $path
770           to be committed in the future.  The implementation details are
771           opaque.  If $recursive is set, recurse below $path, looking for
772           conflicts to resolve.
773
774           If $path is not in a state of conflict to begin with, do nothing.
775
776           If $path's conflict state is removed, call the notify callback with
777           the $path.
778
779       $client->revert($paths, $recursive, $pool);
780           Restore the pristine version of a working copy $paths, effectively
781           undoing any local mods.
782
783           For each path in $paths, if it is a directory and $recursive is
784           true, this will be a recursive operation.
785
786       $client->revprop_get($propname, $url, $revision, $pool);
787           Returns two values, the first of which is the value of $propname on
788           revision $revision in the repository represented by $url.  The
789           second value is the actual revision queried.
790
791           Note that unlike its cousin $client->propget(), this routine
792           doesn't affect working copy at all; it's a pure network operation
793           that queries an unversioned property attached to a revision.  This
794           can be used to query log messages, dates, authors, and the like.
795
796       $client->revprop_list($url, $revision, $pool);
797           Returns two values, the first of which is a reference to a hash
798           containing the properties attached to $revision in the repository
799           represented by $url.  The second value is the actual revision
800           queried.
801
802           Note that unlike its cousin $client->proplist(), this routine
803           doesn't read a working copy at all; it's a pure network operation
804           that reads unversioned properties attached to a revision.
805
806       $client->revprop_set($propname, $propval, $url, $revision, $force,
807       $pool);
808           Set $propname to $propval on revision $revision in the repository
809           represented by $url.
810
811           Returns the actual revision affected.  A $propval of undef will
812           delete the property.
813
814           If $force is true, allow newlines in the author property.
815
816           If $propname is an svn-controlled property (i.e. prefixed with
817           svn:), then the caller is responsible for ensuring that the value
818           is UTF8-encoded and uses LF line-endings.
819
820           Note that unlike its cousin $client->propset(), this routine
821           doesn't affect the working copy at all; it's a pure network
822           operation that changes an unversioned property attached to a
823           revision.  This can be used to tweak log messages, dates, authors,
824           and the like.  Be careful: it's a lossy operation, meaning that any
825           existing value is replaced with the new value, with no way to
826           retrieve the prior value.
827
828           Also note that unless the administrator creates a pre-revprop-
829           change hook in the repository, this feature will fail.
830
831       $client->status($path, $revision, \&status_func, $recursive, $get_all,
832       $update, $no_ignore, $pool);
833           Similar to $client->status2(), but with ignore_externals always set
834           to FALSE, and with the status_func receiving a svn_wc_status2_t
835           instead of a svn_wc_status_t object.
836
837       $client->status2($path, $revision, \&status_func, $recursive, $get_all,
838       $update, $no_ignore, $ignore_externals, $pool);
839           Similar to $client->status3(), but with the changelists passed as
840           undef, and with recursive instead of depth.
841
842       $client->status3($path, $revision, \&status_func, $depth, $get_all,
843       $update, $no_ignore, $ignore_externals, $changelists, $pool);
844           Similar to $client->status4(), without the pool parameter to the
845           callback and the return of the callback is ignored.
846
847       $client->status4($path, $revision, \&status_func, $depth, $get_all,
848       $update, $no_ignore, $ignore_externals, $changelists, $pool);
849           Given $path to a working copy directory (or single file), call
850           status_func() with a set of svn_wc_status2_t objects which describe
851           the status of $path and its children.
852
853           If $recursive is true, recurse fully, else do only immediate
854           children.
855
856           If $get_all is set, retrieve all entries; otherwise, retrieve only
857           'interesting' entries (local mods and/or out-of-date).
858
859           If $update is set, contact the repository and augment the status
860           objects with information about out-of-dateness (with respect to
861           $revision).  Also, will return the value of the actual revision
862           against with the working copy was compared.  (The return will be
863           undef if $update is not set).
864
865           Unless ignore_externals is set, the function recurses into
866           externals definitions ('svn:externals') after handling the main
867           target, if any exist.  The function calls the notify callback with
868           $SVN::Wc::Notify::Action::status_external action before handling
869           each externals definition, and with
870           $SVN::Wc::Notify::Action::status_completed after each.
871
872           $changelists is a reference to an array of changelist names, used
873           as a restrictive filter on items whose statuses are reported; that
874           is don't report status about any item unless it's a member of those
875           changelists.  If changelists is empty (or altogether undef), no
876           changelist filtering occurs.
877
878           The status_func subroutine takes the following parameters: $path,
879           $status, $pool
880
881           $path is the pathname of the file or directory which status is
882           being reported.  $status is a svn_wc_status2_t object.  $pool is an
883           apr_pool_t object which is cleaned between invocations to the
884           callback.
885
886           The return of the status_func subroutine can be a svn_error_t
887           object created by SVN::Error::create in order to propagate an error
888           up.
889
890       $client->switch($path, $url, $revision, $recursive, $pool);
891           Switch working tree $path to $url at $revision.
892
893           $revision must be a number, 'HEAD', or a date, otherwise it raises
894           the $SVN::Error::CLIENT_BAD_REVISION error.
895
896           Calls the notify callback on paths affected by the switch.  Also
897           invokes the callback for files that may be restored from the text-
898           base because they were removed from the working copy.
899
900           Summary of purpose: This is normally used to switch a working
901           directory over to another line of development, such as a branch or
902           a tag.  Switching an existing working directory is more efficient
903           than checking out $url from scratch.
904
905           Returns the value of the revision to which the working copy was
906           actually switched.
907
908       $client->update($path, $revision, $recursive, $pool)
909           Similar to $client->update2() except that it accepts only a single
910           target in $path, returns a single revision, and $ignore_externals
911           is always set to FALSE.
912
913       $client->update2($paths, $revision, $recursive, $ignore_externals,
914       $pool)
915           Similar to $client->update3() but with $allow_unver_obstructions
916           always set to FALSE, $depth_is_sticky to FALSE, and $depth set
917           according to $recursive: if $recursive is TRUE, set $depth to
918           $SVN::Depth::infinity, if $recursive is FALSE, set $depth to
919           $SVN::Depth::files.
920
921       $client->update3($paths, $revision, $depth, $depth_is_sticky,
922       $ignore_externals, $allow_unver_obstructions, $pool)
923           Similar to $client->update4() but with $make_parents always set to
924           FALSE and $adds_as_modification set to TRUE.
925
926       $client->update4($paths, $revision, $depth, $depth_is_sticky,
927       $ignore_externals, $allow_unver_obstructions, $adds_as_modification,
928       $make_parents)
929           Update working trees $paths to $revision.
930
931           $paths is a array reference of paths to be updated.  Unversioned
932           paths that are the direct children of a versioned path will cause
933           an update that attempts to add that path; other unversioned paths
934           are skipped.
935
936           $revision must be a revision number, 'HEAD', or a date or this
937           method will raise the $SVN::Error::CLIENT_BAD_REVISION error.
938
939           The paths in $paths can be from multiple working copies from
940           multiple repositories, but even if they all come from the same
941           repository there is no guarantee that revision represented by
942           'HEAD' will remain the same as each path is updated.
943
944           If $ignore_externals is set, don't process externals definitions as
945           part of this operation.
946
947           If $depth is $SVN::Depth::infinity, update fully recursivelly.
948           Else if it is $SVN::Depth::immediates or $SVN::Depth::files, update
949           each target and its file entries, but not its subdirectories.  Else
950           if $SVN::Depth::empty, update exactly each target, nonrecursively
951           (essentially, update the target's properties).
952
953           If $depth is $SVN::Depth::unknown, take the working depth from
954           $paths and then describe as behaved above.
955
956           If $depth_is_sticky is set and $depth is not $SVN::Depth::unknown,
957           then in addition to update paths, also set their sticky ambient
958           depth value to $depth.
959
960           If $allow_unver_obstructions is TRUE then the update tolerates
961           existing unversioned items that obstruct added paths.  Only
962           obstructions of the same type (file or dir) as the added item are
963           tolerated.  The text of obstructing files is left as-is,
964           effectively treating it as a user modification after the update.
965           Working properties of obstructing items are set equal to the base
966           properties.  If $allow_unver_obstructions is FALSE then the update
967           will abort if there are any unversioned obstructing items.
968
969           If $adds_as_modification is TRUE, a local addition at the same path
970           as an incoming addition of the same node kind results in a normal
971           node with a possible local modification, instead of a tree
972           conflict.
973
974           If $make_parents is TRUE, create any non-existent parent
975           directories also by checking them out at depth=empty.
976
977           Calls the notify callback for each item handled by the update, and
978           also for files restored from the text-base.
979
980           Returns an array reference to an array of revision numbers with
981           each element set to the revision to which $revision was resolved
982           for the corresponding element of $paths.
983
984       $client->url_from_path($target, $pool); or
985       SVN::Client::url_from_path($target, $pool);
986           Returns the URL for $target.
987
988           If $target is already a URL it returns $target.
989
990           If $target is a versioned item, it returns $target's entry URL.
991
992           If $target is unversioned (has no entry), returns undef.
993
994       $client->uuid_from_path($path, $adm_access, $pool);
995           Return the repository uuid for working-copy $path, allocated in
996           $pool.
997
998           Use $adm_access to retrieve the uuid from $path's entry; if not
999           present in the entry, then call $client->uuid_from_url() to
1000           retrieve, using the entry's URL.
1001
1002           Note: The only reason this function falls back on
1003           $client->uuid_from_url is for compatibility purposes.  Old working
1004           copies may not have uuids in the entries files.
1005
1006           Note: This method probably doesn't work right now without a lot of
1007           pain, because SVN::Wc is incomplete and it requires an adm_access
1008           object from it.
1009
1010       $client->uuid_from_url($url, $pool);
1011           Return repository uuid for url.
1012

ATTRIBUTE METHODS

1014       The following attribute methods are provided that allow you to set
1015       various configuration or retrieve it.  They all take value(s) to set
1016       the attribute and return the new value of the attribute or no
1017       parameters which returns the current value.
1018
1019       $client->auth(SVN::Client::get_username_provider());
1020           Provides access to the auth_baton in the svn_client_ctx_t attached
1021           to the SVN::Client object.
1022
1023           This method will accept an array or array ref of values returned
1024           from the authentication provider functions see "AUTHENTICATION
1025           PROVIDERS", which it will convert to an auth_baton for you.  This
1026           is the preferred method of setting the auth_baton.
1027
1028           It will also accept a scalar that references a _p_svn_auth_baton_t
1029           such as those returned from SVN::Core::auth_open and
1030           SVN::Core::auth_open_helper.
1031
1032       $client->notify(\&notify);
1033           Sets the notify callback for the client context to a code reference
1034           that you pass.  It always returns the current codereference set.
1035
1036           The subroutine pointed to by this reference will be called when a
1037           change is made to the working copy.  The return value of this
1038           function is ignored.  It's only purpose is to notify you of the
1039           change.
1040
1041           The subroutine will receive 6 parameters.  The first parameter will
1042           be the path of the changed file (absolute or relative to the cwd).
1043           The second is an integer specifying the type of action taken.  See
1044           SVN::Wc for a list of the possible actions values and what they
1045           mean.  The 3rd is an integer specifying the kind of node the path
1046           is, which can be: $SVN::Node::none, $SVN::Node::file,
1047           $SVN::Node::dir, $SVN::Node::unknown.  The fourth parameter is the
1048           mime-type of the file or undef if the mime-type is unknown (it will
1049           always be undef for directories).  The 5th parameter is the state
1050           of the file, again see SVN::Wc for a list of the possible states.
1051           The 6th and final parameter is the numeric revision number of the
1052           changed file.  The revision number will be -1 except when the
1053           action is $SVN::Wc::Notify::Action::update_completed.
1054
1055       $client->log_msg(\&log_msg)
1056           Sets the log_msg callback for the client context to a code
1057           reference that you pass.  It always returns the current
1058           codereference set.
1059
1060           The subroutine pointed to by this coderef will be called to get the
1061           log message for any operation that will commit a revision to the
1062           repo.
1063
1064           It receives 4 parameters.  The first parameter is a reference to a
1065           scalar value in which the callback should place the log_msg.  If
1066           you wish to cancel the commit you can set this scalar to undef.
1067           The 2nd value is a path to any temporary file which might be
1068           holding that log message, or undef if no such file exists (though,
1069           if log_msg is undef, this value is undefined).  The log message
1070           MUST be a UTF8 string with LF line separators.  The 3rd parameter
1071           is a reference to an array of svn_client_commit_item3_t objects,
1072           which may be fully or only partially filled-in, depending on the
1073           type of commit operation.  The 4th and last parameter will be a
1074           pool.
1075
1076           If the function wishes to return an error it should return a
1077           svn_error_t object made with SVN::Error::create.  Any other return
1078           value will be interpreted as SVN_NO_ERROR.
1079
1080       $client->cancel(\&cancel)
1081           Sets the cancellation callback for the client context to a code
1082           reference that you pass. See "CANCELLATION CALLBACK" below for
1083           details.  It always returns the current codereference set.
1084
1085       $client->pool(new SVN::Pool);
1086           Method that sets or gets the default pool that is passed to method
1087           calls requiring a pool, but which were not explicitly passed one.
1088
1089           See SVN::Core for more information about how pools are managed in
1090           this interface.
1091
1092       $client->config(SVN::Core::config_get_config(undef));
1093           Method that allows access to the config member of the
1094           svn_client_ctx_t.  Accepts a Perl hash to set, which is what
1095           functions like SVN::Core:config_get_config() will return.
1096
1097           It will return a _p_arp_hash_t scalar.  This is a temporary
1098           situation.  The return value is not particular useful.  In the
1099           future, this value will be tied to the actual hash used by the C
1100           API.
1101

AUTHENTICATION PROVIDERS

1103       The following functions get authentication providers for you.  They
1104       come in two forms.  Standard or File versions, which look for
1105       authentication information in the subversion configuration directory
1106       that was previously cached, or Prompt versions which call a subroutine
1107       to allow you to prompt the user for the information.
1108
1109       The functions that return the svn_auth_provider_object_t for prompt
1110       style providers take a reference to a Perl subroutine to use for the
1111       callback.  The first parameter each of these subroutines receive is a
1112       credential object.  The subroutines return the response by setting
1113       members of that object.  Members may be set like so:
1114       $cred->username("breser");  These functions and credential objects
1115       always have a may_save member which specifies if the authentication
1116       data will be cached.
1117
1118       The providers are as follows:
1119
1120               NAME                WHAT IT HANDLES
1121               ----------------    ----------------------------------------
1122               simple              username and password pairs
1123
1124               username            username only
1125
1126               ssl_server_trust    server certificates and failures
1127                                   authenticating them
1128
1129               ssl_client_cert     client side certificate files
1130
1131               ssl_client_cert_pw  password for a client side certificate file.
1132
1133       SVN::Client::get_simple_provider
1134           Returns a simple provider that returns information from previously
1135           cached sessions.  Takes no parameters or one pool parameter.
1136
1137       SVN::Client::get_simple_prompt_provider
1138           Returns a simple provider that prompts the user via a callback.
1139           Takes two or three parameters, the first is the callback
1140           subroutine, the 2nd is the number of retries to allow, the 3rd is
1141           optionally a pool.  The subroutine gets called with the following
1142           parameters: a svn_auth_cred_simple_t object, a realm string, a
1143           default username, may_save, and a pool.  The svn_auth_cred_simple
1144           has the following members: username, password, and may_save.
1145
1146       SVN::Client::get_username_provider
1147           Returns a username provider that returns information from a
1148           previously cached sessions.  Takes no parameters or one pool
1149           parameter.
1150
1151       SVN::Client::get_username_prompt_provider
1152           Returns a username provider that prompts the user via a callback.
1153           Takes two or three parameters, the first is the callback
1154           subroutine, the 2nd is the number of retries to allow, the 3rd is
1155           optionally a pool.  The subroutine gets called with the following
1156           parameters: a svn_auth_cred_username_t object, a realm string, a
1157           default username, may_save, and a pool.  The svn_auth_cred_username
1158           has the following members: username and may_save.
1159
1160       SVN::Client::get_ssl_server_trust_file_provider
1161           Returns a server trust provider that returns information from
1162           previously cached sessions.  Takes no parameters or optionally a
1163           pool parameter.
1164
1165       SVN::Client::get_ssl_server_trust_prompt_provider
1166           Returns a server trust  provider that prompts the user via a
1167           callback. Takes one or two parameters the callback subroutine and
1168           optionally a pool parameter.  The subroutine gets called with the
1169           following parameters.  A svn_auth_cred_ssl_server_trust_t object, a
1170           realm string, an integer specifying how the certificate failed
1171           authentication, a svn_auth_ssl_server_cert_info_t object, may_save,
1172           and a pool.  The svn_auth_cred_ssl_server_trust_t object has the
1173           following members: may_save and accepted_failures.  The
1174           svn_auth_ssl_server_cert_info_t object has the following members
1175           (and behaves just like cred objects though you can't modify it):
1176           hostname, fingerprint, valid_from, valid_until, issuer_dname,
1177           ascii_cert.
1178
1179           The masks used for determining the failures are in SVN::Auth::SSL
1180           and are named:
1181
1182           $SVN::Auth::SSL::NOTYETVALID $SVN::Auth::SSL::EXPIRED
1183           $SVN::Auth::SSL::CNMISMATCH $SVN::Auth::SSL::UNKNOWNCA
1184           $SVN::Auth::SSL::OTHER
1185
1186           You reply by setting the accepted_failures of the cred object with
1187           an integer of the values for what you want to accept bitwise AND'd
1188           together.
1189
1190       SVN::Client::get_ssl_client_cert_file_provider
1191           Returns a client certificate provider that returns information from
1192           previously cached sessions.  Takes no parameters or optionally a
1193           pool parameter.
1194
1195       SVN::Client::get_ssl_client_cert_prompt_provider
1196           Returns a client certificate provider that prompts the user via a
1197           callback.  Takes two or three parameters: the first is the callback
1198           subroutine, the 2nd is the number of retries to allow, the 3rd is
1199           optionally a pool parameter.  The subroutine gets called with the
1200           following parameters.  A svn_auth_cred_ssl_client_cert object, a
1201           realm string, may_save, and a pool.  The
1202           svn_auth_cred_ssl_client_cert the following members: cert_file and
1203           may_save.
1204
1205       SVN::Client::get_ssl_client_cert_pw_file_provider
1206           Returns a client certificate password provider that returns
1207           information from previously cached sessions.  Takes no parameters
1208           or optionally a pool parameter.
1209
1210       SVN::Client::get_ssl_client_cert_pw_prompt_provider
1211           Returns a client certificate password provider that prompts the
1212           user via a callback. Takes two or three parameters, the first is
1213           the callback subroutine, the 2nd is the number of retries to allow,
1214           the 3rd is optionally a pool parameter.  The subroutine gets called
1215           with the following parameters.  A svn_auth_cred_ssl_client_cert_pw
1216           object, a realm string, may_save, and a pool.  The
1217           svn_auth_cred_ssl_client_cert_pw has the following members:
1218           password and may_save.
1219

CANCELLATION CALLBACK

1221       This callback will be called periodically to see if the operation
1222       should be canceled.  If the operation should be canceled, the function
1223       may return one of the following values:
1224
1225       An svn_error_t object made with SVN::Error::create.
1226
1227       Any true value, in which case the bindings will generate an svn_error_t
1228       object for you with the error code of SVN_ERR_CANCELLED and the string
1229       set to "By cancel callback".
1230
1231       A string, in which case the bindings will generate an svn_error_t
1232       object for you with the error code of SVN_ERR_CANCELLED and the string
1233       set to the string you returned.
1234
1235       Any other value will be interpreted as wanting to continue the
1236       operation.  Generally, it's best to return 0 to continue the operation.
1237

OBJECTS

1239       These are some of the object types that are returned from the methods
1240       and functions.  Others are documented in SVN::Core and SVN::Wc.  If an
1241       object is not documented, it is more than likely opaque and not
1242       something you can do anything with, except pass to other functions that
1243       require such objects.
1244
1245   svn_info_t
1246       $info->URL()
1247               Where the item lives in the repository.
1248
1249       $info->rev()
1250               The revision of the object.  If path_or_url is a working-copy
1251               path, then this is its current working revnum.  If path_or_url
1252               is a URL, then this is the repos revision that path_or_url
1253               lives in.
1254
1255       $info->kind()
1256               The node's kind.
1257
1258       $info->repos_root_URL()
1259               The root URL of the repository.
1260
1261       $info->repos_UUID()
1262               The repository's UUID.
1263
1264       $info->last_changed_rev()
1265               The last revision in which this object changed.
1266
1267       $info->last_changed_date()
1268               The date of the last_changed_rev.
1269
1270       $info->last_changed_author()
1271               The author of the last_changed_rev.
1272
1273       $info->lock()
1274               An exclusive lock, if present.  Could be either local or
1275               remote.
1276
1277       See SVN::Wc::svn_wc_entry_t for the rest of these.   svn_client.h
1278       indicates that these were copied from that struct and mean the same
1279       things.   They are also only useful when working with a WC.
1280
1281       $info->has_wc_info()
1282       $info->schedule()
1283       $info->copyfrom_url()
1284       $info->copyfrom_rev()
1285       $info->text_time()
1286       $info->prop_time()
1287       $info->checksum()
1288       $info->conflict_old()
1289       $info->conflict_new()
1290       $info->conflict_wrk()
1291       $info->prejfile()
1292
1293   svn_client_commit_item3_t
1294       $commit_item->path()
1295               Absolute working-copy path of item.
1296
1297       $commit_item->kind()
1298               An integer representing the type of node it is (file/dir).  Can
1299               be one of the following constants: $SVN::Node::none
1300               $SVN::Node::file $SVN::Node::dir $SVN::Node::unknown
1301
1302       $commit_item->url()
1303               Commit URL for this item.
1304
1305       $commit_item->revision()
1306               Revision (copyfrom_rev if state_flags has IS_COPY set).
1307
1308       $commit_item->copyform_url();
1309               CopyFrom URL
1310
1311       $commit_item->state_flags();
1312               One of several state flags: $SVN::Client::COMMIT_ITEM_ADD
1313               $SVN::Client::COMMIT_ITEM_DELETE
1314               $SVN::Client::COMMIT_ITEM_TEXT_MODS
1315               $SVN::Client::COMMIT_ITEM_PROP_MODS
1316               $SVN::Client::COMMIT_ITEM_IS_COPY
1317
1318       $commit_item->incoming_prop_changes()
1319               A reference to an array of svn_prop_t objects representing
1320               changes to WC properties.
1321
1322       $commit_item->outgoing_prop_changes()
1323               A reference to an array of svn_prop_t objects representing
1324               extra changes to properties in the repository (which are not
1325               necessarily reflected by the WC).
1326
1327   svn_client_commit_info_t
1328       $commit_info->revision()
1329           Just committed revision.
1330
1331       $commit_info->date()
1332           Server-Side date of the commit as a string.
1333
1334       $commit_info->author()
1335           Author of the commit.
1336
1337   svn_client_proplist_item_t
1338       $proplist->node_name()
1339               The name of the node on which these properties are set.
1340
1341       $proplist->prop_hash()
1342               A reference to a hash of property names and values.
1343
1344   svn_client_diff_summarize_kind_t - SVN::Summarize
1345       An enum of the following constants:
1346
1347       $SVN::Client::Summarize::normal, $SVN::Client::Summarize::added,
1348       $SVN::Client::Summarize::modified, $SVN::Client::Summarize::deleted.
1349
1350   svn_client_diff_summarize_t
1351       $diff_summarize->path()
1352               Path relative to the target.  If the target is a file, path is
1353               the empty string.
1354
1355       $diff_summarize->summarize_kind()
1356               Change kind.
1357
1358       $diff_summarize->prop_changed()
1359               Properties changed?
1360
1361       $diff_summarize->node_kind()
1362               File or dir?
1363
1364   ADDITIONAL METHODS
1365       The following methods work, but are not currently documented in this
1366       file.  Please consult the svn_client.h section in the Subversion API
1367       for more details.
1368
1369       $client->add_to_changelist(...)
1370       $client->blame2(...)
1371       $client->blame3(...)
1372       $client->blame4(...)
1373       $client->cat2(...)
1374       $client->commit2(...)
1375       $client->commit3(...)
1376       $client->commit4(...)
1377       $client->copy2(...)
1378       $client->copy3(...)
1379       $client->copy4(...)
1380       $client->create_context(...)
1381       $client->delete2(...)
1382       $client->delete3(...)
1383       $client->diff2(...)
1384       $client->diff3(...)
1385       $client->diff4(...)
1386       $client->diff_peg(...)
1387       $client->diff_peg2(...)
1388       $client->diff_peg3(...)
1389       $client->diff_peg4(...)
1390       $client->diff_summarize2(...)
1391       $client->diff_summarize_dup(...)
1392       $client->diff_summarize_peg(...)
1393       $client->diff_summarize_peg2(...)
1394       $client->export2(...)
1395       $client->export3(...)
1396       $client->export4(...)
1397       $client->import2(...)
1398       $client->import3(...)
1399       $client->info2(...)
1400       $client->invoke_blame_receiver(...)
1401       $client->invoke_blame_receiver2(...)
1402       $client->invoke_diff_summarize_func(...)
1403       $client->list(...)
1404       $client->list2(...)
1405       $client->ls2(...)
1406       $client->ls3(...)
1407       $client->merge2(...)
1408       $client->merge3(...)
1409       $client->merge_peg(...)
1410       $client->merge_peg2(...)
1411       $client->merge_peg3(...)
1412       $client->move2(...)
1413       $client->move3(...)
1414       $client->move4(...)
1415       $client->move5(...)
1416       $client->open_ra_session(...)
1417       $client->propget2(...)
1418       $client->propget3(...)
1419       $client->proplist2(...)
1420       $client->proplist3(...)
1421       $client->propset2(...)
1422       $client->propset3(...)
1423       $client->remove_from_changelist(...)
1424       $client->resolve(...)
1425       $client->revert2(...)
1426       $client->switch2(...)
1427       $client->unlock(...)
1428       $client->version(...)
1429

TODO

1431       * Better support for the config.
1432
1433       * Unit tests for cleanup, diff, export, merge, move, relocate, resolved
1434       and switch.  This may reveal problems for using these methods as I
1435       haven't tested them yet that require deeper fixes.
1436

AUTHORS

1438       Chia-liang Kao <clkao@clkao.org>
1439
1440       Ben Reser <ben@reser.org>
1441
1443           Licensed to the Apache Software Foundation (ASF) under one
1444           or more contributor license agreements.  See the NOTICE file
1445           distributed with this work for additional information
1446           regarding copyright ownership.  The ASF licenses this file
1447           to you under the Apache License, Version 2.0 (the
1448           "License"); you may not use this file except in compliance
1449           with the License.  You may obtain a copy of the License at
1450
1451             http://www.apache.org/licenses/LICENSE-2.0
1452
1453           Unless required by applicable law or agreed to in writing,
1454           software distributed under the License is distributed on an
1455           "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
1456           KIND, either express or implied.  See the License for the
1457           specific language governing permissions and limitations
1458           under the License.
1459
1460
1461
1462perl v5.38.0                      2023-11-20                 native::Client(3)
Impressum