1native::Client(3) User Contributed Perl Documentation native::Client(3)
2
6 SVN::Client - Subversion client functions
7
9 use SVN::Client;
10 my $client = new SVN::Client();
11 # 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 # 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 # fetch the head revision of the target
36 $client->cat(\*STDOUT, $target, 'HEAD');
37
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 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 SVN::Client::add($client,$path, $recursive, $pool);
51 $client->add($path, $recursive, $pool);
52 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 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
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 $client
71 An SVN::Client object that you get from the constructor.
72 $url
74 This is a URL to a subversion repository.
75 $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 $paths
84 This argument can either be a single $path (as defined above) or a
85 reference to an array of them.
86 $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 $targets
97 This argument can either be a single $target (as defined above) or
98 a reference to an array of them.
99 $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 $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 $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
125 The following methods are available:
126 $client = SVN::Client->new( %options );
128 This class method constructs a new "SVN::Client" object and returns
129 a reference to it.
130 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 KEY DEFAULT
136 ---------- ----------------------------------------
137 auth auth_baton initiated with providers that
138 read cached authentication options from
139 the subversion config only.
140 cancel undef
142 config Hash containing the config from the
144 default subversion config file location.
145 log_msg undef
147 notify undef
149 pool A new pool is created for the context.
151 $client->add($path, $recursive, $pool);
153 Similar to $client->add2(), but with $force always set to FALSE.
154 $client->add2($path, $recursive, $force, $pool);
156 Similar to $client->add3(), but with $no_ignore always set to
157 FALSE.
158 $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 $client->add4($path, $depth, $force, $no_ignore, $add_parents, $pool);
165 Schedule a working copy $path for addition to the repository.
166 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 $path's parent must be under revision control already (unless
175 $add_parents is TRUE), but $path is not.
176 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 Calls the notify callback for each added item.
184 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 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 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 No return.
204 $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 An Error will be raised if either $start or $end is undef.
211 No return.
213 The blame receiver subroutine receives the following arguments:
215 $line_no, $revision, $author, $date, $line, $pool
216 $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 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 $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 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 $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 $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 $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 The $peg_revision sets the revision at which the path in the $url
250 is treated as representing.
251 $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 $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 $ignore_exteranls if set to TRUE the operation will ignore external
263 definitions.
264 $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 Returns the value of the revision actually checked out of the
275 repository.
276 $client->cleanup($dir, $pool);
278 Recursively cleanup a working copy directory, $dir, finishing any
279 incomplete operations, removing lockfiles, etc.
280 $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 If $targets contains no paths (zero elements), then does nothing
286 and immediately returns without error.
287 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 Use $nonrecursive to indicate that subdirectories of directory
296 targets should be ignored.
297 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 $client->copy($src_target, $src_revision, $dst_target, $pool);
304 Copies $src_target to $dst_target.
305 $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 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 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 Calls the notify callback for each item added at the new location,
324 passing the new, relative path of the added item.
325 $client->delete($targets, $force, $pool);
327 Delete items from a repository or working copy.
328 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 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 The notify callback is called for each item deleted with the path
347 of the deleted item.
348 Has no return.
350 $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 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 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 If $no_diff_deleted is true, then no diff output will be generated
370 on deleted files.
371 $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 Has no return.
378 $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 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 Calls \&summarize_func with with a svn_client_diff_summarize_t
391 structure describing the difference.
392 See diff() for a description of the other parameters.
394 Has no return.
396 $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 $from is either the path to the working copy on disk, or a URL to
403 the repository you wish to export.
404 $to is the path to the directory where you wish to create the
406 exported tree.
407 $revision is the revision that should be exported, which is only
409 used when exporting from a repository. It may be undef otherwise.
410 The notify callback will be called for the items exported.
412 Returns the value of the revision actually exported or
414 $SVN::Core::INVALID_REVNUM for local exports.
415 $client->import($path, $url, $nonrecursive, $pool);
417 Import file or directory $path into repository directory $url at
418 head.
419 If some components of $url do not exist then create parent
421 directories as necessary.
422 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 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 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 Use $nonrecursive to indicate that imported directories should not
438 recurse into any subdirectories they may have.
439 Uses the log_msg callback to determine the log message for the
441 commit when one is needed.
442 Returns a svn_client_commit_info_t object.
444 $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 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 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 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 Uses the authentication baton cached in ctx to authenticate against
466 the repository.
467 If $recurse is true (and $path_or_url is a directory) this will be
469 a recursive operation, invoking $receiver on each child.
470 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 $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 $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 $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 $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 $revision_ranges = ['HEAD', 1];
501 $revision_ranges = [[2, 3], [5, 8], [13, 21]];
502 If $limit is non-zero only invoke "log_entry_receiver" on the first
504 $limit logs.
505 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 If $strict_node_history is true, copy history (if any exists) will
514 not be traversed while harvesting revision logs for each target.
515 If $include_merged_revisions is true, log information for revisions
517 which have been merged to $targets will also be returned.
518 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 Use $pool for any temporary allocation.
525 Calls the notify subroutine with a $SVN::Wc::Notify::Action::skip
527 signal on any unversioned $targets.
528 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 $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 Deprecated.
540 $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 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 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 Deprecated.
558 $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 Deprecated.
565 $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 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 Deprecated.
583 $client->ls($target, $revision, $recursive, $pool);
585 Returns a hash of svn_dirent_t objects for $target at $revision.
586 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 If $target is a file only return an entry for the file.
592 If $target is non-existent, raises the $SVN::Error::FS_NOT_FOUND
594 error.
595 $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 $src1 and $src2 are either URLs that refer to entries in the
602 repository, or paths to entries in the working copy.
603 By 'merging', we mean: apply file differences and schedule
605 additions & deletions when appropriate.
606 $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 If either $rev1 or $rev2 is undef raises the
612 $SVN::Error::CLIENT_BAD_REVISION error.
613 If $recursive is true (and the URLs are directories), apply changes
615 recursively; otherwise, only apply changes in the current
616 directory.
617 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 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 Calls the notify callback once for each merged target, passing the
629 targets local path.
630 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 Has no return.
636 $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 $client->mkdir2($targets, $pool);
643 Similar to $client->mkdir3(), but with $make_parents always FALSE,
644 and $revprop_hash always undef.
645 $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 $client->mkdir4($targets, $make_parents, $revprop_hash,
651 \&commit_callback, $pool);
652 Create a directory, either in a repository or a working copy.
653 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 Else, create the directories on disk, and attempt to schedule them
659 for addition. In this case returns undef.
660 If $make_parents is TRUE, create any non-existent parent
662 directories also.
663 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 Calls the log message callback to query for a commit log message
671 when one is needed.
672 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 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 $client->move($src_path, $src_revision, $dst_path, $force, $pool);
683 Move $src_path to $dst_path.
684 $src_path must be a file or directory under version control, or the
686 URL of a versioned item in the repository.
687 If $src_path is a repository URL:
689 * $dst_path must also be a repository URL (existent or not).
691 * $src_revision is used to choose the revision from which to copy
693 the $src_path.
694 * The log_msg callback will be called for the commit log message.
696 * The move operation will be immediately committed. If the commit
698 succeeds, returns a svn_client_commit_info_t object.
699 If $src_path is a working copy path
701 * $dst_path must also be a working copy path (existent or not).
703 * $src_revision is ignored and may be undef. The log_msg callback
705 will not be called.
706 * 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 * 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 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 $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 $client->proplist($target, $revision, $recursive, $pool);
729 Returns a reference to an array of svn_client_proplist_item_t
730 objects.
731 For each item the node_name member of the proplist_item object
733 contains the name relative to the same base as $target.
734 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 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 If $target is not found, raises the $SVN::Error::ENTRY_NOT_FOUND
744 error.
745 $client->propset($propname, $propval, $target, $recursive, $pool);
747 Set $propname to $propval on $target (a working copy or URL path).
748 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 A $propval of undef will delete the property.
754 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 $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 Has no return.
765 $client->resolved($path, $recursive, $pool);
767 Removed the 'conflicted' state on a working copy path.
768 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 If $path is not in a state of conflict to begin with, do nothing.
775 If $path's conflict state is removed, call the notify callback with
777 the $path.
778 $client->revert($paths, $recursive, $pool);
780 Restore the pristine version of a working copy $paths, effectively
781 undoing any local mods.
782 For each path in $paths, if it is a directory and $recursive is
784 true, this will be a recursive operation.
785 $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 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 $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 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 $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 Returns the actual revision affected. A $propval of undef will
812 delete the property.
813 If $force is true, allow newlines in the author property.
815 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 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 Also note that unless the administrator creates a pre-revprop-
829 change hook in the repository, this feature will fail.
830 $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 $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 $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 $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 If $recursive is true, recurse fully, else do only immediate
854 children.
855 If $get_all is set, retrieve all entries; otherwise, retrieve only
857 'interesting' entries (local mods and/or out-of-date).
858 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 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 $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 The status_func subroutine takes the following parameters: $path,
879 $status, $pool
880 $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 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 $client->switch($path, $url, $revision, $recursive, $pool);
891 Switch working tree $path to $url at $revision.
892 $revision must be a number, 'HEAD', or a date, otherwise it raises
894 the $SVN::Error::CLIENT_BAD_REVISION error.
895 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 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 Returns the value of the revision to which the working copy was
906 actually switched.
907 $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 $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 $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 $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 $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 $revision must be a revision number, 'HEAD', or a date or this
937 method will raise the $SVN::Error::CLIENT_BAD_REVISION error.
938 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 If $ignore_externals is set, don't process externals definitions as
945 part of this operation.
946 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 If $depth is $SVN::Depth::unknown, take the working depth from
954 $paths and then describe as behaved above.
955 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 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 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 If $make_parents is TRUE, create any non-existent parent
975 directories also by checking them out at depth=empty.
976 Calls the notify callback for each item handled by the update, and
978 also for files restored from the text-base.
979 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 $client->url_from_path($target, $pool); or
985 SVN::Client::url_from_path($target, $pool);
986 Returns the URL for $target.
987 If $target is already a URL it returns $target.
989 If $target is a versioned item, it returns $target's entry URL.
991 If $target is unversioned (has no entry), returns undef.
993 $client->uuid_from_path($path, $adm_access, $pool);
995 Return the repository uuid for working-copy $path, allocated in
996 $pool.
997 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 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 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 $client->uuid_from_url($url, $pool);
1011 Return repository uuid for url.
1012
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 $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 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 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 $client->notify(\¬ify);
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 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 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 $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 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 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 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 $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 $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 See SVN::Core for more information about how pools are managed in
1090 this interface.
1091 $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 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
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 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 The providers are as follows:
1119 NAME WHAT IT HANDLES
1121 ---------------- ----------------------------------------
1122 simple username and password pairs
1123 username username only
1125 ssl_server_trust server certificates and failures
1127 authenticating them
1128 ssl_client_cert client side certificate files
1130 ssl_client_cert_pw password for a client side certificate file.
1132 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 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 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 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 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 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 The masks used for determining the failures are in SVN::Auth::SSL
1180 and are named:
1181 $SVN::Auth::SSL::NOTYETVALID $SVN::Auth::SSL::EXPIRED
1183 $SVN::Auth::SSL::CNMISMATCH $SVN::Auth::SSL::UNKNOWNCA
1184 $SVN::Auth::SSL::OTHER
1185 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 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 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 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 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
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 An svn_error_t object made with SVN::Error::create.
1226 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 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 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
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 svn_info_t
1246 $info->URL()
1247 Where the item lives in the repository.
1248 $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 $info->kind()
1256 The node's kind.
1257 $info->repos_root_URL()
1259 The root URL of the repository.
1260 $info->repos_UUID()
1262 The repository's UUID.
1263 $info->last_changed_rev()
1265 The last revision in which this object changed.
1266 $info->last_changed_date()
1268 The date of the last_changed_rev.
1269 $info->last_changed_author()
1271 The author of the last_changed_rev.
1272 $info->lock()
1274 An exclusive lock, if present. Could be either local or
1275 remote.
1276 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 $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 svn_client_commit_item3_t
1294 $commit_item->path()
1295 Absolute working-copy path of item.
1296 $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 $commit_item->url()
1303 Commit URL for this item.
1304 $commit_item->revision()
1306 Revision (copyfrom_rev if state_flags has IS_COPY set).
1307 $commit_item->copyform_url();
1309 CopyFrom URL
1310 $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 $commit_item->incoming_prop_changes()
1319 A reference to an array of svn_prop_t objects representing
1320 changes to WC properties.
1321 $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 svn_client_commit_info_t
1328 $commit_info->revision()
1329 Just committed revision.
1330 $commit_info->date()
1332 Server-Side date of the commit as a string.
1333 $commit_info->author()
1335 Author of the commit.
1336 svn_client_proplist_item_t
1338 $proplist->node_name()
1339 The name of the node on which these properties are set.
1340 $proplist->prop_hash()
1342 A reference to a hash of property names and values.
1343 svn_client_diff_summarize_kind_t - SVN::Summarize
1345 An enum of the following constants:
1346 $SVN::Client::Summarize::normal, $SVN::Client::Summarize::added,
1348 $SVN::Client::Summarize::modified, $SVN::Client::Summarize::deleted.
1349 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 $diff_summarize->summarize_kind()
1356 Change kind.
1357 $diff_summarize->prop_changed()
1359 Properties changed?
1360 $diff_summarize->node_kind()
1362 File or dir?
1363 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 $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
1431 * Better support for the config.
1432 * 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
1438 Chia-liang Kao <clkao@clkao.org>
1439 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 http://www.apache.org/licenses/LICENSE-2.0
1452 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.
1459perl v5.30.0 2019-07-25 native::Client(3)