-
Notifications
You must be signed in to change notification settings - Fork 1
/
hoorex.1.in
205 lines (149 loc) · 6.58 KB
/
hoorex.1.in
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
HooRex(1)
=========
:doctype: manpage
NAME
----
hoorex - shows which other packages in a SlackBuilds.org (SBo) repository
depend on a given package(s). The result list of packages is
ordered such that build dependencies are given before dependent
packages.
SYNOPSIS
--------
*hoorex* ['OPTIONS'] PKG [PKG ...]
DESCRIPTION
-----------
The hoorex(1) command outputs the name(s) of packages in the SBo repository
tree which depend on the target PKG(s) given on the command line.
Alternatively, using the *-r, --reverse* option, hoorex outputs the
complete depenedency tree for the target PKG(s). In both these modes,
output packages are shown in "build order" i.e. any which packages are
build dependencies of others in the result list are output before those
which depend on them.
The main purpose of HooRex is to show all other packages which depend
on the target(s) and which might therefore be affected by some change in the
target. Combining this standard mode with the reverse mode results in an
exhaustive listing of all packages that might need to be (re)built in such
a situation.
OPTIONS
-------
*-d, --debug*::
Show additional informational and *debugging* output.
*-f, --force*::
*Force* reconstruction of the internal cross reference index.
*-g, --group* 'SBO_GROUP [SBO_GROUP ...]'::
Use a known group of packages as input. Groups that HooRex knows
about include the SBo categories (academic, accessibility, ...,
system). Another is the "all" group.
*-h, --help*::
Show HooRex *help* message.
*-1, --column*::
Show output as a single column i.e. newline separated rather than
space separated
*-i, --installed*::
Restrict output to those packages already installed, with the
exception of the target package(s) which are included.
*-I, --installed_strict*::
Strictly restrict output to those packages already installed,
not even the original target packages.
*-l, --long*::
Show category of each resulting package as well as the package
e.g. libraries/json-c
*-m, --multilevel*::
Normally, hoorex outputs the names of packages which directly
depend on the target PKG(s). In *multilevel* mode, these
directly depending packages are also processed to find which
packages depend on them; this process is continued until no
further depending packages are found.
*-r, --reverse*::
*Reverse* the default calculation of dependency tree i.e. instead of
determining which other packages require the target package(s),
calculate which packages are required to build the target package(s).
*-s, --slackbuilds* 'SBO_DIRECTORY'::
Specify full path to the *slackbuilds* directory containing
the full SlackBuilds.org repository tree.
*-U, --unknown_strict*::
Unknown packages will normally be quietly ignored and HooRex will
continue if possible. The previous behaviour, to announce the
unknown package and exit, is invoked with this flag.
*--version*::
Show program version number and exit immediately.
USAGE
-----
When hoorex is run for the first time it will attempt to scan the local
slackbuilds directory tree and create an internal index of the dependency
relationships between all the packages found there. Since it will have
no idea where the slackbuilds directory tree is located, hoorex must be
run again, this time with the *-s* (*--slackbuilds*) option e.g.
hoorex -s /home/kim/slackbuilds
Now, when run again, hoorex will proceed with creating its dependency
index This takes about 15sec., but is nominally a once only operation
since the result is saved for future use. After the index is created
and saved, queries are close to instantaneous. The indexing procedure
may be forced at any time using the *-f* (*--force*) option. This is
only required if there is some change in the slackbuilds repository,
such as an update or change to a different git branch with local
changes.
Running hoorex with some target package name(s) as argument(s) returns
the names of those packages which directly depend on the target package(s).
If package A is directly depended on by packages B, C and D, then
running 'hoorex A' will return A B C D.
It may be that any of the depending packages B, C or D may be depended
on by some other package(s). In turn, these may themselves be depended
on by further packages. The full chain of depending packages can be
seen by running hoorex with the *-m* (*--multilievel*) option e.g.
hoorex -m json-c
Package names may also be passed to hoorex from stdin using a pipe.
Package names input via a pipe are added to any named as an argument i.e.
echo jason-c | hoorex speex
is equivalent to
hoorex json-c speex
or
echo json-c speex | hoorex
A typical use of this ability is to pipe the output of a normal hoorex
instance into a second *-r* (*--reverse*) instance e.g.
hoorex -m speex | hoorex -r
which first determines all the packages which somehow depend on speex
and then calculates all the packages required to build them.
Care should be taken when restricting output to those packages already
installed
(using *-i* (*--installed*) and *-I* (*--installed_strict*) options).
In particular, these options should probably never be used at the same
time as the *-r* (*--reverse*) option; in this case you need to know
which packages will be needed regardless of whether they're already
installed or not.
Specifying a known group or multiple groups to HooRex enables painless
querying of large numbers of packages. For instance to use all the
packages in SBo's network and ruby categories as input to HooRex, run:
hoorex -g network ruby
A special group is the *all* group which consists of all packages known
to HooRex. To generate a build order for the entire SBo repository,
run:
hoorex -g all -r
EXIT STATUS
-----------
*0* All OK
*1* Path to SBo repository is not available
*2* Package name supplied to HooRex is unknown in the SBo repository
(only when *-U* (*--unknown_strict*) flag is invoked)
FILES
-----
*~/.config/hoorex/default.cfg*::
Contains user defaults and preferences
*~/.local/share/hoorex/repoData.pkl*::
Contains the hoorex cross reference index of repo information.
It is generated automatically if it doesn't already exist
or whenever the -f option is invoked.
BUGS
----
See the HooRex distribution BUGS file.
AUTHOR
------
HooRex was originally written by Christoph Willing.
RESOURCES
---------
GitHub: <https://github.com/cwilling/hoorex>
COPYING
-------
Copyright \(C) 2015 Christoph Willing. Free use of this software is
granted under the terms of Version 3 of the GNU General Public License (GPL).
See the HooRex distribution LICENSE.md file for details.