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(&.flush_on_newline = true)
-
STDIN =
IO::FileDescriptor.new(0, blocking: (LibC.isatty(0)) == 0)
-
STDOUT =
(IO::FileDescriptor.new(1, blocking: (LibC.isatty(1)) == 0)).tap(&.flush_on_newline = true)
Method Summary
-
`(command) : String
Returns the standard output of executing command in a subshell.
-
abort(message, status = 1)
Terminates execution immediately, printing message to STDERR and then calling
exit(status)
. -
at_exit(&handler : Int32 -> )
Registers the given
Proc
for execution when the program exits. - caller
-
delay(delay, &block : -> _)
Spawns a
Fiber
to compute &block in the background after delay has elapsed. -
exit(status = 0)
Terminates execution immediately, returning the given status code to the invoking environment.
-
fork
See
Process.fork
-
fork(&block)
See
Process.fork
-
future(&exp : -> _)
Spawns a
Fiber
to compute &block in the background. -
gets(*args, **options)
Reads a line from STDIN.
-
lazy(&block : -> _)
Conditionally spawns a
Fiber
to run &block in the background. -
loop(&block)
Repeatedly executes the block, passing an incremental
Int32
that starts with 0. -
p(*objects)
Prints each object in objects to STDOUT by invoking
inspect(io)
on it, followed by a newline. -
p(object)
Prints object to STDOUT by invoking
inspect(io)
on it, followed by a newline. -
print(*objects : _)
Prints objects to STDOUT and then invokes
STDOUT.flush
. -
printf(format_string, args : Array | Tuple)
Prints a formatted string to STDOUT.
-
printf(format_string, *args)
Prints a formatted string to STDOUT.
-
puts(*objects)
Prints objects to STDOUT, each followed by a newline.
- raise(ex : Exception) : NoReturn
- raise(message : String) : NoReturn
-
rand
see
Random#rand
-
rand(x)
see
Random#rand(x)
-
read_line(*args, **options)
Reads a line from STDIN.
-
sleep(seconds : Number)
Blocks the current fiber for the specified number of seconds.
-
sleep(time : Time::Span)
Blocks the current Fiber for the specified time span.
-
sleep
Blocks the current fiber forever.
-
spawn(*, name : String | Nil = nil, &block)
Spawns a new fiber.
-
sprintf(format_string, *args) : String
Returns a formatted string.
-
sprintf(format_string, args : Array | Tuple) : String
Returns a formatted string.
-
system(command : String, args = nil) : Bool
Executes the given command in a subshell.
- with_color
- with_color(color : Symbol)
Macro Summary
- assert_responds_to(var, method)
- debugger
- parallel(*jobs)
-
pp(*exps)
Prints a series of expressions together with their values.
-
record(name, *properties)
Defines a struct with the given name and properties.
- redefine_main(name = main)
-
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.
Instance methods inherited from module Spec::Expectations
bebe(value) 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
Instance methods inherited from module Spec::DSL
assert(file = __FILE__, line = __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, file = __FILE__, line = __LINE__, &block)
it,
pending(description, file = __FILE__, line = __LINE__, &block)
pending
Method Detail
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 *` # => "LICENSE shard.yml Readme.md spec src\n"
Terminates execution immediately, printing message to STDERR and
then calling exit(status)
.
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
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(Process.pid) }
long_operation
d.cancel
Terminates execution immediately, returning the given status code to the invoking environment.
Registered at_exit
procs are executed.
Spawns a Fiber
to compute &block in the background.
Access to get is synchronized between fibers. &block is only called once.
f = future { http_request }
... other actions ...
f.get #=> String
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) }
Repeatedly executes the block, passing an incremental Int32
that starts with 0.
loop do |i|
print "#{i}) "
line = gets
break unless line
# ...
end
Prints each object in objects to STDOUT by invoking inspect(io)
on it, followed
by a newline. Returns objects.
Prints object to STDOUT by invoking inspect(io)
on it, followed
by a newline. Returns object.
Prints a formatted string to STDOUT. See IO#printf
.
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.
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.
Blocks the current fiber forever.
Meanwhile, other ready-to-execute fibers might start their execution.
Spawns a new fiber.
The newly created fiber doesn't run as soon as spawned.
Example: writing "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 }
Returns a formatted string. See IO#printf
.
Returns a formatted string. See IO#printf
.
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
Macro Detail
Prints a series of expressions together with their values. Useful for print style debugging.
a = 1
pp a # prints "a # => 1"
pp [1, 2, 3].map(&.to_s) # prints "[1, 2, 3].map(&.to_s) # => ["1", "2", "3"]"
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 = Point.new 1, 2
point.to_s # => "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)
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.