The lake Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The lake Reference Manual

This is the lake Reference Manual, version 0.1, generated automatically by Declt version 2.3 "Robert April" on Tue Feb 20 08:53:38 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

Lake

Circle CI Coverage Status

Lake is a GNU make or Ruby's 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.

(use-package '(:lake :cl-syntax))
(use-syntax :interpol)

;; 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 section and API section.

Install

You can install lake via Quicklisp,

(ql:quickload :lake)

or you can also 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

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. forms 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. forms 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.

SYNOPSIS

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

OPTIONS

    -f FILE
        Use FILE as a Lakefile.
    -h
        Print usage.
    -j INTEGER
        Execute multiple tasks simultaneously.
    -T
        Display the tasks with descriptions, then exit.
    -v
        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 gave its name and concept on his GitHub repository. Then, @takagi forked it to design, implement, test, document and CI independently. Afterwards it is renamed to lake.

Author

Copyright

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

License

Licensed under the MIT License.


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

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


Previous: , Up: Systems   [Contents][Index]

2.1 lake

Author

Rudolph Miller and Masayuki Takagi

Home Page

https://github.com/takagi/lake

License

MIT

Description

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

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‘.

(use-package ’(:lake :cl-syntax))
(use-syntax :interpol)

;; 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

You can install lake via Quicklisp,

(ql:quickload :lake)

or you can also 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.

SYNOPSIS

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

OPTIONS

-f FILE
Use FILE as a Lakefile.
-h
Print usage.
-j INTEGER
Execute multiple tasks simultaneously.
-T
Display the tasks with descriptions, then exit.
-v
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

Dependencies
Source

lake.asd (file)

Component

src (module)


Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Previous: , Up: Modules   [Contents][Index]

3.1 lake/src

Parent

lake (system)

Location

src/

Component

lake.lisp (file)


Next: , Previous: , Up: Top   [Contents][Index]

4 Files

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


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 lake.asd

Location

lake.asd

Systems

lake (system)

Packages

lake-asd


Previous: , Up: Lisp files   [Contents][Index]

4.1.2 lake/src/lake.lisp

Parent

src (module)

Location

src/lake.lisp

Packages

lake

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 lake-asd

Source

lake.asd

Use List

Previous: , Up: Packages   [Contents][Index]

5.2 lake

Source

lake.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

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


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Special variables

Special Variable: *path*
Package

lake

Source

lake.lisp (file)

Special Variable: *ssh-host*
Package

lake

Source

lake.lisp (file)

Special Variable: *ssh-identity*
Package

lake

Source

lake.lisp (file)

Special Variable: *ssh-user*
Package

lake

Source

lake.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Macros

Macro: directory NAME &optional DESC
Package

lake

Source

lake.lisp (file)

Macro: file NAME-AND-ARGS DEPENDENCY &body BODY
Package

lake

Source

lake.lisp (file)

Macro: namespace NAMESPACE &body BODY
Package

lake

Source

lake.lisp (file)

Macro: task NAME-AND-ARGS DEPENDENCY &body BODY
Package

lake

Source

lake.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Functions

Function: display-tasks &key PATHNAME VERBOSE
Package

lake

Source

lake.lisp (file)

Function: echo STRING
Package

lake

Source

lake.lisp (file)

Function: execute NAME
Package

lake

Source

lake.lisp (file)

Function: getenv NAME &optional DEFAULT
Package

lake

Source

lake.lisp (file)

Function: lake &key TARGET PATHNAME JOBS VERBOSE
Package

lake

Source

lake.lisp (file)

Function: scp FROM-PLACE PATHSPEC1 TO-PLACE PATHSPEC2 &key ECHO
Package

lake

Source

lake.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.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

lake.lisp (file)

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

lake.lisp (file)

Methods
Method: ssh (COMMAND list) &key ECHO
Method: ssh (COMMAND string) &key ECHO

Previous: , Up: Exported definitions   [Contents][Index]

6.1.5 Classes

Class: task ()
Package

lake

Source

lake.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

task-name (generic function)

Slot: namespace
Initargs

:namespace

Readers

task-namespace (generic function)

Slot: arguments
Initargs

:arguments

Readers

task-arguments (generic function)

Slot: dependency
Initargs

:dependency

Readers

task-dependency (generic function)

Slot: description
Initargs

:description

Readers

task-description (generic function)

Slot: action
Initargs

:action

Readers

task-action (generic function)


Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Special variables

Special Variable: *context-jobs*
Package

lake

Source

lake.lisp (file)

Special Variable: *context-namespace*
Package

lake

Source

lake.lisp (file)

Special Variable: *context-plist*
Package

lake

Source

lake.lisp (file)

Special Variable: *context-tasks*
Package

lake

Source

lake.lisp (file)

Special Variable: *namespace*
Package

lake

Source

lake.lisp (file)

Special Variable: *tasks*
Package

lake

Source

lake.lisp (file)

Special Variable: *verbose*
Package

lake

Source

lake.lisp (file)

Special Variable: +scp-control-string+
Package

lake

Source

lake.lisp (file)

Special Variable: +ssh-control-string+
Package

lake

Source

lake.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Macros

Macro: register-task TASK TASKS
Package

lake

Source

lake.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Functions

Function: %display-tasks TASKS
Package

lake

Source

lake.lisp (file)

Function: %make-kernel WORKER-COUNT
Package

lake

Source

lake.lisp (file)

Function: %run-task TARGET TASKS PLIST JOBS
Package

lake

Source

lake.lisp (file)

Function: arg-pair-p X
Package

lake

Source

lake.lisp (file)

Function: argument-p X
Package

lake

Source

lake.lisp (file)

Function: compute-dependency NAME TASKS
Package

lake

Source

lake.lisp (file)

Function: construct-plist NAME ARGS TASKS
Package

lake

Source

lake.lisp (file)

Function: dependency-file-name TASK-NAME
Package

lake

Source

lake.lisp (file)

Function: directory-task-directory-name DIRECTORY-TASK
Package

lake

Source

lake.lisp (file)

Function: ensure-directory-pathspec PATHSPEC
Package

lake

Source

lake.lisp (file)

Function: ensure-pair X
Package

lake

Source

lake.lisp (file)

Function: escape-for-shell STRING
Package

lake

Source

lake.lisp (file)

Function: file-task-file-name FILE-TASK
Package

lake

Source

lake.lisp (file)

Function: file-task-out-of-date FILE-TASK
Package

lake

Source

lake.lisp (file)

Function: file-task-to-be-executed-p FILE-TASK
Package

lake

Source

lake.lisp (file)

Function: file-timestamp FILE-NAME
Package

lake

Source

lake.lisp (file)

Function: fqtn-endname FQTN
Package

lake

Source

lake.lisp (file)

Function: fqtn-namespace FQTN
Package

lake

Source

lake.lisp (file)

Function: get-environment-variable NAME
Package

lake

Source

lake.lisp (file)

Function: get-lakefile-pathname ()
Package

lake

Source

lake.lisp (file)

Function: get-task NAME TASKS
Package

lake

Source

lake.lisp (file)

Function: get-task-arguments TASK PLIST
Package

lake

Source

lake.lisp (file)

Function: load-lakefile PATHNAME
Package

lake

Source

lake.lisp (file)

Function: make-directory-task NAME NAMESPACE DESC
Package

lake

Source

lake.lisp (file)

Function: make-file-task NAME NAMESPACE ARGS DEPENDENCY DESC ACTION
Package

lake

Source

lake.lisp (file)

Function: make-task NAME NAMESPACE ARGS DEPENDENCY DESC ACTION
Package

lake

Source

lake.lisp (file)

Function: maybe FN X
Package

lake

Source

lake.lisp (file)

Function: name-and-args-p X
Package

lake

Source

lake.lisp (file)

Function: parse-args STRING RESULT
Package

lake

Source

lake.lisp (file)

Function: parse-body FORMS
Package

lake

Source

lake.lisp (file)

Function: parse-target STRING
Package

lake

Source

lake.lisp (file)

Function: read-argument-from-string STRING
Package

lake

Source

lake.lisp (file)

Function: resolve-dependency-task-name NAME NAMESPACE
Package

lake

Source

lake.lisp (file)

Function: resolve-dependency-task-names DEPENDENCY NAMESPACE
Package

lake

Source

lake.lisp (file)

Function: resolve-task-name NAME NAMESPACE
Package

lake

Source

lake.lisp (file)

Function: run-task TARGET TASKS &optional JOBS
Package

lake

Source

lake.lisp (file)

Function: run-task-concurrent TARGET TASKS PLIST JOBS
Package

lake

Source

lake.lisp (file)

Function: run-task-serial TARGET TASKS PLIST
Package

lake

Source

lake.lisp (file)

Function: scp-filepath PATHSPEC PLACE
Package

lake

Source

lake.lisp (file)

Function: split-by-colon STRING
Package

lake

Source

lake.lisp (file)

Function: task-exists-p NAME TASKS
Package

lake

Source

lake.lisp (file)

Function: task= TASK1 TASK2
Package

lake

Source

lake.lisp (file)

Function: tasks-max-width TASKS
Package

lake

Source

lake.lisp (file)

Function: traverse-tasks NAME TASKS
Package

lake

Source

lake.lisp (file)

Function: valid-dependency-task-name-p NAME
Package

lake

Source

lake.lisp (file)

Function: valid-fqtn-p STRING
Package

lake

Source

lake.lisp (file)

Function: valid-name-part-p STRING
Package

lake

Source

lake.lisp (file)

Function: valid-namespace-p NAMESPACE
Package

lake

Source

lake.lisp (file)

Function: valid-task-name-p TASK-NAME
Package

lake

Source

lake.lisp (file)

Function: verbose STRING &optional NEW-LINE STREAM
Package

lake

Source

lake.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.4 Generic functions

Generic Function: execute-task TASK &optional ARGS
Package

lake

Source

lake.lisp (file)

Methods
Method: execute-task (FILE-TASK file-task) &optional ARGS
Method: execute-task (TASK task) &optional ARGS
Generic Function: task-action OBJECT
Package

lake

Methods
Method: task-action (TASK task)

automatically generated reader method

Source

lake.lisp (file)

Generic Function: task-arguments OBJECT
Package

lake

Methods
Method: task-arguments (TASK task)

automatically generated reader method

Source

lake.lisp (file)

Generic Function: task-dependency OBJECT
Package

lake

Methods
Method: task-dependency (TASK task)

automatically generated reader method

Source

lake.lisp (file)

Generic Function: task-description OBJECT
Package

lake

Methods
Method: task-description (TASK task)

automatically generated reader method

Source

lake.lisp (file)

Generic Function: task-name OBJECT
Package

lake

Methods
Method: task-name (TASK task)

automatically generated reader method

Source

lake.lisp (file)

Generic Function: task-namespace OBJECT
Package

lake

Methods
Method: task-namespace (TASK task)

automatically generated reader method

Source

lake.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.5 Classes

Class: directory-task ()
Package

lake

Source

lake.lisp (file)

Direct superclasses

task (class)

Class: file-task ()
Package

lake

Source

lake.lisp (file)

Direct superclasses

task (class)

Direct methods

execute-task (method)


Previous: , Up: Internal definitions   [Contents][Index]

6.2.6 Types

Type: argument ()
Package

lake

Source

lake.lisp (file)

Type: name-and-args ()
Package

lake

Source

lake.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   M  
Index Entry  Section

F
File, Lisp, lake.asd: The lake<dot>asd file
File, Lisp, lake/src/lake.lisp: The lake/src/lake<dot>lisp file

L
lake.asd: The lake<dot>asd file
lake/src: The lake/src module
lake/src/lake.lisp: The lake/src/lake<dot>lisp file
Lisp File, lake.asd: The lake<dot>asd file
Lisp File, lake/src/lake.lisp: The lake/src/lake<dot>lisp file

M
Module, lake/src: The lake/src module

Jump to:   F   L   M  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

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

%
%display-tasks: Internal functions
%make-kernel: Internal functions
%run-task: Internal functions

A
arg-pair-p: Internal functions
argument-p: Internal functions

C
compute-dependency: Internal functions
construct-plist: Internal functions

D
dependency-file-name: Internal functions
directory: Exported macros
directory-task-directory-name: Internal functions
display-tasks: Exported functions

E
echo: Exported functions
ensure-directory-pathspec: Internal functions
ensure-pair: Internal functions
escape-for-shell: Internal functions
execute: Exported functions
execute-task: Internal generic functions
execute-task: Internal generic functions
execute-task: Internal generic functions

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

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

L
lake: Exported functions
load-lakefile: Internal functions

M
Macro, directory: Exported macros
Macro, file: Exported macros
Macro, namespace: Exported macros
Macro, register-task: Internal macros
Macro, task: Exported macros
make-directory-task: Internal functions
make-file-task: Internal functions
make-task: Internal functions
maybe: Internal functions
Method, execute-task: Internal generic functions
Method, execute-task: Internal generic functions
Method, sh: Exported generic functions
Method, sh: Exported generic functions
Method, ssh: Exported generic functions
Method, ssh: Exported generic functions
Method, task-action: Internal generic functions
Method, task-arguments: Internal generic functions
Method, task-dependency: Internal generic functions
Method, task-description: Internal generic functions
Method, task-name: Internal generic functions
Method, task-namespace: Internal generic functions

N
name-and-args-p: Internal functions
namespace: Exported macros

P
parse-args: Internal functions
parse-body: Internal functions
parse-target: Internal functions

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

S
scp: Exported functions
scp-filepath: Internal functions
sh: Exported generic functions
sh: Exported generic functions
sh: Exported generic functions
split-by-colon: Internal functions
ssh: Exported generic functions
ssh: Exported generic functions
ssh: Exported generic functions

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

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

Jump to:   %  
A   C   D   E   F   G   L   M   N   P   R   S   T   V  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

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

*
*context-jobs*: Internal special variables
*context-namespace*: Internal special variables
*context-plist*: Internal special variables
*context-tasks*: Internal special variables
*namespace*: Internal special variables
*path*: Exported special variables
*ssh-host*: Exported special variables
*ssh-identity*: Exported special variables
*ssh-user*: Exported special variables
*tasks*: Internal special variables
*verbose*: Internal special variables

+
+scp-control-string+: Internal special variables
+ssh-control-string+: Internal special variables

A
action: Exported classes
arguments: Exported classes

D
dependency: Exported classes
description: Exported classes

N
name: Exported classes
namespace: Exported classes

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

Jump to:   *   +  
A   D   N   S  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   A   C   D   F   L   N   P   S   T  
Index Entry  Section

A
argument: Internal types

C
Class, directory-task: Internal classes
Class, file-task: Internal classes
Class, task: Exported classes

D
directory-task: Internal classes

F
file-task: Internal classes

L
lake: The lake system
lake: The lake package
lake-asd: The lake-asd package

N
name-and-args: Internal types

P
Package, lake: The lake package
Package, lake-asd: The lake-asd package

S
System, lake: The lake system

T
task: Exported classes
Type, argument: Internal types
Type, name-and-args: Internal types

Jump to:   A   C   D   F   L   N   P   S   T