Top Level Namespace

Included Modules

Extended Modules

Defined in:

Constant Summary

ARGF = IO::ARGF.new(ARGV, STDIN)
ARGV = ((ARGV_UNSAFE + 1).to_slice(ARGC_UNSAFE - 1)).map do |c_str| String.new(c_str) end
PROGRAM_NAME = String.new(ARGV_UNSAFE.value)
STDERR = (IO::FileDescriptor.new(2, blocking: (LibC.isatty(2)) == 0)).tap do |f| f.flush_on_newline = true end
STDIN = IO::FileDescriptor.new(0, blocking: (LibC.isatty(0)) == 0)
STDOUT = (IO::FileDescriptor.new(1, blocking: (LibC.isatty(1)) == 0)).tap do |f| f.flush_on_newline = true end

Method Summary

Macro Summary

Instance methods inherited from module Spec::Methods

assert(file = __FILE__, line = __LINE__, end_line = __END_LINE__, &block) assert, context(description, file = __FILE__, line = __LINE__, &block) context, describe(description, file = __FILE__, line = __LINE__, &block) describe, fail(msg, file = __FILE__, line = __LINE__) fail, it(description = "assert", file = __FILE__, line = __LINE__, end_line = __END_LINE__, &block) it, pending(description = "assert", file = __FILE__, line = __LINE__, end_line = __END_LINE__, &block) pending

Instance methods inherited from module Spec::Expectations

be(value)
be
be
, be_close(expected, delta) be_close, be_false be_false, be_falsey be_falsey, be_nil be_nil, be_true be_true, be_truthy be_truthy, contain(expected) contain, eq(value) eq, match(value) match

Method Detail

