Wrap up a Ruby object using the its VALUE API handle.

The Ruby object is kept safe from garbage collection until the Swift object is deallocated.

This initializer is public to allow use with other parts of the Ruby API. It is not normally needed.

Create another Swift reference to an existing RbObject.

The underlying Ruby object will not be garbage-collected until both RbObjects have been deallocated.

There is still just one Ruby object in the system. To create a separate Ruby object do:

let myClone = myObject.call("clone")

Safely access the VALUE object handle for use with the Ruby C API.

There is no direct access to the VALUE to prevent accidental use outside the corresponding RbObject’s lifetime.

The Ruby type of this object. This is a fairly unfriendly enum but might be useful for debugging.

Is the Ruby object truthy?

Is the Ruby object nil?

If you have Swift nil – that is, you don’t have .some(RbObject) – then Ruby failed – there was probably an exception. Check RbError.history for a list of recent exceptions.

If you’ve got Ruby nil – that is, you’ve got RbObject.isNil – then Ruby worked but the call evaluated to [Ruby] nil.

An RbObject that means nil to Ruby.

A view onto the Ruby object using Swift collection APIs.

Intended for use with Ruby arrays, but any object will work provided it implements [], []=, and length like Array.

This property has a setter to permit syntax like:

myObj.collection[3..<12].sort()

The only thing that can be assigned is the object’s corresponding RbObjectCollection – assigning anything else will trap. Use RbObjectCollection.rubyObject to obtain a collection’s underlying Ruby array.

Retrieve the Swift object bound to this Ruby object.

This is for use on Ruby objects created from classes defined with RbGateway.defineClass(_:under:initializer:) to retrieve the bound object.

This function performs an unsafe cast to the type you specify so be sure to get it right.

Add methods from a module to a class such that methods from the class override any that match in the module.

Add methods from a module to a class such that methods from the module override any that match in the class.

See Module#prepend for a better explanation.

Add methods from a module to the singleton class of this object.

See Module#extend for a better explanation.

Create an RbObject from a Swift type.

RubyGateway conforms most of the Swift standard library types to RbObjectConvertible.

Convert an RbObject to some Swift type.

This is a convenience wrapper around optional conversion for cases where the Swift type can be inferred. See convert(to:) to explicitly specify the desired type.

Convert an RbObject to some Swift type.

This is a convenience wrapper around optional conversion. See convert() for when the desired type can be inferred by the compiler.

Creates an RbObject from a string literal.

Creates an RbObject from a boolean literal.

Creates an RbObject from an integer literal.

Creates an RbObject from a floating-point literal.

Creates an RbObject from an array literal.

Although the element type here is RbObject you can write things like:

let obj: RbObject = [1, 2, 3]

… because of RbObject’s ExpressibleByIntegerLiteralExpressibleByIntegerLiteral conformance that gets applied recursively.

Creates an RbObject from a dictionary literal.

Although the key and value types here are RbObject you can write things like:

let obj: RbObject = [1: "fish", 2: "bucket", 3: "wife", 4: "goat"]

… because of RbObject’s ExpressibleByXxxLiteral conformance that gets applied recursively.

Like a regular Dictionary there must be no duplicate keys in the elements.

Add or replace a method in all instances of the Ruby class.

The RbObject must be for a Ruby class or module. The method is immediately available to all instances of the class.

You can define the class yourself using RbGateway.defineClass(_:parent:under:) or get hold of an existing class from the global Ruby object, for example:

let clazz = try Ruby.get("Array")
try clazz.defineMethod(name: "sum") { rbSelf, _ in
  rbSelf.collection.reduce(0, +)
}

Add or replace a method in all instances of the Ruby class.

This version is for methods that have a value to return.

The object must be a Ruby class defined using RbGateway.defineClass(_:under:initializer:) sharing the same type for SwiftPeer. For example:

class InvaderModel {
    init() { ... }
    func fire(rbMethod: RbMethod) throws -> Bool { ... }
}

let invaderClass = try Ruby.defineClass("Invader", initializer: InvaderModel.init)
try invaderClass.defineMethod("fire", method: Invader.fire)

There are unsafe casts involved here so you must be sure to get the types right.

Add or replace a method in all instances of the Ruby class.

This version is for methods that have no return value. In Ruby all methods return values so RubyBridge substitutes the object itself.

The object must be a Ruby class defined using RbGateway.defineClass(_:under:initializer:) sharing the same type for SwiftPeer. For example:

class InvaderModel {
    init() { ... }
    func initialize(rbMethod: RbMethod) throws -> Void { ... }
}

let invaderClass = try Ruby.defineClass("Invader", initializer: InvaderModel.init)
try invaderClass.defineMethod("initialize",
                              argsSpec: .basic(1),
                              method: InvaderModel.initialize)

There are unsafe casts involved here so you must be sure to get the types right.

Add or replace a method in the Ruby object’s singleton class.

In practice this means: if the RbObject is a class then this adds a class method. Otherwise, if the RbObject is a ‘normal’ instance object then it adds a method valid just for this instance.

Create an instance of a given Ruby class.

Fails (returns nil) if anything goes wrong along the way - check RbError.history to find out what failed.

Create an instance of a given Ruby class passing a Swift closure as a block.

Fails (returns nil) if anything goes wrong along the way - check RbError.history to find out what failed.

Create a Ruby Proc object from a Swift closure.

A string representation of the Ruby object.

This is the same as String(rbObject) which is approximately Kernel#String.

A developer-appropriate string representation of the Ruby object.

This is the result of inspect with a fallback to description.

The text from description.

The hash value for the Ruby object.

Calls the Ruby hash method.

Returns a Boolean value indicating whether two values are equal.

Calls the Ruby == method of the lhs passing rhs as the parameter.

Returns a Boolean value indicating whether the value of the first argument is less than that of the second argument.

Calls the Ruby < method of lhs passing rhs as the parameter.

Create a Ruby object from some type conforming to BinaryIntegerBinaryInteger

Subtraction operator for RbObjects.

Addition operator for RbObjects.

Multiplication operator for RbObjects.

Division operator for RbObjects.

Remainder operator for RbObjects.

Addition-assignment operator for RbObjects.

Subtraction-assignment operator for RbObjects.

Multiplication-assignment operator for RbObjects.

Division-assignment operator for RbObjects.

Remainder-assignment operator for RbObjects.

The magnitude of the value.

The negated version of the value.

Unary plus operator.

Subscript operator, supports both get + set.

Although you can use RbObjectConvertibles as the subscript arguments, the value assigned in the setter has to be an RbObject. So this doesn’t work:

try myObj[1, "fish", myThirdParamObj] = 4

…instead you have to do:

try myObj[1, "fish", myThirdParamObj] = RbObject(4)