[![GitHub CI](https://github.com/juhp/rpmbuild-order/workflows/build/badge.svg)](https://github.com/juhp/rpmbuild-order/actions)
[![Hackage](http://img.shields.io/hackage/v/rpmbuild-order.png)](http://hackage.haskell.org/package/rpmbuild-order)
[![license](https://img.shields.io/badge/license-BSD-brightgreen.svg)](https://opensource.org/licenses/BSD-3-Clause)

# rpmbuild-order

This is a tool to sort RPM source packages in build dependency order.
The code was originally derived from
[cabal-sort](http://hackage.haskell.org/package/cabal-sort)
by Henning Thielemann.

## Usage

`$ rpmbuild-order --version`

```
0.4.12
```
`$ rpmbuild-order --help`

```
Order packages by build dependencies

Usage: rpmbuild-order [--version] COMMAND

  Sort package sources (spec files) in build dependency order

Available options:
  -h,--help                Show this help text
  --version                Show version

Available commands:
  sort                     sort packages
  deps                     sort dependencies in neighbouring package dirs
  rdeps                    sort dependents in neighbouring package dirs
  layers                   ordered output of dependency layers
  chain                    ordered output suitable for a chain-build
  leaves                   List of the top leaves of package graph
  roots                    List lowest root packages
  render                   Show graph with graphviz
```

```
$ rpmbuild-order sort mycore mylib myapp
mylib mycore myapp
```

The arguments passed can either be directories containing the package
or spec files.

If the dependency graph has cycles then an error will be output with
a list of cycles and any shortest path subcycles.

Using the rpmbuild-order `deps` and `rdeps` commands the ordered
dependencies and reverse dependencies of a package can be obtained
within the current set of checked out package sources.
ie If you have a directory with packages:
```
pkg1/ pkg2/ lib1/ lib2/ lib3/ misc1/
```
then the output of `rpmbuild-order deps pkg1` might be `lib1 lib3 pkg1`
for example.

The `render` command displays a graph of package dependencies
using graphviz and X11 or can print the dot format to stdout.

## Library
As of version 0.4, a library is also provided.

There are two modules:

- `Distribution.RPM.Build.Order` provides higher level functions for
  sorting packages in build dependency orders and output. It is built on top of:
- `Distribution.RPM.Build.Graph` provides lower level functions for generating
  RPM dependency graphs

Please see their documentation for more details.

## Notes and known problems
0. Handles pkgconfig() provides by grepping .spec for .pc files

1. Given packages A, B, C, where C depends on B, and B depends on A,
and you call

       rpmbuild-order sort C.spec A.spec

   then the output may be wrong if C does not have a direct dependency on A.
   Even if the order is correct, B is missing in the output
   and thus in this case the list of packages cannot be reliably used
   for a sequence of builds.

   However the `deps` and `rdeps` commands take
   other neighbouring package directories into account.

2. repoquery is not used to resolve meta-dependencies or files to packages.
So if a package BuildRequires a file, it will not be resolved to a package.
This may get addressed some day, but file dependencies seem uncommon for
BuildRequires compared to Requires.

3. rpmspec is used to parse spec files (for macro expansion etc):
so missing macros packages can lead to erroneous results in some cases.

4. Since version 0.4.6 there is some support now for packages using
dynamic buildrequires (in Fedora: golang, python, ruby, and rust packages).

5. Since version 0.4.8 %{_isa} suffixed Provides are filtered out for x86_64.

## Installation

rpmbuild-order is packaged in Fedora Linux.

## Building from source

Use `cabal-rpm builddep && cabal install` or `stack install`.