module Crystal::Macros


The Macros module is a fictitious module used to document macros and macro methods.

You can invoke a fixed subset of methods on AST nodes at compile-time. These methods are documented on the classes in this module. Additionally, methods of the Macros module are top-level methods that you can invoke, like #puts and #run.

Defined in:


Instance Method Summary

Instance Method Detail

def `(command) : MacroId #

Executes a system command and returns the output as a MacroId. Gives a compile-time error if the command failed to execute.

[View source]
def compare_versions(v1 : StringLiteral, v2 : StringLiteral) : NumberLiteral #

Compares two semantic versions. Returns -1 if v1 < v2, 0 if v1 == v2 and 1 if v1 > v2.

{{ compare_versions("1.10.0", "1.2.0") }} # => 1

[View source]
def debug(format = true) : Nop #

Outputs the current macro's buffer to the standard output. Useful for debugging a macro to see what's being generated. Use it like {{debug()}}, the parenthesis are mandatory.

By default, the output is tried to be formatted using Crystal's formatter, but you can disable this by passing false to this method.

[View source]
def env(name) : StringLiteral | NilLiteral #

Gets the value of an environment variable at compile-time, or nil if it doesn't exist.

[View source]
def p(expression) : Nop #

Same as #puts.

[View source]
def puts(expression) : Nop #

Prints an AST node at compile-time. Useful for debugging macros.

[View source]
def raise(message) : NoReturn #

Gives a compile-time error with the given message.

[View source]
def run(filename, *args) : MacroId #

Compiles and execute a Crystal program and returns its output as a MacroId.

The file denote by filename must be a valid Crystal program. This macro invocation passes args to the program as regular program arguments. The program must output a valid Crystal expression. This output is the result of this macro invocation, as a MacroId.

The #run macro is useful when the subset of available macro methods are not enough for your purposes and you need something more powerful. With #run you can read files at compile time, connect to the internet or to a database.

A simple example:

macro read_file_at_compile_time(filename)
  {{ run("./read", filename).stringify }}

puts read_file_at_compile_time("some_file.txt")

The above generates a program that will have the contents of some_file.txt. The file, however, is read at compile time and will not be needed at runtime.

NOTE the compiler is allowed to cache the executable generated for filename and only recompile it if any of the files it depends on changes (their modified time). This is why it's strongly discouraged to use a program for #run that changes in subsequent compilations (for example, if it executes shell commands at compile time, or other macro run programs). It's also strongly discouraged to have a macro run program take a lot of time, because this will slow down compilation times. Reading files is OK, opening an HTTP connection at compile-time will most likely result if very slow compilations.

[View source]
def system(command) : MacroId #

Executes a system command and returns the output as a MacroId. Gives a compile-time error if the command failed to execute.

[View source]