├── .gitignore
├── .travis.yml
├── CODEOWNERS
├── Cargo.lock
├── Cargo.toml
├── LICENSE
├── README.md
├── Rotefile
├── appveyor.yml
├── docs
    ├── mkdocs.yml
    ├── src
    │   ├── examples.md
    │   ├── extending.md
    │   ├── getting-started.md
    │   ├── index.md
    │   ├── logo.png
    │   ├── modules.md
    │   ├── reference.md
    │   ├── rotefiles.md
    │   ├── rules.md
    │   ├── tasks.md
    │   └── variables.md
    └── theme
    │   ├── base.html
    │   ├── favicon.ico
    │   ├── highlight.pack.js
    │   ├── theme.css
    │   └── theme.js
├── src
    ├── graph.rs
    ├── logger.rs
    ├── main.rs
    ├── modules
    │   ├── cpp.lua
    │   ├── cpp.rs
    │   ├── fs.rs
    │   ├── http.rs
    │   ├── java.lua
    │   ├── java.rs
    │   ├── json.rs
    │   ├── mod.rs
    │   ├── stdlib.rs
    │   └── table.lua
    ├── rule.rs
    ├── runner.rs
    ├── runtime
    │   ├── environment.rs
    │   ├── iter.rs
    │   └── mod.rs
    └── task.rs
└── tests
    ├── core.lua
    ├── fixtures
        ├── fs1.in
        └── fs2.in
    ├── fs.lua
    └── json.lua


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled files
 2 | *.o
 3 | *.so
 4 | *.rlib
 5 | *.dll
 6 | 
 7 | # Executables
 8 | *.exe
 9 | 
