Struct rutie::Class[−][src]

pub struct Class { /* fields omitted */ }

Class

Also see def, def_self, define and some more functions from Object trait.

#[macro_use] extern crate rutie;

use std::error::Error;

use rutie::{Class, Fixnum, Object, Exception, VM};

methods!(
   Fixnum,
   itself,

    fn pow(exp: Fixnum) -> Fixnum {
        // `exp` is not a valid `Fixnum`, raise an exception
        if let Err(ref error) = exp {
            VM::raise(error.class(), &error.message());
        }

        // We can safely unwrap here, because an exception was raised if `exp` is `Err`
        let exp = exp.unwrap().to_i64() as u32;

        Fixnum::new(itself.to_i64().pow(exp))
    }
);

fn main() {
    Class::from_existing("Fixnum").define(|itself| {
        itself.def("pow", pow);
    });
}

Ruby:

class Fixnum
  def pow(exp)
    raise TypeError unless exp.is_a?(Fixnum)

    self ** exp
  end
end

Methods

impl Class
[src]

Creates a new Class.

superclass can receive the following values:

  • None to inherit from Object class (standard Ruby behavior when superclass is not given explicitly);
  • Some(&Class) to inherit from the given class

Examples

use rutie::{Class, VM};

let basic_record_class = Class::new("BasicRecord", None);

assert_eq!(basic_record_class, Class::from_existing("BasicRecord"));
assert_eq!(basic_record_class.superclass(), Some(Class::from_existing("Object")));

let record_class = Class::new("Record", Some(&basic_record_class));

assert_eq!(record_class, Class::from_existing("Record"));
assert_eq!(record_class.superclass(), Some(Class::from_existing("BasicRecord")));

Ruby:

class BasicRecord
end

class Record < BasicRecord
end

BasicRecord.superclass == Object

Record.superclass == BasicRecord

Retrieves an existing Class object.

Examples

use rutie::{Class, VM};

let class = Class::new("Record", None);

assert_eq!(class, Class::from_existing("Record"));

Ruby:

class Record
end

# get class

Record

# or

Object.const_get('Record')

Creates a new instance of Class

Arguments must be passed as a vector of AnyObject (see example).

Examples

use rutie::{Class, Fixnum, Object};

// Without arguments
Class::from_existing("Hello").new_instance(None);

// With arguments passing arguments to constructor
let arguments = [
    Fixnum::new(1).to_any_object(),
    Fixnum::new(2).to_any_object()
];

Class::from_existing("Worker").new_instance(Some(&arguments));

Ruby:

Hello.new

Worker.new(1, 2)

Creates a new instance of Class

Examples

use rutie::{Class, Object};

Class::from_existing("String").allocate();

Ruby:

String.allocate

Returns a superclass of the current class

Examples

use rutie::{Class, Object, VM};

assert_eq!(
    Class::from_existing("Array").superclass(),
    Some(Class::from_existing("Object"))
);

assert_eq!(Class::from_existing("BasicObject").superclass(), None);

ⓘImportant traits for Vec<u8>

Returns a Vector of ancestors of current class

Examples

Getting all the ancestors

use rutie::{Class, VM};

let true_class_ancestors = Class::from_existing("TrueClass").ancestors();

let expected_ancestors = vec![
    Class::from_existing("TrueClass"),
    Class::from_existing("Object"),
    Class::from_existing("Kernel"),
    Class::from_existing("BasicObject")
];

assert_eq!(true_class_ancestors, expected_ancestors);

Searching for an ancestor

use rutie::{Class, VM};

let basic_record_class = Class::new("BasicRecord", None);
let record_class = Class::new("Record", Some(&basic_record_class));

let ancestors = record_class.ancestors();

assert!(ancestors.iter().any(|class| *class == basic_record_class));

Retrieves a Class nested to current Class.

Examples

use rutie::{Class, Object, VM};

Class::new("Outer", None).define(|itself| {
    itself.define_nested_class("Inner", None);
});

