Struct rutie::Module [−][src]
pub struct Module { /* fields omitted */ }
Expand description
Module
Also see def
, def_self
, define
and some more functions from Object
trait.
#[macro_use] extern crate rutie;
use std::error::Error;
use rutie::{Module, Fixnum, Object, Exception, VM};
module!(Example);
methods!(
Example,
rtself,
fn square(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();
Fixnum::new(exp * exp)
}
);
fn main() {
Module::new("Example").define(|klass| {
klass.def("square", square);
});
}
Ruby:
module Example
def square(exp)
raise TypeError unless exp.is_a?(Fixnum)
exp * exp
end
end
Implementations
Creates a new Module
.
Examples
use rutie::{Module, VM};
let basic_record_module = Module::new("BasicRecord");
assert_eq!(basic_record_module, Module::from_existing("BasicRecord"));
Ruby:
module BasicRecord
end
Retrieves an existing Module
object.
Examples
use rutie::{Module, VM};
let module = Module::new("Record");
assert_eq!(module, Module::from_existing("Record"));
Ruby:
module Record
end
Record
Object.const_get('Record')
Returns a Vector of ancestors of current module
Examples
Getting all the ancestors
use rutie::{Module, VM};
let process_module_ancestors = Module::from_existing("Process").ancestors();
let expected_ancestors = vec![
Module::from_existing("Process")
];
assert_eq!(process_module_ancestors, expected_ancestors);
Searching for an ancestor
use rutie::{Module, VM};
let record_module = Module::new("Record");
let ancestors = record_module.ancestors();
assert!(ancestors.iter().any(|module| *module == record_module));
Retrieves a Module
nested to current Module
.
Examples
use rutie::{Module, Object, VM};
Module::new("Outer").define(|klass| {
klass.define_nested_module("Inner");
});
Module::from_existing("Outer").get_nested_module("Inner");
Ruby:
module Outer
module Inner
end
end
Outer::Inner
Outer.const_get('Inner')
Retrieves a Class
nested to current Module
.
Examples
use rutie::{Class, Module, Object, VM};
Module::new("Outer").define(|klass| {
klass.define_nested_class("Inner", None);
});
Module::from_existing("Outer").get_nested_class("Inner");
Ruby:
module Outer
class Inner
end
end
Outer::Inner
Outer.const_get('Inner')
Creates a new Module
nested into current Module
.
Examples
use rutie::{Module, Object, VM};
Module::new("Outer").define(|klass| {
klass.define_nested_module("Inner");
});
Module::from_existing("Outer").get_nested_module("Inner");
Ruby:
module Outer
module Inner
end
end
Outer::Inner
Outer.const_get('Inner')
Creates a new Class
nested into current module.
Examples
use rutie::{Class, Module, Object, VM};
Module::new("Outer").define(|klass| {
klass.define_nested_class("Inner", None);
});
Module::from_existing("Outer").get_nested_class("Inner");
Ruby:
module Outer
class Inner
end
end
Outer::Inner
Outer.const_get('Inner')
Defines an instance method for the given module.
Use methods!
macro to define a callback
.
You can also use def()
alias for this function combined with Module::define()
for a
nicer DSL.
Panics
Ruby can raise an exception if you try to define instance method directly on an instance
of some class (like Fixnum
, String
, Array
etc).
Use this method only on classes (or singleton classes of objects).
Examples
The famous String#blank? method
#[macro_use] extern crate rutie;
use rutie::{Boolean, Module, Class, Object, RString, VM};
methods!(
RString,
rtself,
fn is_blank() -> Boolean {
Boolean::new(rtself.to_str().chars().all(|c| c.is_whitespace()))
}
);
fn main() {
Module::new("Blank").define(|klass| {
klass.mod_func("blank?", is_blank);
});
Class::from_existing("String").include("Blank");
}
Ruby:
module Blank
def blank?
self.chars.all? { |c| c == ' ' }
end
module_function :blank?
end
String.include Blank
Receiving arguments
Raise Fixnum
to the power of exp
.
#[macro_use] extern crate rutie;
use std::error::Error;
use rutie::{Module, Fixnum, Object, Exception, VM};
methods!(
Fixnum,
rtself,
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(rtself.to_i64().pow(exp))
}
fn pow_with_default_argument(exp: Fixnum) -> Fixnum {
let default_exp = 0;
let exp = exp.map(|exp| exp.to_i64()).unwrap_or(default_exp);
let result = rtself.to_i64().pow(exp as u32);
Fixnum::new(result)
}
);
fn main() {
Module::from_existing("Fixnum").define(|klass| {
klass.mod_func("pow", pow);
klass.mod_func("pow_with_default_argument", pow_with_default_argument);
});
}
Ruby:
module Fixnum
def pow(exp)
raise ArgumentError unless exp.is_a?(Fixnum)
self ** exp
end
module_function :pow
def pow_with_default_argument(exp)
default_exp = 0
exp = default_exp unless exp.is_a?(Fixnum)
self ** exp
end
module_function :pow_with_default_argument
end
An alias for define_module_function
(similar to Ruby module_function :some_method
).
Retrieves a constant from module.
Examples
use rutie::{Module, Object, RString, VM};
Module::new("Greeter").define(|klass| {
klass.const_set("GREETING", &RString::new_utf8("Hello, World!"));
});
let greeting = Module::from_existing("Greeter")
.const_get("GREETING")
.try_convert_to::<RString>()
.unwrap();
assert_eq!(greeting.to_str(), "Hello, World!");
Ruby:
module Greeter
GREETING = 'Hello, World!'
end
Greeter = Module.new
Greeter.const_set('GREETING', 'Hello, World!')
Greeter::GREETING == 'Hello, World!'
Greeter.const_get('GREETING') == 'Hello, World'
Defines a constant for module.
Examples
use rutie::{Module, Object, RString, VM};
Module::new("Greeter").define(|klass| {
klass.const_set("GREETING", &RString::new_utf8("Hello, World!"));
});
let greeting = Module::from_existing("Greeter")
.const_get("GREETING")
.try_convert_to::<RString>()
.unwrap();
assert_eq!(greeting.to_str(), "Hello, World!");
Ruby:
module Greeter
GREETING = 'Hello, World!'
end
Greeter = Module.new
Greeter.const_set('GREETING', 'Hello, World!')
Greeter::GREETING == 'Hello, World!'
Greeter.const_get('GREETING') == 'Hello, World'
Includes module into current module
Examples
use rutie::{Module, VM};
Module::new("A");
Module::new("B").include("A");
let b_module_ancestors = Module::from_existing("B").ancestors();
let expected_ancestors = vec![
Module::from_existing("B"),
Module::from_existing("A")
];
assert_eq!(b_module_ancestors, expected_ancestors);
Prepends module into current module
Examples
use rutie::{Module, VM};
Module::new("A");
Module::new("B").prepend("A");
let b_module_ancestors = Module::from_existing("B").ancestors();
let expected_ancestors = vec![
Module::from_existing("A"),
Module::from_existing("B")
];
assert_eq!(b_module_ancestors, expected_ancestors);
Defines an attr_reader
for module
Examples
use rutie::{Module, Object, VM};
Module::new("Test").define(|klass| {
klass.attr_reader("reader");
});
Ruby:
module Test
attr_reader :reader
end
Defines an attr_writer
for module
Examples
use rutie::{Module, Object, VM};
Module::new("Test").define(|klass| {
klass.attr_writer("writer");
});
Ruby:
module Test
attr_writer :writer
end
Defines an attr_accessor
for module
Examples
use rutie::{Module, Object, VM};
Module::new("Test").define(|klass| {
klass.attr_accessor("accessor");
});
Ruby:
module Test
attr_accessor :accessor
end
Wraps Rust structure into a new Ruby object of the current module.
See the documentation for wrappable_struct!
macro for more information.
Examples
Wrap Server
structs to RubyServer
objects. Note: Example shows use
with class but the method still applies to module.
#[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,
rtself,
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 = rtself.get_data(&*SERVER_WRAPPER).host();
RString::new_utf8(host)
}
fn ruby_server_port() -> Fixnum {
let port = rtself.get_data(&*SERVER_WRAPPER).port();
Fixnum::new(port as i64)
}
);
fn main() {
let data_class = Class::from_existing("Object");
Class::new("RubyServer", None).define(|klass| {
klass.def_self("new", ruby_server_new);
klass.def("host", ruby_server_host);
klass.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
Returns a singleton class of current object. Read more
Gets an immutable reference to the Rust structure which is wrapped into a Ruby object. Read more
Gets a mutable reference to the Rust structure which is wrapped into a Ruby object.
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
Checks whether the object responds to given method Read more
fn protect_send(
&self,
method: &str,
arguments: &[AnyObject]
) -> Result<AnyObject, AnyException>
fn protect_send(
&self,
method: &str,
arguments: &[AnyObject]
) -> Result<AnyObject, AnyException>
protect_send
returns Result<AnyObject, AnyObject> Read more
fn protect_public_send(
&self,
method: &str,
arguments: &[AnyObject]
) -> Result<AnyObject, AnyException>
fn protect_public_send(
&self,
method: &str,
arguments: &[AnyObject]
) -> Result<AnyObject, AnyException>
protect_public_send
returns Result<AnyObject, AnyObject> Read more
Converts struct to AnyObject
Read more
Gets an instance variable of object Read more
Sets an instance variable for 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