def `(command) : String #

Returns the standard output of executing command in a subshell. Standard input, and error are inherited. The special $? variable is set to a Process::Status associated with this execution.

Example:

`echo hi` # => "hi\n"

View source
def abort(message, status = 1) : NoReturn #

Terminates execution immediately, printing message to STDERR and then calling exit(status).


View source
def at_exit(&handler : Int32 -> ) : Nil #

Registers the given Proc for execution when the program exits. If multiple handlers are registered, they are executed in reverse order of registration.

def do_at_exit(str1)
  at_exit { print str1 }
end

at_exit { puts "cruel world" }
do_at_exit("goodbye ")
exit

Produces:

goodbye cruel world

View source
def caller #

View source
def delay(delay, &block : -> _) #

Spawns a Fiber to compute &block in the background after delay has elapsed. Access to get is synchronized between fibers. &block is only called once. May be canceled before &block is called by calling cancel.

d = delay(1) { Process.kill(Signal::KILL, Process.pid) }
# ... long operations ...
d.cancel

View source
def exit(status = 0) : NoReturn #

Terminates execution immediately, returning the given status code to the invoking environment.

Registered at_exit procs are executed.


View source
def fork #

See also: Process.fork


View source
def fork(&block) #

See also: Process.fork


View source
def future(&exp : -> _) #

Spawns a Fiber to compute &block in the background. Access to get is synchronized between fibers. &block is only called once.

f = future { `echo hello` }
# ... other actions ...
f.get # => "hello\n"

View source
def gets(*args, **options) #

Reads a line from STDIN.

See also: IO#gets.


View source
def lazy(&block : -> _) #

Conditionally spawns a Fiber to run &block in the background. Access to get is synchronized between fibers. &block is only called once. &block doesn't run by default, only when get is called.

l = lazy { expensive_computation }
spawn { maybe_use_computation(l) }
spawn { maybe_use_computation(l) }

View source
def loop(&block) #

Repeatedly executes the block, passing an incremental Int32 that starts with 0.

loop do |i|
  print "#{i}) "
  line = gets
  break unless line
  # ...
end

View source
def p(*objects) #

Pretty prints each object in objects to STDOUT, followed by a newline. Returns objects.

See also: Object#pretty_print(pp).


View source
def p #

Pretty prints each object in objects to STDOUT, followed by a newline. Returns objects.

p foo: 23, bar: 42 # => {foo: 23, bar: 42}

See Object#pretty_print(pp)


View source
def p(object) #

Pretty prints object to STDOUT followed by a newline. Returns object.

See also: Object#pretty_print(pp).


View source
def print(*objects : _) : Nil #

Prints objects to STDOUT and then invokes STDOUT.flush.

See also: IO#print.


View source
def printf(format_string, args : Array | Tuple) : Nil #

Prints a formatted string to STDOUT.

See also: IO#printf.


View source
def printf(format_string, *args) : Nil #

Prints a formatted string to STDOUT.

See also: IO#printf.


View source
def puts(*objects) : Nil #

Prints objects to STDOUT, each followed by a newline.

See also: IO#puts.


View source
def raise(exception : Exception) : NoReturn #

Raises the exception.

This will set the exception's callstack if it hasn't been already. Re-raising a previously catched exception won't replace the callstack.


View source
def raise(message : String) : NoReturn #

Raises an Exception with the message.


View source
def rand(x) #

See Random#rand(x).


View source
def rand #

See Random#rand.


View source
def read_line(*args, **options) #

Reads a line from STDIN.

See also: IO#read_line.


View source
def sleep #

Blocks the current fiber forever.

Meanwhile, other ready-to-execute fibers might start their execution.


View source
def sleep(time : Time::Span) #

Blocks the current Fiber for the specified time span.

While this fiber is waiting this time other ready-to-execute fibers might start their execution.


View source
def sleep(seconds : Number) #

Blocks the current fiber for the specified number of seconds.

While this fiber is waiting this time other ready-to-execute fibers might start their execution.


View source
def spawn(*, name : String? = nil, &block) #

Spawns a new fiber.

The newly created fiber doesn't run as soon as spawned.

Example:

# Write "1" every 1 second and "2" every 2 seconds for 6 seconds.

ch = Channel(Nil).new

spawn do
  6.times do
    sleep 1
    puts 1
  end
  ch.send(nil)
end

spawn do
  3.times do
    sleep 2
    puts 2
  end
  ch.send(nil)
end

2.times { ch.receive }

View source
def sprintf(format_string, *args) : String #

Returns a formatted string.

See also: IO#printf.


View source
def sprintf(format_string, args : Array | Tuple) : String #

Returns a formatted string.

See also: IO#printf.


View source
def system(command : String, args = nil) : Bool #

Executes the given command in a subshell. Standard input, output and error are inherited. Returns true if the command gives zero exit code, false otherwise. The special $? variable is set to a Process::Status associated with this execution.

If command contains no spaces and args is given, it will become its argument list.

If command contains spaces and args is given, command must include "${@}" (including the quotes) to receive the argument list.

No shell interpretation is done in args.

Example:

system("echo *")

Produces:

LICENSE shard.yml Readme.md spec src

View source
def with_color(color : Symbol) #

View source
def with_color #

View source

Macro Detail

macro assert_responds_to(var, method) #

View source
macro debugger #

View source
macro parallel(*jobs) #

View source
macro pp(*exps) #

Prints a series of expressions together with their values. Useful for print style debugging.

a = 1
pp a # => "a # => 1"

pp [1, 2, 3].map(&.to_s) # => "[1, 2, 3].map(&.to_s) # => ["1", "2", "3"]"

View source
macro record(name, *properties) #

Defines a Struct with the given name and properties.

The generated struct has a constructor with the given properties in the same order as declared. The struct only provides getters, not setters, making it immutable by default.

The properties can be type declarations or assignments.

You can pass a block to this macro, that will be inserted inside the struct definition.

record Point, x : Int32, y : Int32

Point.new 1, 2 # => #<Point(@x=1, @y=2)>

An example with the block version:

record Person, first_name : String, last_name : String do
  def full_name
    "#{first_name} #{last_name}"
  end
end

person = Person.new "John", "Doe"
person.full_name # => "John Doe"

An example with type declarations and default values:

record Point, x : Int32 = 0, y : Int32 = 0

Point.new      # => #<Point(@x=0, @y=0)>
Point.new y: 2 # => #<Point(@x=0, @y=2)>

An example with assignments (in this case the compiler must be able to infer the types from the default values):

record Point, x = 0, y = 0

Point.new      # => #<Point(@x=0, @y=0)>
Point.new y: 2 # => #<Point(@x=0, @y=2)>

View source
macro redefine_main(name = main) #

View source
macro spawn(call, *, name = nil) #

Spawns a fiber by first creating a Proc, passing the call's expressions to it, and letting the Proc finally invoke the call.

Compare this:

i = 0
while i < 5
  spawn { print(i) }
  i += 1
end
Fiber.yield
# Output: 55555

To this:

i = 0
while i < 5
  spawn print(i)
  i += 1
end
Fiber.yield
# Output: 01234

This is because in the first case all spawned fibers refer to the same local variable, while in the second example copies of i are passed to a Proc that eventually invokes the call.


View source