10 | # Generated by Cargo
11 | target/
12 | 
13 | # Test output
14 | tests/fixtures/*.out
15 | 
16 | # Mkdocs output
17 | site/
18 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: rust
 2 | sudo: required
 3 | dist: trusty
 4 | 
 5 | rust:
 6 |   - 1.10.0
 7 |   - 1.11.0
 8 |   - beta
 9 |   - nightly
10 | 
11 | matrix:
12 |   allow_failures:
13 |     - rust: nightly
14 | 


--------------------------------------------------------------------------------
/CODEOWNERS:
--------------------------------------------------------------------------------
1 | * me@stephencoakley.com
2 | 


--------------------------------------------------------------------------------
/Cargo.lock:
--------------------------------------------------------------------------------
  1 | [root]
  2 | name = "rote"
  3 | version = "0.2.0"
  4 | dependencies = [
  5 |  "getopts 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
  6 |  "glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
  7 |  "hyper 0.9.10 (registry+https://github.com/rust-lang/crates.io-index)",
  8 |  "json 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)",
  9 |  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 10 |  "lua 0.0.9 (git+https://github.com/jcmoyer/rust-lua53)",
 11 |  "num_cpus 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)",
 12 |  "regex 0.1.73 (registry+https://github.com/rust-lang/crates.io-index)",
 13 |  "term 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
 14 | ]
 15 | 
 16 | [[package]]
 17 | name = "aho-corasick"
 18 | version = "0.5.2"
 19 | source = "registry+https://github.com/rust-lang/crates.io-index"
 20 | dependencies = [
 21 |  "memchr 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 22 | ]
 23 | 
 24 | [[package]]
 25 | name = "bitflags"
 26 | version = "0.1.1"
 27 | source = "registry+https://github.com/rust-lang/crates.io-index"
 28 | 
 29 | [[package]]
 30 | name = "cookie"
 31 | version = "0.2.5"
 32 | source = "registry+https://github.com/rust-lang/crates.io-index"
 33 | dependencies = [
 34 |  "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
 35 |  "url 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 36 | ]
 37 | 
 38 | [[package]]
 39 | name = "gcc"
 40 | version = "0.3.33"
 41 | source = "registry+https://github.com/rust-lang/crates.io-index"
 42 | 
 43 | [[package]]
 44 | name = "getopts"
 45 | version = "0.2.14"
 46 | source = "registry+https://github.com/rust-lang/crates.io-index"
 47 | 
 48 | [[package]]
 49 | name = "glob"
 50 | version = "0.2.11"
 51 | source = "registry+https://github.com/rust-lang/crates.io-index"
 52 | 
 53 | [[package]]
 54 | name = "hpack"
 55 | version = "0.2.0"
 56 | source = "registry+https://github.com/rust-lang/crates.io-index"
 57 | dependencies = [
 58 |  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 59 | ]
 60 | 
 61 | [[package]]
 62 | name = "httparse"
 63 | version = "1.1.2"
 64 | source = "registry+https://github.com/rust-lang/crates.io-index"
 65 | 
 66 | [[package]]
 67 | name = "hyper"
 68 | version = "0.9.10"
 69 | source = "registry+https://github.com/rust-lang/crates.io-index"
 70 | dependencies = [
 71 |  "cookie 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
 72 |  "httparse 1.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 73 |  "language-tags 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 74 |  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 75 |  "mime 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 76 |  "num_cpus 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)",
 77 |  "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
 78 |  "solicit 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
 79 |  "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
 80 |  "traitobject 0.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 81 |  "typeable 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 82 |  "unicase 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 83 |  "url 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 84 | ]
 85 | 
 86 | [[package]]
 87 | name = "idna"
 88 | version = "0.1.0"
 89 | source = "registry+https://github.com/rust-lang/crates.io-index"
 90 | dependencies = [
 91 |  "matches 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 92 |  "unicode-bidi 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 93 |  "unicode-normalization 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 94 | ]
 95 | 
 96 | [[package]]
 97 | name = "json"
 98 | version = "0.10.2"
 99 | source = "registry+https://github.com/rust-lang/crates.io-index"
100 | 
101 | [[package]]
102 | name = "kernel32-sys"
103 | version = "0.2.2"
104 | source = "registry+https://github.com/rust-lang/crates.io-index"
105 | dependencies = [
106 |  "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
107 |  "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
108 | ]
109 | 
110 | [[package]]
111 | name = "language-tags"
112 | version = "0.2.2"
113 | source = "registry+https://github.com/rust-lang/crates.io-index"
114 | 
115 | [[package]]
116 | name = "libc"
117 | version = "0.2.15"
118 | source = "registry+https://github.com/rust-lang/crates.io-index"
119 | 
120 | [[package]]
121 | name = "log"
122 | version = "0.3.6"
123 | source = "registry+https://github.com/rust-lang/crates.io-index"
124 | 
125 | [[package]]
126 | name = "lua"
127 | version = "0.0.9"
128 | source = "git+https://github.com/jcmoyer/rust-lua53#97baee9ebfbde235ac970c5f1edd9dc746b6aa78"
129 | dependencies = [
130 |  "bitflags 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
131 |  "gcc 0.3.33 (registry+https://github.com/rust-lang/crates.io-index)",
132 |  "libc 0.2.15 (registry+https://github.com/rust-lang/crates.io-index)",
133 | ]
134 | 
135 | [[package]]
136 | name = "matches"
137 | version = "0.1.2"
138 | source = "registry+https://github.com/rust-lang/crates.io-index"
139 | 
140 | [[package]]
141 | name = "memchr"
142 | version = "0.1.11"
143 | source = "registry+https://github.com/rust-lang/crates.io-index"
144 | dependencies = [
145 |  "libc 0.2.15 (registry+https://github.com/rust-lang/crates.io-index)",
146 | ]
147 | 
148 | [[package]]
149 | name = "mime"
150 | version = "0.2.2"
151 | source = "registry+https://github.com/rust-lang/crates.io-index"
152 | dependencies = [
153 |  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
154 | ]
155 | 
156 | [[package]]
157 | name = "num_cpus"
158 | version = "0.2.13"
159 | source = "registry+https://github.com/rust-lang/crates.io-index"
160 | dependencies = [
161 |  "libc 0.2.15 (registry+https://github.com/rust-lang/crates.io-index)",
162 | ]
163 | 
164 | [[package]]
165 | name = "regex"
166 | version = "0.1.73"
167 | source = "registry+https://github.com/rust-lang/crates.io-index"
168 | dependencies = [
169 |  "aho-corasick 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
170 |  "memchr 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
171 |  "regex-syntax 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
172 |  "thread_local 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
173 |  "utf8-ranges 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
174 | ]
175 | 
176 | [[package]]
177 | name = "regex-syntax"
178 | version = "0.3.4"
179 | source = "registry+https://github.com/rust-lang/crates.io-index"
180 | 
181 | [[package]]
182 | name = "rustc-serialize"
183 | version = "0.3.19"
184 | source = "registry+https://github.com/rust-lang/crates.io-index"
185 | 
186 | [[package]]
187 | name = "rustc_version"
188 | version = "0.1.7"
189 | source = "registry+https://github.com/rust-lang/crates.io-index"
190 | dependencies = [
191 |  "semver 0.1.20 (registry+https://github.com/rust-lang/crates.io-index)",
192 | ]
193 | 
194 | [[package]]
195 | name = "semver"
196 | version = "0.1.20"
197 | source = "registry+https://github.com/rust-lang/crates.io-index"
198 | 
199 | [[package]]
200 | name = "solicit"
201 | version = "0.4.4"
202 | source = "registry+https://github.com/rust-lang/crates.io-index"
203 | dependencies = [
204 |  "hpack 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
205 |  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
206 | ]
207 | 
208 | [[package]]
209 | name = "term"
210 | version = "0.4.4"
211 | source = "registry+https://github.com/rust-lang/crates.io-index"
212 | dependencies = [
213 |  "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
214 |  "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
215 | ]
216 | 
217 | [[package]]
218 | name = "thread-id"
219 | version = "2.0.0"
220 | source = "registry+https://github.com/rust-lang/crates.io-index"
221 | dependencies = [
222 |  "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
223 |  "libc 0.2.15 (registry+https://github.com/rust-lang/crates.io-index)",
224 | ]
225 | 
226 | [[package]]
227 | name = "thread_local"
228 | version = "0.2.6"
229 | source = "registry+https://github.com/rust-lang/crates.io-index"
230 | dependencies = [
231 |  "thread-id 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
232 | ]
233 | 
234 | [[package]]
235 | name = "time"
236 | version = "0.1.35"
237 | source = "registry+https://github.com/rust-lang/crates.io-index"
238 | dependencies = [
239 |  "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
240 |  "libc 0.2.15 (registry+https://github.com/rust-lang/crates.io-index)",
241 |  "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
242 | ]
243 | 
244 | [[package]]
245 | name = "traitobject"
246 | version = "0.0.1"
247 | source = "registry+https://github.com/rust-lang/crates.io-index"
248 | 
249 | [[package]]
250 | name = "typeable"
251 | version = "0.1.2"
252 | source = "registry+https://github.com/rust-lang/crates.io-index"
253 | 
254 | [[package]]
255 | name = "unicase"
256 | version = "1.4.0"
257 | source = "registry+https://github.com/rust-lang/crates.io-index"
258 | dependencies = [
259 |  "rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
260 | ]
261 | 
262 | [[package]]
263 | name = "unicode-bidi"
264 | version = "0.2.3"
265 | source = "registry+https://github.com/rust-lang/crates.io-index"
266 | dependencies = [
267 |  "matches 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
268 | ]
269 | 
270 | [[package]]
271 | name = "unicode-normalization"
272 | version = "0.1.2"
273 | source = "registry+https://github.com/rust-lang/crates.io-index"
274 | 
275 | [[package]]
276 | name = "url"
277 | version = "1.2.0"
278 | source = "registry+https://github.com/rust-lang/crates.io-index"
279 | dependencies = [
280 |  "idna 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
281 |  "matches 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
282 | ]
283 | 
284 | [[package]]
285 | name = "utf8-ranges"
286 | version = "0.1.3"
287 | source = "registry+https://github.com/rust-lang/crates.io-index"
288 | 
289 | [[package]]
290 | name = "winapi"
291 | version = "0.2.8"
292 | source = "registry+https://github.com/rust-lang/crates.io-index"
293 | 
294 | [[package]]
295 | name = "winapi-build"
296 | version = "0.1.1"
297 | source = "registry+https://github.com/rust-lang/crates.io-index"
298 | 
299 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "rote"
 3 | version = "0.2.0"
 4 | authors = ["Stephen Coakley <me@stephencoakley.com>"]
 5 | license = "Apache-2.0"
 6 | repository = "http://github.com/sagebind/rote"
 7 | readme = "README.md"
 8 | 
 9 | [dependencies]
10 | getopts = "0.2"
11 | glob = "0.2"
12 | json = "0.10"
13 | log = "0.3"
14 | num_cpus = "0.2"
15 | regex = "0.1"
16 | term = "0.4"
17 | 
18 | [dependencies.hyper]
19 | version = "0.9"
20 | default-features = false
21 | 
22 | [dependencies.lua]
23 | git = "https://github.com/jcmoyer/rust-lua53"
24 | 
25 | [[bin]]
26 | name = "rote"
27 | path = "src/main.rs"
28 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "{}"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright {yyyy} {name of copyright owner}
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 
203 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # ![Rote](docs/src/logo.png?raw=true)
  2 | ##### Automate everything.
  3 | 
  4 | [![Build Status](https://img.shields.io/travis/sagebind/rote.svg)](https://travis-ci.org/sagebind/rote) [![Release](https://img.shields.io/github/release/sagebind/rote.svg)]() [![Downloads](https://img.shields.io/github/downloads/sagebind/rote/total.svg)]()
  5 | 
  6 | Rote is a multi-threaded task runner and build tool designed to be easy to use, portable, and fast. Automate your entire development workflow using Rote's scriptable task system to implement builds, deployment, and maintenance using a unified script syntax.
  7 | 
  8 | 
  9 | ## Status
 10 | **Rote is basically unfinished and on hold indefinitely. The actual rule and task running works rather well, and is very fast, but the tool isn't fleshed out, nor is the Rotefile syntax finalized. This is not recommended to be used outside of experiments.**
 11 | 
 12 | I don't have enough personal bandwidth to work on Rote at this point, and Rote deserves more thought to be put into its design. I fully intend to revisit Rote in the future, as I believe it is something that is sorely needed today as a "spiritual successor" to Make. Lua may or may not be the right script language, though coroutines might make the run process faster.
 13 | 
 14 | Go ahead and download Rote, try it out, see what you like and what you don't. I'd *love* to hear your opinions; I'm always listening via email ([me@stephencoakley.com](mailto:me@stephencoakley.com)) or on Twitter ([@sagebind](https://twitter.com/sagebind)).
 15 | 
 16 | ---
 17 | 
 18 | ## Features
 19 | - Ridiculously fast.
 20 | - Task parallelization with threading.
 21 | - Incremental builds.
 22 | - Scriptable runtime.
 23 | - Familiar syntax that doesn't get in your way when you need to do some logic in your build.
 24 | - Completely portable binary with no system dependencies.
 25 | 
 26 | 
 27 | ## Compiling
 28 | 
 29 |     cargo build
 30 | 
 31 | This will compile Rote along with a downloaded Lua 5.3 interpreter.
 32 | 
 33 | ### Ubuntu 16.04 Specific
 34 | 
 35 | You may need to install `libreadline6-dev` before compiling.
 36 | 
 37 | 
 38 | ## Usage
 39 | To use Rote in your project, create a `Rotefile` in your project root. A `Rotefile` is a valid Lua script and should contain valid Lua code. Below is an example `Rotefile`:
 40 | 
 41 | ```lua
 42 | require "cargo"
 43 | default "debug"
 44 | 
 45 | task("debug", function()
 46 |     cargo.build()
 47 | end)
 48 | 
 49 | task("release", function()
 50 |     cargo.build {
 51 |         release = true
 52 |     }
 53 | end)
 54 | 
 55 | task("clean", function()
 56 |     cargo.clean()
 57 | end)
 58 | ```
 59 | 
 60 | Rote uses [Lua](http://www.lua.org) as a configuration syntax. You do not need to be familiar with Lua to use Rote; the syntax is very simple to understand!
 61 | 
 62 | Now to execute the `debug` task, we can run `rote debug`. Rote will look for the `Rotefile` in the current directory. If the file is in a different directory or has a different name, you can use the `-f` flag to specify a different location:
 63 | 
 64 |     rote -f my/Rotefile debug
 65 | 
 66 | See the `default "debug"` near the top? That sets the default task to `debug`. When `rote` is run without a task name, it assumes the "default" task should be run. To run the "debug" task then, we can just run
 67 | 
 68 |     rote
 69 | 
 70 | See `rote -h` for more on command usage.
 71 | 
 72 | 
 73 | ## Batteries included
 74 | Since your task runner and build tool typically runs before your dependency managers, it makes little sense for you to have to install a plethora of plugins before running tasks. That's why Rote includes many common tasks built-in directly; Rote comes batteries included.
 75 | 
 76 | If there is a reusable component you'd like to use, but keep out of your actual `Rotefile`, you can save it as a simple Lua module too inside your project repository, or in one of your system's Lua include paths. Then using it in your `Rotefile` is as simple as requiring the module by name:
 77 | 
 78 | ```lua
 79 | require "my_custom_module"
 80 | ```
 81 | 
 82 | 
 83 | ## Really? *Another* build tool?
 84 | The ecosystem for build and task tools is already so saturated that Rote can hardly offer anything new, right? Actually, that is the point of Rote entirely. Rote *intentionally* has less features than other tools like Ant or CMake, because too many features can make a build tool too complicated or slow.
 85 | 
 86 | The idea for Rote came from the failures of other existing tools. Here are just a few of the common issues:
 87 | 
 88 | - Nonstandard file formats or confusing configuration syntaxes.
 89 | - Making you write verbose code instead of defining tasks.
 90 | - Non-native tools themselves depend on interpreters to be installed, like Node.js, Python, or Ruby. This introduces additional complexity that does not come from a project itself, but with the build tool.
 91 | 
 92 | For more insulting comparisons to your favorite tool, here is a lengthier list:
 93 | 
 94 | - Make is lightweight and simple, but has a horrible, confusing syntax.
 95 | - Autotools are built on Make, but are the opposite of simple.
 96 | - Ant uses XML, which is incredibly verbose for even simple tasks. Plus XML isn't designed for logic.
 97 | - Phing is basically a PHP clone of Ant, so it inherits all the problems of Ant.
 98 | - Rake is written in Ruby.
 99 | - Grunt is a huge beast of a program.
100 | - CMake? lol.
101 | 
102 | 
103 | ## Acknowledgements
104 | Like most amazing software, Rote stands on the shoulders of the many who provide essential libraries and components, often a thankless job. So here's our thanks to some projects we'd like to highlight that have inspired Rote or are being used in Rote:
105 | 
106 | - [The Rust Programming Language](https://www.rust-lang.org), for an excellent native programming language
107 | - [Lua](https://www.lua.org), for such a simple, elegant scripting language
108 | - [rust-lua53](https://github.com/jcmoyer/rust-lua53), for Lua 5.3 bindings for Rust
109 | - [term](https://github.com/Stebalien/term), for simplifying cross-platform terminal colors
110 | - [GNU Make](https://www.gnu.org/software/make), for starting it all
111 | - [Jake](http://jakejs.com), for script syntax inspiration
112 | - [Cake](http://cakebuild.net), for script syntax inspiration
113 | 
114 | 
115 | ## License
116 | All documentation and source code is licensed under the Apache License, Version 2.0 (Apache-2.0). See the [LICENSE](LICENSE) file for details.
117 | 


--------------------------------------------------------------------------------
/Rotefile:
--------------------------------------------------------------------------------
 1 | fs = require "fs"
 2 | default "debug"
 3 | 
 4 | 
 5 | desc("Build a debug binary")
 6 | task("debug", function()
 7 |     exec("cargo", "build")
 8 | end)
 9 | 
10 | desc("Build a release binary for all supported platforms")
11 | task("release", function()
12 |     -- Build a static binary usin musl libc.
13 |     exec("cargo", "build", "--release", "--target=x86_64-unknown-linux-musl")
14 | end)
15 | 
16 | desc("Clean the project directory")
17 | task("clean", function()
18 |     fs.remove("./target")
19 | end)
20 | 
21 | desc("Installs Rote into system path")
22 | task("install", {"release"}, function()
23 |     exec("install", "-s", "-T", "target/release/rote", "/usr/local/bin/rote")
24 | end)
25 | 
26 | desc("Runs tests")
27 | task("test", {"debug"}, function()
28 |     local path = rote.current_dir() .. "/target/debug/rote"
29 | 
30 |     if rote.current_exe() ~= path then
31 |         exec(path, "test")
32 |         return
33 |     end
34 | 
35 |     local ok = true
36 |     for file in glob("tests/*.lua") do
37 |         print("[" .. file .. "]")
38 |         local success, err = pcall(function()
39 |             return dofile(file)
40 |         end)
41 | 
42 |         if not success then
43 |             print("FAIL! Reason: " .. err)
44 |             ok = false
45 |         else
46 |             print("PASS")
47 |         end
48 |     end
49 | 
50 |     if not ok then
51 |         error("some tests failed")
52 |     end
53 | end)
54 | 


--------------------------------------------------------------------------------
/appveyor.yml:
--------------------------------------------------------------------------------
 1 | environment:
 2 |   global:
 3 |     PROJECT_NAME: rote
 4 |   matrix:
 5 |     # Stable channel
 6 |     - TARGET: i686-pc-windows-gnu
 7 |       CHANNEL: stable
 8 |     - TARGET: i686-pc-windows-msvc
 9 |       CHANNEL: stable
10 |     - TARGET: x86_64-pc-windows-gnu
11 |       CHANNEL: stable
12 |     - TARGET: x86_64-pc-windows-msvc
13 |       CHANNEL: stable
14 |     # Beta channel
15 |     - TARGET: i686-pc-windows-gnu
16 |       CHANNEL: beta
17 |     - TARGET: i686-pc-windows-msvc
18 |       CHANNEL: beta
19 |     - TARGET: x86_64-pc-windows-gnu
20 |       CHANNEL: beta
21 |     - TARGET: x86_64-pc-windows-msvc
22 |       CHANNEL: beta
23 |     # Nightly channel
24 |     - TARGET: i686-pc-windows-gnu
25 |       CHANNEL: nightly
26 |     - TARGET: i686-pc-windows-msvc
27 |       CHANNEL: nightly
28 |     - TARGET: x86_64-pc-windows-gnu
29 |       CHANNEL: nightly
30 |     - TARGET: x86_64-pc-windows-msvc
31 |       CHANNEL: nightly
32 | 
33 | # Install Rust and Cargo
34 | # (Based on from https://github.com/rust-lang/libc/blob/master/appveyor.yml)
35 | install:
36 |   - ps: Start-FileDownload "https://static.rust-lang.org/dist/channel-rust-stable"
37 |   - ps: $env:RUST_VERSION = Get-Content channel-rust-stable | select -first 1 | %{$_.split('-')[1]}
38 |   - if NOT "%CHANNEL%" == "stable" set RUST_VERSION=%CHANNEL%
39 |   - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-${env:RUST_VERSION}-${env:TARGET}.exe"
40 |   - rust-%RUST_VERSION%-%TARGET%.exe /VERYSILENT /NORESTART /DIR="C:\Program Files (x86)\Rust"
41 |   - SET PATH=%PATH%;C:\Program Files (x86)\Rust\bin
42 |   - if "%TARGET%" == "i686-pc-windows-gnu" set PATH=%PATH%;C:\msys64\mingw32\bin
43 |   - if "%TARGET%" == "x86_64-pc-windows-gnu" set PATH=%PATH%;C:\msys64\mingw64\bin
44 |   - rustc -V
45 |   - cargo -V
46 | 
47 | build: false
48 | 
49 | test_script:
50 |   - cargo build --verbose
51 |   - cargo run
52 |   - cargo test
53 | 
54 | before_deploy:
55 |   - cargo build --release
56 |   - mkdir staging
57 |   - copy target\release\rote.exe staging
58 |   - cd staging
59 |   - 7z a ../%PROJECT_NAME%-%APPVEYOR_REPO_TAG_NAME%-%TARGET%.zip *
60 |   - appveyor PushArtifact ../%PROJECT_NAME%-%APPVEYOR_REPO_TAG_NAME%-%TARGET%.zip
61 | 
62 | branches:
63 |   only:
64 |     - master
65 | 


--------------------------------------------------------------------------------
/docs/mkdocs.yml:
--------------------------------------------------------------------------------
 1 | site_name: Rote
 2 | site_description: "The inspiringly simple taks runner and build tool."
 3 | site_author: "Stephen Coakley"
 4 | 
 5 | strict: true
 6 | docs_dir: src
 7 | site_dir: build
 8 | theme_dir: theme
 9 | markdown_extensions:
10 |     - admonition
11 |     - def_list
12 | extra:
13 |     logo: "logo.png"
14 | 
15 | pages:
16 |     - Overview: index.md
17 |     - Getting started: getting-started.md
18 |     - Rotefiles: rotefiles.md
19 |     - Writing tasks: tasks.md
20 |     - File rules: rules.md
21 |     - Variables: variables.md
22 |     - Extending Rote: extending.md
23 | 


--------------------------------------------------------------------------------
/docs/src/examples.md:
--------------------------------------------------------------------------------
 1 | # Examples
 2 | 
 3 | ```lua
 4 | require "cargo"
 5 | default "debug"
 6 | 
 7 | 
 8 | desc("Build a debug binary")
 9 | task("debug", function()
10 |     print "Building debug version..."
11 |     cargo.build()
12 | end)
13 | 
14 | desc("Build a release binary")
15 | task("release", function()
16 |     cargo.build {
17 |         release = true
18 |     }
19 | end)
20 | 
21 | desc("Clean the project directory")
22 | task("clean", function()
23 |     cargo.clean()
24 | end)
25 | 
26 | desc("Runs tests")
27 | task("test", function()
28 |     for _, file in ipairs(glob("tests/*.lua")) do
29 |         print("[" .. file .. "]")
30 |         local success, err = pcall(function()
31 |             return dofile(file)
32 |         end)
33 | 
34 |         if not success then
35 |             print "FAIL!"
36 |             print("Reason: " .. err)
37 |         else
38 |             print "PASS"
39 |         end
40 |     end
41 | end)
42 | ```
43 | 
44 | 
45 | 
46 | C++ example:
47 | 
48 | ```lua
49 | desc("Build a C++ program")
50 | task("main", {"target/main"})
51 | 
52 | rule("target/main", cpp.binary {
53 |     bin = "target/main",
54 |     srcs = glob("src/**"),
55 |     libs = {"glibc"},
56 | })
57 | 
58 | cpp.binary("target/main", {}, {
59 |     srcs = glob("src/**"),
60 |     libs = {"glibc"},
61 | })
62 | ```
63 | 


--------------------------------------------------------------------------------
/docs/src/extending.md:
--------------------------------------------------------------------------------
 1 | # Extending Rote
 2 | 
 3 | Rote provides many useful features for writing tasks and build scripts built-in, but by no means does it have a convenient function for every use case! One of Rote's core values is extensibility to allow script authors to tailor Rote for the types of tasks they need to perform.
 4 | 
 5 | Extending Rote is as simple as writing a standard Lua module. The standard `require` function is available automatically and works on both Lua and native modules.
 6 | 
 7 | For more details on Lua modules and the `require` function, see [section 6.3 of the Lua manual][lua-manual-6.3].
 8 | 
 9 | ## Creating a custom module
10 | 
11 | The easiest and most portable way of creating a custom module is to follow the normal Lua conventions for modules. Let's start out with a quick example:
12 | 
13 | ```lua
14 | local clean = {}
15 | 
16 | -- Cleans a path of unwanted files
17 | function clean.clean(path, force, noWrite)
18 |     -- todo: Implement cleaning
19 | end
20 | 
21 | return clean
22 | ```
23 | 
24 | This defines a module called `clean` that provides a single function called `clean()`. To make this a module, we can put the above code into a file called `clean.lua`.
25 | 
26 | ## Reserved names
27 | 
28 | While you can name Lua modules almost anything, Rote reserves a few module names for the modules that it provides built-in.
29 | 
30 | 
31 | [lua-manual-6.3]: https://www.lua.org/manual/5.3/manual.html#6.3
32 | 


--------------------------------------------------------------------------------
/docs/src/getting-started.md:
--------------------------------------------------------------------------------
 1 | # Getting started
 2 | 
 3 | ## Installing
 4 | 
 5 | Rote supports nearly any platform that Rust supports.
 6 | 
 7 | The Rote command-line tool is a self-contained binary program that has very minimal system dependencies, so Rote can be run just about anywhere.
 8 | 
 9 | ```sh
10 | $ git clone https://github.com/sagebind/rote
11 | $ cd rote
12 | $ ./install.sh
13 | ```
14 | 
15 | ### Compiling it yourself
16 | 
17 | If you are developing Rote or need to run it on an unsupported operating system, you can compile the Rote executable yourself. The CLI is written in [Rust], so you will need to set up a Rust compilation environment first. You will also need Cargo, the Rust dependency manager. See the [Rust documentation](https://doc.rust-lang.org/stable/book/installing-rust.html) for more on installing Rust.
18 | 
19 | Once you have `rustc` and `cargo` installed, you can compile Rote with
20 | 
21 | ```sh
22 | $ cargo build --release
23 | ```
24 | 
25 | ## Basic usage
26 | 
27 | Using Rote is straightforward: we describe how to perform some [tasks](tasks.md), and then Rote executes them. Tasks are defined as functions using the [Lua] scripting language, and placed into a [Rotefile](rotefiles.md). To run one or more tasks that you have defined, you invoke the `rote` command-line utility, which parses the script file and runs the requested task(s).
28 | 
29 | 
30 | 
31 | [lua]: https://www.lua.org
32 | [rust]: https://www.rust-lang.org
33 | 


--------------------------------------------------------------------------------
/docs/src/index.md:
--------------------------------------------------------------------------------
 1 | # ![Rote](logo.png)
 2 | 
 3 | Rote is a pleasantly simple task runner and build tool to supercharge your workflow.
 4 | 
 5 | ## Why use a task runner?
 6 | 
 7 | Software has become much more complex since 1990, and it is only getting more complex. There is code to compile, test suites to run, containers to build, scripts to lint, and archives to deploy. Task runners help you to simplify your development workflow by making it simpler to automate some of these repetitive tasks. Put all of your tasks in one place and let a task runner to the boring work for you.
 8 | 
 9 | ## Why use Rote?
10 | 
11 | Rote is designed to be a flexible, portable tool for any development environment. Just a single executable with no runtime dependencies, Rote can be installed on just about anything.
12 | 
13 | A task runner for all projects. Rote at its core concept is a simple task runner. Tasks are scripted in Lua, but nothing else about Rote is Lua-specific. The flexible, built-in scripting environment makes it easy to perform all kinds of complicated tasks with just a few lines of configuration.
14 | 
15 | A build tool for any language.
16 | 
17 | ## Features
18 | 
19 | - Ridiculously fast.
20 | - Task parallelization with threading.
21 | - Incremental builds.
22 | - Scriptable runtime.
23 | - Familiar syntax that doesn't get in your way when you need to do some logic in your build.
24 | - Completely portable binary with no system dependencies.
25 | 
26 | ## Thanks
27 | 
28 | No software is an island. Both the ideas behind Rote and the technology it uses stand on the shoulders of the many who provide essential research, ideas, and code; often a thankless job. So here's our thanks to things that inspired Rote and projects that have helped Rote:
29 | 
30 | - [The Rust Programming Language](https://www.rust-lang.org), for an excellent native programming language;
31 | - [Lua](https://www.lua.org), for such a simple, elegant scripting language;
32 | - [rust-lua53](https://github.com/jcmoyer/rust-lua53), for Lua 5.3 bindings for Rust;
33 | - [term](https://github.com/Stebalien/term), for simplifying cross-platform terminal colors;
34 | - [GNU Make](https://www.gnu.org/software/make), for starting it all;
35 | - [Jake](http://jakejs.com), for script syntax inspiration;
36 | - [Cake](http://cakebuild.net), for script syntax inspiration;
37 | 
38 | ## License
39 | 
40 | All documentation and source code is licensed under the Apache License, Version 2.0 (Apache-2.0). See the [LICENSE](LICENSE) file for details.
41 | 


--------------------------------------------------------------------------------
/docs/src/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sagebind/rote/3b724b99d8a7ad4c4138a7397f461da589b7ce6b/docs/src/logo.png


--------------------------------------------------------------------------------
/docs/src/modules.md:
--------------------------------------------------------------------------------
1 | # Modules
2 | 


--------------------------------------------------------------------------------
/docs/src/reference.md:
--------------------------------------------------------------------------------
 1 | Complete reference to all built-in functions and modules provided by Rote for scripts.
 2 | 
 3 | ## rote
 4 | 
 5 | This module provides the core set functions available in every build script. The `rote` module is always implicitly `require`d.
 6 | 
 7 | ### `rote.create_task(name, deps={}, action=nil)`
 8 | 
 9 | Defines a new task with the name given by `name`.
10 | 
11 | ### `rote.create_rule()`
12 | ### `rote.change_dir()`
13 | ### `rote.current_dir()`
14 | ### `rote.current_exe()`
15 | ### `rote.env()`
16 | ### `rote.execute()`
17 | ### `rote.expand()`
18 | ### `rote.export()`
19 | ### `rote.glob()`
20 | ### `rote.merge()`
21 | ### `rote.pipe()`
22 | ### `rote.print()`
23 | ### `rote.set_default_task()`
24 | ### `rote.version()`
25 | 
26 | 
27 | ## fs
28 | ### `fs.exists()`
29 | ### `fs.is_dir()`
30 | ### `fs.is_file()`
31 | ### `fs.is_symlink()`
32 | ### `fs.mkdir()`
33 | ### `fs.copy()`
34 | ### `fs.rename()`
35 | ### `fs.remove()`
36 | ### `fs.get()`
37 | ### `fs.put()`
38 | ### `fs.append()`
39 | ### `fs.combine()`
40 | 
41 | 
42 | ## http
43 | ### `http.get()`
44 | ### `http.post()`
45 | 
46 | 
47 | ## json
48 | ### `json.parse(json)`
49 | Parses a JSON string into appropriate native values and returns the result.
50 | 
51 | ### `json.stringify(value, pretty=false, spaces=4)`
52 | Converts `value` into an appropriate JSON string representation. If `pretty` is set to `true`, the string is formatted for maximum readability instead of storage efficiency, using `spaces` number of spaces as an indentation amount.
53 | 
54 | 
55 | ## cpp
56 | ### `cpp.binary()`
57 | 
58 | 
59 | ## java
60 | ### `java.binary()`
61 | 


--------------------------------------------------------------------------------
/docs/src/rotefiles.md:
--------------------------------------------------------------------------------
 1 | # Rotefiles
 2 | 
 3 | A *Rotefile* is a Lua script that contains all of the available [tasks](tasks.md) for a project. Typically in the root directory of a project, it is usually a file named `Rotefile` and should be committed with your project's source code.
 4 | 
 5 | An example can speak a thousand words, so let's start by dissecting a basic Rotefile:
 6 | 
 7 | ```lua
 8 | default "debug"
 9 | 
10 | desc("Build a debug binary")
11 | task("debug", function()
12 |     exec("cargo", "build")
13 | end)
14 | 
15 | desc("Build a release binary")
16 | task("release", function()
17 |     exec("cargo", "build", "--release")
18 | end)
19 | ```
20 | 
21 | Here we define two tasks called "debug" and "release".
22 | 
23 | Now to execute the `debug` task, we can run `rote debug`. Rote will look for the `Rotefile` in the current directory. If the file is in a different directory or has a different name, you can use the `-f` flag to specify a different location:
24 | 
25 | ```sh
26 | $ rote -f my/Rotefile debug
27 | ```
28 | 
29 | See the `default "debug"` at the start of the file? That sets the default task to `debug`. When `rote` is run without a task name, it assumes the "default" task should be run. To run the "debug" task then, we can just run
30 | 
31 | ```sh
32 | $ rote
33 | ```
34 | 
35 | ## Alternate file names
36 | 
37 | In larger projects, it may be necessary to have multiple Rotefiles. You can run tasks contained in other files using the `--file` command line option:
38 | 
39 | ```sh
40 | $ rote --file rotefiles/Rotefile1 my-task
41 | ```
42 | 


--------------------------------------------------------------------------------
/docs/src/rules.md:
--------------------------------------------------------------------------------
 1 | # File rules
 2 | 
 3 | A _rule_ is a powerful way to dynamically define tasks based on a set of input and output files. Rules are not tasks, but act as a template for tasks to be automatically generated.
 4 | 
 5 | ## Defining rules
 6 | 
 7 | To define a new rule, we use the `rule()` function:
 8 | 
 9 | ```lua
10 | rule("foo.txt", function(output)
11 |     fs.put(output, "foo")
12 | end)
13 | ```
14 | 
15 | This looks similar to a task definition, but has a couple of important differences. The first difference is in the name of the rule. When creating a task, the name acts as a canonical identifier for that task and is used to recall that task from the command line. In rules, the name of the rule is also the name of the *output* file that the rule produces.
16 | 


--------------------------------------------------------------------------------
/docs/src/tasks.md:
--------------------------------------------------------------------------------
 1 | # Writing tasks
 2 | 
 3 | Tasks are the basic building blocks of a robust build script. A task represents a single unit of work that can be performed as part of a build process.
 4 | 
 5 | To define a task, you can use the aptly-named `task()` function:
 6 | 
 7 | ```lua
 8 | task("release", {"build"}, function()
 9 |     exec("tar", "-czvf", "build/")
10 | end)
11 | ```
12 | 
13 | ```lua
14 | task("release"):depends("build"):does(function()
15 |     exec("tar", "-czvf", "build/")
16 | end)
17 | ```
18 | 
19 | ```lua
20 | cpp.binary "foo" {
21 |     srcs = glob("src/*.cpp"),
22 |     debug = false,
23 | }
24 | 
25 | task "release" {
26 |     depends = {"build"},
27 |     impl = function()
28 |         exec("tar", "-czvf", "build/")
29 |     end
30 | }
31 | ```
32 | 
33 | The `task()` function takes up to three arguments. The first one is required, and must be a string defining the full name of the task. The second argument is an optional table that lists all of the task's *dependencies*, and the last is a function that contains all of the task's logic.
34 | 
35 | ## Running commands
36 | Most actions can be performed by running executable commands
37 | pipe()
38 | exec()
39 | 
40 | ## Task dependencies
41 | 
42 | ## Parallel execution
43 | 
44 | By default, Rote will attempt to run your tasks in parallel threads if possible to speed up overall execution time. Unlike some tools, you do not have to write your tasks in any special kind of way to use parallel execution; Rote will happily run any of your normal tasks in parallel for you. This makes parallelization much more useful, but it is not without caveats, so it is only fair for us to tell you about them ahead of time to save you potential headache later.
45 | 
46 | Rote implements parallel execution using multithreading, which we believe provides the best guarantees for correct and reproducible task execution. Unfortunately, multithreading is hard, so Rote makes some design choices that can affect how you write your tasks in order to ensure complete thread safety and to guarantee that your scripts cannot cause deadlock or race conditions.
47 | 
48 | The first thing you should know is that Rotefile scripts are initialized once for every thread that Rote creates. Normally, you shouldn't need to run anything substantial outside of a task besides set up some global variables, but this may cause a problem if you are working with the file system, for example. Let's take a look at the following Rotefile:
49 | 
50 | ```lua
51 | global_value = 42
52 | ```
53 | 
54 | If Rote is started with two task threads, the value of `global_value`
55 | 
56 | The second, and more important thing to know is that _global variables are thread-local_. Updating the value of a global variable from within a task **only updates it for the current thread** and the new value _is not guaranteed_ to be available to the next task to run. Below is an example of how _not_ to write your tasks:
57 | 
58 | ```lua
59 | fs = require "fs"
60 | global_value = 42
61 | 
62 | 
63 | task("mutator", function()
64 |     global_value = 32
65 | end)
66 | 
67 | task("my-task", {"mutator"}, function()
68 |     fs.put(("build/%d.txt"):format(global_value))
69 | end)
70 | ```
71 | 
72 | Tasks should be self-contained and should not expect global values to change after initialization. Shared mutable state tends to cause more problems than it solves, so Rote takes the safe road and keeps all global state in a per-thread basis.
73 | 
74 | 
75 | 
76 | [rust]: https://www.rust-lang.org
77 | 


--------------------------------------------------------------------------------
/docs/src/variables.md:
--------------------------------------------------------------------------------
1 | # Variables
2 | 


--------------------------------------------------------------------------------
/docs/theme/base.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 |     <head>
  4 |         <meta charset="utf-8">
  5 |         <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6 |         {%- if page_description -%}
  7 |             <meta name="description" content="{{ page_description }}">
  8 |         {%- endif %}
  9 |         {%- if site_author -%}
 10 |             <meta name="author" content="{{ site_author }}">
 11 |         {%- endif %}
 12 |         <title>
 13 |             {%- if page_title -%}
 14 |                 {{ page_title }} · {% endif -%}
 15 |             {{ site_name -}}
 16 |         </title>
 17 |         {% if favicon -%}
 18 |             <link rel="shortcut icon" href="{{ favicon }}">
 19 |         {%- else -%}
 20 |             <link rel="shortcut icon" href="{{ base_url }}/favicon.ico">
 21 |         {%- endif %}
 22 |         <link href="https://fonts.googleapis.com/css?family=Inconsolata:400,400i|Metamorphous|Open+Sans:400,400i,700,700i" rel="stylesheet">
 23 |         <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.6.0/styles/atelier-estuary-light.min.css">
 24 |         <link rel="stylesheet" href="{{ base_url }}/theme.css">
 25 |         {%- if current_page -%}
 26 |         <script>
 27 |             var mkdocs_page_name = "{{ page_title }}";
 28 |             var mkdocs_page_input_path = "{{ current_page.input_path }}";
 29 |             var mkdocs_page_url = "{{ current_page.abs_url }}";
 30 |             var base_url = '{{ base_url }}';
 31 |         </script>
 32 |         {%- endif %}
 33 |         <script data-main="{{ base_url }}/mkdocs/js/search.js" src="{{ base_url }}/mkdocs/js/require.js"></script>
 34 |         <script src="{{ base_url }}/highlight.pack.js"></script>
 35 |     </head>
 36 | 
 37 |     <body role="document">
 38 |         <nav role="navigation">
 39 |             <header>
 40 |                 <a href="{{ homepage_url }}">
 41 |                 {%- if config.extra.logo -%}
 42 |                     <img src="{{ base_url }}/{{ config.extra.logo }}" draggable="false"/>
 43 |                 {%- else -%}
 44 |                     {{ site_name }}
 45 |                 {%- endif -%}
 46 |                 </a>
 47 |             </header>
 48 | 
 49 |             <input id="mkdocs-search-query" role="search" type="text" name="q" placeholder="Enter search" autocomplete="off" tabindex="1"/>
 50 | 
 51 |             {% if previous_page -%}
 52 |             <div>
 53 |                 <a href="{{ previous_page.url }}">Previous: {{ previous_page.title }}</a>
 54 |             </div>
 55 |             {%- endif %}
 56 | 
 57 |             {% if next_page -%}
 58 |             <div>
 59 |                 <a href="{{ next_page.url }}">Next: {{ next_page.title }}</a>
 60 |             </div>
 61 |             {%- endif %}
 62 | 
 63 |             {% macro tree(items) -%}
 64 |             <ul>
 65 |                 {% for item in items -%}
 66 |                 <li{% if item.active %} class="active"{% endif %}>
 67 |                     {% if item.url -%}
 68 |                         <a href="{{ item.url }}">{{ item.title }}</a>
 69 |                     {%- else -%}
 70 |                         <span>{{ item.title }}</span>
 71 |                     {%- endif %}
 72 |                     {% if item.children -%}
 73 |                         {{ tree(item.children) }}
 74 |                     {%- elif item == current_page -%}
 75 |                         {%- if (toc | first).title == page_title -%}
 76 |                             {{ tree((toc | first).children) }}
 77 |                         {%- else -%}
 78 |                             {{ tree(toc) }}
 79 |                         {%- endif -%}
 80 |                     {%- endif %}
 81 |                 </li>
 82 |                 {%- endfor %}
 83 |             </ul>
 84 |             {%- endmacro -%}
 85 |             {{ tree(nav) }}
 86 | 
 87 |             <footer>
 88 |                 {% if copyright -%}
 89 |                     <p>&copy; {{ copyright }}</p>
 90 |                 {%- endif %}
 91 |                 <p>Built with <a href="http://www.mkdocs.org">MkDocs</a> {{ mkdocs_version }} on {{ build_date_utc.strftime('%b %d, %Y') }}.</p>
 92 |             </footer>
 93 |         </nav>
 94 | 
 95 |         <main role="main">
 96 |             <div id="content">
 97 |                 {{ content }}
 98 |             </div>
 99 | 
100 |             <aside id="search-results">
101 |                 <h1>Search results</h1>
102 |                 <div id="mkdocs-search-results"></div>
103 |             </aside>
104 |         </main>
105 | 
106 |         <a id="sidebar-toggle">Menu</a>
107 | 
108 |         <script>{% include "theme.js" %}</script>
109 |     </body>
110 | </html>
111 | 


--------------------------------------------------------------------------------
/docs/theme/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sagebind/rote/3b724b99d8a7ad4c4138a7397f461da589b7ce6b/docs/theme/favicon.ico


--------------------------------------------------------------------------------
/docs/theme/highlight.pack.js:
--------------------------------------------------------------------------------
1 | /*! highlight.js v9.6.0 | BSD3 License | git.io/hljslicense */
2 | !function(e){var n="object"==typeof window&&window||"object"==typeof self&&self;"undefined"!=typeof exports?e(exports):n&&(n.hljs=e({}),"function"==typeof define&&define.amd&&define([],function(){return n.hljs}))}(function(e){function n(e){return e.replace(/[&<>]/gm,function(e){return I[e]})}function t(e){return e.nodeName.toLowerCase()}function r(e,n){var t=e&&e.exec(n);return t&&0===t.index}function a(e){return k.test(e)}function i(e){var n,t,r,i,o=e.className+" ";if(o+=e.parentNode?e.parentNode.className:"",t=B.exec(o))return R(t[1])?t[1]:"no-highlight";for(o=o.split(/\s+/),n=0,r=o.length;r>n;n++)if(i=o[n],a(i)||R(i))return i}function o(e,n){var t,r={};for(t in e)r[t]=e[t];if(n)for(t in n)r[t]=n[t];return r}function u(e){var n=[];return function r(e,a){for(var i=e.firstChild;i;i=i.nextSibling)3===i.nodeType?a+=i.nodeValue.length:1===i.nodeType&&(n.push({event:"start",offset:a,node:i}),a=r(i,a),t(i).match(/br|hr|img|input/)||n.push({event:"stop",offset:a,node:i}));return a}(e,0),n}function c(e,r,a){function i(){return e.length&&r.length?e[0].offset!==r[0].offset?e[0].offset<r[0].offset?e:r:"start"===r[0].event?e:r:e.length?e:r}function o(e){function r(e){return" "+e.nodeName+'="'+n(e.value)+'"'}l+="<"+t(e)+w.map.call(e.attributes,r).join("")+">"}function u(e){l+="</"+t(e)+">"}function c(e){("start"===e.event?o:u)(e.node)}for(var s=0,l="",f=[];e.length||r.length;){var g=i();if(l+=n(a.substr(s,g[0].offset-s)),s=g[0].offset,g===e){f.reverse().forEach(u);do c(g.splice(0,1)[0]),g=i();while(g===e&&g.length&&g[0].offset===s);f.reverse().forEach(o)}else"start"===g[0].event?f.push(g[0].node):f.pop(),c(g.splice(0,1)[0])}return l+n(a.substr(s))}function s(e){function n(e){return e&&e.source||e}function t(t,r){return new RegExp(n(t),"m"+(e.cI?"i":"")+(r?"g":""))}function r(a,i){if(!a.compiled){if(a.compiled=!0,a.k=a.k||a.bK,a.k){var u={},c=function(n,t){e.cI&&(t=t.toLowerCase()),t.split(" ").forEach(function(e){var t=e.split("|");u[t[0]]=[n,t[1]?Number(t[1]):1]})};"string"==typeof a.k?c("keyword",a.k):E(a.k).forEach(function(e){c(e,a.k[e])}),a.k=u}a.lR=t(a.l||/\w+/,!0),i&&(a.bK&&(a.b="\\b("+a.bK.split(" ").join("|")+")\\b"),a.b||(a.b=/\B|\b/),a.bR=t(a.b),a.e||a.eW||(a.e=/\B|\b/),a.e&&(a.eR=t(a.e)),a.tE=n(a.e)||"",a.eW&&i.tE&&(a.tE+=(a.e?"|":"")+i.tE)),a.i&&(a.iR=t(a.i)),null==a.r&&(a.r=1),a.c||(a.c=[]);var s=[];a.c.forEach(function(e){e.v?e.v.forEach(function(n){s.push(o(e,n))}):s.push("self"===e?a:e)}),a.c=s,a.c.forEach(function(e){r(e,a)}),a.starts&&r(a.starts,i);var l=a.c.map(function(e){return e.bK?"\\.?("+e.b+")\\.?":e.b}).concat([a.tE,a.i]).map(n).filter(Boolean);a.t=l.length?t(l.join("|"),!0):{exec:function(){return null}}}}r(e)}function l(e,t,a,i){function o(e,n){var t,a;for(t=0,a=n.c.length;a>t;t++)if(r(n.c[t].bR,e))return n.c[t]}function u(e,n){if(r(e.eR,n)){for(;e.endsParent&&e.parent;)e=e.parent;return e}return e.eW?u(e.parent,n):void 0}function c(e,n){return!a&&r(n.iR,e)}function g(e,n){var t=N.cI?n[0].toLowerCase():n[0];return e.k.hasOwnProperty(t)&&e.k[t]}function h(e,n,t,r){var a=r?"":y.classPrefix,i='<span class="'+a,o=t?"":C;return i+=e+'">',i+n+o}function p(){var e,t,r,a;if(!E.k)return n(B);for(a="",t=0,E.lR.lastIndex=0,r=E.lR.exec(B);r;)a+=n(B.substr(t,r.index-t)),e=g(E,r),e?(M+=e[1],a+=h(e[0],n(r[0]))):a+=n(r[0]),t=E.lR.lastIndex,r=E.lR.exec(B);return a+n(B.substr(t))}function d(){var e="string"==typeof E.sL;if(e&&!x[E.sL])return n(B);var t=e?l(E.sL,B,!0,L[E.sL]):f(B,E.sL.length?E.sL:void 0);return E.r>0&&(M+=t.r),e&&(L[E.sL]=t.top),h(t.language,t.value,!1,!0)}function b(){k+=null!=E.sL?d():p(),B=""}function v(e){k+=e.cN?h(e.cN,"",!0):"",E=Object.create(e,{parent:{value:E}})}function m(e,n){if(B+=e,null==n)return b(),0;var t=o(n,E);if(t)return t.skip?B+=n:(t.eB&&(B+=n),b(),t.rB||t.eB||(B=n)),v(t,n),t.rB?0:n.length;var r=u(E,n);if(r){var a=E;a.skip?B+=n:(a.rE||a.eE||(B+=n),b(),a.eE&&(B=n));do E.cN&&(k+=C),E.skip||(M+=E.r),E=E.parent;while(E!==r.parent);return r.starts&&v(r.starts,""),a.rE?0:n.length}if(c(n,E))throw new Error('Illegal lexeme "'+n+'" for mode "'+(E.cN||"<unnamed>")+'"');return B+=n,n.length||1}var N=R(e);if(!N)throw new Error('Unknown language: "'+e+'"');s(N);var w,E=i||N,L={},k="";for(w=E;w!==N;w=w.parent)w.cN&&(k=h(w.cN,"",!0)+k);var B="",M=0;try{for(var I,j,O=0;;){if(E.t.lastIndex=O,I=E.t.exec(t),!I)break;j=m(t.substr(O,I.index-O),I[0]),O=I.index+j}for(m(t.substr(O)),w=E;w.parent;w=w.parent)w.cN&&(k+=C);return{r:M,value:k,language:e,top:E}}catch(T){if(T.message&&-1!==T.message.indexOf("Illegal"))return{r:0,value:n(t)};throw T}}function f(e,t){t=t||y.languages||E(x);var r={r:0,value:n(e)},a=r;return t.filter(R).forEach(function(n){var t=l(n,e,!1);t.language=n,t.r>a.r&&(a=t),t.r>r.r&&(a=r,r=t)}),a.language&&(r.second_best=a),r}function g(e){return y.tabReplace||y.useBR?e.replace(M,function(e,n){return y.useBR&&"\n"===e?"<br>":y.tabReplace?n.replace(/\t/g,y.tabReplace):void 0}):e}function h(e,n,t){var r=n?L[n]:t,a=[e.trim()];return e.match(/\bhljs\b/)||a.push("hljs"),-1===e.indexOf(r)&&a.push(r),a.join(" ").trim()}function p(e){var n,t,r,o,s,p=i(e);a(p)||(y.useBR?(n=document.createElementNS("http://www.w3.org/1999/xhtml","div"),n.innerHTML=e.innerHTML.replace(/\n/g,"").replace(/<br[ \/]*>/g,"\n")):n=e,s=n.textContent,r=p?l(p,s,!0):f(s),t=u(n),t.length&&(o=document.createElementNS("http://www.w3.org/1999/xhtml","div"),o.innerHTML=r.value,r.value=c(t,u(o),s)),r.value=g(r.value),e.innerHTML=r.value,e.className=h(e.className,p,r.language),e.result={language:r.language,re:r.r},r.second_best&&(e.second_best={language:r.second_best.language,re:r.second_best.r}))}function d(e){y=o(y,e)}function b(){if(!b.called){b.called=!0;var e=document.querySelectorAll("pre code");w.forEach.call(e,p)}}function v(){addEventListener("DOMContentLoaded",b,!1),addEventListener("load",b,!1)}function m(n,t){var r=x[n]=t(e);r.aliases&&r.aliases.forEach(function(e){L[e]=n})}function N(){return E(x)}function R(e){return e=(e||"").toLowerCase(),x[e]||x[L[e]]}var w=[],E=Object.keys,x={},L={},k=/^(no-?highlight|plain|text)$/i,B=/\blang(?:uage)?-([\w-]+)\b/i,M=/((^(<[^>]+>|\t|)+|(?:\n)))/gm,C="</span>",y={classPrefix:"hljs-",tabReplace:null,useBR:!1,languages:void 0},I={"&":"&amp;","<":"&lt;",">":"&gt;"};return e.highlight=l,e.highlightAuto=f,e.fixMarkup=g,e.highlightBlock=p,e.configure=d,e.initHighlighting=b,e.initHighlightingOnLoad=v,e.registerLanguage=m,e.listLanguages=N,e.getLanguage=R,e.inherit=o,e.IR="[a-zA-Z]\\w*",e.UIR="[a-zA-Z_]\\w*",e.NR="\\b\\d+(\\.\\d+)?",e.CNR="(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",e.BNR="\\b(0b[01]+)",e.RSR="!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",e.BE={b:"\\\\[\\s\\S]",r:0},e.ASM={cN:"string",b:"'",e:"'",i:"\\n",c:[e.BE]},e.QSM={cN:"string",b:'"',e:'"',i:"\\n",c:[e.BE]},e.PWM={b:/\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|like)\b/},e.C=function(n,t,r){var a=e.inherit({cN:"comment",b:n,e:t,c:[]},r||{});return a.c.push(e.PWM),a.c.push({cN:"doctag",b:"(?:TODO|FIXME|NOTE|BUG|XXX):",r:0}),a},e.CLCM=e.C("//","$"),e.CBCM=e.C("/\\*","\\*/"),e.HCM=e.C("#","$"),e.NM={cN:"number",b:e.NR,r:0},e.CNM={cN:"number",b:e.CNR,r:0},e.BNM={cN:"number",b:e.BNR,r:0},e.CSSNM={cN:"number",b:e.NR+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",r:0},e.RM={cN:"regexp",b:/\//,e:/\/[gimuy]*/,i:/\n/,c:[e.BE,{b:/\[/,e:/\]/,r:0,c:[e.BE]}]},e.TM={cN:"title",b:e.IR,r:0},e.UTM={cN:"title",b:e.UIR,r:0},e.METHOD_GUARD={b:"\\.\\s*"+e.UIR,r:0},e});hljs.registerLanguage("makefile",function(e){var a={cN:"variable",b:/\$\(/,e:/\)/,c:[e.BE]};return{aliases:["mk","mak"],c:[e.HCM,{b:/^\w+\s*\W*=/,rB:!0,r:0,starts:{e:/\s*\W*=/,eE:!0,starts:{e:/$/,r:0,c:[a]}}},{cN:"section",b:/^[\w]+:\s*$/},{cN:"meta",b:/^\.PHONY:/,e:/$/,k:{"meta-keyword":".PHONY"},l:/[\.\w]+/},{b:/^\t+/,e:/$/,r:0,c:[e.QSM,a]}]}});hljs.registerLanguage("xml",function(s){var e="[A-Za-z0-9\\._:-]+",t={eW:!0,i:/</,r:0,c:[{cN:"attr",b:e,r:0},{b:/=\s*/,r:0,c:[{cN:"string",endsParent:!0,v:[{b:/"/,e:/"/},{b:/'/,e:/'/},{b:/[^\s"'=<>`]+/}]}]}]};return{aliases:["html","xhtml","rss","atom","xjb","xsd","xsl","plist"],cI:!0,c:[{cN:"meta",b:"<!DOCTYPE",e:">",r:10,c:[{b:"\\[",e:"\\]"}]},s.C("<!--","-->",{r:10}),{b:"<\\!\\[CDATA\\[",e:"\\]\\]>",r:10},{b:/<\?(php)?/,e:/\?>/,sL:"php",c:[{b:"/\\*",e:"\\*/",skip:!0}]},{cN:"tag",b:"<style(?=\\s|>|$)",e:">",k:{name:"style"},c:[t],starts:{e:"</style>",rE:!0,sL:["css","xml"]}},{cN:"tag",b:"<script(?=\\s|>|$)",e:">",k:{name:"script"},c:[t],starts:{e:"</script>",rE:!0,sL:["actionscript","javascript","handlebars","xml"]}},{cN:"meta",v:[{b:/<\?xml/,e:/\?>/,r:10},{b:/<\?\w+/,e:/\?>/}]},{cN:"tag",b:"</?",e:"/?>",c:[{cN:"name",b:/[^\/><\s]+/,r:0},t]}]}});hljs.registerLanguage("json",function(e){var i={literal:"true false null"},n=[e.QSM,e.CNM],r={e:",",eW:!0,eE:!0,c:n,k:i},t={b:"{",e:"}",c:[{cN:"attr",b:/"/,e:/"/,c:[e.BE],i:"\\n"},e.inherit(r,{b:/:/})],i:"\\S"},c={b:"\\[",e:"\\]",c:[e.inherit(r)],i:"\\S"};return n.splice(n.length,0,t,c),{c:n,k:i,i:"\\S"}});hljs.registerLanguage("markdown",function(e){return{aliases:["md","mkdown","mkd"],c:[{cN:"section",v:[{b:"^#{1,6}",e:"$"},{b:"^.+?\\n[=-]{2,}$"}]},{b:"<",e:">",sL:"xml",r:0},{cN:"bullet",b:"^([*+-]|(\\d+\\.))\\s+"},{cN:"strong",b:"[*_]{2}.+?[*_]{2}"},{cN:"emphasis",v:[{b:"\\*.+?\\*"},{b:"_.+?_",r:0}]},{cN:"quote",b:"^>\\s+",e:"$"},{cN:"code",v:[{b:"^```w*s*$",e:"^```s*$"},{b:"`.+?`"},{b:"^( {4}|	)",e:"$",r:0}]},{b:"^[-\\*]{3,}",e:"$"},{b:"\\[.+?\\][\\(\\[].*?[\\)\\]]",rB:!0,c:[{cN:"string",b:"\\[",e:"\\]",eB:!0,rE:!0,r:0},{cN:"link",b:"\\]\\(",e:"\\)",eB:!0,eE:!0},{cN:"symbol",b:"\\]\\[",e:"\\]",eB:!0,eE:!0}],r:10},{b:/^\[[^\n]+\]:/,rB:!0,c:[{cN:"symbol",b:/\[/,e:/\]/,eB:!0,eE:!0},{cN:"link",b:/:\s*/,e:/$/,eB:!0}]}]}});hljs.registerLanguage("rust",function(e){var t="([uif](8|16|32|64|size))?",r=e.inherit(e.CBCM);r.c.push("self");var i="alignof as be box break const continue crate do else enum extern false fn for if impl in let loop match mod mut offsetof once priv proc pub pure ref return self Self sizeof static struct super trait true type typeof unsafe unsized use virtual while where yield move default int i8 i16 i32 i64 isize uint u8 u32 u64 usize float f32 f64 str char bool",n="Copy Send Sized Sync Drop Fn FnMut FnOnce drop Box ToOwned Clone PartialEq PartialOrd Eq Ord AsRef AsMut Into From Default Iterator Extend IntoIterator DoubleEndedIterator ExactSizeIterator Option Result SliceConcatExt String ToString Vec assert! assert_eq! bitflags! bytes! cfg! col! concat! concat_idents! debug_assert! debug_assert_eq! env! panic! file! format! format_args! include_bin! include_str! line! local_data_key! module_path! option_env! print! println! select! stringify! try! unimplemented! unreachable! vec! write! writeln! macro_rules!";return{aliases:["rs"],k:{keyword:i,literal:"true false Some None Ok Err",built_in:n},l:e.IR+"!?",i:"</",c:[e.CLCM,r,e.inherit(e.QSM,{b:/b?"/,i:null}),{cN:"string",v:[{b:/r(#*)".*?"\1(?!#)/},{b:/b?'\\?(x\w{2}|u\w{4}|U\w{8}|.)'/}]},{cN:"symbol",b:/'[a-zA-Z_][a-zA-Z0-9_]*/},{cN:"number",v:[{b:"\\b0b([01_]+)"+t},{b:"\\b0o([0-7_]+)"+t},{b:"\\b0x([A-Fa-f0-9_]+)"+t},{b:"\\b(\\d[\\d_]*(\\.[0-9_]+)?([eE][+-]?[0-9_]+)?)"+t}],r:0},{cN:"function",bK:"fn",e:"(\\(|<)",eE:!0,c:[e.UTM]},{cN:"meta",b:"#\\!?\\[",e:"\\]",c:[{cN:"meta-string",b:/"/,e:/"/}]},{cN:"class",bK:"type",e:";",c:[e.inherit(e.UTM,{endsParent:!0})],i:"\\S"},{cN:"class",bK:"trait enum struct",e:"{",c:[e.inherit(e.UTM,{endsParent:!0})],i:"[\\w\\d]"},{b:e.IR+"::",k:{built_in:n}},{b:"->"}]}});hljs.registerLanguage("javascript",function(e){return{aliases:["js","jsx"],k:{keyword:"in of if for while finally var new function do return void else break catch instanceof with throw case default try this switch continue typeof delete let yield const export super debugger as async await static import from as",literal:"true false null undefined NaN Infinity",built_in:"eval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Error EvalError InternalError RangeError ReferenceError StopIteration SyntaxError TypeError URIError Number Math Date String RegExp Array Float32Array Float64Array Int16Array Int32Array Int8Array Uint16Array Uint32Array Uint8Array Uint8ClampedArray ArrayBuffer DataView JSON Intl arguments require module console window document Symbol Set Map WeakSet WeakMap Proxy Reflect Promise"},c:[{cN:"meta",r:10,b:/^\s*['"]use (strict|asm)['"]/},{cN:"meta",b:/^#!/,e:/$/},e.ASM,e.QSM,{cN:"string",b:"`",e:"`",c:[e.BE,{cN:"subst",b:"\\$\\{",e:"\\}"}]},e.CLCM,e.CBCM,{cN:"number",v:[{b:"\\b(0[bB][01]+)"},{b:"\\b(0[oO][0-7]+)"},{b:e.CNR}],r:0},{b:"("+e.RSR+"|\\b(case|return|throw)\\b)\\s*",k:"return throw case",c:[e.CLCM,e.CBCM,e.RM,{b:/</,e:/(\/\w+|\w+\/)>/,sL:"xml",c:[{b:/<\w+\s*\/>/,skip:!0},{b:/<\w+/,e:/(\/\w+|\w+\/)>/,skip:!0,c:["self"]}]}],r:0},{cN:"function",bK:"function",e:/\{/,eE:!0,c:[e.inherit(e.TM,{b:/[A-Za-z$_][0-9A-Za-z$_]*/}),{cN:"params",b:/\(/,e:/\)/,eB:!0,eE:!0,c:[e.CLCM,e.CBCM]}],i:/\[|%/},{b:/\$[(.]/},e.METHOD_GUARD,{cN:"class",bK:"class",e:/[{;=]/,eE:!0,i:/[:"\[\]]/,c:[{bK:"extends"},e.UTM]},{bK:"constructor",e:/\{/,eE:!0}],i:/#(?!!)/}});hljs.registerLanguage("lua",function(e){var t="\\[=*\\[",a="\\]=*\\]",r={b:t,e:a,c:["self"]},n=[e.C("--(?!"+t+")","$"),e.C("--"+t,a,{c:[r],r:10})];return{l:e.UIR,k:{keyword:"and break do else elseif end false for if in local nil not or repeat return then true until while",built_in:"_G _VERSION assert collectgarbage dofile error getfenv getmetatable ipairs load loadfile loadstring module next pairs pcall print rawequal rawget rawset require select setfenv setmetatable tonumber tostring type unpack xpcall coroutine debug io math os package string table"},c:n.concat([{cN:"function",bK:"function",e:"\\)",c:[e.inherit(e.TM,{b:"([_a-zA-Z]\\w*\\.)*([_a-zA-Z]\\w*:)?[_a-zA-Z]\\w*"}),{cN:"params",b:"\\(",eW:!0,c:n}].concat(n)},e.CNM,e.ASM,e.QSM,{cN:"string",b:t,e:a,c:[r],r:5}])}});hljs.registerLanguage("bash",function(e){var t={cN:"variable",v:[{b:/\$[\w\d#@][\w\d_]*/},{b:/\$\{(.*?)}/}]},s={cN:"string",b:/"/,e:/"/,c:[e.BE,t,{cN:"variable",b:/\$\(/,e:/\)/,c:[e.BE]}]},a={cN:"string",b:/'/,e:/'/};return{aliases:["sh","zsh"],l:/-?[a-z\._]+/,k:{keyword:"if then else elif fi for while in do done case esac function",literal:"true false",built_in:"break cd continue eval exec exit export getopts hash pwd readonly return shift test times trap umask unset alias bind builtin caller command declare echo enable help let local logout mapfile printf read readarray source type typeset ulimit unalias set shopt autoload bg bindkey bye cap chdir clone comparguments compcall compctl compdescribe compfiles compgroups compquote comptags comptry compvalues dirs disable disown echotc echoti emulate fc fg float functions getcap getln history integer jobs kill limit log noglob popd print pushd pushln rehash sched setcap setopt stat suspend ttyctl unfunction unhash unlimit unsetopt vared wait whence where which zcompile zformat zftp zle zmodload zparseopts zprof zpty zregexparse zsocket zstyle ztcp",_:"-ne -eq -lt -gt -f -d -e -s -l -a"},c:[{cN:"meta",b:/^#![^\n]+sh\s*$/,r:10},{cN:"function",b:/\w[\w\d_]*\s*\(\s*\)\s*\{/,rB:!0,c:[e.inherit(e.TM,{b:/\w[\w\d_]*/})],r:0},e.HCM,s,a,t]}});hljs.registerLanguage("css",function(e){var c="[a-zA-Z-][a-zA-Z0-9_-]*",t={b:/[A-Z\_\.\-]+\s*:/,rB:!0,e:";",eW:!0,c:[{cN:"attribute",b:/\S/,e:":",eE:!0,starts:{eW:!0,eE:!0,c:[{b:/[\w-]+\(/,rB:!0,c:[{cN:"built_in",b:/[\w-]+/},{b:/\(/,e:/\)/,c:[e.ASM,e.QSM]}]},e.CSSNM,e.QSM,e.ASM,e.CBCM,{cN:"number",b:"#[0-9A-Fa-f]+"},{cN:"meta",b:"!important"}]}}]};return{cI:!0,i:/[=\/|'\$]/,c:[e.CBCM,{cN:"selector-id",b:/#[A-Za-z0-9_-]+/},{cN:"selector-class",b:/\.[A-Za-z0-9_-]+/},{cN:"selector-attr",b:/\[/,e:/\]/,i:"$"},{cN:"selector-pseudo",b:/:(:)?[a-zA-Z0-9\_\-\+\(\)"'.]+/},{b:"@(font-face|page)",l:"[a-z-]+",k:"font-face page"},{b:"@",e:"[{;]",i:/:/,c:[{cN:"keyword",b:/\w+/},{b:/\s/,eW:!0,eE:!0,r:0,c:[e.ASM,e.QSM,e.CSSNM]}]},{cN:"selector-tag",b:c,r:0},{b:"{",e:"}",i:/\S/,c:[e.CBCM,t]}]}});


--------------------------------------------------------------------------------
/docs/theme/theme.css:
--------------------------------------------------------------------------------
  1 | *, *::before, *::after {
  2 |     box-sizing: border-box;
  3 | }
  4 | 
  5 | 
  6 | /**
  7 |  * Colors and borders
  8 |  */
  9 | body {
 10 |     color: hsl(60, 33%, 15%);
 11 | }
 12 | 
 13 | body, input {
 14 |     background-color: hsl(60, 33%, 99%);
 15 | }
 16 | 
 17 | [role=navigation] {
 18 |     background-color: hsl(60, 33%, 95%);
 19 | }
 20 | 
 21 | 
 22 | /**
 23 |  * Typography
 24 |  */
 25 | body {
 26 |     font-family: "Open Sans", sans-serif;
 27 |     font-size: 100%;
 28 |     line-height: 1.75;
 29 | }
 30 | 
 31 | h1, h2, h3, h4, h5, h6, p, table, pre > code, .admonition {
 32 |     margin: 1.5rem 0;
 33 | }
 34 | 
 35 | a {
 36 |     cursor: pointer;
 37 | }
 38 | 
 39 | a:link {
 40 |     color: #00397b;
 41 |     text-decoration: none;
 42 | }
 43 | 
 44 | a:hover {
 45 |     text-decoration: underline;
 46 | }
 47 | 
 48 | a:visited {
 49 |     color: #7237cf;
 50 | }
 51 | 
 52 | h1, h2, h3, h4, h5, h6 {
 53 |     margin-top: 3rem;
 54 |     font-family: "Metamorphous", serif;
 55 |     line-height: 1.25em;
 56 | }
 57 | 
 58 | h1 {
 59 |     text-align: center;
 60 | }
 61 | 
 62 | blockquote {
 63 |     margin: 0;
 64 |     padding: 0 1.5rem;
 65 |     border-left: 0.5rem solid #e9eff5;
 66 |     border-right: 0.5rem solid #e9eff5;
 67 |     font-size: 1.25rem;
 68 |     font-style: italic;
 69 | }
 70 | 
 71 | blockquote cite {
 72 |     display: block;
 73 |     font-size: 1rem;
 74 |     font-style: normal;
 75 |     text-align: right;
 76 | }
 77 | 
 78 | blockquote cite::before {
 79 |     content: "—";
 80 |     padding-right: 0.5em;
 81 | }
 82 | 
 83 | pre, code {
 84 |     font-family: "Inconsolata", monospace;
 85 |     border-radius: 2px;
 86 | }
 87 | 
 88 | :not(pre) > code {
 89 |     padding: 0.125em 0.25em;
 90 |     background-color: #f4f3ec;
 91 | }
 92 | 
 93 | pre > code {
 94 |     padding: 0.75rem !important;
 95 |     line-height: 1.2em;
 96 | }
 97 | 
 98 | pre {
 99 |     direction: ltr;
100 |     text-align: left;
101 |     white-space: pre-wrap;
102 |     word-spacing: normal;
103 |     word-break: normal;
104 |     word-wrap: break-word;
105 | }
106 | 
107 | hr {
108 |     margin: 2rem 0;
109 |     border: 1px solid rgba(0, 0, 0, 0.2);
110 | }
111 | 
112 | img {
113 |     vertical-align: middle;
114 | }
115 | 
116 | 
117 | /**
118 |  * Layout
119 |  */
120 | body {
121 |     position: relative;
122 |     width: 100%;
123 |     height: 100%;
124 |     margin: 0;
125 | }
126 | 
127 | [role=main] {
128 |     display: block;
129 |     position: absolute;
130 |     top: 0;
131 |     right: 0;
132 |     bottom: auto;
133 |     left: 300px;
134 |     margin: 0 auto;
135 |     padding: 0 1rem 1rem 1rem;
136 |     max-width: 56rem;
137 | }
138 | 
139 | [role=main] #content {
140 |     display: block;
141 | }
142 | 
143 | [role=main] #search-results {
144 |     display: none;
145 | }
146 | 
147 | [role=main].searching #content {
148 |     display: none;
149 | }
150 | 
151 | [role=main].searching #search-results {
152 |     display: block;
153 | }
154 | 
155 | [role=navigation] {
156 |     display: block;
157 |     position: fixed;
158 |     top: 0;
159 |     bottom: 0;
160 |     left: 0;
161 |     width: 300px;
162 |     overflow-x: hidden;
163 |     overflow-y: auto;
164 |     z-index: 2;
165 |     border-right: 2px solid hsl(60, 33%, 90%);
166 |     transition: 0.2s ease-out left;
167 | }
168 | 
169 | [role=navigation] > *:not(:last-child), #search-results article:not(:last-child) {
170 |     display: block;
171 |     border-bottom: 2px solid hsl(60, 33%, 90%);
172 | }
173 | 
174 | [role=navigation] > * {
175 |     margin: 0;
176 |     padding: 0.75rem 1rem;
177 | }
178 | 
179 | [role=navigation] > header {
180 |     text-align: center;
181 |     -webkit-user-select: none;
182 |     -moz-user-select: none;
183 |     -ms-user-select: none;
184 |     user-select: none;
185 | }
186 | 
187 | [role=navigation] > header img {
188 |     display: inline-block;
189 |     height: 3rem;
190 | }
191 | 
192 | [role=navigation] > footer {
193 |     font-size: 0.75rem;
194 | }
195 | 
196 | [role=search] {
197 |     display: block;
198 |     width: 100%;
199 |     outline: 0;
200 |     border: none;
201 |     border-right: none !important;
202 |     font-family: inherit;
203 |     font-size: inherit;
204 |     color: inherit;
205 | }
206 | 
207 | [role=navigation] ul {
208 |     margin: 0;
209 |     padding-left: 1rem;
210 |     list-style: none;
211 | }
212 | 
213 | [role=navigation] > ul {
214 |     padding: 0.5rem 0;
215 | }
216 | 
217 | [role=navigation] ul a {
218 |     display: block;
219 |     padding: 0.375rem 1rem;
220 |     color: inherit;
221 | }
222 | 
223 | [role=navigation] > ul a.current {
224 |     color: blue;
225 | }
226 | 
227 | #sidebar-toggle {
228 |     display: none;
229 | }
230 | 
231 | @media screen and (max-width: 56rem) {
232 |     [role=main] {
233 |         left: 0;
234 |     }
235 | 
236 |     [role=navigation] {
237 |         left: -300px;
238 |     }
239 | 
240 |     [role=navigation].visible {
241 |         left: 0;
242 |     }
243 | 
244 |     #sidebar-toggle {
245 |         display: block;
246 |         position: fixed;
247 |         top: 0;
248 |         left: 0;
249 |         width: 4rem;
250 |         height: 2rem;
251 |         line-height: 2rem;
252 |         text-align: center;
253 |         z-index: 3;
254 |         background-color: #f4f3ec;
255 |     }
256 | }
257 | 
258 | 
259 | /**
260 |  * Definition lists. Usually for parameter lists.
261 |  */
262 | dl > dt {
263 |     color: #4a9ddb;
264 | }
265 | 
266 | dl > dt:not(:first-of-type) {
267 |     margin-top: 1rem;
268 | }
269 | 
270 | dl > dd > :first-child {
271 |     margin-top: 0;
272 | }
273 | 
274 | 
275 | /**
276 |  * Styling for admonitions (notes, tips, etc.).
277 |  */
278 | .admonition {
279 |     padding-bottom: 1px;
280 | }
281 | 
282 | .admonition > .admonition-title {
283 |     padding: 0.5rem 0.75rem;
284 |     background-color: rgba(0, 0, 0, 0.2);
285 |     font-weight: bold;
286 | }
287 | 
288 | .admonition > p {
289 |     margin: 1rem 0;
290 |     padding: 0 0.75rem;
291 | }
292 | 
293 | .admonition.note {
294 |     background-color: #a3c1d9;
295 | }
296 | 
297 | .admonition.tip {
298 |     background-color: #8de5b2;
299 | }
300 | 
301 | .admonition.warning {
302 |     background-color: #f8e07f;
303 | }
304 | 
305 | 
306 | /**
307 |  * Styling for tables.
308 |  */
309 | table {
310 |     width: 100%;
311 |     border-collapse: collapse;
312 |     border-spacing: 0;
313 | }
314 | 
315 | th, td {
316 |     padding: 0.5rem 0.75rem;
317 |     vertical-align: top;
318 |     font-size: 0.9em;
319 | }
320 | 
321 | thead {
322 |     background-color: #71b2e3;
323 |     color: #fff;
324 | }
325 | 
326 | th {
327 |     font-weight: bold;
328 |     text-align: left;
329 | }
330 | 
331 | tbody > tr:nth-child(odd), tbody > tr > td:nth-child(even) {
332 |     background-color: rgba(0, 0, 0, 0.05);
333 | }
334 | 
335 | thead > tr > th:nth-child(even) {
336 |     background-color: rgba(0, 0, 0, 0.15);
337 | }
338 | 


