svk::command::log(3) [osx man page]

SVK::Command::Log(3)					User Contributed Perl Documentation				      SVK::Command::Log(3)

NAME

       SVK::Command::Log - Show log messages for revisions

SYNOPSIS

	log DEPOTPATH
	log PATH
	log -r N[:M] [DEPOT]PATH

OPTIONS

	-r [--revision] ARG	 : ARG (some commands also take ARG1:ARG2 range)

				 A revision argument can be one of:

				 "HEAD"       latest in repository
				 {DATE}       revision at start of the date
				 NUMBER       revision number
				 NUMBER@      interpret as remote revision number
				 NUM1:NUM2    revision range

				 Unlike other commands,  negative NUMBER has no
				 meaning.

	-l [--limit] REV       : stop after displaying REV revisions
	-q [--quiet]	       : Don't display the actual log message itself
	-x [--cross]	       : track revisions copied from elsewhere
	-v [--verbose]	       : print extra information
	   --xml	       : display the log messages in XML format
	   --filter FILTER     : select revisions based on FILTER
	   --output FILTER     : display logs using the given FILTER

DESCRIPTION

       Display the log messages and other meta-data associated with revisions.

       SVK provides a flexible system allowing log messages and other revision properties to be displayed and processed in many ways.  This
       flexibility comes through the use of "log filters."  Log filters are of two types: selection and output.  Selection filters determine which
       revisions are included in the output, while output filters determine how the information about those revisions is displayed.  Here's a
       simple example.	These two invocations produce equivalent output:

	   svk log -l 5 //local/project
	   svk log --filter "head 5" --output std //local/project

       The "head" filter chooses only the first revisions that it encounters, in this case, the first 5 revisions.  The "std" filter displays the
       revisions using SVK's default output format.

       Selection filters can be connected together into pipelines.  For example, to see the first 3 revisions with log messages containing the
       string 'needle', we might do this

	   svk log --filter "grep needle | head 3" //local/project

       That example introduced the "grep" filter.  The argument for the grep filter is a valid Perl pattern (with any '|' characters as '|' and
       '' as '\').  A revision is allowed to continue to the next stage of the pipeline if the revision's log message matches the pattern.  If
       we wanted to search only the first 10 revisions for 'needle' we could use either of the following commands

	   svk log --filter "head 10 | grep needle" //local/project
	   svk log -l 10 --filter "grep needle" //local/project

       You may change SVK's default output filter by setting the SVKLOGOUTPUT environment.  See svk help environment for details.

       Standard Filters

       The following log filters are included with the standard SVK distribution:

	   Selection : grep, head, author
	   Output    : std, xml

       For detailed documentation about any of these filters, try "perldoc SVK::Log::Filter::Name" where "Name" is "Grep", "Head", "XML", etc..
       Other log filters are available from CPAN <http://search.cpan.org> by searching for "SVK::Log::Filter".	For details on writing log
       filters, see the documentation for the SVK::Log::Filter module.

perl v5.10.0							    2008-08-04						      SVK::Command::Log(3)

SVK::Command::Patch(3)					User Contributed Perl Documentation				    SVK::Command::Patch(3)

NAME

       SVK::Command::Patch - Manage patches

SYNOPSIS

	patch --ls    [--list]
	patch --cat   [--view]	     PATCHNAME
	patch --regen [--regenerate] PATCHNAME
	patch --up    [--update]     PATCHNAME
	patch --apply		     PATCHNAME [DEPOTPATH | PATH] [-- MERGEOPTIONS]
	patch --rm    [--delete]     PATCHNAME

OPTIONS

	--depot DEPOTNAME      : operate on a depot other than the default one

DESCRIPTION

       To create a patch, use "commit -P" or "smerge -P".  To import a patch that's sent to you by someone else, just drop it into the "patch"
       directory in your local svk repository. (That's usually "~/.svk/".)

       svk patches are compatible with GNU patch. Extra svk-specific metadata is stored in an encoded chunk at the end of the file.

       A patch name of "-" refers to the standard input and output.

INTRODUCTION

       "svk patch" command can help out on the situation where you want to maintain your patchset to a given project.  It is used under the
       situation that you have no direct write access to remote repository, thus "svk push" cannot be used.

       Suppose you mirror project "foo" to "//mirror/foo", create a local copy on "//local/foo", and check out to "~/dev/foo". After you've done
       some work, you type:

	   svk commit -m "Add my new feature"

       to commit changes from "~/dev/foo" to "//local/foo". If you have commit access to the upstream repository, you can submit your changes
       directly like this:

	   svk push //local/foo

       Sometimes, it's useful to send a patch, rather than submit changes directly, either because you don't have permission to commit to the
       upstream repository or because you don't think your changes are ready to be committed.

       To create a patch containing the differences between "//local/foo" and "//mirror/foo", use this command:

	   svk push -P Foo //local/foo

       The "-P" flag tells svk that you want to create a patch rather than push the changes to the upstream repository.  "-P" takes a single flag:
       a patch name.  It probably makes sense to name it after the feature implemented or bug fixed by the patch. Patch files you generate will be
       created in the "patch" subdirectory of your local svk repository.

       Over time, other developers will make changes to project "foo". From time to time, you may need to update your patch so that it still
       applies cleanly.

       First, make sure your local branch is up to date with any changes made upstream:

	   svk pull //local/foo

       Next, update your patch so that it will apply cleanly to the newest version of the upstream repository:

	   svk patch --update Foo

       Finally, regenerate your patch to include other changes you've made on your local branch since you created or last regenerated the patch:

	   svk patch --regen Foo

       To get a list of all patches your svk knows about, run:

	   svk patch --list

       To see the current version of a specific patch, run:

	   svk patch --view Foo

       When you're done with a patch and don't want it hanging around anymore, run:
	   svk patch --delete Foo

       To apply a patch to the repository that someone else has sent you, run:

	   svk patch --apply - < contributed_feature.patch

perl v5.10.0							    2008-08-04						    SVK::Command::Patch(3)