summaryrefslogtreecommitdiff
path: root/support/arara/scripts/rules/context.yaml
blob: 5b8546486edbc0925969b961ee01c68936a1618c (plain)
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
!config
# Arara, the cool TeX automation tool
# Copyright (c) 2020, Island of TeX
# All rights reserved.
#
# This rule is part of arara.
identifier: context
name: ConTeXt
authors:
- Island of TeX
commands:
- name: ConTeXt engine
  command: >
    @{
        return getCommand('context', make, ctx, interface, autopdf, purge,
                          modules, environments, mode, path, arguments,
                          trackers, directives, silent, errors, interaction,
                          synctex, options, reference);
    }
arguments:
- identifier: make
  flag: >
    @{
        return isTrue(parameters.make, '--make');
    }
- identifier: ctx
  flag: >
    @{
        return '--ctx='.concat(parameters.ctx);
    }
- identifier: interface
  flag: >
    @{
        return [ '--interface', parameters.interface ];
    }
- identifier: autopdf
  flag: >
    @{
        return isTrue(parameters.autopdf, '--autopdf');
    }
- identifier: purge
  flag: >
    @{
        p = [ 'partial' : '--purge', 'all' : '--purgeall',
              'result' : '--purgeresult' ];
        if (p.keySet().contains(parameters.purge)) {
            return p.get(parameters.purge);
        }
        else {
            throwError('Invalid value, expected either partial or all.');
        }
    }
- identifier: modules
  flag: >
    @{
        if (isList(parameters.modules)) {
            return '--usemodule='.concat(String.join(',', parameters.modules));
        }
        else {
            throwError('I was expecting a list.');
        }
    }
- identifier: environments
  flag: >
    @{
        if (isList(parameters.environments)) {
            return '--environment='.concat(String.join(',',
                   parameters.environments));
        }
        else {
            throwError('I was expecting a list.');
        }
    }
- identifier: mode
  flag: >
    @{
        if (isList(parameters.mode)) {
            return '--mode='.concat(String.join(',', parameters.mode));
        }
        else {
            throwError('I was expecting a list.');
        }
    }
- identifier: path
  flag: >
    @{
        if (isList(parameters.path)) {
            return '--path='.concat(String.join(',', parameters.path));
        }
        else {
            throwError('I was expecting a list.');
        }
    }
- identifier: arguments
  flag: >
    @{
        if (isList(parameters.arguments)) {
            return '--arguments='.concat(String.join(',',
                   parameters.arguments));
        }
        else {
            throwError('I was expecting a list.');
        }
    }
- identifier: trackers
  flag: >
    @{
        if (isList(parameters.trackers)) {
            return '--trackers='.concat(String.join(',', parameters.trackers));
        }
        else {
            throwError('I was expecting a list.');
        }
    }
- identifier: directives
  flag: >
    @{
        if (isList(parameters.directives)) {
            return '--directives='.concat(String.join(',',
                   parameters.directives));
        }
        else {
            throwError('I was expecting a list.');
        }
    }
- identifier: silent
  flag: >
    @{
        if (isList(parameters.modules)) {
            return '--silent='.concat(String.join(',', parameters.silent));
        }
        else {
            throwError('I was expecting a list.');
        }
    }
- identifier: errors
  flag: >
    @{
        if (isList(parameters.errors)) {
            return '--errors='.concat(String.join(',', parameters.errors));
        }
        else {
            throwError('I was expecting a list.');
        }
    }
- identifier: interaction
  flag: >
    @{
        if ([ 'batchmode', 'nonstopmode' ].contains(parameters.interaction)) {
            return '--'.concat(parameters.interaction);
        }
        else {
            throwError('The provided interaction value is not valid.');
        }
    }
- identifier: synctex
  flag: >
    @{
        return isTrue(parameters.synctex, '--synctex', '--nosynctex');
    }
- identifier: options
  flag: >
    @{
        if (isList(parameters.options)) {
            return parameters.options;
        }
        else {
            throwError('I was expecting a list of options.');
        }
    }