--------------------------------------------------------------------------------
/docs/theme/theme.js:
--------------------------------------------------------------------------------
 1 | window.jQuery = false;
 2 | hljs.initHighlightingOnLoad();
 3 | 
 4 | document.getElementById("mkdocs-search-query").addEventListener("keyup", function () {
 5 |     if (this.value === "") {
 6 |         document.querySelector("[role=main]").classList.remove("searching");
 7 |     } else {
 8 |         document.querySelector("[role=main]").classList.add("searching");
 9 |     }
10 | });
11 | 
12 | document.getElementById("sidebar-toggle").addEventListener("click", function () {
13 |     document.querySelector("[role=navigation]").classList.toggle("visible");
14 | });
15 | 
16 | document.querySelector("[role=main]").addEventListener("click", function () {
17 |     document.querySelector("[role=navigation]").classList.remove("visible");
18 | });
19 | 


--------------------------------------------------------------------------------
/src/graph.rs:
--------------------------------------------------------------------------------
  1 | use std::collections::{HashMap, HashSet, VecDeque};
  2 | use std::error::Error;
  3 | use std::rc::Rc;
  4 | use task::Task;
  5 | 
  6 | 
  7 | /// Stores a directional, sparse graph of tasks and their dependencies.
  8 | pub struct Graph {
  9 |     tasks: HashMap<String, Rc<Task>>,
 10 | }
 11 | 
 12 | impl Graph {
 13 |     /// Creates a new graph.
 14 |     pub fn new() -> Graph {
 15 |         Graph {
 16 |             tasks: HashMap::new(),
 17 |         }
 18 |     }
 19 | 
 20 |     pub fn contains<S: AsRef<str>>(&self, name: S) -> bool {
 21 |         self.tasks.contains_key(name.as_ref())
 22 |     }
 23 | 
 24 |     /// Gets a task by name.
 25 |     pub fn get<S: AsRef<str>>(&self, name: S) -> Result<Rc<Task>, Box<Error>> {
 26 |         if let Some(task) = self.tasks.get(name.as_ref()) {
 27 |             Ok(task.clone())
 28 |         } else {
 29 |             Err(format!("task '{}' not found", name.as_ref()).into())
 30 |         }
 31 |     }
 32 | 
 33 |     /// Adds a task to the graph.
 34 |     pub fn insert(&mut self, rule: Rc<Task>) {
 35 |         self.tasks.insert(rule.name().into(), rule);
 36 |     }
 37 | 
 38 |     /// Produces a queue of tasks to run in order to satisfy all task dependencies.
 39 |     ///
 40 |     /// Dependency solving is done by performing a topological sort of the entire graph using a
 41 |     /// depth-first search-based algorithm.
 42 |     pub fn solve(&self, skip_satisfied_tasks: bool) -> Result<VecDeque<Rc<Task>>, Box<Error>> {
 43 |         Solver::new(&self, skip_satisfied_tasks).solve()
 44 |     }
 45 | }
 46 | 
 47 | struct Solver<'a> {
 48 |     graph: &'a Graph,
 49 |     // Set of tasks that have already been resolved.
 50 |     resolved: HashSet<Rc<Task>>,
 51 |     // Set of tasks that have been visited but not resolved.
 52 |     unresolved: HashSet<Rc<Task>>,
 53 |     // Resulting queue of tasks in solved order.
 54 |     schedule: VecDeque<Rc<Task>>,
 55 |     // Skip satisfied tasks?
 56 |     skip_satisfied_tasks: bool,
 57 | }
 58 | 
 59 | impl<'a> Solver<'a> {
 60 |     fn new<'b>(graph: &'b Graph, skip_satisfied_tasks: bool) -> Solver<'b> {
 61 |         Solver {
 62 |             graph: graph,
 63 |             resolved: HashSet::new(),
 64 |             unresolved: HashSet::new(),
 65 |             schedule: VecDeque::new(),
 66 |             skip_satisfied_tasks: skip_satisfied_tasks,
 67 |         }
 68 |     }
 69 | 
 70 |     fn solve(mut self) -> Result<VecDeque<Rc<Task>>, Box<Error>> {
 71 |         // Loop over each task in the graph.
 72 |         for task in self.graph.tasks.values() {
 73 |             // If this task has not already been visited, search its dependencies to verify that it
 74 |             // can be satisfied.
 75 |             if !self.resolved.contains(task) {
 76 |                 try!(self.resolve(task.clone()));
 77 |             }
 78 |         }
 79 | 
 80 |         Ok(self.schedule)
 81 |     }
 82 | 
 83 |     fn resolve(&mut self, task: Rc<Task>) -> Result<(), Box<Error>> {
 84 |         // First, check if the task is already satisfied. If it is, it and its dependencies do not
 85 |         // need to run and we can skip this task in the schedule.
 86 |         if self.skip_satisfied_tasks && try!(self.satisfied(task.clone())) {
 87 |             info!("task '{}' is up to date", task.name());
 88 |             self.resolved.insert(task.clone());
 89 |             return Ok(());
 90 |         }
 91 | 
 92 |         // Mark this task as unresolved.
 93 |         self.unresolved.insert(task.clone());
 94 | 
 95 |         // Resolve each dependency.
 96 |         for dependency in task.dependencies() {
 97 |             trace!("task '{}' depends on '{}'", task.name(), dependency);
 98 | 
 99 |             // Lookup the dependency in the graph.
100 |             let dependency = try!(self.graph.get(dependency));
101 | 
102 |             if !self.resolved.contains(&dependency) {
103 |                 if self.unresolved.contains(&dependency) {
104 |                     return Err(format!("circular dependency detected: {} -> {}", task.name(), dependency.name()).into());
105 |                 }
106 | 
107 |                 try!(self.resolve(dependency.clone()));
108 |             }
109 |         }
110 | 
111 |         // The task is now resolved.
112 |         trace!("task '{}' resolved", task.name());
113 |         self.unresolved.remove(&task);
114 |         self.resolved.insert(task.clone());
115 |         self.schedule.push_back(task.clone());
116 | 
117 |         Ok(())
118 |     }
119 | 
120 |     /// Determines recursively if a task is satisfied. For a task to be satisfied, its dependencies
121 |     /// must also be satisfied.
122 |     fn satisfied(&self, task: Rc<Task>) -> Result<bool, Box<Error>> {
123 |         if !task.satisfied() {
124 |             return Ok(false);
125 |         }
126 | 
127 |         for dependency in task.dependencies() {
128 |             let dependency = try!(self.graph.get(dependency));
129 | 
130 |             if !try!(self.satisfied(dependency)) {
131 |                 return Ok(false);
132 |             }
133 |         }
134 | 
135 |         Ok(true)
136 |     }
137 | }
138 | 


