How to Publish your Software on Copr, Fedora’s User Repository

Push to the commits & tags to the remote using `git push --follow-tags`, and
we're ready to release the package on Copr.

== Step 2: Publishing the package in a Copr repository

. Go to https://copr.fedorainfracloud.org/ and log in. Once done, click on
  _New Project_ to start creating a repository for our program. On the
  following input mask,

.. Under _1. Project information_ -> _Project name_ set the name to what you
   want your repo to be called - since this will only contain a single package,
   it makes sense to use projectname = packagename, i.e. _hellocopr_. This is
   the only settings that cannot be changed later.

.. Under _2. Build options_ tick all distributions you want to create
   repositories for - usually all Fedora versions & maybe EPEL versions as well

.. Under _4. Other Options_ make sure that _Follow Fedora branching_ is ticked,
   this will ensure that your repository will automatically update for new
   Fedora release.

. Go to _Packages_ -> _New Package_

.. Under _1. Provide the source_, set the package name & the URL of your git
   repository

.. Under _2. How to build SRPM from the source_ select _tito_

.. Under _3. Generic package setup_ tick the box for _Auto-rebuild_

. Your package will appear in the list of packages. Hit _Rebuild_ to trigger a
  build. The following page lets you change any build options if necessary,
  we'll just use the defaults, i.e. the options we set in the previous
  step. Hit _Submit_ and Copr will build the package from the tito tag we
  created in Step 1.

Once the build has finished, you can test installing the package from Copr
by activating your repository.  ``` user@host ~/copr-tito-quickdoc % sudo
dnf copr enable <username>/hellocopr

user@host ~/copr-tito-quickdoc % sudo dnf install hellocopr ```

== Step 3: Automate package (re)-builds

Next, we want to set up Copr to automatically build a new package version
whenever we create one, so that we no longer need to log in and trigger one
manually. To achieve this, we simply need to trigger a build whenever we
push a new tag to the repository.

This requires some configuration both of your Git repository and of the Copr
project.

Configuration can be found under _Settings_ -> _Integrations_, the page also
explains the steps to configure your git repository for all common Git
forges (Pagure, Github, Gitlab & Bitbucket).

Now, to test this, let's make some changes to our program that will come in
handy for the final layer of automation and create a new release for our
software.

Currently, the example program has its version hardcoded at multiple
places.
link:https://pagure.io/copr-tito-quickdoc/c/61abf1cdf622d8c9fb4f03eb6b06c4ddc1677362?branch=master[Let's
change this] so that the version string is sourced from a single file. Which
file this is doesn't matter, but ideally the version variable should be the
only thing in it that is likely to change. In this case, we use the
previously empty `src/hellocopr/pass:[__]initpass:[__].py`. We name this new
version '1.0.1'.

Commit the changes, and create a new release with tito

Note that by ommiting the `--use-version` option, tito now updates the version automatically. It does so by

. Increasing the Version's final digit by 1 - `1.0.0` -> `1.0.1`
. Resetting the Release to 1 it it isn't already.

If you want to bump to a different version, say `1.1.0`, you can do so again
by passing `--use-version`.

Push the resulting commit & tag, and if you now check your projects page on
Copr, you'll see that a new build of `hellocopr-1.0.1-1` has been triggered
by our pushing a tag.

== Step 4: Let tito manage the program version

If you check the git log, you'll find that I actually forgot to update
hellocopr's version variable to 1.0.1. We don't want that to happen
again. Luckily, since we single-source our version, we can let tito
automatically generate this file from a template.

First, copy the version source file
`src/hellocopr/pass:[__]initpass:[__].py` to
`.tito/templates/pass:[__]initpass:[__].py.template`. Then, open the
template file and replace the version string with `$version`. It also makes
sense to add a note that the file is managed by tito and should not be
edited manually.  ``` user@host ~/copr-tito-quickdoc % cat
.tito/templates/__init__.py.template ...  # This file is automatically
created from a template by tito. Do not edit it manually.

__version__ = '$version' ```

Next, add the following to `.tito/tito.props` ```
[version_template]
destination_file = src/hellocopr/__init__.py template_file =
.tito/templates/__init__.py.template ```
https://pagure.io/copr-tito-quickdoc/c/28600f6e41d5a4b60f2e47cf077f2fe2d9224e1d?branch=master[Commit
the changes]. Now, when we tag a new release, tito will take the template,
replace `$version` with whatever version was tagged, and copy the resulting
file to `src/hellocopr/pass:[__]initpass:[__].py` before updating the spec
file and commiting the changes.

We can test this by tagging a new release: