{ "content": [ { "type": "text", "text": "# SVN::Client (perldoc)\n\n## NAME\n\nSVN::Client - Subversion client functions\n\n## SYNOPSIS\n\nuse SVN::Client;\nmy $client = new SVN::Client();\n# setup to handle authentication the same as the command line client\nmy $configdir = undef; # use default location\nmy $config = SVN:Core::configgetconfig($configdir);\nmy $configcategory = $cfg->{SVN::Core::CONFIGCATEGORYCONFIG};\n$client->auth(\nSVN::Core::cmdlinecreateauthbaton(0, #noninteractive\nundef, #username\nundef, #password\n$configdir,\n0, #noauthcache\n0, #trustservercert\n$configcategory,\nundef) #cancelcallback\n);\n# Use first argument as target and canonicalize it before using\nmy $target;\nif (SVN::Core::pathisurl($ARGV[0])) {\n$target = SVN::Core::uricanonicalize($ARGV[0]);\n} else {\n$target = SVN::Core::direntcanonicalize($ARGV[0]);\n}\n# fetch the head revision of the target\n$client->cat(\\*STDOUT, $target, 'HEAD');\n\n## DESCRIPTION\n\nSVN::Client wraps the highest level of functions provided by subversion to accomplish specific\ntasks in an object oriented API. Methods are similar to the functions provided by the C API and\nas such the documentation for it may be helpful in understanding this interface.\n\n## Sections\n\n- **NAME**\n- **SYNOPSIS**\n- **DESCRIPTION**\n- **PARAMETER NOTES**\n- **METHODS**\n- **ATTRIBUTE METHODS**\n- **AUTHENTICATION PROVIDERS**\n- **CANCELLATION CALLBACK**\n- **OBJECTS**\n- **TODO**\n- **AUTHORS**\n- **COPYRIGHT**\n\nUse structuredContent.sections for detailed options, examples, and full documentation.\n" } ], "structuredContent": { "command": "SVN::Client", "section": "", "mode": "perldoc", "summary": "SVN::Client - Subversion client functions", "synopsis": "use SVN::Client;\nmy $client = new SVN::Client();\n# setup to handle authentication the same as the command line client\nmy $configdir = undef; # use default location\nmy $config = SVN:Core::configgetconfig($configdir);\nmy $configcategory = $cfg->{SVN::Core::CONFIGCATEGORYCONFIG};\n$client->auth(\nSVN::Core::cmdlinecreateauthbaton(0, #noninteractive\nundef, #username\nundef, #password\n$configdir,\n0, #noauthcache\n0, #trustservercert\n$configcategory,\nundef) #cancelcallback\n);\n# Use first argument as target and canonicalize it before using\nmy $target;\nif (SVN::Core::pathisurl($ARGV[0])) {\n$target = SVN::Core::uricanonicalize($ARGV[0]);\n} else {\n$target = SVN::Core::direntcanonicalize($ARGV[0]);\n}\n# fetch the head revision of the target\n$client->cat(\\*STDOUT, $target, 'HEAD');", "tldr_summary": null, "tldr_examples": [], "tldr_source": null, "flags": [], "examples": [], "see_also": [], "section_outline": [ { "name": "NAME", "lines": 2, "subsections": [] }, { "name": "SYNOPSIS", "lines": 29, "subsections": [] }, { "name": "DESCRIPTION", "lines": 21, "subsections": [] }, { "name": "PARAMETER NOTES", "lines": 50, "subsections": [] }, { "name": "METHODS", "lines": 745, "subsections": [] }, { "name": "ATTRIBUTE METHODS", "lines": 71, "subsections": [] }, { "name": "AUTHENTICATION PROVIDERS", "lines": 95, "subsections": [] }, { "name": "CANCELLATION CALLBACK", "lines": 14, "subsections": [] }, { "name": "OBJECTS", "lines": 180, "subsections": [] }, { "name": "TODO", "lines": 5, "subsections": [] }, { "name": "AUTHORS", "lines": 4, "subsections": [] }, { "name": "COPYRIGHT", "lines": 17, "subsections": [] } ], "sections": { "NAME": { "content": "SVN::Client - Subversion client functions\n", "subsections": [] }, "SYNOPSIS": { "content": "use SVN::Client;\nmy $client = new SVN::Client();\n\n# setup to handle authentication the same as the command line client\nmy $configdir = undef; # use default location\nmy $config = SVN:Core::configgetconfig($configdir);\nmy $configcategory = $cfg->{SVN::Core::CONFIGCATEGORYCONFIG};\n$client->auth(\nSVN::Core::cmdlinecreateauthbaton(0, #noninteractive\nundef, #username\nundef, #password\n$configdir,\n0, #noauthcache\n0, #trustservercert\n$configcategory,\nundef) #cancelcallback\n);\n\n# Use first argument as target and canonicalize it before using\nmy $target;\nif (SVN::Core::pathisurl($ARGV[0])) {\n$target = SVN::Core::uricanonicalize($ARGV[0]);\n} else {\n$target = SVN::Core::direntcanonicalize($ARGV[0]);\n}\n\n# fetch the head revision of the target\n$client->cat(\\*STDOUT, $target, 'HEAD');\n", "subsections": [] }, "DESCRIPTION": { "content": "SVN::Client wraps the highest level of functions provided by subversion to accomplish specific\ntasks in an object oriented API. Methods are similar to the functions provided by the C API and\nas such the documentation for it may be helpful in understanding this interface.\n\nThere are a few notable differences from the C API. Most C function calls take a\nsvnclientctxt pointer as the next to last parameter. The Perl method calls take a SVN::Client\nobject as the first parameter. This allows method call invocation of the methods to be possible.\nFor example, the following are equivalent:\n\nSVN::Client::add($client,$path, $recursive, $pool);\n$client->add($path, $recursive, $pool);\n\nMany of the C API calls also take a aprpoolt pointer as their last argument. The Perl bindings\ngenerally deal with this for you and you do not need to pass a pool parameter. However, you may\nstill pass a pool parameter as the last parameter to override the automatic handling of this for\nyou.\n\nUsers of this interface should not directly manipulate the underlying hash values but should use\nthe respective attribute methods. Many of these attribute methods do other things, especially\nwhen setting an attribute, besides simply manipulating the value in the hash.\n", "subsections": [] }, "PARAMETER NOTES": { "content": "The client methods described below take a variety of parameters. Many of them are similar.\nMethods accepting parameters named below will follow the rules below or will be noted otherwise\nin the method description.\n\n$client\nAn SVN::Client object that you get from the constructor.\n\n$url\nThis is a URL to a subversion repository.\n\n$path\nThis is a path to a file or directory on the local file system. Paths need to be\ncanonicalized before being passed into the Subversion APIs. Paths on the local file system\nare called dirents and can be canonicalized by calling \"SVN::Core::direntcanonicalize\".\n\n$paths\nThis argument can either be a single $path (as defined above) or a reference to an array of\nthem.\n\n$target\nThis is a path to a file or directory in a working copy or a URL to a file or directory in a\nsubversion repository. Both paths and URLs need to be canonicalized before being passed into\nthe Subversion APIs. Paths on the local file system are called dirents and can be\ncanonicalized by calling \"SVN::Core::direntcanonicalize\". URLs can be canonicalized by\ncalling \"SVN::Core::uricanonicalize\".\n\n$targets\nThis argument can either be a single $target (as defined above) or a reference to an array\nof them.\n\n$revision\nThis specifies a revision in the Subversion repository. You can specify a revision in\nseveral ways. The easiest and most obvious is to directly provide the revision number. You\nmay also use the strings (aka revision keywords) 'HEAD', 'BASE', 'COMMITTED', and 'PREV'\nwhich have the same meanings as in the command line client. When referencing a working copy\nyou can use the string 'WORKING\" to reference the BASE plus any local modifications. \"undef\"\nmay be used to specify an unspecified revision. You may also pass a date by specifying the\ndate inside curly braces '{}'. The date formats accepted are the same as the command line\nclient accepts. Finally a \"psvnoptrevisiont\" object is accepted (which may have been\nreturned by some Subversion function).\n\n$recursive $nonrecursive.\nA boolean parameter that specifies if the action should follow directories. It should only\nbe 1 or 0. $recursive means, 1 means to descend into directories, 0 means not to.\n$nonrecursive has the inverse meaning.\n\n$pool\nPool is always an option parameter. If you wish to pass a pool parameter it should be a\nSVN::Pool or an aprpoolt object.\n", "subsections": [] }, "METHODS": { "content": "The following methods are available:\n\n$client = SVN::Client->new( %options );\nThis class method constructs a new \"SVN::Client\" object and returns a reference to it.\n\nKey/value pair arguments may be provided to set up the initial state of the user agent. The\nfollowing methods correspond to attribute methods described below:\n\nKEY DEFAULT\n---------- ----------------------------------------\nauth authbaton initiated with providers that\nread cached authentication options from\nthe subversion config only.\n\ncancel undef\n\nconfig Hash containing the config from the\ndefault subversion config file location.\n\nlogmsg undef\n\nnotify undef\n\npool A new pool is created for the context.\n\n$client->add($path, $recursive, $pool);\nSimilar to $client->add2(), but with $force always set to FALSE.\n\n$client->add2($path, $recursive, $force, $pool);\nSimilar to $client->add3(), but with $noignore always set to FALSE.\n\n$client->add3($path, $recursive, $force, $noignore, $pool);\nSimilar to $client->add4(), but with $addparents always set to FALSE and $depth set\naccording to $recursive; if TRUE, then depth is $SVN::Depth::infinity, if FALSE, then\n$SVN::Depth::empty.\n\n$client->add4($path, $depth, $force, $noignore, $addparents, $pool);\nSchedule a working copy $path for addition to the repository.\n\nIf $depth is $SVN::Depth::empty, add just $path and nothing below it. If $SVN::Depth::files,\nadd $path and any file children of $path. If $SVN::Depth::immediates, add $path, any file\nchildren, and any immediate subdirectories (but nothing underneath those subdirectories). If\n$SVN::Depth::infinity, add $path and everything under it fully recursively.\n\n$path's parent must be under revision control already (unless $addparents is TRUE), but\n$path is not.\n\nUnless $force is TRUE and $path is already under version control, returns an\n$SVN::Error::ENTRYEXISTS object. If $force is set, do not error on already-versioned items.\nWhen used with $depth set to $SVN::Depth::infinity it will enter versioned directories;\nscheduling unversioned children.\n\nCalls the notify callback for each added item.\n\nIf $noignore is FALSE, don't add any file or directory (or recurse into any directory) that\nis unversioned and found by recursion (as opposed to being the explicit target $path) and\nwhose name matches the svn:ignore property on its parent directory or the global-ignores\nlist in $client->config. If $noignore is TRUE, do include such files and directories. (Note\nthat an svn:ignore property can influence this behaviour only when recursing into an already\nversioned directory with $force).\n\nIf $addparents is TRUE, recurse up $path's directory and look for a versioned directory. If\nfound, add all intermediate paths between it and $path. If not found return\n$SVN::Error::NOVERSIONEDPARENT.\n\nImportant: this is a scheduling operation. No changes will happen to the repository until a\ncommit occurs. This scheduling can be removed with $client->revert().\n\nNo return.\n\n$client->blame($target, $start, $end, \\&receiver, $pool);\nInvoke \\&receiver subroutine on each line-blame item associated with revision $end of\n$target, using $start as the default source of all blame.\n\nAn Error will be raised if either $start or $end is undef.\n\nNo return.\n\nThe blame receiver subroutine receives the following arguments: $lineno, $revision,\n$author, $date, $line, $pool\n\n$lineno is the line number of the file (starting with 0). The line was last changed in\nrevision number $revision by $author on $date and the contents were $line.\n\nThe blame receiver subroutine can return an svnerrort object to return an error. All other\nreturns will be ignored. You can create an svnerrort object with SVN::Error::create().\n\n$client->cat(\\*FILEHANDLE, $target, $revision, $pool);\nOutputs the content of the file identified by $target and $revision to the FILEHANDLE.\nFILEHANDLE is a reference to a filehandle.\n\nIf $target is not a local path and if $revision is 'PREV' (or some other kind that requires\na local path), then an error will be raised, because the desired revision can not be\ndetermined.\n\n$client->checkout($url, $path, $revision, $recursive, $pool);\nSimilar to $client->checkout2(), but with $pegrevision always set to undef (unspecified)\nand $ignoreexternals always set to FALSE.\n\n$client->checkout2($url, $path, $pegrevision, $revision, $recursive, $ignoreexternals, $pool);\nSimilar to $client->checkout3(), but with $allowunverobstructions always set to FALSE, and\n$depth set according to $recurse: if $recurse is TRUE, $depth is $SVN::Depth::infinity, if\n$recurse is FALSE, set $depth to $SVN::Depth::files.\n\n$client->checkout3($url, $path, $pregrevision, $revision, $depth, $ignoreexternals,\n$allowunverobstructions, $pool);\nCheckout a working copy of $url at $revision using $path as the root directory of the newly\nchecked out working copy.\n\nThe $pegrevision sets the revision at which the path in the $url is treated as\nrepresenting.\n\n$revision must be a number, 'HEAD', or a date. If $revision does not meet these requirements\nthe $SVN::Error::CLIENTBADREVISION is raised.\n\n$depth is one of the constants in SVN::Depth and specifies the depth of the operation. If\nset to $SVN::Depth::unknown, then behave as if for $SVN::Depth::infinity, except in the case\nof resuming a previous checkout of $path (i.e. updating) in which case use the depth of the\nexisting working copy.\n\n$ignoreexteranls if set to TRUE the operation will ignore external definitions.\n\n$allowunverobstructions if set to TRUE the operation will tolerate existing unversioned\nitems that obstruct incoming paths. Only obstructions of the same type (file or dir) as the\nadded item are tolerated. The text of obstructing files is left as-is, effectively treating\nit as a user modification after the checkout. Working properties of obstructing items are\nset equal to the base properties. If set to FALSE, then abort if there are any unversioned\nobstructing items.\n\nReturns the value of the revision actually checked out of the repository.\n\n$client->cleanup($dir, $pool);\nRecursively cleanup a working copy directory, $dir, finishing any incomplete operations,\nremoving lockfiles, etc.\n\n$client->commit($targets, $nonrecursive, $pool);\nCommit files or directories referenced by target. Will use the logmsg callback to obtain\nthe log message for the commit.\n\nIf $targets contains no paths (zero elements), then does nothing and immediately returns\nwithout error.\n\nCalls the notify callback as the commit progresses with any of the following actions:\n$SVN::Wc::Notify::Action::commitmodified, $SVN::Wc::Notify::Action::commitadded,\n$SVN::Wc::Notify::Action::commitdeleted, $SVN::Wc::Notify::Action::commitreplaced,\n$SVN::Wc::Notify::Action::commitpostfixtxdelta.\n\nUse $nonrecursive to indicate that subdirectories of directory targets should be ignored.\n\nReturns a svnclientcommitinfot object. If the revision member of the commit information\nobject is $SVN::Core::INVALIDREVNUM and no error was raised, then the commit was a no-op;\nnothing needed to be committed.\n\n$client->copy($srctarget, $srcrevision, $dsttarget, $pool);\nCopies $srctarget to $dsttarget.\n\n$srctarget must be a file or directory under version control, or the URL of a versioned\nitem in the repository. If $srctarget is a URL, $srcrevision is used to choose the\nrevision from which to copy the $srctarget. $dstpath must be a file or directory under\nversion control, or a repository URL, existing or not.\n\nIf $dsttarget is a URL, immediately attempt to commit the copy action to the repository.\nThe logmsg callback will be called to query for a commit log message. If the commit\nsucceeds, return a svnclientcommitinfot object.\n\nIf $dsttarget is not a URL, then this is just a variant of $client->add(), where the\n$dstpath items are scheduled for addition as copies. No changes will happen to the\nrepository until a commit occurs. This scheduling can be removed with $client->revert().\nundef will be returned in this case.\n\nCalls the notify callback for each item added at the new location, passing the new, relative\npath of the added item.\n\n$client->delete($targets, $force, $pool);\nDelete items from a repository or working copy.\n\nIf the paths in $targets are URLs, immediately attempt to commit a deletion of the URLs from\nthe repository. The logmsg callback will be called to query for a commit log message. If\nthe commit succeeds, return a svnclientcommitinfot object. Every path must belong to the\nsame repository.\n\nElse, schedule the working copy paths in $targets for removal from the repository. Each\npath's parent must be under revision control. This is just a scheduling operation. No\nchanges will happen to the repository until a commit occurs. This scheduling can be removed\nwith $client->revert(). If a path is a file it is immediately removed from the working copy.\nIf the path is a directory it will remain in the working copy but all the files, and all\nunversioned items it contains will be removed. If $force is not set then this operation will\nfail if any path contains locally modified and/or unversioned items. If $force is set such\nitems will be deleted.\n\nThe notify callback is called for each item deleted with the path of the deleted item.\n\nHas no return.\n\n$client->diff($diffoptions, $target1, $revision1, $target2, $revision2, $recursive,\n$ignoreancestry, $nodiffdeleted, $outfile, $errfile, $pool);\nProduces diff output which describes the delta between $target1 at $revision1 and $target2\nat $revision2. They both must represent the same node type (i.e. they most both be\ndirectories or files). The revisions must not be undef.\n\nPrints the output of the diff to the filename or filehandle passed as $outfile, and any\nerrors to the filename or filehandle passed as $errfile.\n\nUse $ignoreancestry to control whether or not items being diffed will be checked for\nrelatedness first. Unrelated items are typically transmitted to the editor as a deletion of\none thing and the addition of another, but if this flag is true, unrelated items will be\ndiffed as if they were related.\n\nIf $nodiffdeleted is true, then no diff output will be generated on deleted files.\n\n$diffoptions is a reference to an array of additional arguments to pass to diff process\ninvoked to compare files. You'll usually just want to use [] to pass an empty array to\nreturn a unified context diff (like `diff -u`).\n\nHas no return.\n\n$client->diffsummarize($target1, $revision1, $target2, $revision2, $recursive,\n$ignoreancestry, \\&summarizefunc, $pool);\nProduce a diff summary which lists the changed items between $target1 at $revision1 and\n$target2 at $revision2 without creating text deltas. $target1 and $target2 can be either\nworking-copy paths or URLs.\n\nThe function may report false positives if $ignoreancestry is false, since a file might\nhave been modified between two revisions, but still have the same contents.\n\nCalls \\&summarizefunc with with a svnclientdiffsummarizet structure describing the\ndifference.\n\nSee diff() for a description of the other parameters.\n\nHas no return.\n\n$client->export($from, $to, $revision, $force, $pool);\nExport the contents of either a subversion repository or a subversion working copy into a\n'clean' directory (meaning a directory with no administrative directories).\n\n$from is either the path to the working copy on disk, or a URL to the repository you wish to\nexport.\n\n$to is the path to the directory where you wish to create the exported tree.\n\n$revision is the revision that should be exported, which is only used when exporting from a\nrepository. It may be undef otherwise.\n\nThe notify callback will be called for the items exported.\n\nReturns the value of the revision actually exported or $SVN::Core::INVALIDREVNUM for local\nexports.\n\n$client->import($path, $url, $nonrecursive, $pool);\nImport file or directory $path into repository directory $url at head.\n\nIf some components of $url do not exist then create parent directories as necessary.\n\nIf $path is a directory, the contents of that directory are imported directly into the\ndirectory identified by $url. Note that the directory $path itself is not imported; that is,\nthe basename of $path is not part of the import.\n\nIf $path is a file, then the dirname of $url is the directory receiving the import. The\nbasename of $url is the filename in the repository. In this case if $url already exists,\nraise an error.\n\nThe notify callback (if defined) will be called as the import progresses, with any of the\nfollowing actions: $SVN::Wc::Notify::Action::commitadded,\n$SVN::Wc::Notify::Action::commitpostfixtxdelta.\n\nUse $nonrecursive to indicate that imported directories should not recurse into any\nsubdirectories they may have.\n\nUses the logmsg callback to determine the log message for the commit when one is needed.\n\nReturns a svnclientcommitinfot object.\n\n$client->info($pathorurl, $pegrevision, $revision, \\&receiver, $recurse);\nInvokes \\&receiver passing it information about $pathorurl for $revision. The information\nreturned is system-generated metadata, not the sort of \"property\" metadata created by users.\nFor methods available on the object passed to \\&receiver, see svninfot.\n\nIf both revision arguments are either svnoptrevisionunspecified or NULL, then information\nwill be pulled solely from the working copy; no network connections will be made.\n\nOtherwise, information will be pulled from a repository. The actual node revision selected\nis determined by the $pathorurl as it exists in $pegrevision. If $pegrevision is undef,\nthen it defaults to HEAD for URLs or WORKING for WC targets.\n\nIf $pathorurl is not a local path, then if $revision is PREV (or some other kind that\nrequires a local path), an error will be returned, because the desired revision cannot be\ndetermined.\n\nUses the authentication baton cached in ctx to authenticate against the repository.\n\nIf $recurse is true (and $pathorurl is a directory) this will be a recursive operation,\ninvoking $receiver on each child.\n\nmy $receiver = sub {\nmy( $path, $info, $pool ) = @;\nprint \"Current revision of $path is \", $info->rev, \"\\n\";\n};\n$client->info( 'foo/bar.c', undef, 'WORKING', $receiver, 0 );\n\n$client->log5($targets, $pegrevision, $revisionranges, $limit, $discoverchangedpaths,\n$strictnodehistory, $includemergedrevisions, $revprops, \\&logentryreceiver, $pool);\nInvoke \"logentryreceiver\" on each log message from each revision range in $revisionranges\nin turn, inclusive (but never invoke \"logentryreceiver\" on a given log message more than\nonce).\n\n$targets is a reference to an array of either a URL followed by zero or more relative paths,\nor 1 working copy path, for which log messages are desired. If the array contains only a\nsingle element you may set $targets to this element instead. \"logentryreceiver\" is invoked\nonly on messages whose revisions involved a change to some path in $targets.\n\n$pegrevision indicates in which revision $targets are valid. If $pegrevision is \"undef\",\nit defaults to 'HEAD' for URLs or 'WORKING' for WC paths.\n\n$revisionranges is either a single *revision range* or a reference to an array of them. A\n*revision range* may be specified as a reference to a two-element array \"[$start, $end]\" of\n$revisions or a SVN::Core::svnoptrevisionranget object. Examples:\n\n$revisionranges = ['HEAD', 1];\n$revisionranges = [[2, 3], [5, 8], [13, 21]];\n\nIf $limit is non-zero only invoke \"logentryreceiver\" on the first $limit logs.\n\nIf $discoverchangedpaths is true, then the *changedpaths2* field in the $logentry\nargument to \"logentryreceiver\" will be populated on each invocation. *Note:* The\n*textmodified* and *propsmodified* fields of the *changedpaths2* structure may have the\nvalue $SVN::Tristate::unknown if the repository does not report that information.\n\nIf $strictnodehistory is true, copy history (if any exists) will not be traversed while\nharvesting revision logs for each target.\n\nIf $includemergedrevisions is true, log information for revisions which have been merged\nto $targets will also be returned.\n\nIf $revprops is \"undef\", retrieve all revision properties. Otherwise $revpros should be a\nreference to an array of property names and only these properties will be retrieved (i.e.\nnone if the array is empty).\n\nUse $pool for any temporary allocation.\n\nCalls the notify subroutine with a $SVN::Wc::Notify::Action::skip signal on any unversioned\n$targets.\n\nThe \"logentryreceiver\" takes the following arguments: \"$logentry, $pool\". $logentry is a\nSVN::Core::svnlogentryt object.\n\n$client->log4($targets, $pegrevision, $start, $end, $limit, $discoverchangedpaths,\n$strictnodehistory, $includemergedrevisions, $revprops, \\&logentryreceiver, $pool);\nSimilar to \"$client->log5()\", but takes explicit $start and $end parameters instead of\n$revisionranges.\n\nDeprecated.\n\n$client->log3($targets, $pegrevision, $start, $end, $limit, $discoverchangedpaths,\n$strictnodehistory, \\&logmessagereceiver, $pool);\nSimilar to \"$client->log4()\", but using \"logmessagereceiver\" instead of\n\"logentryreceiver\". Also, $includemergedrevisions is false and $revprops is [qw(\nsvn:author svn:date and svn:log )].\n\nThe \"logmessagereceiver\" takes the following arguments: \"$changedpaths, $revision,\n$author, $date, $message, $pool\". It is called once for each log $message from the $revision\non $date by $author. $author, $date or $message may be \"undef\".\n\nIf $changedpaths is defined it references a hash with the keys every path committed in\n$revision; the values are SVN::Core::svnlogchangedpatht objects.\n\nDeprecated.\n\n$client->log2($targets, $start, $end, $limit, $discoverchangedpaths, $strictnodehistory,\n\\&logmessagereceiver, $pool);\nSimilar to \"$client->log3()\", but with $pegrevision set to \"undef\".\n\nDeprecated.\n\n$client->log($targets, $start, $end, $discoverchangedpaths, $strictnodehistory,\n\\&logmessagereceiver, $pool);\nSimilar to \"$client->log2()\", but with $limit set to 0.\n\n*Special case for repositories at revision 0:* If $start is 'HEAD' and $end is 1, then\nhandle an empty (no revisions) repository specially: instead of erroring because requested\nrevision 1 when the highest revision is 0, just invoke \"logmessagereceiver\" on revision 0,\npassing \"undef\" to $changedpaths and empty strings for the author and date. This is because\nthat particular combination of $start and $end usually indicates the common case of log\ninvocation; the user wants to see all log messages from youngest to oldest, where the oldest\ncommit is revision 1. That works fine, except there are no commits in the repository, hence\nthis special case.\n\nDeprecated.\n\n$client->ls($target, $revision, $recursive, $pool);\nReturns a hash of svndirentt objects for $target at $revision.\n\nIf $target is a directory, returns entries for all of the directories' contents. If\n$recursive is true, it will recurse subdirectories in $target.\n\nIf $target is a file only return an entry for the file.\n\nIf $target is non-existent, raises the $SVN::Error::FSNOTFOUND error.\n\n$client->merge($src1, $rev1, $src2, $rev2, $targetwcpath, $recursive, $ignoreancestry, $force,\n$dryrun, $pool);\nMerge changes from $src1/$rev1 to $src2/$rev2 into the working-copy path $targetwcpath.\n\n$src1 and $src2 are either URLs that refer to entries in the repository, or paths to entries\nin the working copy.\n\nBy 'merging', we mean: apply file differences and schedule additions & deletions when\nappropriate.\n\n$src1 and $src2 must both represent the same node kind; that is, if $src1 is a directory,\n$src2 must also be, and if $src1 is a file, $src2 must also be.\n\nIf either $rev1 or $rev2 is undef raises the $SVN::Error::CLIENTBADREVISION error.\n\nIf $recursive is true (and the URLs are directories), apply changes recursively; otherwise,\nonly apply changes in the current directory.\n\nUse $ignoreancestry to control whether or not items being diffed will be checked for\nrelatedness first. Unrelated items are typically transmitted to the editor as a deletion of\none thing and the addition of another, but if this flag is true, unrelated items will be\ndiffed as if they were related.\n\nIf $force is not set and the merge involves deleting locally modified or unversioned items\nthe operation will raise an error. If $force is set such items will be deleted.\n\nCalls the notify callback once for each merged target, passing the targets local path.\n\nIf $dryrun is true the merge is carried out, and the full notification feedback is\nprovided, but the working copy is not modified.\n\nHas no return.\n\n$client->mkdir($targets, $pool);\nSimilar to $client->mkdir2() except it returns an svnclientcommitinfot object instead of\na svncommitinfot object.\n\n$client->mkdir2($targets, $pool);\nSimilar to $client->mkdir3(), but with $makeparents always FALSE, and $revprophash always\nundef.\n\n$client->mkdir3($targets, $makeparents, $revprophash, $pool);\nSimilar to $client->mkdir4(), but returns a svncommitinfot object rather than through a\ncallback function.\n\n$client->mkdir4($targets, $makeparents, $revprophash, \\&commitcallback, $pool);\nCreate a directory, either in a repository or a working copy.\n\nIf $targets contains URLs, immediately attempts to commit the creation of the directories in\n$targets in the repository. Returns a svnclientcommitinfot object.\n\nElse, create the directories on disk, and attempt to schedule them for addition. In this\ncase returns undef.\n\nIf $makeparents is TRUE, create any non-existent parent directories also.\n\nIf not undef, $revprophash is a reference to a hash table holding additional custom\nrevision properites (property names mapped to strings) to be set on the new revision in the\nevent that this is a committing operation. This hash cannot contain any standard Subversion\nproperties.\n\nCalls the log message callback to query for a commit log message when one is needed.\n\nCalls the notify callback when the directory has been created (successfully) in the working\ncopy, with the path of the new directory. Note this is only called for items added to the\nworking copy.\n\nIf \\&commitcallback is not undef, then for each successful commit, call \\&commitcallback\nwith the svncommitinfot object for the commit.\n\n$client->move($srcpath, $srcrevision, $dstpath, $force, $pool);\nMove $srcpath to $dstpath.\n\n$srcpath must be a file or directory under version control, or the URL of a versioned item\nin the repository.\n\nIf $srcpath is a repository URL:\n\n* $dstpath must also be a repository URL (existent or not).\n\n* $srcrevision is used to choose the revision from which to copy the $srcpath.\n\n* The logmsg callback will be called for the commit log message.\n\n* The move operation will be immediately committed. If the commit succeeds, returns a\nsvnclientcommitinfot object.\n\nIf $srcpath is a working copy path\n\n* $dstpath must also be a working copy path (existent or not).\n\n* $srcrevision is ignored and may be undef. The logmsg callback will not be called.\n\n* This is a scheduling operation. No changes will happen to the repository until a commit\noccurs. This scheduling can be removed with $client->revert(). If $srcpath is a file it is\nremoved from the working copy immediately. If $srcpath is a directory it will remain in the\nworking copy but all files, and unversioned items, it contains will be removed.\n\n* If $srcpath contains locally modified and/or unversioned items and $force is not set, the\ncopy will raise an error. If $force is set such items will be removed.\n\nThe notify callback will be called twice for each item moved, once to indicate the deletion\nof the moved node, and once to indicate the addition of the new location of the node.\n\n$client->propget($propname, $target, $revision, $recursive, $pool);\nReturns a reference to a hash containing paths or URLs, prefixed by $target (a working copy\nor URL), of items for which the property $propname is set, and whose values represent the\nproperty value for $propname at that path.\n\n$client->proplist($target, $revision, $recursive, $pool);\nReturns a reference to an array of svnclientproplistitemt objects.\n\nFor each item the nodename member of the proplistitem object contains the name relative to\nthe same base as $target.\n\nIf $revision is undef, then get properties from the working copy, if $target is a working\ncopy, or from the repository head if $target is a URL. Else get the properties as of\n$revision.\n\nIf $recursive is false, or $target is a file, the returned array will only contain a single\nelement. Otherwise, it will contain one entry for each versioned entry below (and including)\n$target.\n\nIf $target is not found, raises the $SVN::Error::ENTRYNOTFOUND error.\n\n$client->propset($propname, $propval, $target, $recursive, $pool);\nSet $propname to $propval on $target (a working copy or URL path).\n\nIf $recursive is true, then $propname will be set recursively on $target and all children.\nIf $recursive is false, and $target is a directory, $propname will be set on only $target.\n\nA $propval of undef will delete the property.\n\nIf $propname is an svn-controlled property (i.e. prefixed with svn:), then the caller is\nresponsible for ensuring that $propval is UTF8-encoded and uses LF line-endings.\n\n$client->relocate($dir, $from, $to, $recursive, $pool);\nModify a working copy directory $dir, changing any repository URLs that begin with $from to\nbegin with $to instead, recursing into subdirectories if $recursive is true.\n\nHas no return.\n\n$client->resolved($path, $recursive, $pool);\nRemoved the 'conflicted' state on a working copy path.\n\nThis will not semantically resolve conflicts; it just allows $path to be committed in the\nfuture. The implementation details are opaque. If $recursive is set, recurse below $path,\nlooking for conflicts to resolve.\n\nIf $path is not in a state of conflict to begin with, do nothing.\n\nIf $path's conflict state is removed, call the notify callback with the $path.\n\n$client->revert($paths, $recursive, $pool);\nRestore the pristine version of a working copy $paths, effectively undoing any local mods.\n\nFor each path in $paths, if it is a directory and $recursive is true, this will be a\nrecursive operation.\n\n$client->revpropget($propname, $url, $revision, $pool);\nReturns two values, the first of which is the value of $propname on revision $revision in\nthe repository represented by $url. The second value is the actual revision queried.\n\nNote that unlike its cousin $client->propget(), this routine doesn't affect working copy at\nall; it's a pure network operation that queries an unversioned property attached to a\nrevision. This can be used to query log messages, dates, authors, and the like.\n\n$client->revproplist($url, $revision, $pool);\nReturns two values, the first of which is a reference to a hash containing the properties\nattached to $revision in the repository represented by $url. The second value is the actual\nrevision queried.\n\nNote that unlike its cousin $client->proplist(), this routine doesn't read a working copy at\nall; it's a pure network operation that reads unversioned properties attached to a revision.\n\n$client->revpropset($propname, $propval, $url, $revision, $force, $pool);\nSet $propname to $propval on revision $revision in the repository represented by $url.\n\nReturns the actual revision affected. A $propval of undef will delete the property.\n\nIf $force is true, allow newlines in the author property.\n\nIf $propname is an svn-controlled property (i.e. prefixed with svn:), then the caller is\nresponsible for ensuring that the value is UTF8-encoded and uses LF line-endings.\n\nNote that unlike its cousin $client->propset(), this routine doesn't affect the working copy\nat all; it's a pure network operation that changes an unversioned property attached to a\nrevision. This can be used to tweak log messages, dates, authors, and the like. Be careful:\nit's a lossy operation, meaning that any existing value is replaced with the new value, with\nno way to retrieve the prior value.\n\nAlso note that unless the administrator creates a pre-revprop-change hook in the repository,\nthis feature will fail.\n\n$client->status($path, $revision, \\&statusfunc, $recursive, $getall, $update, $noignore,\n$pool);\nSimilar to $client->status2(), but with ignoreexternals always set to FALSE, and with the\nstatusfunc receiving a svnwcstatus2t instead of a svnwcstatust object.\n\n$client->status2($path, $revision, \\&statusfunc, $recursive, $getall, $update, $noignore,\n$ignoreexternals, $pool);\nSimilar to $client->status3(), but with the changelists passed as undef, and with recursive\ninstead of depth.\n\n$client->status3($path, $revision, \\&statusfunc, $depth, $getall, $update, $noignore,\n$ignoreexternals, $changelists, $pool);\nSimilar to $client->status4(), without the pool parameter to the callback and the return of\nthe callback is ignored.\n\n$client->status4($path, $revision, \\&statusfunc, $depth, $getall, $update, $noignore,\n$ignoreexternals, $changelists, $pool);\nGiven $path to a working copy directory (or single file), call statusfunc() with a set of\nsvnwcstatus2t objects which describe the status of $path and its children.\n\nIf $recursive is true, recurse fully, else do only immediate children.\n\nIf $getall is set, retrieve all entries; otherwise, retrieve only 'interesting' entries\n(local mods and/or out-of-date).\n\nIf $update is set, contact the repository and augment the status objects with information\nabout out-of-dateness (with respect to $revision). Also, will return the value of the actual\nrevision against with the working copy was compared. (The return will be undef if $update is\nnot set).\n\nUnless ignoreexternals is set, the function recurses into externals definitions\n('svn:externals') after handling the main target, if any exist. The function calls the\nnotify callback with $SVN::Wc::Notify::Action::statusexternal action before handling each\nexternals definition, and with $SVN::Wc::Notify::Action::statuscompleted after each.\n\n$changelists is a reference to an array of changelist names, used as a restrictive filter on\nitems whose statuses are reported; that is don't report status about any item unless it's a\nmember of those changelists. If changelists is empty (or altogether undef), no changelist\nfiltering occurs.\n\nThe statusfunc subroutine takes the following parameters: $path, $status, $pool\n\n$path is the pathname of the file or directory which status is being reported. $status is a\nsvnwcstatus2t object. $pool is an aprpoolt object which is cleaned between invocations\nto the callback.\n\nThe return of the statusfunc subroutine can be a svnerrort object created by\nSVN::Error::create in order to propagate an error up.\n\n$client->switch($path, $url, $revision, $recursive, $pool);\nSwitch working tree $path to $url at $revision.\n\n$revision must be a number, 'HEAD', or a date, otherwise it raises the\n$SVN::Error::CLIENTBADREVISION error.\n\nCalls the notify callback on paths affected by the switch. Also invokes the callback for\nfiles that may be restored from the text-base because they were removed from the working\ncopy.\n\nSummary of purpose: This is normally used to switch a working directory over to another line\nof development, such as a branch or a tag. Switching an existing working directory is more\nefficient than checking out $url from scratch.\n\nReturns the value of the revision to which the working copy was actually switched.\n\n$client->update($path, $revision, $recursive, $pool)\nSimilar to $client->update2() except that it accepts only a single target in $path, returns\na single revision, and $ignoreexternals is always set to FALSE.\n\n$client->update2($paths, $revision, $recursive, $ignoreexternals, $pool)\nSimilar to $client->update3() but with $allowunverobstructions always set to FALSE,\n$depthissticky to FALSE, and $depth set according to $recursive: if $recursive is TRUE,\nset $depth to $SVN::Depth::infinity, if $recursive is FALSE, set $depth to\n$SVN::Depth::files.\n\n$client->update3($paths, $revision, $depth, $depthissticky, $ignoreexternals,\n$allowunverobstructions, $pool)\nSimilar to $client->update4() but with $makeparents always set to FALSE and\n$addsasmodification set to TRUE.\n\n$client->update4($paths, $revision, $depth, $depthissticky, $ignoreexternals,\n$allowunverobstructions, $addsasmodification, $makeparents)\nUpdate working trees $paths to $revision.\n\n$paths is a array reference of paths to be updated. Unversioned paths that are the direct\nchildren of a versioned path will cause an update that attempts to add that path; other\nunversioned paths are skipped.\n\n$revision must be a revision number, 'HEAD', or a date or this method will raise the\n$SVN::Error::CLIENTBADREVISION error.\n\nThe paths in $paths can be from multiple working copies from multiple repositories, but even\nif they all come from the same repository there is no guarantee that revision represented by\n'HEAD' will remain the same as each path is updated.\n\nIf $ignoreexternals is set, don't process externals definitions as part of this operation.\n\nIf $depth is $SVN::Depth::infinity, update fully recursivelly. Else if it is\n$SVN::Depth::immediates or $SVN::Depth::files, update each target and its file entries, but\nnot its subdirectories. Else if $SVN::Depth::empty, update exactly each target,\nnonrecursively (essentially, update the target's properties).\n\nIf $depth is $SVN::Depth::unknown, take the working depth from $paths and then describe as\nbehaved above.\n\nIf $depthissticky is set and $depth is not $SVN::Depth::unknown, then in addition to\nupdate paths, also set their sticky ambient depth value to $depth.\n\nIf $allowunverobstructions is TRUE then the update tolerates existing unversioned items\nthat obstruct added paths. Only obstructions of the same type (file or dir) as the added\nitem are tolerated. The text of obstructing files is left as-is, effectively treating it as\na user modification after the update. Working properties of obstructing items are set equal\nto the base properties. If $allowunverobstructions is FALSE then the update will abort if\nthere are any unversioned obstructing items.\n\nIf $addsasmodification is TRUE, a local addition at the same path as an incoming addition\nof the same node kind results in a normal node with a possible local modification, instead\nof a tree conflict.\n\nIf $makeparents is TRUE, create any non-existent parent directories also by checking them\nout at depth=empty.\n\nCalls the notify callback for each item handled by the update, and also for files restored\nfrom the text-base.\n\nReturns an array reference to an array of revision numbers with each element set to the\nrevision to which $revision was resolved for the corresponding element of $paths.\n\n$client->urlfrompath($target, $pool); or SVN::Client::urlfrompath($target, $pool);\nReturns the URL for $target.\n\nIf $target is already a URL it returns $target.\n\nIf $target is a versioned item, it returns $target's entry URL.\n\nIf $target is unversioned (has no entry), returns undef.\n\n$client->uuidfrompath($path, $admaccess, $pool);\nReturn the repository uuid for working-copy $path, allocated in $pool.\n\nUse $admaccess to retrieve the uuid from $path's entry; if not present in the entry, then\ncall $client->uuidfromurl() to retrieve, using the entry's URL.\n\nNote: The only reason this function falls back on $client->uuidfromurl is for\ncompatibility purposes. Old working copies may not have uuids in the entries files.\n\nNote: This method probably doesn't work right now without a lot of pain, because SVN::Wc is\nincomplete and it requires an admaccess object from it.\n\n$client->uuidfromurl($url, $pool);\nReturn repository uuid for url.\n", "subsections": [] }, "ATTRIBUTE METHODS": { "content": "The following attribute methods are provided that allow you to set various configuration or\nretrieve it. They all take value(s) to set the attribute and return the new value of the\nattribute or no parameters which returns the current value.\n\n$client->auth(SVN::Client::getusernameprovider());\nProvides access to the authbaton in the svnclientctxt attached to the SVN::Client\nobject.\n\nThis method will accept an array or array ref of values returned from the authentication\nprovider functions see \"AUTHENTICATION PROVIDERS\", which it will convert to an authbaton\nfor you. This is the preferred method of setting the authbaton.\n\nIt will also accept a scalar that references a psvnauthbatont such as those returned\nfrom SVN::Core::authopen and SVN::Core::authopenhelper.\n\n$client->notify(\\¬ify);\nSets the notify callback for the client context to a code reference that you pass. It always\nreturns the current codereference set.\n\nThe subroutine pointed to by this reference will be called when a change is made to the\nworking copy. The return value of this function is ignored. It's only purpose is to notify\nyou of the change.\n\nThe subroutine will receive 6 parameters. The first parameter will be the path of the\nchanged file (absolute or relative to the cwd). The second is an integer specifying the type\nof action taken. See SVN::Wc for a list of the possible actions values and what they mean.\nThe 3rd is an integer specifying the kind of node the path is, which can be:\n$SVN::Node::none, $SVN::Node::file, $SVN::Node::dir, $SVN::Node::unknown. The fourth\nparameter is the mime-type of the file or undef if the mime-type is unknown (it will always\nbe undef for directories). The 5th parameter is the state of the file, again see SVN::Wc for\na list of the possible states. The 6th and final parameter is the numeric revision number of\nthe changed file. The revision number will be -1 except when the action is\n$SVN::Wc::Notify::Action::updatecompleted.\n\n$client->logmsg(\\&logmsg)\nSets the logmsg callback for the client context to a code reference that you pass. It\nalways returns the current codereference set.\n\nThe subroutine pointed to by this coderef will be called to get the log message for any\noperation that will commit a revision to the repo.\n\nIt receives 4 parameters. The first parameter is a reference to a scalar value in which the\ncallback should place the logmsg. If you wish to cancel the commit you can set this scalar\nto undef. The 2nd value is a path to any temporary file which might be holding that log\nmessage, or undef if no such file exists (though, if logmsg is undef, this value is\nundefined). The log message MUST be a UTF8 string with LF line separators. The 3rd parameter\nis a reference to an array of svnclientcommititem3t objects, which may be fully or only\npartially filled-in, depending on the type of commit operation. The 4th and last parameter\nwill be a pool.\n\nIf the function wishes to return an error it should return a svnerrort object made with\nSVN::Error::create. Any other return value will be interpreted as SVNNOERROR.\n\n$client->cancel(\\&cancel)\nSets the cancellation callback for the client context to a code reference that you pass. See\n\"CANCELLATION CALLBACK\" below for details. It always returns the current codereference set.\n\n$client->pool(new SVN::Pool);\nMethod that sets or gets the default pool that is passed to method calls requiring a pool,\nbut which were not explicitly passed one.\n\nSee SVN::Core for more information about how pools are managed in this interface.\n\n$client->config(SVN::Core::configgetconfig(undef));\nMethod that allows access to the config member of the svnclientctxt. Accepts a Perl hash\nto set, which is what functions like SVN::Core:configgetconfig() will return.\n\nIt will return a parphasht scalar. This is a temporary situation. The return value is\nnot particular useful. In the future, this value will be tied to the actual hash used by the\nC API.\n", "subsections": [] }, "AUTHENTICATION PROVIDERS": { "content": "The following functions get authentication providers for you. They come in two forms. Standard\nor File versions, which look for authentication information in the subversion configuration\ndirectory that was previously cached, or Prompt versions which call a subroutine to allow you to\nprompt the user for the information.\n\nThe functions that return the svnauthproviderobjectt for prompt style providers take a\nreference to a Perl subroutine to use for the callback. The first parameter each of these\nsubroutines receive is a credential object. The subroutines return the response by setting\nmembers of that object. Members may be set like so: $cred->username(\"breser\"); These functions\nand credential objects always have a maysave member which specifies if the authentication data\nwill be cached.\n\nThe providers are as follows:\n\nNAME WHAT IT HANDLES\n---------------- ----------------------------------------\nsimple username and password pairs\n\nusername username only\n\nsslservertrust server certificates and failures\nauthenticating them\n\nsslclientcert client side certificate files\n\nsslclientcertpw password for a client side certificate file.\n\nSVN::Client::getsimpleprovider\nReturns a simple provider that returns information from previously cached sessions. Takes no\nparameters or one pool parameter.\n\nSVN::Client::getsimplepromptprovider\nReturns a simple provider that prompts the user via a callback. Takes two or three\nparameters, the first is the callback subroutine, the 2nd is the number of retries to allow,\nthe 3rd is optionally a pool. The subroutine gets called with the following parameters: a\nsvnauthcredsimplet object, a realm string, a default username, maysave, and a pool. The\nsvnauthcredsimple has the following members: username, password, and maysave.\n\nSVN::Client::getusernameprovider\nReturns a username provider that returns information from a previously cached sessions.\nTakes no parameters or one pool parameter.\n\nSVN::Client::getusernamepromptprovider\nReturns a username provider that prompts the user via a callback. Takes two or three\nparameters, the first is the callback subroutine, the 2nd is the number of retries to allow,\nthe 3rd is optionally a pool. The subroutine gets called with the following parameters: a\nsvnauthcredusernamet object, a realm string, a default username, maysave, and a pool.\nThe svnauthcredusername has the following members: username and maysave.\n\nSVN::Client::getsslservertrustfileprovider\nReturns a server trust provider that returns information from previously cached sessions.\nTakes no parameters or optionally a pool parameter.\n\nSVN::Client::getsslservertrustpromptprovider\nReturns a server trust provider that prompts the user via a callback. Takes one or two\nparameters the callback subroutine and optionally a pool parameter. The subroutine gets\ncalled with the following parameters. A svnauthcredsslservertrustt object, a realm\nstring, an integer specifying how the certificate failed authentication, a\nsvnauthsslservercertinfot object, maysave, and a pool. The\nsvnauthcredsslservertrustt object has the following members: maysave and\nacceptedfailures. The svnauthsslservercertinfot object has the following members (and\nbehaves just like cred objects though you can't modify it): hostname, fingerprint,\nvalidfrom, validuntil, issuerdname, asciicert.\n\nThe masks used for determining the failures are in SVN::Auth::SSL and are named:\n\n$SVN::Auth::SSL::NOTYETVALID $SVN::Auth::SSL::EXPIRED $SVN::Auth::SSL::CNMISMATCH\n$SVN::Auth::SSL::UNKNOWNCA $SVN::Auth::SSL::OTHER\n\nYou reply by setting the acceptedfailures of the cred object with an integer of the values\nfor what you want to accept bitwise AND'd together.\n\nSVN::Client::getsslclientcertfileprovider\nReturns a client certificate provider that returns information from previously cached\nsessions. Takes no parameters or optionally a pool parameter.\n\nSVN::Client::getsslclientcertpromptprovider\nReturns a client certificate provider that prompts the user via a callback. Takes two or\nthree parameters: the first is the callback subroutine, the 2nd is the number of retries to\nallow, the 3rd is optionally a pool parameter. The subroutine gets called with the following\nparameters. A svnauthcredsslclientcert object, a realm string, maysave, and a pool.\nThe svnauthcredsslclientcert the following members: certfile and maysave.\n\nSVN::Client::getsslclientcertpwfileprovider\nReturns a client certificate password provider that returns information from previously\ncached sessions. Takes no parameters or optionally a pool parameter.\n\nSVN::Client::getsslclientcertpwpromptprovider\nReturns a client certificate password provider that prompts the user via a callback. Takes\ntwo or three parameters, the first is the callback subroutine, the 2nd is the number of\nretries to allow, the 3rd is optionally a pool parameter. The subroutine gets called with\nthe following parameters. A svnauthcredsslclientcertpw object, a realm string,\nmaysave, and a pool. The svnauthcredsslclientcertpw has the following members:\npassword and maysave.\n", "subsections": [] }, "CANCELLATION CALLBACK": { "content": "This callback will be called periodically to see if the operation should be canceled. If the\noperation should be canceled, the function may return one of the following values:\n\nAn svnerrort object made with SVN::Error::create.\n\nAny true value, in which case the bindings will generate an svnerrort object for you with the\nerror code of SVNERRCANCELLED and the string set to \"By cancel callback\".\n\nA string, in which case the bindings will generate an svnerrort object for you with the error\ncode of SVNERRCANCELLED and the string set to the string you returned.\n\nAny other value will be interpreted as wanting to continue the operation. Generally, it's best\nto return 0 to continue the operation.\n", "subsections": [] }, "OBJECTS": { "content": "These are some of the object types that are returned from the methods and functions. Others are\ndocumented in SVN::Core and SVN::Wc. If an object is not documented, it is more than likely\nopaque and not something you can do anything with, except pass to other functions that require\nsuch objects.\n\nsvninfot\n$info->URL()\nWhere the item lives in the repository.\n\n$info->rev()\nThe revision of the object. If pathorurl is a working-copy path, then this is its\ncurrent working revnum. If pathorurl is a URL, then this is the repos revision that\npathorurl lives in.\n\n$info->kind()\nThe node's kind.\n\n$info->reposrootURL()\nThe root URL of the repository.\n\n$info->reposUUID()\nThe repository's UUID.\n\n$info->lastchangedrev()\nThe last revision in which this object changed.\n\n$info->lastchangeddate()\nThe date of the lastchangedrev.\n\n$info->lastchangedauthor()\nThe author of the lastchangedrev.\n\n$info->lock()\nAn exclusive lock, if present. Could be either local or remote.\n\nSee SVN::Wc::svnwcentryt for the rest of these. svnclient.h indicates that these were copied\nfrom that struct and mean the same things. They are also only useful when working with a WC.\n\n$info->haswcinfo()\n$info->schedule()\n$info->copyfromurl()\n$info->copyfromrev()\n$info->texttime()\n$info->proptime()\n$info->checksum()\n$info->conflictold()\n$info->conflictnew()\n$info->conflictwrk()\n$info->prejfile()\n\nsvnclientcommititem3t\n$commititem->path()\nAbsolute working-copy path of item.\n\n$commititem->kind()\nAn integer representing the type of node it is (file/dir). Can be one of the following\nconstants: $SVN::Node::none $SVN::Node::file $SVN::Node::dir $SVN::Node::unknown\n\n$commititem->url()\nCommit URL for this item.\n\n$commititem->revision()\nRevision (copyfromrev if stateflags has ISCOPY set).\n\n$commititem->copyformurl();\nCopyFrom URL\n\n$commititem->stateflags();\nOne of several state flags: $SVN::Client::COMMITITEMADD\n$SVN::Client::COMMITITEMDELETE $SVN::Client::COMMITITEMTEXTMODS\n$SVN::Client::COMMITITEMPROPMODS $SVN::Client::COMMITITEMISCOPY\n\n$commititem->incomingpropchanges()\nA reference to an array of svnpropt objects representing changes to WC properties.\n\n$commititem->outgoingpropchanges()\nA reference to an array of svnpropt objects representing extra changes to properties\nin the repository (which are not necessarily reflected by the WC).\n\nsvnclientcommitinfot\n$commitinfo->revision()\nJust committed revision.\n\n$commitinfo->date()\nServer-Side date of the commit as a string.\n\n$commitinfo->author()\nAuthor of the commit.\n\nsvnclientproplistitemt\n$proplist->nodename()\nThe name of the node on which these properties are set.\n\n$proplist->prophash()\nA reference to a hash of property names and values.\n\nsvnclientdiffsummarizekindt - SVN::Summarize\nAn enum of the following constants:\n\n$SVN::Client::Summarize::normal, $SVN::Client::Summarize::added,\n$SVN::Client::Summarize::modified, $SVN::Client::Summarize::deleted.\n\nsvnclientdiffsummarizet\n$diffsummarize->path()\nPath relative to the target. If the target is a file, path is the empty string.\n\n$diffsummarize->summarizekind()\nChange kind.\n\n$diffsummarize->propchanged()\nProperties changed?\n\n$diffsummarize->nodekind()\nFile or dir?\n\nADDITIONAL METHODS\nThe following methods work, but are not currently documented in this file. Please consult the\nsvnclient.h section in the Subversion API for more details.\n\n$client->addtochangelist(...)\n$client->blame2(...)\n$client->blame3(...)\n$client->blame4(...)\n$client->cat2(...)\n$client->commit2(...)\n$client->commit3(...)\n$client->commit4(...)\n$client->copy2(...)\n$client->copy3(...)\n$client->copy4(...)\n$client->createcontext(...)\n$client->delete2(...)\n$client->delete3(...)\n$client->diff2(...)\n$client->diff3(...)\n$client->diff4(...)\n$client->diffpeg(...)\n$client->diffpeg2(...)\n$client->diffpeg3(...)\n$client->diffpeg4(...)\n$client->diffsummarize2(...)\n$client->diffsummarizedup(...)\n$client->diffsummarizepeg(...)\n$client->diffsummarizepeg2(...)\n$client->export2(...)\n$client->export3(...)\n$client->export4(...)\n$client->import2(...)\n$client->import3(...)\n$client->info2(...)\n$client->invokeblamereceiver(...)\n$client->invokeblamereceiver2(...)\n$client->invokediffsummarizefunc(...)\n$client->list(...)\n$client->list2(...)\n$client->ls2(...)\n$client->ls3(...)\n$client->merge2(...)\n$client->merge3(...)\n$client->mergepeg(...)\n$client->mergepeg2(...)\n$client->mergepeg3(...)\n$client->move2(...)\n$client->move3(...)\n$client->move4(...)\n$client->move5(...)\n$client->openrasession(...)\n$client->propget2(...)\n$client->propget3(...)\n$client->proplist2(...)\n$client->proplist3(...)\n$client->propset2(...)\n$client->propset3(...)\n$client->removefromchangelist(...)\n$client->resolve(...)\n$client->revert2(...)\n$client->switch2(...)\n$client->unlock(...)\n$client->version(...)\n", "subsections": [] }, "TODO": { "content": "* Better support for the config.\n\n* Unit tests for cleanup, diff, export, merge, move, relocate, resolved and switch. This may\nreveal problems for using these methods as I haven't tested them yet that require deeper fixes.\n", "subsections": [] }, "AUTHORS": { "content": "Chia-liang Kao \n\nBen Reser \n", "subsections": [] }, "COPYRIGHT": { "content": "Licensed to the Apache Software Foundation (ASF) under one\nor more contributor license agreements. See the NOTICE file\ndistributed with this work for additional information\nregarding copyright ownership. The ASF licenses this file\nto you under the Apache License, Version 2.0 (the\n\"License\"); you may not use this file except in compliance\nwith the License. You may obtain a copy of the License at\n\nhttp://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing,\nsoftware distributed under the License is distributed on an\n\"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\nKIND, either express or implied. See the License for the\nspecific language governing permissions and limitations\nunder the License.\n", "subsections": [] } } } }