--------------------------------------------------------------------------------
/src/logger.rs:
--------------------------------------------------------------------------------
 1 | use log::*;
 2 | use term;
 3 | 
 4 | pub use log::LogLevelFilter as Filter;
 5 | 
 6 | 
 7 | /// Writes log messages to standard error.
 8 | ///
 9 | /// The enabled filter level can be customized by passing in a specific filter.
10 | struct Logger(LogLevelFilter);
11 | 
12 | impl Log for Logger {
13 |     fn enabled(&self, metadata: &LogMetadata) -> bool {
14 |         metadata.level() <= self.0
15 |     }
16 | 
17 |     fn log(&self, record: &LogRecord) {
18 |         if self.enabled(record.metadata()) {
19 |             let mut err = term::stderr().expect("failed to open stderr");
20 | 
21 |             // Print with colors matching the level.
22 |             match record.level() {
23 |                 LogLevel::Error => {
24 |                     err.attr(term::Attr::Bold).ok();
25 |                     err.fg(term::color::BRIGHT_RED).ok();
26 |                     write!(err, "error: ").unwrap();
27 | 
28 |                     err.fg(term::color::BRIGHT_WHITE).ok();
29 |                     writeln!(err, "{}", record.args()).unwrap();
30 |                     err.reset().ok();
31 |                 }
32 |                 LogLevel::Warn => {
33 |                     err.fg(term::color::BRIGHT_YELLOW).ok();
34 |                     write!(err, "warn: ").unwrap();
35 |                     err.reset().ok();
36 | 
37 |                     err.attr(term::Attr::Bold).ok();
38 |                     err.fg(term::color::BRIGHT_WHITE).ok();
39 |                     writeln!(err, "{}", record.args()).unwrap();
40 |                     err.reset().ok();
41 |                 }
42 |                 LogLevel::Info => {
43 |                     err.fg(term::color::BRIGHT_GREEN).ok();
44 |                     write!(err, "info: ").unwrap();
45 | 
46 |                     err.fg(term::color::BRIGHT_WHITE).ok();
47 |                     writeln!(err, "{}", record.args()).unwrap();
48 |                     err.reset().ok();
49 |                 }
50 |                 LogLevel::Debug => {
51 |                     err.fg(term::color::BRIGHT_BLUE).ok();
52 |                     write!(err, "debug: ").unwrap();
53 |                     err.reset().ok();
54 | 
55 |                     err.fg(term::color::BRIGHT_WHITE).ok();
56 |                     writeln!(err, "{}", record.args()).unwrap();
57 |                     err.reset().ok();
58 |                 }
59 |                 LogLevel::Trace => {
60 |                     err.fg(term::color::BRIGHT_WHITE).ok();
61 |                     writeln!(err, "trace: {}", record.args()).unwrap();
62 |                     err.reset().ok();
63 |                 }
64 |             }
65 | 
66 |             err.flush().unwrap();
67 |         }
68 |     }
69 | }
70 | 
71 | /// Initializes the global logger with a given level filter.
72 | pub fn init(level: LogLevelFilter) -> Result<(), SetLoggerError> {
73 |     set_logger(|max_log_level| {
74 |         max_log_level.set(level);
75 |         Box::new(Logger(level))
76 |     })
77 | }
78 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
  1 | extern crate getopts;
  2 | extern crate glob;
  3 | extern crate hyper;
  4 | extern crate json;
  5 | #[macro_use]
  6 | extern crate log;
  7 | extern crate lua;
  8 | extern crate num_cpus;
  9 | extern crate regex;
 10 | extern crate term;
 11 | 
 12 | use getopts::Options;
 13 | use runner::Runner;
 14 | use std::env;
 15 | use std::path;
 16 | use std::process;
 17 | 
 18 | mod graph;
 19 | mod logger;
 20 | mod modules;
 21 | mod rule;
 22 | mod runner;
 23 | mod runtime;
 24 | mod task;
 25 | 
 26 | 
 27 | const ROTE_VERSION: &'static str = env!("CARGO_PKG_VERSION");
 28 | 
 29 | 
 30 | /// Prints the program usage to the console.
 31 | fn print_usage(options: Options) {
 32 |     let short_usage = options.short_usage("rote");
 33 | 
 34 |     println!("
 35 |    ▄████████  ▄██████▄      ███        ▄████████
 36 |   ███    ███ ███    ███ ▀█████████▄   ███    ███
 37 |   ███    ███ ███    ███    ▀███▀▀██   ███    █▀
 38 |  ▄███▄▄▄▄██▀ ███    ███     ███   ▀  ▄███▄▄▄
 39 | ▀▀███▀▀▀▀▀   ███    ███     ███     ▀▀███▀▀▀
 40 | ▀███████████ ███    ███     ███       ███    █▄
 41 |   ███    ███ ███    ███     ███       ███    ███
 42 |   ███    ███  ▀██████▀     ▄████▀     ██████████
 43 |   ███    ███
 44 | 
 45 | {}
 46 | Report issues at <https://github.com/sagebind/rote/issues>.
 47 | Rote home page: <https://github.com/sagebind/rote>"
 48 |     , options.usage(&short_usage));
 49 | }
 50 | 
 51 | /// Parses command-line options and runs retest.
 52 | fn main() {
 53 |     let args: Vec<String> = env::args().collect();
 54 | 
 55 |     // Parse command-line flags.
 56 |     let mut options = Options::new();
 57 |     options.optflag("B", "run-all", "Unconditionally run all tasks, including those up-to-date.");
 58 |     options.optopt("C", "directory", "Change to DIRECTORY before running tasks.", "DIRECTORY");
 59 |     options.optmulti("D", "var", "Override a variable value.", "NAME=VALUE");
 60 |     options.optopt("f", "file", "Read FILE as the Rotefile.", "FILE");
 61 |     options.optflag("h", "help", "Print this help message and exit.");
 62 |     options.optmulti("I", "include-path", "Include PATH in the search path for modules.", "PATH");
 63 |     options.optopt("j", "jobs", "The number of jobs to run simultaneously.", "N");
 64 |     options.optflag("k", "keep-going", "Keep going if some tasks fail.");
 65 |     options.optflag("l", "list", "List all tasks and exit.");
 66 |     options.optflag("n", "dry-run", "Simulate running tasks without executing them.");
 67 |     options.optflag("q", "quiet", "Supress all non-task output.");
 68 |     options.optflagmulti("v", "verbose", "Enable verbose logging.");
 69 |     options.optflag("V", "version", "Print the program version and exit.");
 70 | 
 71 |     let matches = options.parse(&args[1..]).unwrap_or_else(|err| {
 72 |         logger::init(logger::Filter::Error).unwrap();
 73 |         error!("{}", err);
 74 |         process::exit(2);
 75 |     });
 76 | 
 77 |     // Set the logging verbosity level.
 78 |     logger::init(if matches.opt_present("quiet") {
 79 |         logger::Filter::Error
 80 |     } else {
 81 |         match matches.opt_count("verbose") {
 82 |             0 => logger::Filter::Info,
 83 |             1 => logger::Filter::Debug,
 84 |             _ => logger::Filter::Trace,
 85 |         }
 86 |     }).unwrap();
 87 | 
 88 |     // Notify the user if higher vebosity has been achieved.
 89 |     debug!("debug messages turned on");
 90 |     trace!("trace messages turned on");
 91 | 
 92 |     // If the help flag is present show the usage message.
 93 |     if matches.opt_present("help") {
 94 |         print_usage(options);
 95 |         return;
 96 |     }
 97 | 
 98 |     // If the version flag is present, show the program version.
 99 |     if matches.opt_present("version") {
100 |         println!("Rote {}", ROTE_VERSION);
101 |         return;
102 |     }
103 | 
104 |     // If the directory flag is present, change directories first.
105 |     if let Some(directory) = matches.opt_str("directory") {
106 |         if env::set_current_dir(&directory).is_err() {
107 |             error!("failed to change directory to '{}'", &directory);
108 |             process::exit(1);
109 |         }
110 |     }
111 | 
112 |     // Get the full path of the Rotefile to run.
113 |     let filename = matches.opt_str("file").unwrap_or("Rotefile".to_string());
114 |     let path = path::Path::new(&filename)
115 |         .canonicalize()
116 |         .unwrap_or_else(|_| {
117 |             error!("the path '{}' is not a file or is not readable", filename);
118 |             process::exit(1);
119 |         });
120 | 
121 |     // Create a new task runner.
122 |     let mut runner = Runner::new(path).unwrap_or_else(|e| {
123 |         error!("{}", e);
124 |         process::exit(1);
125 |     });
126 | 
127 |     info!("build file: {}", runner.path().to_string_lossy());
128 | 
129 |     // Set the new current directory to the directory containing the Rotefile.
130 |     if env::set_current_dir(runner.directory()).is_err() {
131 |         error!("failed to change directory to '{}'", runner.directory().to_string_lossy());
132 |         process::exit(1);
133 |     }
134 | 
135 |     // Set project-local and global include path.
136 |     runner.include_path("./rote");
137 |     runner.include_path("/usr/lib/rote/plugins");
138 | 
139 |     // User-specified paths.
140 |     for value in matches.opt_strs("include-path") {
141 |         runner.include_path(value);
142 |     }
143 | 
144 |     // Set environment variables.
145 |     for value in matches.opt_strs("var") {
146 |         let parts: Vec<_> = value.split('=').collect();
147 | 
148 |         if parts.len() != 2 {
149 |             warn!("invalid variable syntax: '{}'", value);
150 |         } else {
151 |             runner.set_var(parts[0], parts[1]);
152 |         }
153 |     }
154 | 
155 |     // Toggle dry run.
156 |     if matches.opt_present("dry-run") {
157 |         info!("dry run is enabled; no task actions will be run");
158 |         runner.dry_run();
159 |     }
160 | 
161 |     // Toggle always run.
162 |     if matches.opt_present("run-all") {
163 |         info!("running all tasks unconditionally");
164 |         runner.always_run();
165 |     }
166 | 
167 |     // Toggle keep going.
168 |     if matches.opt_present("keep-going") {
169 |         info!("errors will be ignored");
170 |         runner.keep_going();
171 |     }
172 | 
173 |     // Set number of jobs.
174 |     if let Some(jobs) = matches.opt_str("jobs") {
175 |         if let Ok(jobs) = jobs.parse::<usize>() {
176 |             runner.jobs(jobs);
177 |         } else {
178 |             warn!("invalid number of jobs");
179 |         }
180 |     }
181 | 
182 |     // Load the script.
183 |     if let Err(e) = runner.load() {
184 |         error!("{}", e);
185 |         process::exit(1);
186 |     }
187 | 
188 |     // List all tasks instead of running one.
189 |     if matches.opt_present("list") {
190 |         runner.print_task_list();
191 |         return;
192 |     }
193 | 
194 |     // Get all of the tasks to run.
195 |     let tasks = matches.free;
196 | 
197 |     // Run the specified task, or the default if none is specified.
198 |     if let Err(e) = {
199 |         if tasks.is_empty() {
200 |             runner.run_default()
201 |         } else {
202 |             // Run the specified tasks.
203 |             runner.run(&tasks)
204 |         }
205 |     } {
206 |         error!("{}", e);
207 |         process::exit(1);
208 |     }
209 | }
210 | 