Class::from_existing("Outer").get_nested_class("Inner");

Ruby:

class Outer
  class Inner
  end
end

Outer::Inner

# or

Outer.const_get('Inner')

Retrieves a Module nested to current Class.

Examples

use rutie::{Class, Module, Object, VM};

Class::new("Outer", None).define(|itself| {
    itself.define_nested_module("Inner");
});

Class::from_existing("Outer").get_nested_module("Inner");

Ruby:

class Outer
  module Inner
  end
end

Outer::Inner

# or

Outer.const_get('Inner')

Creates a new Class nested into current class.

superclass can receive the following values:

  • None to inherit from Object class (standard Ruby behavior when superclass is not given explicitly);
  • Some(&class) to inherit from the given class

Examples

use rutie::{Class, Object, VM};

Class::new("Outer", None).define(|itself| {
    itself.define_nested_class("Inner", None);
});

Class::from_existing("Outer").get_nested_class("Inner");

Ruby:

class Outer
  class Inner
  end
end

Outer::Inner

# or

Outer.const_get('Inner')

Creates a new Module nested into current Class.

Examples

use rutie::{Class, Module, Object, VM};

Class::new("Outer", None).define(|itself| {
    itself.define_nested_module("Inner");
});

Module::from_existing("Outer").get_nested_module("Inner");

Ruby:

class Outer
  module Inner
  end
end

Outer::Inner

# or

Outer.const_get('Inner')

Retrieves a constant from class.

Examples

use rutie::{Class, Object, RString, VM};

Class::new("Greeter", None).define(|itself| {
    itself.const_set("GREETING", &RString::new("Hello, World!"));
});

let greeting = Class::from_existing("Greeter")
    .const_get("GREETING")
    .try_convert_to::<RString>()
    .unwrap();

assert_eq!(greeting.to_str(), "Hello, World!");

Ruby:

class Greeter
  GREETING = 'Hello, World!'
end

# or

Greeter = Class.new
Greeter.const_set('GREETING', 'Hello, World!')

# ...

Greeter::GREETING == 'Hello, World!'

# or

Greeter.const_get('GREETING') == 'Hello, World'

Defines a constant for class.

Examples

use rutie::{Class, Object, RString, VM};

Class::new("Greeter", None).define(|itself| {
    itself.const_set("GREETING", &RString::new("Hello, World!"));
});

let greeting = Class::from_existing("Greeter")
    .const_get("GREETING")
    .try_convert_to::<RString>()
    .unwrap();

assert_eq!(greeting.to_str(), "Hello, World!");

Ruby:

class Greeter
  GREETING = 'Hello, World!'
end

# or

Greeter = Class.new
Greeter.const_set('GREETING', 'Hello, World!')

# ...

Greeter::GREETING == 'Hello, World!'

# or

Greeter.const_get('GREETING') == 'Hello, World'

Includes module into current class

Examples

use rutie::{Class, Module, VM};

let a_module = Module::new("A");
Class::new("B", None).include("A");

let b_class_ancestors = Class::from_existing("B").ancestors();
let expected_ancestors = vec![Module::from_existing("A")];

assert!(expected_ancestors.iter().any(|anc| *anc == a_module));

Prepends module into current class

Examples

use rutie::{Class, Module, VM};

let a_module = Module::new("A");
Class::new("B", None).prepend("A");

let b_class_ancestors = Class::from_existing("B").ancestors();
let expected_ancestors = vec![Module::from_existing("A")];

assert!(expected_ancestors.iter().any(|anc| *anc == a_module));

Defines an attr_reader for class

Examples

use rutie::{Class, Object, VM};

Class::new("Test", None).define(|itself| {
    itself.attr_reader("reader");
});

Ruby:

class Test
  attr_reader :reader
end

Defines an attr_writer for class

Examples

use rutie::{Class, Object, VM};

Class::new("Test", None).define(|itself| {
    itself.attr_writer("writer");
});

Ruby:

class Test
  attr_writer :writer
