The lake Reference Manual

This is the lake Reference Manual, version 0.1.3, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon May 15 05:26:05 2023 GMT+0.

Table of Contents


1 Introduction


2 Systems

The main system appears first, followed by any subsystem dependency.


2.1 lake

Lake is a GNU make like build utility in Common Lisp.

Author

Rudolph Miller and Masayuki Takagi

Home Page

https://github.com/takagi/lake

License

MIT

Long Description

# Lake

[![Circle CI](https://circleci.com/gh/takagi/lake.svg?style=shield)](https://circleci.com/gh/takagi/lake)
[![Coverage Status](https://coveralls.io/repos/takagi/lake/badge.svg?branch=master&service=github)](https://coveralls.io/github/takagi/lake?branch=master)

Lake is a GNU make or Ruby’s [rake](https://github.com/ruby/rake) like build utility in Common Lisp. Instead of Makefile or Rakefile, it uses Lakefile where tasks executed are defined.

Make is, originally, a program to build executable files to compile multiple source files and resolve their dependency, however its use case may not be limited as a build utility but shell command management is also good. Lake’s main use case would be the latter.

## Usage

In lake, you use ‘Lakefile‘ instead of ‘Makefile‘ or ‘Rakefile‘.

;; Tasks that build an executable with dependency.
(defparameter cc (getenv "CC" "gcc"))

(file "hello" ("hello.o" "message.o")
(sh #?"${cc} -o hello hello.o message.o"))

(file "hello.o" ("hello.c")
(sh #?"${cc} -c hello.c"))

(file "message.o" ("message.c")
(sh #?"${cc} -c message.c"))

(task "clean" ()
(sh "rm -rf hello hello.o message.o"))

From REPL, you can call ‘hello‘ task with the following form. Ensure that the REPL process’ current directory is same as the ‘Lakefile‘.

(lake:lake :target "hello")

Or you can also call it from command line, which would be the main use case of lake.

$ lake hello

As a tip, you can generate an empty Lakefile with package related boilerplates in the current directory as:

$ lake-tools init

Further detail, please see [Lakefile](#Lakefile) section and [API](#API) section.

## Install

### On OSX

brew tap takagi/lake https://github.com/takagi/lake
brew install lake

### Via Quicklisp

(ql:quickload :lake)

### Using Roswell

Also you can install it using Roswell including ‘lake‘ command. Ensure that ‘PATH‘ environment variable contains ‘~/.roswell/bin‘.

$ ros install lake
$ which lake
/path/to/home/.roswell/bin/lake

## Lakefile

Lake provides the following forms to define tasks and namespaces in ‘Lakefile‘:
- **Task** is the fundamental concept processing a sequence of shell commands
- **File Task** is a task resolving file dependency with up-to-date check
- **Directory Task** is a task that ensures a directory exists.
- **Namespace** is for grouping up multiple tasks to magage them.

### Task

TASK task-name dependency-list [description] form*

‘task‘ represents a sequence of operations to accomplish some task. ‘task-name‘ is a string that specifies the target task by its name. ‘dependency-list‘ is a list of task names on which the target task depends. The dependency task names are given in both relative and absolute manner, which begins with a colon ‘:‘. ‘description‘ is a doc string. ‘form‘s can be any Common Lisp forms.

$ cat Lakefile
...
(namespace "hello"

(task "foo" ("bar") ; dependency task in relative manner
(echo "hello.foo"))

(task "bar" (":hello:baz") ; dependency task in absolute manner
(echo "hello.bar"))

(task "baz" ()
(echo "hello.baz")))

$ lake hello:foo
hello.foo
hello.bar
hello.baz

### File

FILE file-name dependency-list [description] form*

‘file‘ task represents a sequence of operations as well as ‘task‘ except that it is executed only when the target file is out of date. ‘file-name‘ is a string that specifies the target file’s name. ‘dependency-list‘ is a list of tasks or file names on which the target file depends. The dependency task/file names are given in both relative and absolute manner, which begins with a colon ‘:‘. ‘description‘ is a doc string. ‘form‘s can be any Common Lisp forms.

$ cat Lakefile
...
(file "hello" ("hello.c")
"Compile hello from C source code."
(sh "gcc -o hello hello.c"))

$ lake hello
$ ls
Lakefile hello hello.c

### Directory

DIRECTORY directory-name [description]

‘directory‘ task represents a task that ensures a directory with name of ‘directory-name‘ exists. ‘description‘ is a doc string. ‘directory‘ task does not depend on other tasks.

$ cat Lakefile
...
(directory "dir")

$ lake dir
$ ls
Lakefile dir

### Namespace

NAMESPACE namespace form*

‘namespace‘ groups up multiple tasks for ease of their management. ‘namespace‘ is a string that specifies the namespace. Tasks in a namespace are refered with the namespace as prefix separated with a colon ‘:‘. Namespaces may be recursive.

$ cat Lake
...
(namespace "foo"
(namespace "bar"
(task "baz" ()
(echo "foo.bar.baz")))))

$ lake foo:bar:baz
foo.bar.baz

### Task arguments

‘task‘ and ‘file‘ task may take task arguments with which users can supply additional information used in task execution. Task arguments are defined as following:

(task ("hello" first-name last-name) ()
(echo #?"Hello ${first-name} ${last-name}!"))

Here ‘hello‘ task takes two task arguments, ‘first-name‘ and ‘last-name‘, and uses them in the task action to echo a line.

Task arguments may have their default value as following:

(task ("hello" (first-name "john") (last-name "doe") ()
(echo #?"Hello ${first-name} ${last-name}!"))

To supply task arguments to a task, the task name followed by bracket enclosed string is passed to ‘lake‘ function:

> (lake "hello[john,doe]")
Hello john doe!

or ‘lake‘ command in the command line:

$ lake hello[john,doe]
Hello john doe!

If no task argument is supplied, environment variable whose name is the upcase of the name of the task argument is searched and its value is used if it is found. If no such an environment variable, the default value of the task argument is used. If no default value is defined, the task argument has ‘nil‘.

Note that task arguments following the task name does not include spaces because the shell splits the command at the existence of the spaces.

$ lake hello[john, doe]
No task "hello[john," found.

If spaces are needed, the task name and following task arguments should be quoted.

$ lake "hello[billy bob, smith]"
Hello billy bob smith!

For convenience, if the string supplied to a task argument via a bracket enclosed string or an environment variable is "t", "nil" or their uppercase, it is read to ‘t‘ or ‘nil‘ and the task argument has the read value. Otherwise, the task argument has the string as it is without being read.

### Lakefile Modularity

Lakefile modularity is quite easy without any special facilities, just ‘load‘ a Lakefile from another is enough. Tasks with same name are replaced with newer loaded as ones in a Lakefile. Namespaces with same name are merged into.

Lakefile

(load "Lakefile.sub")

(namespace "name"
(task "foo"
(echo "name.foo")))

Lakefile.sub

(namespace "name"
(task "bar"
(echo "name.bar")))

So you can execute the two tasks respectively as following.

$ ls
Lakefile Lakefile.sub
$ lake name:foo
name.foo
$ lake name:bar
name.bar

## API

### [Function] lake

LAKE &key target pathname jobs verbose

Loads a Lakefile specified with ‘pathname‘ to execute a task of name ‘target‘ defined in the Lakefile. ‘jobs‘ as an integer gives how many tasks execute simultaneously. The default number is one, which means serial execution. Not nil ‘verbose‘ provides verbose mode. If ‘target‘ is not given, ‘"default"‘ is used for the default task name. If ‘pathname‘ is not given, a file of name ‘Lakefile‘ in the current directory is searched for. You should be aware that where the Common Lisp process’ current directory is.

(lake :target "hello")

### [Function] echo

ECHO string

Writes the given ‘string‘ into the standard output followed by a new line, provided for UNIX terminology convenience.

(task "say-hello" ()
(echo "Hello world!"))

### [Function] sh

SH command &key echo

Spawns a subprocess that runs the specified ‘command‘ given as a string or list of strings. When ‘echo‘ is not ‘nil‘, prints ‘command‘ to the standard output before running it. Actually it is a very thin wrapper of ‘uiop:run-program‘ provided for UNIX terminology convenience.
Acompanied with cl-interpol’s ‘#?‘ reader macro, you get more analogous expressions to shell scripts.

(defparameter cc "gcc")

(task "hello" ("hello.c")
(sh #?"${cc} -o hello hello.c"))

### [Function] ssh

SSH command &key echo

Spawns a subprocess that runs the specified ‘command‘, given as a string or list of strings, on a remote host using ‘ssh(1)‘. ‘*ssh-host*‘, ‘*ssh-user*‘ and ‘*ssh-identity*‘ should be bound properly before use this. When ‘echo‘ is not ‘nil‘, prints ‘ssh‘ command published to the standard output before running it.

(setf *ssh-host* "remotehost")
(setf *ssh-user* "user")
(task "hello-via-ssh" ()
(ssh "echo Hello World!"))

Note that the following binding does not work as intended because the dynamic binding only keep when ‘task‘ macro is evaluated, have already exited when ‘ssh‘ function is to be actually evaluated.

;; Does not work as intended.
(let ((*ssh-host* "localhost")
(*ssh-user* "‘whoami‘"))
(task "hello-via-ssh" ()
(ssh "echo Hello World!")))

Instead, the next works as intended. Anyway, the former style with ‘setf‘ would be enough in Lakefile.

;; Works as intended.
(task "hello-via-ssh" ()
(let ((*ssh-host* "localhost")
(*ssh-user* "‘whoami‘"))
(ssh "echo Hello World!")))

### [Special Variable] \*ssh-host\*, \*ssh-user\*, \*ssh-identity\*

These special variables are used to establish a secure connection using ‘ssh‘ function. The default value of ‘*ssh-host*‘ is unbound so it should be always bound properly when using secure connections. The default value of ‘*ssh-user*‘ is ‘nil‘, for giving optional user name. The default value of ‘*ssh-identity*‘ is ‘nil‘, for giving optional identity file to prove his/her identity to the remote machine.

### [Function] scp

SCP from-place pathspec1 to-place pathspec2 &key echo

Copies files between hosts on a network using ‘scp(1)‘. ‘from-place‘, which must be ‘:local‘ or ‘:remote‘, specifies if ‘pathspec1‘ is a file path on local host or remote host respectively. ‘pathspec1‘ is a file path to be copied from, given as a string or a pathname. ‘to-place‘ and ‘pathspec2‘ are same as ‘from-place‘ and ‘pathspec1‘ except that they are about files to be copied to.

As ‘ssh‘ function above, ‘*ssh-host*‘, ‘*ssh-user*‘ and ‘*ssh-identity*‘ should be bound properly before use this. When ‘echo‘ is not ‘nil‘, prints ‘scp‘ command published to the standard output before running it.

(setf *ssh-host* "remotehost")
(setf *ssh-user* "user")
(task "scp" ()
"Copy ~/foo on local host to ~/foo on remote host."
(scp :local "~/foo" :remote "~/foo"))

### [Function] execute

EXECUTE target

Executes a task specified with ‘target‘ as a string within another. The name of the target task is resolved as well as ‘task‘ macro’s dependency list in both relative and absolute manner.

(task "hello" ("hello.c")
(sh "gcc -o hello hello.c")
(execute "ls"))

(task "ls" ()
(sh "ls -l"))

### [Function] display-tasks

DISPLAY-TASKS &key pathname verbose

Displays the tasks with descriptions in a Lakefile specified with ‘pathname‘. Not nil ‘verbose‘ provides verbose mode. If ‘pathname‘ is not given, a file of name ‘Lakefile‘ in the current direcotry is searched for. You should be aware that where the Common Lisp process’ current directory is.

(display-tasks)

## Command Line Interface

### lake

Lake provides its command line interface as a roswell script or a
binary, if built with the Homebrew.

SYNOPSIS

lake [ -f lakefile ] [ options ] ... [ targets ] ...

OPTIONS

-f, –file FILE
Use FILE as a Lakefile.
-h, –help
Print usage.
-j INTEGER
Execute multiple tasks simultaneously.
-T, –list
Display the tasks with descriptions, then exit.
-v, –verbose
Verbose mode.

EXAMPLE

$ lake hello:foo hello:bar

### lake-tools

Lake also provides ‘lake-tools‘ command as a roswell script which is a complementary program to provide some useful goodies.

Here shows ‘lake-tools‘ command’s detail. ‘lake-tools init‘ command would be replaced by roswell’s ‘ros init‘ facility (See issue #12).

SYNOPSIS

lake-tools COMMAND

COMMANDS

dump Prepare LAKE command to make it run much faster.
init Create an empty Lakefile with boilerplates in current directory.

EXAMPLE

$ lake-tools init
$ ls
Lakefile

## Brief History

Originally lake was called clake, and [@Rudolph-Miller](https://github.com/Rudolph-Miller) gave its name and concept on his GitHub repository. Then, [@takagi](https://github.com/takagi) forked it to design, implement, test, document and CI independently. Afterwards it is renamed to lake.

## Author

* Rudolph Miller (chopsticks.tk.ppfm@gmail.com)
* Masayuki Takagi (kamonama@gmial.com)

## Copyright

Copyright (c) 2015 Rudolph Miller (chopsticks.tk.ppfm@gmail.com)

## License

Licensed under the MIT License.

Version

0.1.3

Dependencies
Source

lake.asd.


2.2 lake/main

Author

Rudolph Miller and Masayuki Takagi

Home Page

https://github.com/takagi/lake

License

MIT

Dependency

lake/user (system).

Source

lake.asd.


2.3 lake/user

Author

Rudolph Miller and Masayuki Takagi

Home Page

https://github.com/takagi/lake

License

MIT

Dependency

lake/core (system).

Source

lake.asd.


2.4 lake/core

Author

Rudolph Miller and Masayuki Takagi

Home Page

https://github.com/takagi/lake

License

MIT

Dependencies
  • cl-ppcre (system).
  • cl-syntax (system).
  • alexandria (system).
  • split-sequence (system).
Source

lake.asd.


3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


3.1 Lisp


3.1.1 lake/lake.asd

Source

lake.asd.

Parent Component

lake (system).

ASDF Systems
Packages

lake-asd.


3.1.2 lake/main/file-type.lisp

Source

lake.asd.

Parent Component

lake/main (system).

Packages

lake/main.

Public Interface
Internals

3.1.3 lake/user/file-type.lisp

Source

lake.asd.

Parent Component

lake/user (system).

Packages

lake/user.


3.1.4 lake/core/file-type.lisp

Source

lake.asd.

Parent Component

lake/core (system).

Packages

lake.

Public Interface
Internals

4 Packages

Packages are listed by definition order.


4.1 lake/main

Source

file-type.lisp.

Use List

common-lisp.

Public Interface
Internals

4.2 lake

Source

file-type.lisp.

Nickname

lake/core

Use List

common-lisp.

Used By List

lake/user.

Public Interface
Internals

4.3 lake/user

Source

file-type.lisp.

Use List
  • common-lisp.
  • lake.

4.4 lake-asd

Source

lake.asd.

Use List
  • asdf/interface.
  • common-lisp.

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


5.1 Public Interface


5.1.1 Special variables

Special Variable: *path*
Package

lake.

Source

file-type.lisp.

Special Variable: *ssh-host*
Package

lake.

Source

file-type.lisp.

Special Variable: *ssh-identity*
Package

lake.

Source

file-type.lisp.

Special Variable: *ssh-user*
Package

lake.

Source

file-type.lisp.


5.1.2 Macros

Macro: directory (name &optional desc)
Package

lake.

Source

file-type.lisp.

Macro: file (name-and-args dependency &body body)
Package

lake.

Source

file-type.lisp.

Macro: namespace (namespace &body body)
Package

lake.

Source

file-type.lisp.

Macro: task (name-and-args dependency &body body)
Package

lake.

Source

file-type.lisp.


5.1.3 Ordinary functions

Function: display-tasks (&key pathname verbose)
Package

lake.

Source

file-type.lisp.

Function: echo (string)
Package

lake.

Source

file-type.lisp.

Function: execute (name)
Package

lake.

Source

file-type.lisp.

Function: getenv (name &optional default)
Package

lake.

Source

file-type.lisp.

Function: lake (&key target filename jobs verbose)
Package

lake.

Source

file-type.lisp.

Function: main (&rest argv)
Package

lake/main.

Source

file-type.lisp.

Function: scp (from-place pathspec1 to-place pathspec2 &key echo)
Package

lake.

Source

file-type.lisp.

Function: uiop-main ()
Package

lake/main.

Source

file-type.lisp.


5.1.4 Generic functions

Generic Function: sh (command &key echo)

Takes a string or list of strings and runs it from a shell.

Package

lake.

Source

file-type.lisp.

Methods
Method: sh ((command list) &key echo)
Method: sh ((command string) &key echo)
Generic Function: ssh (command &key echo)

Takes a string or list of strings and runs it from a shell on a remote host.

Package

lake.

Source

file-type.lisp.

Methods
Method: ssh ((command list) &key echo)
Method: ssh ((command string) &key echo)

5.1.5 Standalone methods

Method: print-object ((task task) stream)
Source

file-type.lisp.


5.1.6 Classes

Class: task
Package

lake.

Source

file-type.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

task-name.

Writers

This slot is read-only.

Slot: namespace
Initargs

:namespace

Readers

task-namespace.

Writers

This slot is read-only.

Slot: arguments
Initargs

:arguments

Readers

task-arguments.

Writers

This slot is read-only.

Slot: dependency
Initargs

:dependency

Readers

task-dependency.

Writers

This slot is read-only.

Slot: description
Initargs

:description

Readers

task-description.

Writers

This slot is read-only.

Slot: action
Initargs

:action

Readers

task-action.

Writers

This slot is read-only.


5.2 Internals


5.2.1 Special variables

Special Variable: *context-jobs*
Package

lake.

Source

file-type.lisp.

Special Variable: *context-namespace*
Package

lake.

Source

file-type.lisp.

Special Variable: *context-plist*
Package

lake.

Source

file-type.lisp.

Special Variable: *context-tasks*
Package

lake.

Source

file-type.lisp.

Special Variable: *current-lakefile*
Package

lake.

Source

file-type.lisp.

Special Variable: *namespace*
Package

lake.

Source

file-type.lisp.

Special Variable: *tasks*
Package

lake.

Source

file-type.lisp.

Special Variable: *verbose*
Package

lake.

Source

file-type.lisp.

Special Variable: +lakefile-template+
Package

lake.

Source

file-type.lisp.

Special Variable: +scp-control-string+
Package

lake.

Source

file-type.lisp.

Special Variable: +ssh-control-string+
Package

lake.

Source

file-type.lisp.


5.2.2 Macros

Macro: register-task (task tasks)
Package

lake.

Source

file-type.lisp.


5.2.3 Ordinary functions

Function: %display-tasks (tasks)
Package

lake.

Source

file-type.lisp.

Function: %run-task (target tasks plist jobs)
Package

lake.

Source

file-type.lisp.

Function: arg-pair-p (x)
Package

lake.

Source

file-type.lisp.

Function: argument-p (x)
Package

lake.

Source

file-type.lisp.

Function: compute-dependency (name tasks)
Package

lake.

Source

file-type.lisp.

Function: construct-plist (name args tasks)
Package

lake.

Source

file-type.lisp.

Function: dependency-file-name (task-name)
Package

lake.

Source

file-type.lisp.

Function: directory-task-directory-name (directory-task)
Package

lake.

Source

file-type.lisp.

Function: ensure-directory-pathspec (pathspec)
Package

lake.

Source

file-type.lisp.

Function: ensure-pair (x)
Package

lake.

Source

file-type.lisp.

Function: escape-for-shell (string)
Package

lake.

Source

file-type.lisp.

Function: file-task-file-name (file-task)
Package

lake.

Source

file-type.lisp.

Function: file-task-out-of-date (file-task)
Package

lake.

Source

file-type.lisp.

Function: file-task-to-be-executed-p (file-task)
Package

lake.

Source

file-type.lisp.

Function: file-timestamp (file-name)
Package

lake.

Source

file-type.lisp.

Function: fqtn-endname (fqtn)
Package

lake.

Source

file-type.lisp.

Function: fqtn-namespace (fqtn)
Package

lake.

Source

file-type.lisp.

Function: get-environment-variable (name)
Package

lake.

Source

file-type.lisp.

Function: get-lakefile-pathname (&optional name)
Package

lake.

Source

file-type.lisp.

Function: get-task (name tasks)
Package

lake.

Source

file-type.lisp.

Function: get-task-arguments (task plist)
Package

lake.

Source

file-type.lisp.

Function: initialize-lakefile (path)
Package

lake.

Source

file-type.lisp.

Function: load-lakefile (pathname)
Package

lake.

Source

file-type.lisp.

Function: make-directory-task (name namespace desc)
Package

lake.

Source

file-type.lisp.

Function: make-file-task (name namespace args dependency desc action)
Package

lake.

Source

file-type.lisp.

Function: make-task (name namespace args dependency desc action)
Package

lake.

Source

file-type.lisp.

Function: maybe (fn x)
Package

lake.

Source

file-type.lisp.

Function: name-and-args-p (x)
Package

lake.

Source

file-type.lisp.

Function: parse-args (string result)
Package

lake.

Source

file-type.lisp.

Function: parse-body (forms)
Package

lake.

Source

file-type.lisp.

Function: parse-target (string)
Package

lake.

Source

file-type.lisp.

Function: print-help ()
Package

lake/main.

Source

file-type.lisp.

Function: print-tasks (pathname &key verbose)
Package

lake/main.

Source

file-type.lisp.

Function: prompt (message &key allowed-answers)
Package

lake.

Source

file-type.lisp.

Function: read-argument-from-string (string)
Package

lake.

Source

file-type.lisp.

Function: resolve-dependency-task-name (name namespace)
Package

lake.

Source

file-type.lisp.

Function: resolve-dependency-task-names (dependency namespace)
Package

lake.

Source

file-type.lisp.

Function: resolve-task-name (name namespace)
Package

lake.

Source

file-type.lisp.

Function: run-task (target tasks &optional jobs)
Package

lake.

Source

file-type.lisp.

Function: run-task-serial (target tasks plist)
Package

lake.

Source

file-type.lisp.

Function: scp-filepath (pathspec place)
Package

lake.

Source

file-type.lisp.

Function: split-by-colon (string)
Package

lake.

Source

file-type.lisp.

Function: task-exists-p (name tasks)
Package

lake.

Source

file-type.lisp.

Function: task= (task1 task2)
Package

lake.

Source

file-type.lisp.

Function: tasks-max-width (tasks)
Package

lake.

Source

file-type.lisp.

Function: traverse-tasks (name tasks)
Package

lake.

Source

file-type.lisp.

Function: valid-dependency-task-name-p (name)
Package

lake.

Source

file-type.lisp.

Function: valid-fqtn-p (string)
Package

lake.

Source

file-type.lisp.

Function: valid-name-part-p (string)
Package

lake.

Source

file-type.lisp.

Function: valid-namespace-p (namespace)
Package

lake.

Source

file-type.lisp.

Function: valid-task-name-p (task-name)
Package

lake.

Source

file-type.lisp.

Function: verbose (string &optional new-line stream)
Package

lake.

Source

file-type.lisp.


5.2.4 Generic functions

Generic Function: execute-task (task &optional args)
Package

lake.

Source

file-type.lisp.

Methods
Method: execute-task ((file-task file-task) &optional args)
Method: execute-task ((task task) &optional args)
Generic Reader: task-action (object)
Package

lake.

Methods
Reader Method: task-action ((task task))

automatically generated reader method

Source

file-type.lisp.

Target Slot

action.

Generic Reader: task-arguments (object)
Package

lake.

Methods
Reader Method: task-arguments ((task task))

automatically generated reader method

Source

file-type.lisp.

Target Slot

arguments.

Generic Reader: task-dependency (object)
Package

lake.

Methods
Reader Method: task-dependency ((task task))

automatically generated reader method

Source

file-type.lisp.

Target Slot

dependency.

Generic Reader: task-description (object)
Package

lake.

Methods
Reader Method: task-description ((task task))

automatically generated reader method

Source

file-type.lisp.

Target Slot

description.

Generic Reader: task-name (object)
Package

lake.

Methods
Reader Method: task-name ((task task))

automatically generated reader method

Source

file-type.lisp.

Target Slot

name.

Generic Reader: task-namespace (object)
Package

lake.

Methods
Reader Method: task-namespace ((task task))

automatically generated reader method

Source

file-type.lisp.

Target Slot

namespace.


5.2.5 Classes

Class: directory-task
Package

lake.

Source

file-type.lisp.

Direct superclasses

task.

Class: file-task
Package

lake.

Source

file-type.lisp.

Direct superclasses

task.

Direct methods

execute-task.


5.2.6 Types

Type: argument ()
Package

lake.

Source

file-type.lisp.

Type: name-and-args ()
Package

lake.

Source

file-type.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   %  
A   C   D   E   F   G   I   L   M   N   P   R   S   T   U   V  
Index Entry  Section

%
%display-tasks: Private ordinary functions
%run-task: Private ordinary functions

A
arg-pair-p: Private ordinary functions
argument-p: Private ordinary functions

C
compute-dependency: Private ordinary functions
construct-plist: Private ordinary functions

D
dependency-file-name: Private ordinary functions
directory: Public macros
directory-task-directory-name: Private ordinary functions
display-tasks: Public ordinary functions

E
echo: Public ordinary functions
ensure-directory-pathspec: Private ordinary functions
ensure-pair: Private ordinary functions
escape-for-shell: Private ordinary functions
execute: Public ordinary functions
execute-task: Private generic functions
execute-task: Private generic functions
execute-task: Private generic functions

F
file: Public macros
file-task-file-name: Private ordinary functions
file-task-out-of-date: Private ordinary functions
file-task-to-be-executed-p: Private ordinary functions
file-timestamp: Private ordinary functions
fqtn-endname: Private ordinary functions
fqtn-namespace: Private ordinary functions
Function, %display-tasks: Private ordinary functions
Function, %run-task: Private ordinary functions
Function, arg-pair-p: Private ordinary functions
Function, argument-p: Private ordinary functions
Function, compute-dependency: Private ordinary functions
Function, construct-plist: Private ordinary functions
Function, dependency-file-name: Private ordinary functions
Function, directory-task-directory-name: Private ordinary functions
Function, display-tasks: Public ordinary functions
Function, echo: Public ordinary functions
Function, ensure-directory-pathspec: Private ordinary functions
Function, ensure-pair: Private ordinary functions
Function, escape-for-shell: Private ordinary functions
Function, execute: Public ordinary functions
Function, file-task-file-name: Private ordinary functions
Function, file-task-out-of-date: Private ordinary functions
Function, file-task-to-be-executed-p: Private ordinary functions
Function, file-timestamp: Private ordinary functions
Function, fqtn-endname: Private ordinary functions
Function, fqtn-namespace: Private ordinary functions
Function, get-environment-variable: Private ordinary functions
Function, get-lakefile-pathname: Private ordinary functions
Function, get-task: Private ordinary functions
Function, get-task-arguments: Private ordinary functions
Function, getenv: Public ordinary functions
Function, initialize-lakefile: Private ordinary functions
Function, lake: Public ordinary functions
Function, load-lakefile: Private ordinary functions
Function, main: Public ordinary functions
Function, make-directory-task: Private ordinary functions
Function, make-file-task: Private ordinary functions
Function, make-task: Private ordinary functions
Function, maybe: Private ordinary functions
Function, name-and-args-p: Private ordinary functions
Function, parse-args: Private ordinary functions
Function, parse-body: Private ordinary functions
Function, parse-target: Private ordinary functions
Function, print-help: Private ordinary functions
Function, print-tasks: Private ordinary functions
Function, prompt: Private ordinary functions
Function, read-argument-from-string: Private ordinary functions
Function, resolve-dependency-task-name: Private ordinary functions
Function, resolve-dependency-task-names: Private ordinary functions
Function, resolve-task-name: Private ordinary functions
Function, run-task: Private ordinary functions
Function, run-task-serial: Private ordinary functions
Function, scp: Public ordinary functions
Function, scp-filepath: Private ordinary functions
Function, split-by-colon: Private ordinary functions
Function, task-exists-p: Private ordinary functions
Function, task=: Private ordinary functions
Function, tasks-max-width: Private ordinary functions
Function, traverse-tasks: Private ordinary functions
Function, uiop-main: Public ordinary functions
Function, valid-dependency-task-name-p: Private ordinary functions
Function, valid-fqtn-p: Private ordinary functions
Function, valid-name-part-p: Private ordinary functions
Function, valid-namespace-p: Private ordinary functions
Function, valid-task-name-p: Private ordinary functions
Function, verbose: Private ordinary functions

G
Generic Function, execute-task: Private generic functions
Generic Function, sh: Public generic functions
Generic Function, ssh: Public generic functions
Generic Function, task-action: Private generic functions
Generic Function, task-arguments: Private generic functions
Generic Function, task-dependency: Private generic functions
Generic Function, task-description: Private generic functions
Generic Function, task-name: Private generic functions
Generic Function, task-namespace: Private generic functions
get-environment-variable: Private ordinary functions
get-lakefile-pathname: Private ordinary functions
get-task: Private ordinary functions
get-task-arguments: Private ordinary functions
getenv: Public ordinary functions

I
initialize-lakefile: Private ordinary functions

L
lake: Public ordinary functions
load-lakefile: Private ordinary functions

M
Macro, directory: Public macros
Macro, file: Public macros
Macro, namespace: Public macros
Macro, register-task: Private macros
Macro, task: Public macros
main: Public ordinary functions
make-directory-task: Private ordinary functions
make-file-task: Private ordinary functions
make-task: Private ordinary functions
maybe: Private ordinary functions
Method, execute-task: Private generic functions
Method, execute-task: Private generic functions
Method, print-object: Public standalone methods
Method, sh: Public generic functions
Method, sh: Public generic functions
Method, ssh: Public generic functions
Method, ssh: Public generic functions
Method, task-action: Private generic functions
Method, task-arguments: Private generic functions
Method, task-dependency: Private generic functions
Method, task-description: Private generic functions
Method, task-name: Private generic functions
Method, task-namespace: Private generic functions

N
name-and-args-p: Private ordinary functions
namespace: Public macros

P
parse-args: Private ordinary functions
parse-body: Private ordinary functions
parse-target: Private ordinary functions
print-help: Private ordinary functions
print-object: Public standalone methods
print-tasks: Private ordinary functions
prompt: Private ordinary functions

R
read-argument-from-string: Private ordinary functions
register-task: Private macros
resolve-dependency-task-name: Private ordinary functions
resolve-dependency-task-names: Private ordinary functions
resolve-task-name: Private ordinary functions
run-task: Private ordinary functions
run-task-serial: Private ordinary functions

S
scp: Public ordinary functions
scp-filepath: Private ordinary functions
sh: Public generic functions
sh: Public generic functions
sh: Public generic functions
split-by-colon: Private ordinary functions
ssh: Public generic functions
ssh: Public generic functions
ssh: Public generic functions

T
task: Public macros
task-action: Private generic functions
task-action: Private generic functions
task-arguments: Private generic functions
task-arguments: Private generic functions
task-dependency: Private generic functions
task-dependency: Private generic functions
task-description: Private generic functions
task-description: Private generic functions
task-exists-p: Private ordinary functions
task-name: Private generic functions
task-name: Private generic functions
task-namespace: Private generic functions
task-namespace: Private generic functions
task=: Private ordinary functions
tasks-max-width: Private ordinary functions
traverse-tasks: Private ordinary functions

U
uiop-main: Public ordinary functions

V
valid-dependency-task-name-p: Private ordinary functions
valid-fqtn-p: Private ordinary functions
valid-name-part-p: Private ordinary functions
valid-namespace-p: Private ordinary functions
valid-task-name-p: Private ordinary functions
verbose: Private ordinary functions


A.3 Variables

Jump to:   *   +  
A   D   N   S  
Index Entry  Section

*
*context-jobs*: Private special variables
*context-namespace*: Private special variables
*context-plist*: Private special variables
*context-tasks*: Private special variables
*current-lakefile*: Private special variables
*namespace*: Private special variables
*path*: Public special variables
*ssh-host*: Public special variables
*ssh-identity*: Public special variables
*ssh-user*: Public special variables
*tasks*: Private special variables
*verbose*: Private special variables

+
+lakefile-template+: Private special variables
+scp-control-string+: Private special variables
+ssh-control-string+: Private special variables

A
action: Public classes
arguments: Public classes

D
dependency: Public classes
description: Public classes

N
name: Public classes
namespace: Public classes

S
Slot, action: Public classes
Slot, arguments: Public classes
Slot, dependency: Public classes
Slot, description: Public classes
Slot, name: Public classes
Slot, namespace: Public classes
Special Variable, *context-jobs*: Private special variables
Special Variable, *context-namespace*: Private special variables
Special Variable, *context-plist*: Private special variables
Special Variable, *context-tasks*: Private special variables
Special Variable, *current-lakefile*: Private special variables
Special Variable, *namespace*: Private special variables
Special Variable, *path*: Public special variables
Special Variable, *ssh-host*: Public special variables
Special Variable, *ssh-identity*: Public special variables
Special Variable, *ssh-user*: Public special variables
Special Variable, *tasks*: Private special variables
Special Variable, *verbose*: Private special variables
Special Variable, +lakefile-template+: Private special variables
Special Variable, +scp-control-string+: Private special variables
Special Variable, +ssh-control-string+: Private special variables


A.4 Data types