--------------------------------------------------------------------------------
/src/modules/cpp.lua:
--------------------------------------------------------------------------------
 1 | -- Module for generating C/C++ build tasks.
 2 | local cpp = {}
 3 | 
 4 | 
 5 | function cpp.binary(options)
 6 |     options = rote.merge({
 7 |         standard = "c++11",
 8 |         debug = true,
 9 |         includes = {},
10 |         opt_level = 0,
11 |         macros = {},
12 |     }, options)
13 | 
14 |     if not options.name then
15 |         error("name must be specified")
16 |     end
17 | 
18 |     if not options.srcs then
19 |         error("srcs must be specified")
20 |     end
21 | 
22 |     local compiler = CC or "g++"
23 |     local linker = CC or "g++"
24 | 
25 |     local compiler_flags = {"-Wall", "--std=" .. string.lower(options.standard)}
26 |     local linker_flags = {}
27 | 
28 |     -- Add include paths.
29 |     for _, include in ipairs(options.includes) do
30 |         table.insert(compiler_flags, "-I" .. include)
31 |     end
32 | 
33 |     if options.debug then
34 |         table.insert(compiler_flags, "-g")
35 |     end
36 | 
37 |     -- Set optimization level.
38 |     table.insert(compiler_flags, ("-O%d"):format(options.opt_level))
39 |     table.insert(linker_flags, ("-O%d"):format(options.opt_level))
40 | 
41 |     -- Pass all macro definitions to the preprocessor. Macros will be set to `1`
42 |     -- if given as a truthy, non-string value.
43 |     for macro, def in ipairs(options.macros) do
44 |         if type(def) == "string" then
45 |             table.insert(compiler_flags, "-D" .. macro .. "=" .. def)
46 |         elseif def then
47 |             table.insert(compiler_flags, "-D" .. macro)
48 |         end
49 |     end
50 | 
51 |     -- Create individual rules for each source file.
52 |     local object_files = {}
53 |     for i, file in ipairs(options.srcs) do
54 |         local object_file = file .. ".o"
55 |         table.insert(object_files, object_file)
56 | 
57 |         rote.create_rule(object_file, function(object_file)
58 |             local args = {}
59 |             for _, flag in ipairs(compiler_flags) do
60 |                 table.insert(args, flag)
61 |             end
62 |             table.insert(args, "-c")
63 |             table.insert(args, "-o")
64 |             table.insert(args, object_file)
65 |             table.insert(args, file)
66 | 
67 |             exec(compiler, table.unpack(args))
68 |         end)
69 |     end
70 | 
71 |     -- Create a rule for the final binary.
72 |     rote.create_rule(options.name, object_files, function(name)
73 |         local args = {}
74 |         for _, flag in ipairs(linker_flags) do
75 |             table.insert(args, flag)
76 |         end
77 |         table.insert(args, "-o")
78 |         table.insert(args, name)
79 |         for _, object_file in ipairs(object_files) do
80 |             table.insert(args, object_file)
81 |         end
82 | 
83 |         exec(linker, table.unpack(args))
84 |     end)
85 | end
86 | 
87 | 
88 | return cpp
89 | 


--------------------------------------------------------------------------------
/src/modules/cpp.rs:
--------------------------------------------------------------------------------
 1 | use runtime::{Runtime, ScriptResult};
 2 | 
 3 | const SOURCE: &'static str = include_str!("cpp.lua");
 4 | 
 5 | 
 6 | /// Module loader.
 7 | pub fn load(runtime: Runtime) -> ScriptResult {
 8 |     try!(runtime.eval(SOURCE));
 9 | 
10 |     Ok(1)
11 | }
12 | 


--------------------------------------------------------------------------------
/src/modules/fs.rs:
--------------------------------------------------------------------------------
  1 | use runtime::{Runtime, ScriptResult};
  2 | use std::fs;
  3 | use std::fs::{File, OpenOptions};
  4 | use std::io::prelude::*;
  5 | 
  6 | 
  7 | /// Checks if a file exists and is readable.
  8 | ///
  9 | /// # Lua arguments
 10 | /// * `path: string`            - Path to the file to check.
 11 | fn exists(runtime: Runtime) -> ScriptResult {
 12 |     let path = runtime.state().check_string(1).to_string();
 13 | 
 14 |     runtime.state().push_bool(fs::metadata(path).is_ok());
 15 | 
 16 |     Ok(1)
 17 | }
 18 | 
 19 | /// Checks if a given path is a directory.
 20 | ///
 21 | /// # Lua arguments
 22 | /// * `path: string`            - Path to check.
 23 | fn is_dir(runtime: Runtime) -> ScriptResult {
 24 |     let path = runtime.state().check_string(1).to_string();
 25 | 
 26 |     let metadata = fs::metadata(path);
 27 |     runtime.state().push_bool(metadata.is_ok() && metadata.unwrap().file_type().is_dir());
 28 | 
 29 |     Ok(1)
 30 | }
 31 | 
 32 | /// Checks if a given path is a file.
 33 | ///
 34 | /// # Lua arguments
 35 | /// * `path: string`            - Path to check.
 36 | fn is_file(runtime: Runtime) -> ScriptResult {
 37 |     let path = runtime.state().check_string(1).to_string();
 38 | 
 39 |     let metadata = fs::metadata(path);
 40 |     runtime.state().push_bool(metadata.is_ok() && metadata.unwrap().file_type().is_file());
 41 | 
 42 |     Ok(1)
 43 | }
 44 | 
 45 | /// Checks if a given path is a symbolic link.
 46 | ///
 47 | /// # Lua arguments
 48 | /// * `path: string`            - Path to check.
 49 | fn is_symlink(runtime: Runtime) -> ScriptResult {
 50 |     let path = runtime.state().check_string(1).to_string();
 51 | 
 52 |     let metadata = fs::metadata(path);
 53 |     runtime.state().push_bool(metadata.is_ok() && metadata.unwrap().file_type().is_symlink());
 54 | 
 55 |     Ok(1)
 56 | }
 57 | 
 58 | /// Creates a directory.
 59 | ///
 60 | /// # Lua arguments
 61 | /// * `path: string`            - Path to create the directory.
 62 | fn mkdir(runtime: Runtime) -> ScriptResult {
 63 |     // Get the path as the first argument.
 64 |     let path = runtime.state().check_string(1).to_string();
 65 | 
 66 |     if fs::create_dir(&path).is_err() {
 67 |         return Err(format!("failed to create directory \"{}\"", path).into());
 68 |     }
 69 | 
 70 |     Ok(0)
 71 | }
 72 | 
 73 | /// Copies a file to another location.
 74 | ///
 75 | /// # Lua arguments
 76 | /// * `source: string`          - Path of the file to copy.
 77 | /// * `dest: string`            - Path to copy the file to.
 78 | fn copy(runtime: Runtime) -> ScriptResult {
 79 |     let source = runtime.state().check_string(1).to_string();
 80 |     let dest = runtime.state().check_string(2).to_string();
 81 | 
 82 |     if fs::copy(&source, dest).is_err() {
 83 |         return Err(format!("failed to copy \"{}\"", source).into());
 84 |     }
 85 | 
 86 |     Ok(0)
 87 | }
 88 | 
 89 | /// Moves a file from one name to another.
 90 | ///
 91 | /// # Lua arguments
 92 | /// * `source: string`          - Path of the file to move.
 93 | /// * `dest: string`            - Path to move the file to.
 94 | fn rename(runtime: Runtime) -> ScriptResult {
 95 |     let source = runtime.state().check_string(1).to_string();
 96 |     let destination = runtime.state().check_string(2).to_string();
 97 | 
 98 |     if fs::rename(source, destination).is_err() {
 99 |         return Err("no such file or directory".into());
100 |     }
101 | 
102 |     Ok(0)
103 | }
104 | 
105 | /// Removes a file or empty directory.
106 | ///
107 | /// # Lua arguments
108 | /// * `path: string`            - Path of the file or directory to remove.
109 | fn remove(runtime: Runtime) -> ScriptResult {
110 |     let path = runtime.state().check_string(1).to_string();
111 | 
112 |     if let Ok(metadata) = fs::metadata(&path) {
113 |         if metadata.file_type().is_dir() {
114 |             if fs::remove_dir_all(path).is_err() {
115 |                 return Err("failed to remove directory".into());
116 |             }
117 |         } else {
118 |             if fs::remove_file(path).is_err() {
119 |                 return Err("failed to remove file".into());
120 |             }
121 |         }
122 |     }
123 | 
124 |     Ok(0)
125 | }
126 | 
127 | /// Reads an entire file and returns its contents.
128 | ///
129 | /// # Lua arguments
130 | /// * `path: string`            - Path of the file to read from.
131 | fn get(runtime: Runtime) -> ScriptResult {
132 |     let path = runtime.state().check_string(1).to_string();
133 | 
134 |     let file = File::open(path);
135 | 
136 |     if file.is_err() {
137 |         return Err("failed to open file".into());
138 |     }
139 | 
140 |     let mut file = file.unwrap();
141 |     let mut buffer = String::new();
142 | 
143 |     if file.read_to_string(&mut buffer).is_err() {
144 |         return Err("failed to read file".into());
145 |     }
146 | 
147 |     runtime.state().push_string(&buffer);
148 | 
149 |     Ok(1)
150 | }
151 | 
152 | /// Puts a string into the contents of a file.
153 | ///
154 | /// # Lua arguments
155 | /// * `path: string`            - Path to the file to write to.
156 | /// * `contents: string`        - The contents to write.
157 | fn put(runtime: Runtime) -> ScriptResult {
158 |     let path = runtime.state().check_string(1).to_string();
159 |     let contents = String::from(runtime.state().check_string(2));
160 | 
161 |     let file = OpenOptions::new()
162 |                    .write(true)
163 |                    .truncate(true)
164 |                    .create(true)
165 |                    .open(path);
166 | 
167 |     if file.is_err() {
168 |         return Err("failed to open file".into());
169 |     }
170 | 
171 |     let mut file = file.unwrap();
172 |     if file.write_all(contents.as_bytes()).is_err() {
173 |         return Err("failed to write to file".into());
174 |     }
175 | 
176 |     Ok(0)
177 | }
178 | 
179 | /// Appends a string to the end of the contents of a file.
180 | ///
181 | /// # Lua arguments
182 | /// * `path: string`            - Path to the file to append to.
183 | /// * `contents: string`        - The contents to append.
184 | fn append(runtime: Runtime) -> ScriptResult {
185 |     let path = runtime.state().check_string(1).to_string();
186 |     let contents = String::from(runtime.state().check_string(2));
187 | 
188 |     let file = OpenOptions::new()
189 |                    .write(true)
190 |                    .append(true)
191 |                    .open(path);
192 | 
193 |     if file.is_err() {
194 |         return Err("failed to open file".into());
195 |     }
196 | 
197 |     let mut file = file.unwrap();
198 |     if file.write_all(contents.as_bytes()).is_err() {
199 |         return Err("failed to write to file".into());
200 |     }
201 | 
202 |     Ok(0)
203 | }
204 | 
205 | /// Combines the contents of two or more files into a new, single file.
206 | ///
207 | /// # Lua arguments
208 | /// * `sources: table`          - A list of source files to combine.
209 | /// * `dest: string`            - The path to the output file.
210 | fn combine(runtime: Runtime) -> ScriptResult {
211 |     if !runtime.state().is_table(1) {
212 |         return Err("first argument must be a table".into());
213 |     }
214 | 
215 |     // Open the output file for writing.
216 |     let dest = runtime.state().check_string(2).to_string();
217 |     let out_file = OpenOptions::new()
218 |                        .write(true)
219 |                        .truncate(true)
220 |                        .create(true)
221 |                        .open(&dest);
222 | 
223 |     if out_file.is_err() {
224 |         return Err(format!("failed to open file \"{}\"", dest).into());
225 |     }
226 | 
227 |     let mut out_file = out_file.unwrap();
228 | 
229 |     // Walk through each path in the sources table and write their contents.
230 |     for (_, value) in runtime.iter(1) {
231 |         let source = runtime.state().to_str_in_place(value).unwrap().to_string();
232 | 
233 |         let in_file = File::open(&source);
234 |         if in_file.is_err() {
235 |             return Err(format!("failed to open file \"{}\"", source).into());
236 |         }
237 | 
238 |         // Read the source file's contents.
239 |         let mut in_file = in_file.unwrap();
240 |         let mut buffer = String::new();
241 | 
242 |         if in_file.read_to_string(&mut buffer).is_err() {
243 |             return Err(format!("failed to read file \"{}\"", source).into());
244 |         }
245 | 
246 |         // Write the source file contents into the output file.
247 |         if out_file.write_all(buffer.as_bytes()).is_err() {
248 |             return Err(format!("failed to write to file \"{}\"", dest).into());
249 |         }
250 |     }
251 | 
252 |     Ok(0)
253 | }
254 | 
255 | /// Module loader.
256 | pub fn load(runtime: Runtime) -> ScriptResult {
257 |     runtime.load_lib(&[
258 |         ("exists", exists),
259 |         ("is_dir", is_dir),
260 |         ("is_file", is_file),
261 |         ("is_symlink", is_symlink),
262 |         ("mkdir", mkdir),
263 |         ("copy", copy),
264 |         ("rename", rename),
265 |         ("remove", remove),
266 |         ("get", get),
267 |         ("put", put),
268 |         ("append", append),
269 |         ("combine", combine)
270 |     ]);
271 | 
272 |     Ok(1)
273 | }
274 | 


--------------------------------------------------------------------------------
/src/modules/http.rs:
--------------------------------------------------------------------------------
 1 | use hyper::client::Client;
 2 | use runtime::{Runtime, ScriptResult};
 3 | use std::io::Read;
 4 | 
 5 | 
 6 | /// Sends an HTTP GET request and returns the response.
 7 | fn get(runtime: Runtime) -> ScriptResult {
 8 |     let url = runtime.state().check_string(1).to_string();
 9 |     let client = Client::new();
10 | 
11 |     // Send the request.
12 |     let mut response = try!(client.get(&url).send());
13 | 
14 |     // Return the response text and the status code.
15 |     let mut body = String::new();
16 |     try!(response.read_to_string(&mut body));
17 |     runtime.state().push(body);
18 |     runtime.state().push(response.status.to_u16() as f64);
19 | 
20 |     Ok(2)
21 | }
22 | 
23 | /// Sends an HTTP POST request with a body and returns the response.
24 | fn post(runtime: Runtime) -> ScriptResult {
25 |     let url = runtime.state().check_string(1).to_string();
26 |     let client = Client::new();
27 | 
28 |     // Get the request body.
29 |     let request_body = runtime.state().to_str(2).unwrap_or("").to_string();
30 | 
31 |     // Send the request.
32 |     let mut response = try!(client.post(&url).body(&request_body).send());
33 | 
34 |     // Return the response text and the status code.
35 |     let mut response_body = String::new();
36 |     try!(response.read_to_string(&mut response_body));
37 |     runtime.state().push(response_body);
38 |     runtime.state().push(response.status.to_u16() as f64);
39 | 
40 |     Ok(2)
41 | }
42 | 
43 | pub fn load(runtime: Runtime) -> ScriptResult {
44 |     runtime.load_lib(&[
45 |         ("get", get),
46 |         ("post", post),
47 |     ]);
48 | 
49 |     Ok(1)
50 | }
51 | 


--------------------------------------------------------------------------------
/src/modules/java.lua:
--------------------------------------------------------------------------------
 1 | -- Module for Java build tasks.
 2 | local java = {}
 3 | 
 4 | 
 5 | function java.binary(options)
 6 |     options = rote.merge({
 7 |         dest = ".",
 8 |         paths = {"."},
 9 |         warnings = true,
10 |         debug = true,
11 |         compiler = "javac",
12 |         encoding = "utf-8",
13 |         mainClass = "Main"
14 |     }, options)
15 | 
16 |     local compiler_flags = {
17 |         "-verbose",
18 |         "-encoding", options.encoding,
19 |         "-cp", table.concat(options.paths, ":"),
20 |         "-d", options.dest
21 |     }
22 | 
23 |     if not options.warnings then
24 |         table.insert(compiler_flags, "-nowarn")
25 |     end
26 | 
27 |     if options.debug then
28 |         table.insert(compiler_flags, "-g")
29 |     else
30 |         table.insert(compiler_flags, "-g:none")
31 |     end
32 | 
33 |     for i, file in ipairs(glob(options.srcs)) do
34 |         table.insert(compiler_flags, file)
35 |     end
36 | 
37 |     exec(options.compiler .. " " .. table.concat(compiler_flags, " "))
38 | end
39 | 
40 | function java.jar(options)
41 |     local options = core.options(options, {
42 |         out = "out.jar",
43 |         main_class = "org.myapp.Main",
44 |         manifest = false
45 |     })
46 | 
47 |     local jar_flags = {"-c", "-v", "-f", options.out}
48 | 
49 |     if options.mainClass then
50 |         table.insert(jar_flags, "-e")
51 |         table.insert(jar_flags, options.mainClass)
52 |     end
53 | 
54 |     if options.manifest then
55 |         table.insert(jar_flags, "-m")
56 |         table.insert(jar_flags, options.manifest)
57 |     end
58 | 
59 |     exec("jar " .. table.concat(jar_flags, " ") .. options.srcs)
60 | end
61 | 
62 | 
63 | return java
64 | 


--------------------------------------------------------------------------------
/src/modules/java.rs:
--------------------------------------------------------------------------------
 1 | use runtime::{Runtime, ScriptResult};
 2 | 
 3 | const SOURCE: &'static str = include_str!("java.lua");
 4 | 
 5 | 
 6 | /// Module loader.
 7 | pub fn load(runtime: Runtime) -> ScriptResult {
 8 |     try!(runtime.eval(SOURCE));
 9 | 
10 |     Ok(1)
11 | }
12 | 


--------------------------------------------------------------------------------
/src/modules/json.rs:
--------------------------------------------------------------------------------
  1 | use json::{self, JsonValue};
  2 | use lua;
  3 | use runtime::{Runtime, ScriptResult};
  4 | use std::error::Error;
  5 | 
  6 | 
  7 | fn parse(runtime: Runtime) -> ScriptResult {
  8 |     fn push_value(runtime: &Runtime, value: &JsonValue) {
  9 |         match value {
 10 |             &JsonValue::Null => {
 11 |                 runtime.state().push_nil();
 12 |             },
 13 |             &JsonValue::Short(_) | &JsonValue::String(_) => {
 14 |                 runtime.state().push_string(value.as_str().unwrap());
 15 |             },
 16 |             &JsonValue::Number(_) => {
 17 |                 runtime.state().push_number(value.as_f64().unwrap());
 18 |             },
 19 |             &JsonValue::Boolean(value) => {
 20 |                 runtime.state().push_bool(value);
 21 |             },
 22 |             &JsonValue::Object(_) => {
 23 |                 runtime.state().new_table();
 24 | 
 25 |                 for (key, value) in value.entries() {
 26 |                     runtime.state().push_string(key);
 27 |                     push_value(runtime, value);
 28 |                     runtime.state().set_table(-3);
 29 |                 }
 30 |             },
 31 |             &JsonValue::Array(_) => {
 32 |                 runtime.state().new_table();
 33 | 
 34 |                 let mut index = 1;
 35 |                 for value in value.members() {
 36 |                     runtime.state().push_number(index as f64);
 37 |                     push_value(runtime, value);
 38 |                     runtime.state().set_table(-3);
 39 | 
 40 |                     index += 1;
 41 |                 }
 42 |             },
 43 |         }
 44 |     }
 45 | 
 46 |     let source = runtime.state().check_string(1).to_string();
 47 |     let value = try!(json::parse(&source));
 48 |     push_value(&runtime, &value);
 49 | 
 50 |     Ok(1)
 51 | }
 52 | 
 53 | fn stringify(runtime: Runtime) -> ScriptResult {
 54 |     fn to_json(runtime: &Runtime, index: i32) -> Result<JsonValue, Box<Error>> {
 55 |         let lua_type = runtime.state().type_of(index);
 56 | 
 57 |         match lua_type {
 58 |             Some(lua::Type::Nil) | None => Ok(JsonValue::Null),
 59 |             Some(lua::Type::Boolean) => Ok(runtime.state().to_bool(index).into()),
 60 |             Some(lua::Type::Number) => Ok(runtime.state().to_number(index).into()),
 61 |             Some(lua::Type::String) => Ok(runtime.state().to_str_in_place(index).into()),
 62 |             Some(lua::Type::Table) => {
 63 |                 // If the table contains only sequential numeric keys, we need to create an array instead. To do this
 64 |                 // in one pass, we will fill up an object and an array simultaneously, then determine which one to
 65 |                 // return at the end.
 66 |                 let mut object = JsonValue::new_object();
 67 |                 let mut array = JsonValue::new_array();
 68 |                 let mut is_array = true;
 69 |                 let mut array_index = 1;
 70 | 
 71 |                 for (key, value) in runtime.iter(index) {
 72 |                     // Check for sequential numeric keys.
 73 |                     if !runtime.state().is_number(key) || runtime.state().to_number(key) as i32 != array_index {
 74 |                         is_array = false;
 75 |                     }
 76 | 
 77 |                     let value = try!(to_json(runtime, value));
 78 | 
 79 |                     // Insert into the array if there is still hope for it being an indexed table.
 80 |                     if is_array {
 81 |                         try!(array.push(value.clone()));
 82 |                         array_index += 1;
 83 |                     }
 84 | 
 85 |                     // Insert into the object.
 86 |                     let key = runtime.state().to_str(key).unwrap().to_string();
 87 |                     runtime.state().pop(1);
 88 |                     object[key] = value;
 89 |                 }
 90 | 
 91 |                 Ok(if is_array {
 92 |                     array
 93 |                 } else {
 94 |                     object
 95 |                 })
 96 |             },
 97 |             _ => {
 98 |                 Err(format!("cannot convert {} to JSON", runtime.state().typename_of(lua_type.unwrap_or(lua::Type::None))).into())
 99 |             },
100 |         }
101 |     }
102 | 
103 |     let value = try!(to_json(&runtime, 1));
104 |     let string = if runtime.state().to_bool(2) {
105 |         let spaces = if runtime.state().get_top() >= 3 {
106 |             runtime.state().check_number(3) as u16
107 |         } else {
108 |             4
109 |         };
110 | 
111 |         json::stringify_pretty(value, spaces)
112 |     } else {
113 |         json::stringify(value)
114 |     };
115 |     runtime.state().push_string(&string);
116 | 
117 |     Ok(1)
118 | }
119 | 
120 | pub fn load(runtime: Runtime) -> ScriptResult {
121 |     runtime.load_lib(&[
122 |         ("parse", parse),
123 |         ("stringify", stringify),
124 |     ]);
125 | 
126 |     Ok(1)
127 | }
128 | 


--------------------------------------------------------------------------------
/src/modules/mod.rs:
--------------------------------------------------------------------------------
 1 | use runtime::Runtime;
 2 | 
 3 | pub mod cpp;
 4 | pub mod http;
 5 | pub mod fs;
 6 | pub mod java;
 7 | pub mod json;
 8 | pub mod stdlib;
 9 | 
10 | 
11 | pub fn register_all(runtime: &Runtime) {
12 |     self::stdlib::load(runtime.clone());
13 |     runtime.register_lib("cpp", self::cpp::load);
14 |     runtime.register_lib("http", self::http::load);
15 |     runtime.register_lib("fs", self::fs::load);
16 |     runtime.register_lib("java", self::java::load);
17 |     runtime.register_lib("json", self::json::load);
18 | }
19 | 