end

Defines an attr_accessor for class

Examples

use rutie::{Class, Object, VM};

Class::new("Test", None).define(|itself| {
    itself.attr_accessor("accessor");
});

Ruby:

class Test
  attr_accessor :accessor
end

Wraps Rust structure into a new Ruby object of the current class.

See the documentation for wrappable_struct! macro for more information.

Examples

Wrap Server structs to RubyServer objects

#[macro_use] extern crate rutie;
#[macro_use] extern crate lazy_static;

use rutie::{AnyObject, Class, Fixnum, Object, RString, VM};

// The structure which we want to wrap
pub struct Server {
    host: String,
    port: u16,
}

impl Server {
    fn new(host: String, port: u16) -> Self {
        Server {
            host: host,
            port: port,
        }
    }

    fn host(&self) -> &str {
        &self.host
    }

    fn port(&self) -> u16 {
        self.port
    }
}

wrappable_struct!(Server, ServerWrapper, SERVER_WRAPPER);

class!(RubyServer);

methods!(
    RubyServer,
    itself,

    fn ruby_server_new(host: RString, port: Fixnum) -> AnyObject {
        let server = Server::new(host.unwrap().to_string(),
                                 port.unwrap().to_i64() as u16);

        Class::from_existing("RubyServer").wrap_data(server, &*SERVER_WRAPPER)
    }

    fn ruby_server_host() -> RString {
        let host = itself.get_data(&*SERVER_WRAPPER).host();

        RString::new(host)
    }

    fn ruby_server_port() -> Fixnum {
        let port = itself.get_data(&*SERVER_WRAPPER).port();

        Fixnum::new(port as i64)
    }
);

fn main() {
    let data_class = Class::from_existing("Object");

    Class::new("RubyServer", Some(&data_class)).define(|itself| {
        itself.def_self("new", ruby_server_new);

        itself.def("host", ruby_server_host);
        itself.def("port", ruby_server_port);
    });
}

To use the RubyServer class in Ruby:

server = RubyServer.new("127.0.0.1", 3000)

server.host == "127.0.0.1"
server.port == 3000

Trait Implementations

impl Debug for Class
[src]

Formats the value using the given formatter. Read more

impl PartialEq for Class
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl From<Value> for Class
[src]

Performs the conversion.

impl Object for Class
[src]

Returns internal value of current object. Read more

Returns a class of current object. Read more

Returns a singleton class of current object. Read more

ⓘImportant traits for &'a mut R

Gets an immutable reference to the Rust structure which is wrapped into a Ruby object. Read more

ⓘImportant traits for &'a mut R

Gets a mutable reference to the Rust structure which is wrapped into a Ruby object.

ⓘImportant traits for &'a mut R

Wraps calls to the object. Read more

Defines an instance method for the given class or object. Read more

Defines a private instance method for the given class or object. Read more

Defines a class method for given class or singleton method for object. Read more

An alias for define_method (similar to Ruby syntax def some_method).

An alias for define_private_method (similar to Ruby syntax private def some_method).

An alias for define_singleton_method (similar to Ruby def self.some_method).

Calls a given method on an object similarly to Ruby Object#send method Read more

Alias for Ruby's == Read more

Alias for Ruby's === Read more

Alias for Ruby's eql? Read more

Alias for Ruby's equal? Read more

Checks whether the object responds to given method Read more

protect_send returns Result<AnyObject, AnyObject> Read more

protect_public_send returns Result<AnyObject, AnyObject> Read more

Checks whether the object is nil Read more

Converts struct to AnyObject Read more

Gets an instance variable of object Read more

Sets an instance variable for object Read more

Returns the freeze status of the object. Read more

Prevents further modifications to the object. Read more

Unsafely casts current object to the specified Ruby type Read more

Safely casts current object to the specified Ruby type Read more

Determines the value type of the object Read more

impl VerifiedObject for Class
[src]

Auto Trait Implementations

impl Send for Class

impl Sync for Class