A unified frontend for several package managers that simplifies the command line and makes it easy to install repositories and source tar.gz's as .deb, .rpm, or slackbuilds. Uses checkinstall, gorepo, and wget.
C++ Shell
Switch branches/tags
Nothing to show
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Failed to load latest commit information.
.park-meta
src
.gitignore
README
makefile

README

Park is a frontend for your package manager that simplifies the command line
and provides the ability to easily install repositories and downloaded tar.gz
files as packages, using checkinstall, wget and gorepo.

Here is a summary of its usage:


	park +

		List all *explicitly installed* packages. On a fresh install of
		Cambria, the only installed package will be "cambria", as the
		dependencies form your entire system and are not explicitly
		installed. As you add more packages with the following command,
		they will be added to this list, which will make it trivially
		easy to manually (or throught a script) clean your system back
		to a fresh install state.

	park + packagename [otherpackage]

		Install a package to your system. You can install as many as
		you want with a single command, they're space-seperated.

	*park + repolocation [--as name] [--to directory]

		Install a package from a repo address. If no name is given,
		the folder name retrieved by the repo program will be used.
		If a name is given, then that will be used as the folder name
		in /usr/src. Note that this can be mixed freely with other
		packages, and is really the same command as above, but showing
		off different features. 

		Also note that you can use the same name as an "official" 
		package in the park registry, as all official packages can be 
		accessed through "!name", where "name" is the name of the 
		package. So I could install some weird variant of Python as
		"python", but I'm still fully capable of referencing the "real"
		Python package as "!python" (as in, "park + !python"). You can
		think of non-! names as softlinks that point to their !
		counterparts unless overridden by custom packages. Using the
		same name twice will cause park to ask you if you want to 
		overwrite the existing custom package, which is the only way
		to install a new package to an existing override name (this
		will uninstall the old custom package).

		The "--as" keyword also takes the official names of repos, so
		you can make a pseudonym for a package if it makes your life
		easier. This will duplicate the source code on your system, but
		allows you to more easily have two versions of a package side-
		by-side on your system. I could enter "park + ruby --as newruby"
		to install the ruby package under the name "newruby", whether
		it was currently installed or not.

		The --to directory is an optionally directory where you want
		a hardlink to the package stored. For example, I can install
		a package --to ~/project/foreign/node.js, and it will still be
		in /usr/src as well, with no extra disk usage as it's the same
		copy. If the hardlink fails, a softlink will be attempted.

	park -

		Remove all installed packages that are neither explicitly
		installed nor dependencies of explicitly installed packages,
		equivalent to apt-get autoremove.

	park - packagename [otherpackage]

		Uninstall one or more packages. Does not support repo links.

	park x

		Update your repository cache, including the park channel
		packages, but does not pull repo updates.

	park x packagename [--to version] [otherpackage]

		Update one or more packages. 

		You can use the "--to" keyword for metapackages, to specify
		what version you want to set the package to. For example, 
		"park x python --to 2.7", which will update the dependencies of
		the python package to contain only "python2.7" and attempt to
		update python. Trying to set to a version not specified in the
		metapackage will generate an error but not interfere in other
		updates.

		Package names work like file globbing here, though you have to
		use quotes around things with asterisks to keep your shell from
		using your current working directory to glob from.

		park x "*" is interpreted as its equivalent `park xx` for the
		sake of efficiency.

	park xx

		Upgrade all packages.

	park xxx

		Equivalent to `park x && park xx`

	*park /

		List all installed packages in a dependency tree.

	park / packagename

		List information about the package, "packagename".

	*park .

		Statistics about your packages in terms of how many are of
		each type of repo (# of git, # of Mercurial, etc). Adding a -v
		will cause park to spit out a 3-column list of the format:

		packagename repo_up repo_down

	*park . packagename in message

		Where "in" is a keyword, and "message" a commit message. This
		commits or "checks in" the working directory. This includes
		staging the whole src/pkg/packagename directory, for repos
		with a staging step (so, git add . && git commit -m message).

	*park . packagename out [--hash|-h hash]|[-x]

		Checks out a state from the repo into the working directory.

		With no extra arguments, pulls out the latest version. With -h
		or --hash, you can specify the hash of the version you want
		to check out, or use -x (where x is a number) to check out the
		version -x versions from the current head (park . python out -5
		will check out the version 5 commits before the current, you
		can think of the no-arguments call as equivalent to using -0).

	*park . packagename up [address] [channel]

		Pushes local commits to the internet.

		Address can be a link, "repo_up" (default and redundant),
		"repo_down", or "otherpackage:repo_up"/"otherpackage:repo_down"
		where otherpackage is a reference to another package (allowing
		you to push commits to other packages' repo links).


	*park . packagename down [address] [channel]

		Pulls updates from the internet.

		Like . packagename up, this subcommand is mostly useful if you
		are someone who maintains a package, knows what you're doing,
		and has to move commits across packages, in which case these
		commands will actually be simpler than using the simpler
		"x packagename" syntax.

		This command will never change the channel or any other
		variables of your local package, and neither will up. This
		means less surprises, less "helping" you behind your back. I
		think the target audience of the . series of subcommands will
		appreciate the simplicity :)


	park ? [search terms]

		Searches your installed packages according to your terms. A
		handy and accurate way to see what packages are included in
		a glob before using that glob in a more powerful command, like
		park - "perl*".

		With no search terms, returns a list of all installed packages.


	park ?? search terms

		Global search. This uses the backend package manager to search
		the whole known set of repositories, notably including all
		packages regardless of whether you've installed them or not.

		This is handy for finding the package you want to install when
		you don't know its exact package name.

As a general rule:

	+ commands involve installation,
	- commands involve uninstallation,
	x commands involve updates,
	/ commands tell you things,
	. commands give you closer (but still generalized) repo control.
	? commands are search

*Finally: appending a simple "-" to the end of any command as a final argument
will tell park to run "park -" (autoremove) once the main command is finished,
which is more convenient than "&& park -" by 8 characters.

Note to developers: if you're having trouble with filenames that include the !,
and bash (or your shell of choice) making some aggravating assumptions about
history completion, you can escape the ! character with a backslash; for 
example, "less dep/\!cambria" instead of "less dep/!cambria".

* not implemented yet