--------------------------------------------------------------------------------
/src/modules/stdlib.rs:
--------------------------------------------------------------------------------
  1 | use glob;
  2 | use lua;
  3 | use regex::{Captures, Regex};
  4 | use rule::Rule;
  5 | use runtime::{Runtime, ScriptResult};
  6 | use std::env;
  7 | use std::io::prelude::*;
  8 | use std::path::PathBuf;
  9 | use std::process::{Command, Stdio};
 10 | use std::str;
 11 | use task::NamedTask;
 12 | 
 13 | 
 14 | /// Expands global and environment variables inside a given string.
 15 | pub fn expand_string(input: &str, runtime: Runtime) -> String {
 16 |     // Replace anything that looks like a variable expansion.
 17 |     let pattern = Regex::new(r"\$(\w+)").unwrap();
 18 | 
 19 |     pattern.replace_all(input, |caps: &Captures| {
 20 |         let name = caps.at(1).unwrap_or("");
 21 | 
 22 |         // Attempt to match a variable definition, or fallback to an empty string.
 23 |         runtime.state().get_global(name);
 24 |         let value = runtime.state().to_str_in_place(-1).unwrap_or("").to_string();
 25 |         runtime.state().pop(1);
 26 | 
 27 |         value
 28 |     })
 29 | }
 30 | 
 31 | fn get_next_description(runtime: Runtime) -> Option<String> {
 32 |     runtime.reg_get("rote.nextDescription");
 33 | 
 34 |     let result = if runtime.state().is_string(-1) {
 35 |         Some(runtime.state().check_string(-1).to_string())
 36 |     } else {
 37 |         None
 38 |     };
 39 | 
 40 |     runtime.state().pop(1);
 41 |     runtime.state().push_nil();
 42 |     runtime.reg_set("rote.nextDescription");
 43 | 
 44 |     result
 45 | }
 46 | 
 47 | 
 48 | /// Sets the current working directory.
 49 | fn change_dir(runtime: Runtime) -> ScriptResult {
 50 |     let path = runtime.state().check_string(1).to_string();
 51 | 
 52 |     if env::set_current_dir(path).is_err() {
 53 |         Err("failed to change directory".into())
 54 |     } else {
 55 |         Ok(0)
 56 |     }
 57 | }
 58 | 
 59 | /// Defines a new rule.
 60 | ///
 61 | /// # Lua arguments
 62 | /// * `pattern: string`      - The name of the task.
 63 | /// * `description: string`  - A description of the task. (Optional)
 64 | /// * `dependencies: table`  - A list of task names that the rule depends on. (Optional)
 65 | /// * `func: function`       - A function that should be called when the rule is run. (Optional)
 66 | fn create_rule(runtime: Runtime) -> ScriptResult {
 67 |     let pattern = runtime.state().check_string(1).to_string();
 68 |     let mut func_index = 3;
 69 | 
 70 |     // Get the list of dependencies if given.
 71 |     let deps = if runtime.state().type_of(2) == Some(lua::Type::Table) {
 72 |         runtime.iter(2)
 73 |             .map(|(_, value)| runtime.state().to_str_in_place(value).unwrap().to_string())
 74 |             .collect()
 75 |     } else {
 76 |         func_index -= 1;
 77 |         Vec::new()
 78 |     };
 79 | 
 80 |     // Get the task function if given.
 81 |     runtime.state().push_value(func_index);
 82 |     let func = if runtime.state().type_of(-1) == Some(lua::Type::Function) {
 83 |         // Get a portable reference to the task function.
 84 |         Some(runtime.state().reference(lua::REGISTRYINDEX))
 85 |     } else {
 86 |         runtime.state().pop(1);
 87 |         None
 88 |     };
 89 | 
 90 |     let closure_env = runtime.clone();
 91 |     let callback = func.map(|func| {
 92 |         move |name: &str| {
 93 |             // Get the function reference onto the Lua stack.
 94 |             closure_env.state().raw_geti(lua::REGISTRYINDEX, func.value() as i64);
 95 | 
 96 |             // Push the synthesized name onto the stack.
 97 |             closure_env.state().push(name);
 98 | 
 99 |             // Invoke the task function.
100 |             closure_env.environment().set_current_task(name);
101 |             let result = closure_env.call(1, 0, 0).map(|_| ()).map_err(|e| e.into());
102 |             closure_env.environment().clear_current_task();
103 | 
104 |             result
105 |         }
106 |     });
107 | 
108 |     runtime.environment().create_rule(Rule::new(pattern, deps, callback));
109 |     Ok(0)
110 | }
111 | 
112 | /// Creates a new task.
113 | ///
114 | /// # Lua arguments
115 | /// * `name: string`         - The name of the task.
116 | /// * `description: string`  - A description of the task. (Optional)
117 | /// * `dependencies: table`  - A list of task names that the task depends on. (Optional)
118 | /// * `func: function`       - A function that should be called when the task is run.
119 | fn create_task(runtime: Runtime) -> ScriptResult {
120 |     let name = runtime.state().check_string(1).to_string();
121 |     let desc = get_next_description(runtime.clone());
122 |     let mut func_index = 3;
123 | 
124 |     // Get the list of dependencies if given.
125 |     let deps = if runtime.state().type_of(2) == Some(lua::Type::Table) {
126 |         runtime.iter(2)
127 |             .map(|(_, value)| runtime.state().to_str_in_place(value).unwrap().to_string())
128 |             .collect()
129 |     } else {
130 |         func_index -= 1;
131 |         Vec::new()
132 |     };
133 | 
134 |     // Get the task function if given.
135 |     runtime.state().push_value(func_index);
136 |     let func = if runtime.state().type_of(-1) == Some(lua::Type::Function) {
137 |         // Get a portable reference to the task function.
138 |         Some(runtime.state().reference(lua::REGISTRYINDEX))
139 |     } else {
140 |         runtime.state().pop(1);
141 |         None
142 |     };
143 | 
144 |     let closure_env = runtime.clone();
145 |     let later_name = name.clone();
146 |     let callback = func.map(|func| {
147 |         move || {
148 |             // Get the function reference onto the Lua stack.
149 |             closure_env.state().raw_geti(lua::REGISTRYINDEX, func.value() as i64);
150 | 
151 |             // Invoke the task function.
152 |             let name = name.clone();
153 |             closure_env.environment().set_current_task(name);
154 |             let result = closure_env.call(0, 0, 0).map(|_| ()).map_err(|e| e.into());
155 |             closure_env.environment().clear_current_task();
156 | 
157 |             result
158 |         }
159 |     });
160 | 
161 |     runtime.environment().create_task(NamedTask::new(later_name, desc, deps, callback));
162 |     Ok(0)
163 | }
164 | 
165 | /// Gets the current working directory.
166 | fn current_dir(runtime: Runtime) -> ScriptResult {
167 |     Ok(env::current_dir()
168 |         .map(|dir| {
169 |             runtime.state().push(dir.to_str());
170 |             1
171 |         })
172 |         .unwrap_or(0))
173 | }
174 | 
175 | /// Gets the current Rote executable
176 | fn current_exe(runtime: Runtime) -> ScriptResult {
177 |     Ok(env::current_exe()
178 |         .map(|dir| {
179 |             runtime.state().push(dir.to_str());
180 |             1
181 |         })
182 |         .unwrap_or(0))
183 | }
184 | 
185 | /// Executes a shell command with a given list of arguments.
186 | fn execute(runtime: Runtime) -> ScriptResult {
187 |     // Create a command for the given program name.
188 |     let mut command = Command::new(runtime.state().check_string(1));
189 | 
190 |     // Set the current directory.
191 |     if let Ok(dir) = env::current_dir() {
192 |         command.current_dir(dir);
193 |     }
194 | 
195 |     // For each other parameter given, add it as a shell argument.
196 |     for i in 2..runtime.state().get_top()+1 {
197 |         // Expand each argument as we go.
198 |         command.arg(expand_string(runtime.state().check_string(i), runtime.clone()));
199 |     }
200 | 
201 |     // Spawn the command, capturing its status.
202 |     command.status().map_err(|e| {
203 |         format!("failed to execute process: {}", e).into()
204 |     }).and_then(|status| {
205 |         let status = status.code().unwrap_or(1);
206 | 
207 |         if status > 0 {
208 |             Err("command returned nonzero exit code".into())
209 |         } else {
210 |             runtime.state().push_number(status as f64);
211 |             Ok(1)
212 |         }
213 |     })
214 | }
215 | 
216 | /// Pipes a string into a shell command with a given list of arguments.
217 | fn pipe(runtime: Runtime) -> ScriptResult {
218 |     // Create a command for the given program name.
219 |     let mut command = Command::new(runtime.state().check_string(2));
220 | 
221 |     // Set the current directory.
222 |     if let Ok(dir) = env::current_dir() {
223 |         command.current_dir(dir);
224 |     }
225 | 
226 |     // For each other parameter given, add it as a shell argument.
227 |     for i in 3..runtime.state().get_top()+1 {
228 |         // Expand each argument as we go.
229 |         command.arg(expand_string(runtime.state().check_string(i), runtime.clone()));
230 |     }
231 | 
232 |     // Get the input buffer string, if given.
233 |     let input = if runtime.state().type_of(1) == Some(lua::Type::Nil) {
234 |         command.stdin(Stdio::null());
235 |         None
236 |     } else {
237 |         command.stdin(Stdio::piped());
238 |         Some(runtime.state().check_string(1).to_string())
239 |     };
240 | 
241 |     command.stdout(Stdio::piped());
242 |     command.stderr(Stdio::piped());
243 | 
244 |     // Start running the command process.
245 |     let mut child = match command.spawn() {
246 |         Ok(child) => child,
247 |         Err(e) => return Err(format!("failed to execute process: {}", e).into()),
248 |     };
249 | 
250 |     // Write the input string to the pipe if given.
251 |     if let Some(input) = input {
252 |         if let Err(e) = child.stdin.as_mut().unwrap().write_all(input.as_bytes()) {
253 |             return Err(format!("failed to execute process: {}", e).into());
254 |         }
255 |     }
256 | 
257 |     // Wait for the program to finish and collect the output.
258 |     child.wait_with_output().map_err(|e| {
259 |         format!("failed to execute process: {}", e).into()
260 |     }).and_then(|output| {
261 |         unsafe {
262 |             runtime.state().push_string(str::from_utf8_unchecked(&output.stdout));
263 |             runtime.state().push_string(str::from_utf8_unchecked(&output.stderr));
264 |         }
265 |         runtime.state().push_number(output.status.code().unwrap_or(1) as f64);
266 | 
267 |         Ok(3)
268 |     })
269 | }
270 | 
271 | /// Expands global and environment variables inside a given string.
272 | fn expand(runtime: Runtime) -> ScriptResult {
273 |     // Get the input string.
274 |     let input = runtime.state().check_string(1).to_string();
275 | 
276 |     // Expand the string.
277 |     let result = expand_string(&input, runtime.clone());
278 | 
279 |     // Return the result.
280 |     runtime.state().push_string(&result);
281 |     Ok(1)
282 | }
283 | 
284 | /// Gets the value of an environment variable.
285 | ///
286 | /// # Lua arguments
287 | /// * `key: string` - The variable name.
288 | fn env(runtime: Runtime) -> ScriptResult {
289 |     let key = runtime.state().check_string(1).to_string();
290 | 
291 |     if let Ok(value) = env::var(key) {
292 |         runtime.state().push(value);
293 |     } else {
294 |         runtime.state().push_nil();
295 |     }
296 | 
297 |     Ok(1)
298 | }
299 | 
300 | /// Exports an environment variable.
301 | ///
302 | /// # Lua arguments
303 | /// * `key: string` - The variable name.
304 | /// * `value: string` - The value to set.
305 | fn export(runtime: Runtime) -> ScriptResult {
306 |     let key = runtime.state().check_string(1).to_string();
307 |     let value = runtime.state().check_string(2).to_string();
308 |     let expanded = expand_string(&value, runtime.clone());
309 | 
310 |     env::set_var(key, expanded);
311 |     Ok(0)
312 | }
313 | 
314 | /// Searches for paths matching a pattern.
315 | ///
316 | /// # Lua arguments
317 | /// * `pattern: string` - The glob pattern to match.
318 | fn glob(runtime: Runtime) -> ScriptResult {
319 |     // Get the pattern as the first argument.
320 |     let pattern = runtime.state().check_string(1).to_string();
321 | 
322 |     // Make the pattern absolute if it isn't already.
323 |     let mut full_path = PathBuf::from(pattern);
324 |     if full_path.is_relative() {
325 |         let path = full_path;
326 |         full_path = env::current_dir().unwrap();
327 |         full_path.push(&path);
328 |     }
329 | 
330 |     // Create a table of values to return.
331 |     runtime.state().new_table();
332 | 
333 |     // Get an iterator for the glob result and return a Lua iterator.
334 |     if let Ok(mut iter) = glob::glob(&full_path.to_str().unwrap()) {
335 |         runtime.push_closure(Box::new(move |runtime: Runtime| {
336 |             loop {
337 |                 match iter.next() {
338 |                     Some(Ok(path)) => {
339 |                         // Turn the path into a string.
340 |                         if let Some(path) = path.to_str() {
341 |                             // Push the path onto the return value list.
342 |                             runtime.state().push(path);
343 |                             return Ok(1);
344 |                         } else {
345 |                             warn!("bad characters in path from glob");
346 |                         }
347 |                     }
348 |                     Some(Err(_)) => {
349 |                         // if the path matched but was unreadable,
350 |                         // thereby preventing its contents from matching
351 |                         warn!("unreadable path in glob");
352 |                         // just continue the loop until we find a path we care about
353 |                     }
354 |                     None => {
355 |                         runtime.state().push_nil();
356 |                         return Ok(1);
357 |                     }
358 |                 }
359 |             }
360 |         }));
361 |         Ok(1)
362 |     } else {
363 |         warn!("invalid glob pattern");
364 |         Ok(0)
365 |     }
366 | }
367 | 
368 | /// Creates a new table produced by merging all tables given as arguments.
369 | ///
370 | /// This makes a deep copy of all tables given into a new table. No tables are modified.
371 | fn merge(runtime: Runtime) -> ScriptResult {
372 |     let args_count = runtime.state().get_top();
373 | 
374 |     // merged = {}
375 |     runtime.state().new_table();
376 | 
377 |     // Walk through the arguments, merging as we go.
378 |     for i in 1..args_count+1 {
379 |         if runtime.state().is_table(i) {
380 |             do_merge(runtime.clone(), i, args_count + 1);
381 |         }
382 |     }
383 | 
384 |     fn do_merge(runtime: Runtime, src_index: i32, dest_index: i32) {
385 |         // Iterate over every key in the source table.
386 |         for (key, value) in runtime.iter(src_index) {
387 |             runtime.state().push_value(key);
388 | 
389 |             if runtime.state().is_table(value) {
390 |                 runtime.state().new_table();
391 | 
392 |                 // Merge the inner table recursively.
393 |                 do_merge(runtime.clone(), value, runtime.state().get_top());
394 |             } else {
395 |                 runtime.state().push_value(value);
396 |             }
397 | 
398 |             // t[k] = v
399 |             runtime.state().set_table(dest_index);
400 |         }
401 |     }
402 | 
403 |     // If the input table is nil, just use the defaults table as the result.
404 |     if runtime.state().is_nil(1) {
405 |         runtime.state().push_value(2);
406 |     } else {
407 |         // Copy the input table
408 |         runtime.state().push_value(1);
409 |         // Create a table to be used as the input's metatable
410 |         // Set __index in the metatable to be the defaults table
411 |         runtime.state().push("__index");
412 |         runtime.state().push_value(2);
413 |         runtime.state().set_table(-3);
414 |         runtime.state().set_metatable(-2);
415 |     }
416 | 
417 |     Ok(1)
418 | }
419 | 
420 | /// Prints text to the console output.
421 | ///
422 | /// # Lua arguments
423 | /// * `str: string` - The string to print.
424 | fn print(runtime: Runtime) -> ScriptResult {
425 |     for i in 1..runtime.state().get_top()+1 {
426 |         let string = runtime.state().to_str(i).unwrap_or("").to_string();
427 |         runtime.state().pop(1);
428 | 
429 |         let string = expand_string(&string, runtime.clone());
430 |         println!("{}", string);
431 |     }
432 | 
433 |     Ok(0)
434 | }
435 | 
436 | /// Sets the default task.
437 | ///
438 | /// # Lua arguments
439 | /// * `name: string` - The name of the task to set as default.
440 | fn set_default_task(runtime: Runtime) -> ScriptResult {
441 |     // Get the task name as the first argument.
442 |     let name = runtime.state().check_string(1).to_string();
443 | 
444 |     // Set the default task to the given name.
445 |     runtime.environment().set_default_task(name);
446 | 
447 |     Ok(0)
448 | }
449 | 
450 | /// Sets the description for the next task.
451 | ///
452 | /// # Lua arguments
453 | /// * `name: string` - The description.
454 | fn set_description(runtime: Runtime) -> ScriptResult {
455 |     let desc = runtime.state().check_string(1).to_string();
456 |     runtime.state().push(desc);
457 |     runtime.reg_set("rote.nextDescription");
458 | 
459 |     Ok(0)
460 | }
461 | 
462 | /// Returns the current version of Rote as a string.
463 | fn version(runtime: Runtime) -> ScriptResult {
464 |     runtime.state().push_string(::ROTE_VERSION);
465 |     Ok(1)
466 | }
467 | 
468 | 
469 | /// Makes the standard Rote module functions available in the runtime.
470 | pub fn load(runtime: Runtime) {
471 |     // Load the module functions.
472 |     runtime.load_lib(&[
473 |         ("change_dir", change_dir),
474 |         ("create_rule", create_rule),
475 |         ("create_task", create_task),
476 |         ("current_dir", current_dir),
477 |         ("current_exe", current_exe),
478 |         ("env", env),
479 |         ("execute", execute),
480 |         ("expand", expand),
481 |         ("export", export),
482 |         ("glob", glob),
483 |         ("merge", merge),
484 |         ("pipe", pipe),
485 |         ("print", print),
486 |         ("set_default_task", set_default_task),
487 |         ("version", version),
488 |     ]);
489 |     runtime.state().set_global("rote");
490 | 
491 |     // Define some global aliases.
492 |     runtime.register_fn("default", set_default_task);
493 |     runtime.register_fn("desc", set_description);
494 |     runtime.register_fn("env", env);
495 |     runtime.register_fn("exec", execute);
496 |     runtime.register_fn("export", export);
497 |     runtime.register_fn("glob", glob);
498 |     runtime.register_fn("pipe", pipe);
499 |     runtime.register_fn("print", print);
500 |     runtime.register_fn("rule", create_rule);
501 |     runtime.register_fn("task", create_task);
502 | 
503 |     // Set up reading global values to fallback to environment variables.
504 |     runtime.state().push_global_table();
505 |     runtime.state().new_table();
506 |     runtime.state().push("__index");
507 |     runtime.push_closure(Box::new(|runtime| {
508 |         runtime.state().remove(1);
509 |         env(runtime)
510 |     }));
511 |     runtime.state().set_table(-3);
512 |     runtime.state().set_metatable(-2);
513 |     runtime.state().pop(1);
514 | 
515 |     // Set up pipe to be a string method.
516 |     runtime.state().get_global("string");
517 |     runtime.state().push("pipe");
518 |     runtime.push_fn(pipe);
519 |     runtime.state().set_table(-3);
520 |     runtime.state().pop(1);
521 | }
522 | 


--------------------------------------------------------------------------------
/src/modules/table.lua:
--------------------------------------------------------------------------------
  1 | -- Taken from http://www.cs.tufts.edu/~nr/drop/lua/tabutil.lua
  2 | -- by Norman Ramsey
  3 | 
  4 | local setmetatable, getmetatable, table, type, math, unpack
  5 |     = setmetatable, getmetatable, table, type, math, unpack
  6 | 
  7 | function table.of_generator(f, ...)
  8 |   local l = { }
  9 |   for x in f(...) do table.insert(l, x) end
 10 |   return l
 11 | end
 12 | 
 13 | function table.shift(t, n)
 14 |   n = n or 1
 15 |   for i = 1, n do
 16 |     table.remove(t, 1)
 17 |   end
 18 | end
 19 | 
 20 | function table.random(l, n)
 21 |   n = n or table.getn(l)
 22 |   assert(n > 0, 'random element from empty list')
 23 |   return l[math.random(n)]
 24 | end
 25 | 
 26 | function table.sorted_keys(t, lt)
 27 |   local u = { }
 28 |   for k in pairs(t) do table.insert(u, k) end
 29 |   table.sort(u, lt)
 30 |   return u
 31 | end
 32 | 
 33 | function table.randomize(l)
 34 |   u = { }
 35 |   local n = table.getn(l)
 36 |   for i = 1, n do
 37 |     u[i] = l[i]
 38 |   end
 39 |   for i = 1, n do
 40 |     j = math.random(n)
 41 |     u[i], u[j] = u[j], u[i]
 42 |   end
 43 |   return u
 44 | end
 45 | 
 46 | function table.filter(f, l)
 47 |   local u = { }
 48 |   for _, v in ipairs(l) do
 49 |     if f(v) then
 50 |       table.insert(u, v)
 51 |     end
 52 |   end
 53 |   return u
 54 | end
 55 | 
 56 | function table.map(f, l)
 57 |   local u = { }
 58 |   for k, v in pairs(l) do
 59 |     u[k] = f(v, k)
 60 |   end
 61 |   return u
 62 | end
 63 | 
 64 | local function pack(...) return { ... } end
 65 | 
 66 | function table.fold(f, t, ...)
 67 |   local z = pack(...)
 68 |   for k, v in pairs(t) do
 69 |     z = pack(f(k, v, unpack(z)))
 70 |   end
 71 |   return unpack(z)
 72 | end
 73 | 
 74 | function table.forall(f, l)
 75 |   for _, v in ipairs(l) do
 76 |     if not f(v) then
 77 |       return false
 78 |     end
 79 |   end
 80 |   return true
 81 | end
 82 | 
 83 | function table.exists(f, l)
 84 |   for _, v in ipairs(l) do
 85 |     if f(v) then
 86 |       return true
 87 |     end
 88 |   end
 89 |   return false
 90 | end
 91 | 
 92 | function table.find(f, l)
 93 |   for _, v in ipairs(l) do
 94 |     if f(v) then
 95 |       return v
 96 |     end
 97 |   end
 98 |   return nil
 99 | end
100 | 
101 | function table.index_of(l, v)
102 |   for i = 1, table.getn(l) do
103 |     if l[i] == v then return i end
104 |   end
105 |   return nil
106 | end
107 | 
108 | function table.invert(t)
109 |   local u = { }
110 |   for k, v in pairs(t) do u[v] = k end
111 |   return u
112 | end
113 | 
114 | function table.set(t) -- set of list
115 |   local u = { }
116 |   for _, v in ipairs(t) do u[v] = true end
117 |   return u
118 | end
119 | 
120 | function table.subset(l, r) -- every key in l is in r
121 |   for k in pairs(l) do if r[k] == nil then return false end end
122 |   return true
123 | end
124 | 
125 | function table.numpairs(t)
126 |   local n = 0
127 |   for _ in pairs(t) do n = n + 1 end
128 |   return n
129 | end
130 | 
131 | function table.union(...)
132 |   local u = { }
133 |   for _, t in ipairs { ... } do
134 |     for k in pairs(t) do
135 |       u[k] = true
136 |     end
137 |   end
138 |   return u
139 | end
140 | 
141 | function table.elements(t) --- list of set
142 |   local u = { }
143 |   for v in pairs(t) do table.insert(u, v) end
144 |   return u
145 | end
146 | 
147 | function table.values(t) --- values in table as list
148 |   local u = { }
149 |   for _, v in pairs(t) do table.insert(u, v) end
150 |   return u
151 | end
152 | 
153 | function table.copy(t)
154 |   local u = { }
155 |   for k, v in pairs(t) do u[k] = v end
156 |   return setmetatable(u, getmetatable(t))
157 | end
158 | 
159 | do
160 |   local default_meta = { __index = function(t) return t['*'] or t.default end }
161 |   function table.defaulting(t, defaultkey)
162 |     t = t or { }
163 |     defaultkey = defaultkey or '*'
164 |     local om = getmetatable(t)
165 |     if om then
166 |       assert(om.__index == nil, "Defaulting table already has __index method")
167 |       local m = { }
168 |       for k, v in pairs(om) do m[k] = v end
169 |       m.__index = function(t) return t[defaultkey] or t.default end
170 |       setmetatable(t, m)
171 |     elseif defaultkey == '*' then
172 |       setmetatable(t, default_meta)
173 |     else
174 |       setmetatable(t, { __index = function(t) return t[defaultkey] or t.default end })
175 |     end
176 |     return t
177 |   end
178 | end
179 | 
180 | do
181 |   local meta = { __index = function(t, k) local u = {} t[k] = u return u end }
182 |   function table.of_tables(t)
183 |     t = t or { }
184 |     local om = getmetatable(t)
185 |     if om then
186 |       assert(om.__index == nil, "Defaulting table already has __index method")
187 |       local m = { }
188 |       for k, v in pairs(om) do m[k] = v end
189 |       m.__index = meta.__index
190 |       setmetatable(t, m)
191 |     else
192 |       setmetatable(t, meta)
193 |     end
194 |     return t
195 |   end
196 | end
197 | 
198 | do
199 |   local meta = { __index = function(t, k) t[k] = 0 return 0 end }
200 |   function table.of_zeroes(t)
201 |     t = t or { }
202 |     local om = getmetatable(t)
203 |     if om then
204 |       assert(om.__index == nil, "Defaulting table already has __index method")
205 |       local m = { }
206 |       for k, v in pairs(om) do m[k] = v end
207 |       m.__index = meta.__index
208 |       setmetatable(t, m)
209 |     else
210 |       setmetatable(t, meta)
211 |     end
212 |     return t
213 |   end
214 | end
215 | 
216 | -------------
217 | --- for lexicographic sorting
218 | 
219 | local function listlt(l1, l2, lt)
220 |   for i = 1, table.getn(l1) do
221 |     local v1, v2 = l1[i], l2[i]
222 |     if lt(v1, v2) then return true
223 |     elseif lt(v2, v1) then return false
224 |     end
225 |   end
226 |   return false
227 | end
228 | 
229 | function table.lt(l1, l2, lt) -- must be same length
230 |   if lt then return listlt(l1, l2, lt) end
231 |   for i = 1, table.getn(l1) do
232 |     local v1, v2 = l1[i], l2[i]
233 |     if v1 ~= v2 then
234 |       if type(v1) == 'boolean' then
235 |         return not v1 and v2
236 |       elseif type(v1) == 'nil' then
237 |         return true
238 |       elseif type(v2) == 'nil' then
239 |         return false
240 |       else
241 |         return v1 < v2
242 |       end
243 |     end
244 |   end
245 |   return false
246 | end
247 | 
248 | function table.gt(l1, l2, lt) return table.lt(l2, l1, lt) end
249 | 
250 | 
251 | return table
252 | 


