SYNOPSIS

plaur SUBCOMMAND [ARGS…]

DESCRIPTION

Calls the given plaur subcommand. The meanings of the arguments ARGS depend on the SUBCOMMAND. The available commands and their meanings are described in the COMMANDS section.

USING PLAUR

The Concept

The main idea is to build a plaur repository which is your custom version of the Arch User Repository (AUR). In your plaur repository you can trust the contents of all packages, in particular the PKGBUILD files.

There are two ways of filling the plaur repository with (new) packages:

  • By adding a new package from the AUR. But before you can actually build that new package, you have to verify it first. That means: after looking at the PKGBUILD (and other shipped files), you tell the plaur repository that the package does not contain malicious code.

  • By updating an existing package in your plaur repository to a new version from the AUR. Again, you have to verify the new version. But now, plaur only shows you the differences to the last verified version, so you do not need to go through all the PKGBUILD again!

All the information is automatically saved in a git(1) repository. So you can easily synchronize the AUR packages between various arch linux systems.

First Steps

Similar to git, create a new directory with the name of you choice, enter it, and then type:

$ plaur init

This will initialize a git repository and create empty configuration files plaur.ini and packages.ini. The main information — which packages you have added and which version you have verified — is saved in the packages.ini and is tracked by git.

Adding a new package

In order to import a new package (e.g. named mypackagename) from the AUR, type:

$ plaur add mypackagename

This will do nothing but saving in the packages.ini that you are interested of that package. The following command downloads the package content (in fact downloads and updates all package contents).

$ plaur fetch

This will result in a new directory for the new package, containing its git-repository from the AUR. You have multiple ways for reviewing its content. The easiest way is:

$ plaur verify

It will show all the unverified package contents and asks you whether it looks trustworthy. If all the dependencies of the new packages are met, you can directly build it. But in general (or in order to be sure are that all dependencies are there), you can perform a dependency check:

$ plaur depadd

It will check if there are any unresolved dependencies. It will prompt for installing them from the repositories via pacman, if possible. The still unresolved dependencies are added to your plaur repository, via plaur add. Just like before, you need to download and verify those via

$ plaur fetch && plaur verify

You can iterate that whole proces of

$ plaur depadd && plaur fetch && plaur verify

in order to add the dependencies' dependencies, and so on, until no new dependencies arise.

Finally, you can start building the packages, using plaur build. Unfortunately, it is not yet implemented to build all the packages in dependency order.

COMMANDS

add [--asdeps] PACKAGENAME [PATH]

Add a new package
Add a package with name PACKAGENAME and put it in the directory specified by PATH (either absolute or relative to the current working directory). PATH defaults to PACKAGENAME.
If --asdeps is supplied, then the package will be marked as being a dependency for another package.

asciidoc

Generate documentation in asciidoc format

build [PATH…]

Build the specified packages
Execute makepkg in those of the given PATHs, that are verified, and skip the other (unverified) PATHs. After a successful build, the new packages are installed via pacman.

cat_config

Read and print the plaur.ini
This command exists solely for debugging purposes:
Show the contents of the plaur.ini of the present plaur repository.

cat_srcinfo [FILES…]

Read and print the given .SRCINFO files
This command exists solely for debugging purposes:
Read the supplied FILES of the .SRCINFO format and print them again. The order of options may change, however the order of different options with the same key stays unchanged.

depadd [PATH…]

Add dependencies for the given packages
For each of the given PATHs, check for unresolved dependencies and add them to the plaur repo or install them via pacman, if possible.

diff [PATH…]

Show differences since last verification
For the given PATHs, print the differences between the last verified and the current version.
If no PATH is specified, then the difference of all paths with changes will be shown.

fetch [PATH…]

Update or create a PKGBUILD from upstream
Updates the given PATHs to the current upstream version, and creates them if necessary.
If no PATH is given, then all configured paths will be fetched.

git [ARGS…]

Run a git command on the packages repository
Execute some git command in the main plaur repository.
This allows performing git commands on the plaur repo without leaving the current working directory. This is convenient, because often one is in a subdirectory which is a git repository of a PKGBUILD.

help [CMD]

Print general help or that of a subcommand
Print the long description of the specified subcommand CMD. If no CMD is given, list all the available subcommands.

init

Initalize the present directory
Initialize an empty plaur repository in the current working directory

status

Show package version and build status

verify [PATH…]

Verify a pkgbuild
For the given PATHs, mark the current version as verified. This means, that the PKGBUILD (and the attached files) in them can be sourced and executed.
If no PATH is specified, then all paths are verified interactively.

why [PACKAGES…]

Tell why a package is in the plaur repository
For the given PACKAGES, why they are in the plaur repository. That is, tell whether it was added explicitly or as a dependency, and tell by which other packages it is needed.

FILES

Beside the actual packages plaur manages two files, as described in the following. Both are using the INI FILE FORMAT.

MAIN CONFIGURATION: plaur.ini

The git root of the plaur repository must contain a file named plaur.ini serving two purposes. Firstly it identifies a git repository as a plaur repository. Secondly it contains the user specific configuration. Its content is never written by plaur and is intended to be edited manually by the user if needed. The available options are available in the only file section called options:

packages_file (Default value: packages.ini)

file path to packages config, relative to the plaur git root

PACKAGES CONFIGURATION: packages.ini

In the git root, a file packages.ini (file name and location are configurable in plaur.ini) lists the packages and their options, managed by plaur. It is edited automatically via plaur and not intended to be written by the user.

INI FILE FORMAT

All configuration files are of python’s ini format:

  • Lines beginning with # are treated as commetns

  • The file is divided into sections. Each section starts with a line [name] where name denotes the section name. Then multiple lines of the pattern key = value follow.

RESOURCES

Github page: http://github.com/t-wissmann/plaur