--------------------------------------------------------------------------------
/src/rule.rs:
--------------------------------------------------------------------------------
  1 | use std::error::Error;
  2 | use std::fs;
  3 | use std::rc::Rc;
  4 | use task;
  5 | 
  6 | 
  7 | type ActionFn = Fn(&str) -> Result<(), Box<Error>>;
  8 | 
  9 | /// A rule task that matches against files. Rules are used to generate tasks from file name
 10 | /// patterns.
 11 | pub struct Rule {
 12 |     /// The file pattern to match.
 13 |     pub pattern: String,
 14 | 
 15 |     /// A list of tasks that must be ran before this task.
 16 |     dependencies: Vec<String>,
 17 | 
 18 |     /// Rule action.
 19 |     action: Option<Rc<ActionFn>>,
 20 | }
 21 | 
 22 | impl Rule {
 23 |     pub fn new<S, V, F>(pattern: S, dependencies: V, action: Option<F>) -> Rule
 24 |         where S: Into<String>,
 25 |               V: Into<Vec<String>>,
 26 |               F: Fn(&str) -> Result<(), Box<Error>> + 'static
 27 |     {
 28 |         Rule {
 29 |             pattern: pattern.into(),
 30 |             dependencies: dependencies.into(),
 31 |             action: action.map(|a| Rc::new(a) as Rc<ActionFn>),
 32 |         }
 33 |     }
 34 | 
 35 |     /// Checks if a file name matches the rule.
 36 |     pub fn matches<S: AsRef<str>>(&self, name: S) -> bool {
 37 |         if let Some(index) = self.pattern.find("%") {
 38 |             let (prefix, suffix) = self.pattern.split_at(index);
 39 |             let suffix = &suffix[1..];
 40 | 
 41 |             name.as_ref().starts_with(prefix) && name.as_ref().ends_with(suffix)
 42 |         } else {
 43 |             &self.pattern == name.as_ref()
 44 |         }
 45 |     }
 46 | 
 47 |     /// Creates a task for a given file based on the rule.
 48 |     pub fn create_task<S: Into<String>>(&self, name: S) -> Option<FileTask> {
 49 |         let name = name.into();
 50 | 
 51 |         // First, check if the given filename matches.
 52 |         if !self.matches(&name) {
 53 |             return None;
 54 |         }
 55 | 
 56 |         // Clone the input files (dependencies).
 57 |         let mut inputs = self.dependencies.clone();
 58 | 
 59 |         // If the rule name is a pattern, determine the value of the replacement character "%".
 60 |         if let Some(index) = self.pattern.find("%") {
 61 |             let end = index + 1 + name.len() - self.pattern.len();
 62 |             let replacement = &name[index..end];
 63 | 
 64 |             // Expand the inputs with the corresponding names that match the output name.
 65 |             inputs = inputs.into_iter()
 66 |                 .map(|input| input.replace("%", replacement))
 67 |                 .collect();
 68 |         }
 69 | 
 70 |         Some(FileTask {
 71 |             inputs: inputs,
 72 |             output: name,
 73 |             action: self.action.clone(),
 74 |         })
 75 |     }
 76 | }
 77 | 
 78 | pub struct FileTask {
 79 |     pub inputs: Vec<String>,
 80 |     pub output: String,
 81 |     action: Option<Rc<ActionFn>>,
 82 | }
 83 | 
 84 | impl task::Task for FileTask {
 85 |     fn name<'a>(&'a self) -> &'a str {
 86 |         &self.output
 87 |     }
 88 | 
 89 |     /// Checks if the task is dirty by comparing the file modification time of the input and output
 90 |     /// files. If any of the input files are newer than the output file, then the task is dirty.
 91 |     fn satisfied(&self) -> bool {
 92 |         fs::metadata(&self.output)
 93 |             .and_then(|m| m.modified())
 94 |             .map(|time| {
 95 |                 self.inputs
 96 |                     .iter()
 97 |                     .all(|input| {
 98 |                         fs::metadata(input)
 99 |                             .and_then(|m| m.modified())
100 |                             .map(|t| t <= time)
101 |                             .unwrap_or(true)
102 |                     })
103 |             })
104 |             .unwrap_or(false)
105 |     }
106 | 
107 |     fn dependencies(&self) -> &[String] {
108 |         &self.inputs
109 |     }
110 | 
111 |     fn run(&self) -> Result<(), Box<Error>> {
112 |         if let Some(ref action) = self.action {
113 |             action(&self.output)
114 |         } else {
115 |             Ok(())
116 |         }
117 |     }
118 | }
119 | 


--------------------------------------------------------------------------------
/src/runner.rs:
--------------------------------------------------------------------------------
  1 | use graph::Graph;
  2 | use modules;
  3 | use num_cpus;
  4 | use runtime::{Environment, Runtime};
  5 | use std::cmp;
  6 | use std::collections::{HashMap, HashSet};
  7 | use std::error::Error;
  8 | use std::path::{Path, PathBuf};
  9 | use std::rc::Rc;
 10 | use std::sync::mpsc;
 11 | use std::thread;
 12 | use task::Task;
 13 | use term;
 14 | 
 15 | 
 16 | #[derive(Clone)]
 17 | pub struct EnvironmentSpec {
 18 |     /// Script path.
 19 |     path: PathBuf,
 20 | 
 21 |     /// Script directory.
 22 |     directory: PathBuf,
 23 | 
 24 |     /// Module include paths.
 25 |     include_paths: Vec<PathBuf>,
 26 | 
 27 |     /// Global environment variables.
 28 |     variables: Vec<(String, String)>,
 29 | 
 30 |     /// Indicates if actually running tasks should be skipped.
 31 |     dry_run: bool,
 32 | 
 33 |     /// Indicates if up-to-date tasks should be run anyway.
 34 |     always_run: bool,
 35 | 
 36 |     /// Indicates task errors should be ignored.
 37 |     keep_going: bool,
 38 | }
 39 | 
 40 | impl EnvironmentSpec {
 41 |     /// Creates an environment from the environment specification.
 42 |     pub fn create(&self) -> Result<Runtime, Box<Error>> {
 43 |         // Prepare a new environment.
 44 |         let environment = try!(Environment::new(self.path.clone()));
 45 |         let runtime = Runtime::new(environment);
 46 | 
 47 |         // Open standard library functions.
 48 |         runtime.state().open_libs();
 49 | 
 50 |         // Register modules.
 51 |         modules::register_all(&runtime);
 52 | 
 53 |         // Set include paths.
 54 |         for path in &self.include_paths {
 55 |             runtime.include_path(&path);
 56 |         }
 57 | 
 58 |         // Set the OS
 59 |         runtime.state().push_string(if cfg!(windows) {
 60 |             "windows"
 61 |         } else {
 62 |             "unix"
 63 |         });
 64 |         runtime.state().set_global("OS");
 65 | 
 66 |         // Set configured variables.
 67 |         for &(ref name, ref value) in &self.variables {
 68 |             runtime.state().push(value.clone());
 69 |             runtime.state().set_global(&name);
 70 |         }
 71 | 
 72 |         // Load the script.
 73 |         try!(runtime.load());
 74 | 
 75 |         Ok(runtime)
 76 |     }
 77 | }
 78 | 
 79 | /// A task runner object that holds the state for defined tasks, dependencies, and the scripting
 80 | /// runtime.
 81 | pub struct Runner {
 82 |     /// The current DAG for tasks.
 83 |     graph: Graph,
 84 | 
 85 |     /// The number of threads to use.
 86 |     jobs: usize,
 87 | 
 88 |     /// Environment specification.
 89 |     spec: EnvironmentSpec,
 90 | 
 91 |     /// Runtime local owned by the master thread.
 92 |     runtime: Option<Runtime>,
 93 | }
 94 | 
 95 | impl Runner {
 96 |     /// Creates a new runner instance.
 97 |     pub fn new<P: Into<PathBuf>>(path: P) -> Result<Runner, Box<Error>> {
 98 |         // By default, set the number of jobs to be one less than the number of available CPU cores.
 99 |         let jobs = cmp::max(1, num_cpus::get() - 1);
100 | 
101 |         let path = path.into();
102 |         let directory: PathBuf = match path.parent() {
103 |             Some(path) => path.into(),
104 |             None => {
105 |                 return Err("failed to parse script directory".into());
106 |             }
107 |         };
108 | 
109 |         Ok(Runner {
110 |             graph: Graph::new(),
111 |             jobs: jobs as usize,
112 |             spec: EnvironmentSpec {
113 |                 path: path.into(),
114 |                 directory: directory,
115 |                 include_paths: Vec::new(),
116 |                 variables: Vec::new(),
117 |                 dry_run: false,
118 |                 always_run: false,
119 |                 keep_going: false,
120 |             },
121 |             runtime: None,
122 |         })
123 |     }
124 | 
125 |     pub fn path(&self) -> &Path {
126 |         &self.spec.path
127 |     }
128 | 
129 |     pub fn directory(&self) -> &Path {
130 |         &self.spec.directory
131 |     }
132 | 
133 |     /// Sets "dry run" mode.
134 |     ///
135 |     /// When in "dry run" mode, running tasks will operate as normal, except that no task's actions
136 |     /// will be actually run.
137 |     pub fn dry_run(&mut self) {
138 |         self.spec.dry_run = true;
139 |     }
140 | 
141 |     /// Run all tasks even if they are up-to-date.
142 |     pub fn always_run(&mut self) {
143 |         self.spec.always_run = true;
144 |     }
145 | 
146 |     /// Run all tasks even if they throw errors.
147 |     pub fn keep_going(&mut self) {
148 |         self.spec.keep_going = true;
149 |     }
150 | 
151 |     /// Sets the number of threads to use to run tasks.
152 |     pub fn jobs(&mut self, jobs: usize) {
153 |         self.jobs = jobs;
154 |     }
155 | 
156 |     /// Adds a path to Lua's require path for modules.
157 |     pub fn include_path<P: Into<PathBuf>>(&mut self, path: P) {
158 |         self.spec.include_paths.push(path.into());
159 |     }
160 | 
161 |     /// Sets a variable value.
162 |     pub fn set_var<S: AsRef<str>, V: Into<String>>(&mut self, name: S, value: V) {
163 |         self.spec.variables.push((name.as_ref().to_string(), value.into()));
164 |     }
165 | 
166 |     /// Load the script.
167 |     pub fn load(&mut self) -> Result<(), Box<Error>> {
168 |         if self.runtime.is_none() {
169 |             self.runtime = Some(try!(self.spec.create()));
170 |         }
171 | 
172 |         Ok(())
173 |     }
174 | 
175 |     /// Prints the list of named tasks for a script.
176 |     pub fn print_task_list(&mut self) {
177 |         let mut tasks = self.runtime().environment().tasks();
178 |         tasks.sort_by(|a, b| a.name().cmp(b.name()));
179 | 
180 |         let mut out = term::stdout().unwrap();
181 |         println!("Available tasks:");
182 | 
183 |         for task in tasks {
184 |             out.fg(term::color::BRIGHT_GREEN).unwrap();
185 |             write!(out, "  {:16}", task.name()).unwrap();
186 |             out.reset().unwrap();
187 | 
188 |             if let Some(ref description) = task.description() {
189 |                 write!(out, "{}", description).unwrap();
190 |             }
191 | 
192 |             writeln!(out, "").unwrap();
193 |         }
194 | 
195 |         if let Some(ref default) = self.runtime().environment().default_task() {
196 |             println!("");
197 |             println!("Default task: {}", default);
198 |         }
199 |     }
200 | 
201 |     /// Run the default task.
202 |     pub fn run_default(&mut self) -> Result<(), Box<Error>> {
203 |         if let Some(ref name) = self.runtime().environment().default_task() {
204 |             let tasks = vec![name];
205 |             self.run(&tasks)
206 |         } else {
207 |             Err("no default task defined".into())
208 |         }
209 |     }
210 | 
211 |     /// Runs the specified list of tasks.
212 |     ///
213 |     /// Tasks are run in parallel when possible during execution. The maximum number of parallel
214 |     /// jobs can be set with the `jobs()` method.
215 |     pub fn run<S: AsRef<str>>(&mut self, tasks: &[S]) -> Result<(), Box<Error>> {
216 |         // Resolve all tasks given.
217 |         for task in tasks {
218 |             try!(self.resolve_task(task));
219 |         }
220 | 
221 |         // Determine the schedule of tasks to execute.
222 |         let mut queue = try!(self.graph.solve(!self.spec.always_run));
223 |         let task_count = queue.len();
224 |         let thread_count = cmp::min(self.jobs, task_count);
225 | 
226 |         debug!("running {} task(s) across {} thread(s)",
227 |                task_count,
228 |                thread_count);
229 | 
230 |         // Spawn one thread for each job.
231 |         let mut threads = Vec::new();
232 |         let mut free_threads: HashSet<usize> = HashSet::new();
233 |         let mut channels = Vec::new();
234 |         let (sender, receiver) = mpsc::channel::<Result<usize, usize>>();
235 | 
236 |         // Spawn `jobs` number of threads (but no more than the task count!).
237 |         for thread_id in 0..thread_count {
238 |             let spec = self.spec.clone();
239 |             let thread_sender = sender.clone();
240 | 
241 |             let (parent_sender, thread_receiver) = mpsc::sync_channel::<(String, usize)>(0);
242 |             channels.push(parent_sender);
243 | 
244 |             threads.push(thread::spawn(move || {
245 |                 // Prepare a new runtime.
246 |                 let runtime = spec.create().unwrap_or_else(|e| {
247 |                     error!("{}", e);
248 |                     panic!();
249 |                 });
250 | 
251 |                 if thread_sender.send(Ok(thread_id)).is_err() {
252 |                     trace!("thread {} failed to send channel", thread_id);
253 |                 }
254 | 
255 |                 // Begin executing tasks!
256 |                 while let Ok((name, task_id)) = thread_receiver.recv() {
257 |                     info!("running task '{}' ({} of {})", name, task_id, task_count);
258 | 
259 |                     // Lookup the task to run.
260 |                     let task = {
261 |                         // Lookup the task to run.
262 |                         if let Some(task) = runtime.environment().get_task(&name) {
263 |                             task as Rc<Task>
264 |                         }
265 |                         // Find a rule that matches the task name.
266 |                         else if let Some(rule) = runtime.environment()
267 |                             .rules()
268 |                             .iter()
269 |                             .find(|rule| rule.matches(&name)) {
270 |                             Rc::new(rule.create_task(name).unwrap()) as Rc<Task>
271 |                         }
272 |                         // No matching task.
273 |                         else {
274 |                             panic!("no matching task or rule for '{}'", name);
275 |                         }
276 |                     };
277 | 
278 |                     // Check for dry run.
279 |                     if !spec.dry_run {
280 |                         if let Err(e) = task.run() {
281 |                             // If we ought to keep going, just issue a warning.
282 |                             if spec.keep_going {
283 |                                 warn!("ignoring error: {}", e);
284 |                             } else {
285 |                                 error!("{}", e);
286 |                                 thread_sender.send(Err(thread_id)).unwrap();
287 |                                 return;
288 |                             }
289 |                         }
290 |                     } else {
291 |                         info!("would run task '{}'", task.name());
292 |                     }
293 | 
294 |                     if thread_sender.send(Ok(thread_id)).is_err() {
295 |                         trace!("thread {} failed to send channel", thread_id);
296 |                         break;
297 |                     }
298 |                 }
299 |             }))
300 |         }
301 | 
302 |         drop(sender);
303 | 
304 |         // Keep track of tasks completed and tasks in progress.
305 |         let mut completed_tasks: HashSet<String> = HashSet::new();
306 |         let mut current_tasks: HashMap<usize, String> = HashMap::new();
307 |         let all_tasks: HashSet<String> = queue.iter().map(|s| s.name().to_string()).collect();
308 | 
309 |         while !queue.is_empty() || !current_tasks.is_empty() {
310 |             // Wait for a thread to request a task.
311 |             let result = receiver.recv().unwrap();
312 | 
313 |             // If the thread sent an error, we should stop everything if keep_going isn't enabled.
314 |             if let Err(thread_id) = result {
315 |                 debug!("thread {} errored, waiting for remaining tasks...",
316 |                        thread_id);
317 |                 return Err("not all tasks completed successfully".into());
318 |             }
319 | 
320 |             let thread_id = result.unwrap();
321 |             free_threads.insert(thread_id);
322 |             trace!("thread {} is idle", thread_id);
323 | 
324 |             // If the thread was previously running a task, mark it as completed.
325 |             if let Some(task) = current_tasks.remove(&thread_id) {
326 |                 trace!("task '{}' completed", task);
327 |                 completed_tasks.insert(task);
328 |             }
329 | 
330 |             // Attempt to schedule more tasks to run. The most we can schedule is the number of free
331 |             // threads, but it is limited by the number of tasks that have their dependencies already
332 |             // finished.
333 |             'schedule: for _ in 0..free_threads.len() {
334 |                 // If the queue is empty, we are done.
335 |                 if queue.is_empty() {
336 |                     break;
337 |                 }
338 | 
339 |                 // Check the next task in the queue. If any of its dependencies have not yet been
340 |                 // completed, we cannot schedule it yet.
341 |                 for dependency in queue.front().unwrap().dependencies() {
342 |                     // Check that the dependency needs scheduled at all (some are already satisfied),
343 |                     // and that it hasn't already finished.
344 |                     if all_tasks.contains(dependency) && !completed_tasks.contains(dependency) {
345 |                         // We can't run the next task, so we're done scheduling for now until another
346 |                         // thread finishes.
347 |                         break 'schedule;
348 |                     }
349 |                 }
350 | 
351 |                 // Get the available task from the queue.
352 |                 let task = queue.front().unwrap().clone();
353 | 
354 |                 // Pick a free thread to run the task in.
355 |                 if let Some(thread_id) = free_threads.iter().next().map(|t| *t) {
356 |                     trace!("scheduling task '{}' on thread {}", task.name(), thread_id);
357 |                     let data = (task.name().to_string(), task_count - queue.len() + 1);
358 | 
359 |                     // Send the task name.
360 |                     if channels[thread_id].send(data).is_ok() {
361 |                         current_tasks.insert(thread_id, task.name().to_string());
362 |                         free_threads.remove(&thread_id);
363 | 
364 |                         // Scheduling was successful, so remove the task frome the queue.
365 |                         queue.pop_front().unwrap();
366 |                     } else {
367 |                         trace!("failed to send channel to thread {}", thread_id);
368 |                     }
369 |                 } else {
370 |                     // We can schedule now, but there aren't any free threads. 😢
371 |                     break;
372 |                 }
373 |             }
374 |         }
375 | 
376 |         // Close the input and wait for any remaining threads to finish.
377 |         drop(channels);
378 |         for (thread_id, thread) in threads.into_iter().enumerate() {
379 |             if let Err(e) = thread.join() {
380 |                 trace!("thread {} closed with panic: {:?}", thread_id, e);
381 |             }
382 |         }
383 | 
384 |         info!("all tasks up to date");
385 |         Ok(())
386 |     }
387 | 
388 |     fn resolve_task<S: AsRef<str>>(&mut self, name: S) -> Result<(), Box<Error>> {
389 |         if !self.graph.contains(&name) {
390 |             // Lookup the task to run.
391 |             if let Some(task) = self.runtime().environment().get_task(&name) {
392 |                 debug!("task '{}' matches named task", name.as_ref());
393 |                 self.graph.insert(task.clone());
394 |             }
395 |             // Find a rule that matches the task name.
396 |             else if let Some(rule) = self.runtime()
397 |                 .environment()
398 |                 .rules()
399 |                 .iter()
400 |                 .find(|rule| rule.matches(&name)) {
401 |                 debug!("task '{}' matches rule '{}'", name.as_ref(), rule.pattern);
402 |                 // Create a task for the rule and insert it in the graph.
403 |                 self.graph.insert(Rc::new(rule.create_task(name.as_ref()).unwrap()));
404 |             }
405 |             // No matching task.
406 |             else {
407 |                 return Err(format!("no matching task or rule for '{}'", name.as_ref()).into());
408 |             }
409 |         }
410 | 
411 |         for dependency in self.graph.get(name).unwrap().dependencies() {
412 |             if !self.graph.contains(dependency) {
413 |                 try!(self.resolve_task(dependency));
414 |             }
415 |         }
416 | 
417 |         Ok(())
418 |     }
419 | 
420 |     fn runtime(&self) -> Runtime {
421 |         self.runtime.as_ref().unwrap().clone()
422 |     }
423 | }
424 | 


--------------------------------------------------------------------------------
/src/runtime/environment.rs:
--------------------------------------------------------------------------------
  1 | use rule::Rule;
  2 | use std::cell::RefCell;
  3 | use std::clone::Clone;
  4 | use std::collections::HashMap;
  5 | use std::error::Error;
  6 | use std::path::{Path, PathBuf};
  7 | use std::rc::Rc;
  8 | use task::{Task, NamedTask};
  9 | 
 10 | 
 11 | /// Stores the state of an entire task execution environment.
 12 | pub struct Environment {
 13 |     /// A map of all named tasks.
 14 |     tasks: RefCell<HashMap<String, Rc<NamedTask>>>,
 15 | 
 16 |     /// A vector of all defined file rules.
 17 |     rules: RefCell<Vec<Rc<Rule>>>,
 18 | 
 19 |     /// The default task to run.
 20 |     default_task: RefCell<Option<String>>,
 21 | 
 22 |     /// The name of the task currently running.
 23 |     current_task: RefCell<Option<String>>,
 24 | 
 25 |     /// Full path to the current script.
 26 |     path: PathBuf,
 27 | 
 28 |     /// Directory of the current script.
 29 |     directory: PathBuf,
 30 | }
 31 | 
 32 | impl Environment {
 33 |     /// Creates a new environment for a given script file.
 34 |     ///
 35 |     /// The instance is placed inside a box to ensure the runner has a constant location in memory
 36 |     /// so that it can be referenced by native closures in the runtime.
 37 |     pub fn new<P: Into<PathBuf>>(script: P) -> Result<Environment, Box<Error>> {
 38 |         let script = script.into();
 39 |         let directory = match script.parent() {
 40 |             Some(path) => path.into(),
 41 |             None => {
 42 |                 return Err("failed to parse script directory".into());
 43 |             }
 44 |         };
 45 | 
 46 |         Ok(Environment {
 47 |             tasks: RefCell::new(HashMap::new()),
 48 |             rules: RefCell::new(Vec::new()),
 49 |             default_task: RefCell::new(None),
 50 |             current_task: RefCell::new(None),
 51 |             path: script,
 52 |             directory: directory,
 53 |         })
 54 |     }
 55 | 
 56 |     /// Gets the full path of the script file.
 57 |     pub fn path(&self) -> &Path {
 58 |         &self.path
 59 |     }
 60 | 
 61 |     /// Gets the full path of the directory containing the script file.
 62 |     pub fn directory(&self) -> &Path {
 63 |         &self.directory
 64 |     }
 65 | 
 66 |     /// Gets a list of all registered tasks.
 67 |     pub fn tasks(&self) -> Vec<Rc<NamedTask>> {
 68 |         self.tasks.borrow().values().map(|rc| rc.clone()).collect()
 69 |     }
 70 | 
 71 |     /// Gets a list of all registered rules.
 72 |     pub fn rules(&self) -> Vec<Rc<Rule>> {
 73 |         self.rules.borrow().iter().map(|rc| rc.clone()).collect()
 74 |     }
 75 | 
 76 |     /// Creates a new task.
 77 |     pub fn create_task(&self, task: NamedTask) {
 78 |         // Add it to the master list of tasks.
 79 |         self.tasks.borrow_mut().insert(task.name().into(), Rc::new(task));
 80 |     }
 81 | 
 82 |     /// Creates a new rule.
 83 |     pub fn create_rule(&self, rule: Rule) {
 84 |         self.rules.borrow_mut().push(Rc::new(rule));
 85 |     }
 86 | 
 87 |     /// Gets a task by name.
 88 |     pub fn get_task<S: AsRef<str>>(&self, name: S) -> Option<Rc<NamedTask>> {
 89 |         self.tasks.borrow().get(name.as_ref()).map(|rc| rc.clone())
 90 |     }
 91 | 
 92 |     /// Gets the default task to run.
 93 |     pub fn default_task<'a>(&'a self) -> Option<String> {
 94 |         match *self.default_task.borrow() {
 95 |             Some(ref task) => Some(task.clone()),
 96 |             None => None,
 97 |         }
 98 |     }
 99 | 
100 |     /// Sets the default task.
101 |     pub fn set_default_task<S: Into<String>>(&self, name: S) {
102 |         *self.default_task.borrow_mut() = Some(name.into());
103 |     }
104 | 
105 |     /// Gets the name of the currently running task.
106 |     pub fn current_task<'a>(&'a self) -> Option<String> {
107 |         match *self.current_task.borrow() {
108 |             Some(ref task) => Some(task.clone()),
109 |             None => None,
110 |         }
111 |     }
112 | 
113 |     /// Sets the currently running task.
114 |     pub fn set_current_task<S: Into<String>>(&self, name: S) {
115 |         *self.current_task.borrow_mut() = Some(name.into());
116 |     }
117 | 
118 |     /// Clears the currently running task.
119 |     pub fn clear_current_task(&self) {
120 |         *self.current_task.borrow_mut() = None;
121 |     }
122 | }
123 | 


--------------------------------------------------------------------------------
/src/runtime/iter.rs:
--------------------------------------------------------------------------------
 1 | use lua;
 2 | 
 3 | 
 4 | /// An iterator for looping over the keys and values in a Lua table on the stack.
 5 | pub struct TableIterator {
 6 |     index: lua::Index,
 7 |     state: lua::State,
 8 |     first: bool,
 9 | }
10 | 
11 | impl TableIterator {
12 |     /// Creates a new iterator for a given table on the stack.
13 |     pub fn new(mut state: lua::State, index: lua::Index) -> TableIterator {
14 |         TableIterator {
15 |             // Normalize the index.
16 |             index: if index < 0 {
17 |                 state.get_top() + index
18 |             } else {
19 |                 index
20 |             },
21 |             state: state,
22 |             first: true,
23 |         }
24 |     }
25 | }
26 | 
27 | impl Iterator for TableIterator {
28 |     type Item = (i32, i32);
29 | 
30 |     /// Fetches the next key/value index pair in the table.
31 |     fn next(&mut self) -> Option<(i32, i32)> {
32 |         // On the first call, push an initial key for the call to lua_next().
33 |         if self.first {
34 |             self.state.push_nil();
35 |             self.first = false;
36 |         } else {
37 |             // Pop the previous value.
38 |             self.state.pop(1);
39 |         }
40 | 
41 |         if self.state.next(self.index) {
42 |             let top = self.state.get_top();
43 |             return Some((top - 1, top));
44 |         }
45 | 
46 |         None
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/runtime/mod.rs:
--------------------------------------------------------------------------------
  1 | use lua::{self, ffi};
  2 | use lua::libc::{c_int, c_void};
  3 | use std::any::{Any, TypeId};
  4 | use std::clone::Clone;
  5 | use std::error::Error;
  6 | use std::hash::{Hash, Hasher, SipHasher};
  7 | use std::mem;
  8 | use std::path::PathBuf;
  9 | use std::ptr;
 10 | use std::rc::{Rc, Weak};
 11 | 
 12 | mod environment;
 13 | mod iter;
 14 | 
 15 | pub use self::environment::Environment;
 16 | 
 17 | /// Results that are returned by functions callable from Lua.
 18 | pub type ScriptResult = Result<i32, Box<Error>>;
 19 | 
 20 | /// A function that can be bound to be callable inside the Lua runtime.
 21 | pub type Function = fn(Runtime) -> ScriptResult;
 22 | pub type Closure = FnMut(Runtime) -> ScriptResult;
 23 | 
 24 | 
 25 | /// Manages the Lua interpreter runtime for a Lua script.
 26 | pub struct Runtime {
 27 |     /// Shared environment between all references to the runtime.
 28 |     environment: Rc<Environment>,
 29 | 
 30 |     /// A Lua interpreter state.
 31 |     state: lua::State,
 32 | }
 33 | 
 34 | impl Runtime {
 35 |     /// Creates a new environment for a given script file.
 36 |     ///
 37 |     /// The instance is placed inside a box to ensure the runner has a constant location in memory
 38 |     /// so that it can be referenced by native closures in the runtime.
 39 |     pub fn new(environment: Environment) -> Runtime {
 40 |         let runtime = Runtime {
 41 |             environment: Rc::new(environment),
 42 |             state: lua::State::new(),
 43 |         };
 44 | 
 45 |         // Create a weak pointer to the environment and push it into the registry so that you can
 46 |         // access the environment object by its Lua state.
 47 |         runtime.state().push(type_id_of::<Environment>() as f64);
 48 |         let ptr = runtime.state().new_userdata_typed();
 49 |         let weak = Rc::downgrade(&runtime.environment);
 50 |         unsafe {
 51 |             ptr::write(ptr, weak);
 52 |         }
 53 |         runtime.state().set_table(lua::REGISTRYINDEX);
 54 | 
 55 |         runtime
 56 |     }
 57 | 
 58 |     /// Fetches the environment by its Lua pointer.
 59 |     ///
 60 |     /// This function is far from safe, and should be used with care.
 61 |     pub unsafe fn from_ptr(ptr: *mut ffi::lua_State) -> Runtime {
 62 |         // First, get a State object from the raw pointer.
 63 |         let mut state = lua::State::from_ptr(ptr);
 64 | 
 65 |         // Fetch the environment pointer from the registry.
 66 |         let environment = {
 67 |             state.push(type_id_of::<Environment>() as f64);
 68 |             state.get_table(lua::REGISTRYINDEX);
 69 | 
 70 |             // Read the weak pointer.
 71 |             let weak = match state.to_userdata_typed::<Weak<Environment>>(-1) {
 72 |                 Some(weak) => {
 73 |                     lua::State::from_ptr(ptr).pop(1);
 74 |                     weak
 75 |                 },
 76 |                 None => panic!("unable to read environment pointer")
 77 |             };
 78 | 
 79 |             match Weak::upgrade(&weak) {
 80 |                 Some(rc) => rc,
 81 |                 None => panic!("unable to upgrade environment pointer")
 82 |             }
 83 |         };
 84 | 
 85 |         // Upgrade the pointer and convert it to an environment.
 86 |         Runtime {
 87 |             environment: environment,
 88 |             state: state,
 89 |         }
 90 |     }
 91 | 
 92 |     /// Gets the runtime environment.
 93 |     pub fn environment(&self) -> &Environment {
 94 |         &self.environment
 95 |     }
 96 | 
 97 |     /// Gets a mutable instance of the Lua interpreter state.
 98 |     ///
 99 |     /// This function uses the direct lua_State pointer, so multiple owners can all mutate the same
100 |     /// state simultaneously. Obviously this is a little unsafe, so use responsibly.
101 |     pub fn state(&self) -> lua::State {
102 |         unsafe {
103 |             lua::State::from_ptr(self.state.as_ptr())
104 |         }
105 |     }
106 | 
107 |     /// Executes the script.
108 |     pub fn load(&self) -> Result<(), Box<Error>> {
109 |         let path_str = if let Some(s) = self.environment.path().to_str() {
110 |             s
111 |         } else {
112 |             return Err("path contains invalid characters".into());
113 |         };
114 | 
115 |         // Load the given file.
116 |         match self.state().do_file(path_str) {
117 |             lua::ThreadStatus::Ok => {}
118 |             lua::ThreadStatus::FileError => {
119 |                 return Err(format!("the file \"{}\" could not be read", path_str).into());
120 |             }
121 |             _ => {
122 |                 return Err(self.state().to_str(-1).unwrap().into());
123 |             }
124 |         };
125 | 
126 |         Ok(())
127 |     }
128 | 
129 |     /// Adds a path to Lua's require path for modules.
130 |     pub fn include_path<P: Into<PathBuf>>(&self, path: P) {
131 |         let mut lua_path = path.into();
132 |         let mut native_path = lua_path.clone();
133 |         lua_path.push("?.lua");
134 |         native_path.push("?.so");
135 | 
136 |         self.state().get_global("package");
137 | 
138 |         // Set the Lua file path.
139 |         self.state().get_field(-1, "path");
140 |         let mut search_path = self.state().to_str(-1).unwrap().to_string();
141 |         search_path.push(';');
142 |         search_path.push_str(&lua_path.to_string_lossy());
143 | 
144 |         self.state().push_string(&search_path);
145 |         self.state().set_field(-4, "path");
146 |         self.state().pop(2);
147 | 
148 |         // Set the native file path.
149 |         self.state().get_field(-1, "cpath");
150 |         let mut search_path = self.state().to_str(-1).unwrap().to_string();
151 |         search_path.push(';');
152 |         search_path.push_str(&native_path.to_string_lossy());
153 | 
154 |         self.state().push_string(&search_path);
155 |         self.state().set_field(-4, "cpath");
156 |         self.state().pop(3);
157 |     }
158 | 
159 |     /// Evaluates a Lua string inside the runtime.
160 |     pub fn eval<S: AsRef<str>>(&self, code: S) -> Result<(), Box<Error>> {
161 |         if self.state().do_string(code.as_ref()).is_err() {
162 |             return Err(self.state().to_str(-1).unwrap().into());
163 |         }
164 | 
165 |         Ok(())
166 |     }
167 | 
168 |     /// Registers a global function in the runtime that can be called by Lua scripts.
169 |     pub fn register_fn(&self, name: &str, f: Function) {
170 |         self.push_fn(f);
171 |         self.state().set_global(name);
172 |     }
173 | 
174 |     /// Registers a module using preloading.
175 |     pub fn register_lib<S: AsRef<str>>(&self, name: S, loader: Function) {
176 |         self.state().get_global("package");
177 |         self.state().get_field(-1, "preload");
178 | 
179 |         self.push_fn(loader);
180 | 
181 |         self.state().set_field(-2, name.as_ref());
182 |         self.state().pop(2);
183 |     }
184 | 
185 |     /// Loads a table of functions as a module.
186 |     pub fn load_lib(&self, mtable: &[(&str, Function)]) {
187 |         self.state().create_table(0, mtable.len() as i32);
188 | 
189 |         for &(name, func) in mtable {
190 |             self.push_fn(func);
191 |             self.state().set_field(-2, name);
192 |         }
193 |     }
194 | 
195 |     /// Pushes a safe Rust function onto the stack.
196 |     pub fn push_fn(&self, function: Function) {
197 |         unsafe {
198 |             // Push a pointer to the given function so that we know what function to delegate to.
199 |             self.state().push_light_userdata(function as *mut c_void);
200 |         }
201 | 
202 |         // Push a wrapper function onto the stack, which delegates to the given function.
203 |         self.state().push_closure(Some(fn_wrapper), 1);
204 | 
205 |         // Wrapper function for invoking Rust functions from inside Lua.
206 |         unsafe extern fn fn_wrapper(ptr: *mut ffi::lua_State) -> c_int {
207 |             // Get the runtime from the raw pointer.
208 |             let runtime = Runtime::from_ptr(ptr);
209 | 
210 |             // Get the raw pointer and turn it back into a Rust function pointer.
211 |             let fn_ptr = runtime.state().to_userdata(ffi::lua_upvalueindex(1));
212 |             let function: Function = mem::transmute(fn_ptr);
213 | 
214 |             // Invoke the function.
215 |             function(runtime).unwrap_or_else(|err: Box<Error>| {
216 |                 let mut state = lua::State::from_ptr(ptr);
217 | 
218 |                 state.location(1);
219 |                 state.push_string(err.description());
220 |                 state.concat(2);
221 |                 state.error();
222 |             }) as c_int
223 |         }
224 |     }
225 | 
226 |     /// Pushes a safe Rust closure onto the stack.
227 |     pub fn push_closure(&self, closure: Box<Closure>) {
228 |         unsafe {
229 |             // Push a pointer to the closure so that we know what to delegate to.
230 |             let closure_ptr = self.state().new_userdata_typed();
231 |             ptr::write(closure_ptr, Box::into_raw(closure));
232 | 
233 |             // Tell Lua how to clean up the closure.
234 |             if self.state().get_metatable(-1) {
235 |                 self.state().push_fn(Some(drop_closure));
236 |                 self.state().set_field(-2, "__gc");
237 |                 self.state().pop(1);
238 |             }
239 |         }
240 | 
241 |         // Push a wrapper function onto the stack, which delegates to the given function.
242 |         self.state().push_closure(Some(closure_wrapper), 1);
243 | 
244 |         // Wrapper function for invoking Rust functions from inside Lua.
245 |         unsafe extern fn closure_wrapper(ptr: *mut ffi::lua_State) -> c_int {
246 |             // Get the runtime from the raw pointer.
247 |             let runtime = Runtime::from_ptr(ptr);
248 | 
249 |             // Get the upvalue and turn it back into a Rust closure pointer.
250 |             let closure_ptr = runtime.state().to_userdata(ffi::lua_upvalueindex(1));
251 |             let closure: *mut *mut Closure = mem::transmute(closure_ptr);
252 | 
253 |             // Invoke the closure.
254 |             (**closure)(runtime).unwrap_or_else(|err: Box<Error>| {
255 |                 let mut state = lua::State::from_ptr(ptr);
256 | 
257 |                 state.location(1);
258 |                 state.push_string(err.description());
259 |                 state.concat(2);
260 |                 state.error();
261 |             }) as c_int
262 |         }
263 | 
264 |         // Cleans up the memory of a closure.
265 |         unsafe extern fn drop_closure(ptr: *mut ffi::lua_State) -> c_int {
266 |             let mut state = lua::State::from_ptr(ptr);
267 | 
268 |             // Get the closure to free.
269 |             let closure_ptr = state.to_userdata(1);
270 |             let closure: *mut *mut Closure = mem::transmute(closure_ptr);
271 |             let closure_box = Box::from_raw(*closure);
272 | 
273 |             // Free the closure.
274 |             drop(closure_box);
275 | 
276 |             0
277 |         }
278 |     }
279 | 
280 |     /// Returns an iterator for iterating over the table at the top of the stack.
281 |     pub fn iter(&self, index: lua::Index) -> iter::TableIterator {
282 |         iter::TableIterator::new(self.state(), index)
283 |     }
284 | 
285 |     /// Wrapper around `lua_pcall()` that catches errors as a result.
286 |     pub fn call(&self, nargs: i32, nresults: i32, msgh: i32) -> Result<lua::ThreadStatus, Box<Error>> {
287 |         let status = self.state().pcall(nargs, nresults, msgh);
288 | 
289 |         if status.is_err() {
290 |             if self.state().is_string(-1) {
291 |                 Err(self.state().to_str(-1).unwrap().to_string().into())
292 |             } else {
293 |                 Err("unknown error".into())
294 |             }
295 |         } else {
296 |             Ok(status)
297 |         }
298 |     }
299 | 
300 |     /// Pushes the value of a registry key onto the stack.
301 |     pub fn reg_get(&self, name: &str) {
302 |         self.state().push(name);
303 |         self.state().get_table(lua::REGISTRYINDEX);
304 |     }
305 | 
306 |     /// Sets a registry key to the value at the top of the stack.
307 |     pub fn reg_set(&self, name: &str) {
308 |         self.state().push(name);
309 |         self.state().push_value(-2);
310 |         self.state().set_table(lua::REGISTRYINDEX);
311 |         self.state().pop(1);
312 |     }
313 | }
314 | 
315 | /// Implement cloning for runtime references, with the same semantics as an Rc.
316 | impl Clone for Runtime {
317 |     fn clone(&self) -> Self {
318 |         Runtime {
319 |             environment: self.environment.clone(),
320 |             state: self.state(),
321 |         }
322 |     }
323 | }
324 | 
325 | /// Safe type ID numeric function.
326 | fn type_id_of<T: Any>() -> u64 {
327 |     let type_id = TypeId::of::<T>();
328 |     let mut hasher = SipHasher::new();
329 |     type_id.hash(&mut hasher);
330 |     hasher.finish()
331 | }
332 | 


--------------------------------------------------------------------------------
/src/task.rs:
--------------------------------------------------------------------------------
  1 | use std::cmp::Ordering;
  2 | use std::error::Error;
  3 | use std::hash::{Hash, Hasher};
  4 | 
  5 | 
  6 | /// A single task that can be run.
  7 | ///
  8 | /// A task represents a single unit of work. Tasks are created after all rules and named tasks are
  9 | /// already defined.
 10 | pub trait Task {
 11 |     /// Gets the synthesized name of the task.
 12 |     fn name<'a>(&'a self) -> &'a str;
 13 | 
 14 |     /// Checks if the task is satisfied.
 15 |     ///
 16 |     /// A task is not satisfied when its conditions are not met and its action must be run to
 17 |     /// create the desired output and move to the satisfied state. Task implementations should make
 18 |     /// sure that this always returns `true` after the action is run.
 19 |     fn satisfied(&self) -> bool;
 20 | 
 21 |     /// Gets an array of task names that this task depends on.
 22 |     fn dependencies(&self) -> &[String];
 23 | 
 24 |     /// Runs the task.
 25 |     fn run(&self) -> Result<(), Box<Error>>;
 26 | }
 27 | 
 28 | type ActionFn = Fn() -> Result<(), Box<Error>>;
 29 | 
 30 | /// A single named build task.
 31 | pub struct NamedTask {
 32 |     /// The name of the task.
 33 |     pub name: String,
 34 | 
 35 |     /// The task description.
 36 |     pub description: Option<String>,
 37 | 
 38 |     /// A list of tasks that must be ran before this task.
 39 |     pub dependencies: Vec<String>,
 40 | 
 41 |     /// Rule action.
 42 |     action: Option<Box<ActionFn>>,
 43 | }
 44 | 
 45 | impl NamedTask {
 46 |     pub fn new<S, V, F>(name: S,
 47 |                         description: Option<S>,
 48 |                         dependencies: V,
 49 |                         action: Option<F>)
 50 |                         -> NamedTask
 51 |         where S: Into<String>,
 52 |               V: Into<Vec<String>>,
 53 |               F: Fn() -> Result<(), Box<Error>> + 'static
 54 |     {
 55 |         NamedTask {
 56 |             name: name.into(),
 57 |             description: description.map(|s| s.into()),
 58 |             dependencies: dependencies.into(),
 59 |             action: action.map(|a| Box::new(a) as Box<ActionFn>),
 60 |         }
 61 |     }
 62 | 
 63 |     pub fn description<'a>(&'a self) -> Option<&'a str> {
 64 |         match self.description {
 65 |             Some(ref description) => Some(description),
 66 |             None => None,
 67 |         }
 68 |     }
 69 | }
 70 | 
 71 | impl Task for NamedTask {
 72 |     fn name<'a>(&'a self) -> &'a str {
 73 |         &self.name
 74 |     }
 75 | 
 76 |     // Named tasks should always be run.
 77 |     fn satisfied(&self) -> bool {
 78 |         false
 79 |     }
 80 | 
 81 |     fn dependencies(&self) -> &[String] {
 82 |         &self.dependencies
 83 |     }
 84 | 
 85 |     fn run(&self) -> Result<(), Box<Error>> {
 86 |         if let Some(ref action) = self.action {
 87 |             action()
 88 |         } else {
 89 |             Ok(())
 90 |         }
 91 |     }
 92 | }
 93 | 
 94 | // Implement ordering and comparison for all task types.
 95 | impl Eq for Task {}
 96 | 
 97 | impl PartialEq for Task {
 98 |     fn eq(&self, other: &Task) -> bool {
 99 |         self.name() == other.name()
100 |     }
101 | }
102 | 
103 | impl Ord for Task {
104 |     fn cmp(&self, other: &Task) -> Ordering {
105 |         self.name().cmp(other.name())
106 |     }
107 | }
108 | 
109 | impl PartialOrd for Task {
110 |     fn partial_cmp(&self, other: &Task) -> Option<Ordering> {
111 |         self.name().partial_cmp(other.name())
112 |     }
113 | }
114 | 
115 | impl Hash for Task {
116 |     fn hash<H>(&self, state: &mut H)
117 |         where H: Hasher
118 |     {
119 |         self.name().hash(state)
120 |     }
121 | }
122 | 


--------------------------------------------------------------------------------
/tests/core.lua:
--------------------------------------------------------------------------------
 1 | WORLD = "Earth"
 2 | assert(rote.expand("Hello $WORLD!") == "Hello Earth!")
 3 | 
 4 | assert(rote.merge(nil, {}) ~= nil)
 5 | assert(rote.merge({
 6 |     foo = "bar"
 7 | }, {}).foo == "bar")
 8 | assert(rote.merge({}, {
 9 |     foo = "bar"
10 | }).foo == "bar")
11 | assert(rote.merge({
12 |     foo = "bar"
13 | }, {
14 |     foo = "baz"
15 | }).foo == "baz")
16 | 


--------------------------------------------------------------------------------
/tests/fixtures/fs1.in:
--------------------------------------------------------------------------------
1 | hello
2 | 


--------------------------------------------------------------------------------
/tests/fixtures/fs2.in:
--------------------------------------------------------------------------------
1 | world
2 | 


--------------------------------------------------------------------------------
/tests/fs.lua:
--------------------------------------------------------------------------------
 1 | require "fs"
 2 | 
 3 | 
 4 | assert(fs.exists("tests") == true)
 5 | assert(fs.exists("tests/fs.lua") == true)
 6 | assert(fs.exists("tests/fs.looa") == false)
 7 | 
 8 | fs.mkdir("tests/fstestdir")
 9 | assert(fs.exists("tests/fstestdir") == true)
10 | fs.remove("tests/fstestdir")
11 | assert(fs.exists("tests/fstestdir") == false)
12 | 
13 | assert(fs.get("tests/fixtures/fs1.in") == "hello\n")
14 | 
15 | fs.put("tests/fixtures/fs1.out", "hello\n")
16 | assert(fs.get("tests/fixtures/fs1.out") == "hello\n")
17 | 
18 | fs.append("tests/fixtures/fs1.out", "world\n")
19 | assert(fs.get("tests/fixtures/fs1.out") == "hello\nworld\n")
20 | 
21 | fs.combine(
22 |     {
23 |         "tests/fixtures/fs1.in",
24 |         "tests/fixtures/fs2.in"
25 |     },
26 |     "tests/fixtures/fs2.out"
27 | )
28 | assert(fs.get("tests/fixtures/fs2.out") == "hello\nworld\n")
29 | 
30 | fs.remove("tests/fixtures/fs1.out")
31 | assert(fs.exists("tests/fixtures/fs1.out") == false)
32 | fs.remove("tests/fixtures/fs2.out")
33 | assert(fs.exists("tests/fixtures/fs2.out") == false)
34 | 


--------------------------------------------------------------------------------
/tests/json.lua:
--------------------------------------------------------------------------------
 1 | json = require "json"
 2 | 
 3 | 
 4 | assert(json.parse)
 5 | assert(json.stringify)
 6 | 
 7 | do -- json.parse
 8 |     assert(json.parse("null") == nil)
 9 |     assert(json.parse("true") == true)
10 |     assert(json.parse("42") == 42)
11 |     assert(json.parse("\"marvin\"") == "marvin")
12 | 
13 |     local result = json.parse([[{
14 |         "code": 200,
15 |         "success": true,
16 |         "payload": {
17 |             "features": [
18 |                 "awesome",
19 |                 "easyAPI",
20 |                 "lowLearningCurve"
21 |             ]
22 |         }
23 |     }]])
24 | 
25 |     assert(type(result) == "table")
26 |     assert(result.code == 200)
27 |     assert(result.success == true)
28 |     assert(type(result.payload) == "table")
29 |     assert(type(result.payload.features) == "table")
30 |     assert(result.payload.features[1] == "awesome")
31 |     assert(result.payload.features[2] == "easyAPI")
32 |     assert(result.payload.features[3] == "lowLearningCurve")
33 | end
34 | 
35 | do -- json.stringify
36 |     assert(json.stringify(nil) == "null")
37 |     assert(json.stringify(true) == "true")
38 |     assert(json.stringify(42) == "42")
39 |     assert(json.stringify("marvin") == "\"marvin\"")
40 |     assert(json.stringify({
41 |         life = 42
42 |     }) == "{\"life\":42}")
43 | end
44 | 


--------------------------------------------------------------------------------