pub struct Module { /* private fields */ }
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,
itself,
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(|itself| {
itself.def("square", square);
});
}
Ruby:
module Example
def square(exp)
raise TypeError unless exp.is_a?(Fixnum)
exp * exp
end
end
Implementations
sourceimpl Module
impl Module
sourcepub fn new(name: &str) -> Self
pub fn new(name: &str) -> Self
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
sourcepub fn from_existing(name: &str) -> Self
pub fn from_existing(name: &str) -> Self
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')
sourcepub fn ancestors(&self) -> Vec<Module>
pub fn ancestors(&self) -> Vec<Module>
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));
sourcepub fn get_nested_module(&self, name: &str) -> Self
pub fn get_nested_module(&self, name: &str) -> Self
Retrieves a Module
nested to current Module
.
Examples
use rutie::{Module, Object, VM};
Module::new("Outer").define(|itself| {
itself.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')
sourcepub fn get_nested_class(&self, name: &str) -> Class
pub fn get_nested_class(&self, name: &str) -> Class
Retrieves a Class
nested to current Module
.
Examples
use rutie::{Class, Module, Object, VM};
Module::new("Outer").define(|itself| {
itself.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')
sourcepub fn define_nested_module(&mut self, name: &str) -> Self
pub fn define_nested_module(&mut self, name: &str) -> Self
Creates a new Module
nested into current Module
.
Examples
use rutie::{Module, Object, VM};
Module::new("Outer").define(|itself| {
itself.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')
sourcepub fn define_nested_class(
&mut self,
name: &str,
superclass: Option<&Class>
) -> Class
pub fn define_nested_class(
&mut self,
name: &str,
superclass: Option<&Class>
) -> Class
Creates a new Class
nested into current module.
Examples
use rutie::{Class, Module, Object, VM};
Module::new("Outer").define(|itself| {
itself.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')
sourcepub fn define_module_function<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
pub fn define_module_function<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
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,
itself,
fn is_blank() -> Boolean {
Boolean::new(itself.to_str().chars().all(|c| c.is_whitespace()))
}
);
fn main() {
Module::new("Blank").define(|itself| {
itself.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,
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 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 = itself.to_i64().pow(exp as u32);
Fixnum::new(result)
}
);
fn main() {
Module::from_existing("Fixnum").define(|itself| {
itself.mod_func("pow", pow);
itself.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
sourcepub fn mod_func<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
pub fn mod_func<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
An alias for define_module_function
(similar to Ruby module_function :some_method
).
sourcepub fn const_get(&self, name: &str) -> AnyObject
pub fn const_get(&self, name: &str) -> AnyObject
Retrieves a constant from module.
Examples
use rutie::{Module, Object, RString, VM};
Module::new("Greeter").define(|itself| {
itself.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'
sourcepub fn const_set<T: Object>(&mut self, name: &str, value: &T)
pub fn const_set<T: Object>(&mut self, name: &str, value: &T)
Defines a constant for module.
Examples
use rutie::{Module, Object, RString, VM};
Module::new("Greeter").define(|itself| {
itself.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'
sourcepub fn include(&self, md: &str)
pub fn include(&self, md: &str)
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);
sourcepub fn prepend(&self, md: &str)
pub fn prepend(&self, md: &str)
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);
sourcepub fn attr_reader(&mut self, name: &str)
pub fn attr_reader(&mut self, name: &str)
Defines an attr_reader
for module
Examples
use rutie::{Module, Object, VM};
Module::new("Test").define(|itself| {
itself.attr_reader("reader");
});
Ruby:
module Test
attr_reader :reader
end
sourcepub fn attr_writer(&mut self, name: &str)
pub fn attr_writer(&mut self, name: &str)
Defines an attr_writer
for module
Examples
use rutie::{Module, Object, VM};
Module::new("Test").define(|itself| {
itself.attr_writer("writer");
});
Ruby:
module Test
attr_writer :writer
end
sourcepub fn attr_accessor(&mut self, name: &str)
pub fn attr_accessor(&mut self, name: &str)
Defines an attr_accessor
for module
Examples
use rutie::{Module, Object, VM};
Module::new("Test").define(|itself| {
itself.attr_accessor("accessor");
});
Ruby:
module Test
attr_accessor :accessor
end
sourcepub fn wrap_data<T, O: Object>(
&self,
data: T,
wrapper: &dyn DataTypeWrapper<T>
) -> O
pub fn wrap_data<T, O: Object>(
&self,
data: T,
wrapper: &dyn DataTypeWrapper<T>
) -> O
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,
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_utf8(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", None).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
sourceimpl Object for Module
impl Object for Module
sourcefn singleton_class(&self) -> Class
fn singleton_class(&self) -> Class
sourcefn get_data<'a, T>(&'a self, wrapper: &'a dyn DataTypeWrapper<T>) -> &'_ T
fn get_data<'a, T>(&'a self, wrapper: &'a dyn DataTypeWrapper<T>) -> &'_ T
sourcefn get_data_mut<'a, T>(
&'a mut self,
wrapper: &'a dyn DataTypeWrapper<T>
) -> &'_ mut T
fn get_data_mut<'a, T>(
&'a mut self,
wrapper: &'a dyn DataTypeWrapper<T>
) -> &'_ mut T
sourcefn define_method<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
fn define_method<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
sourcefn define_private_method<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
fn define_private_method<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
sourcefn define_singleton_method<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
fn define_singleton_method<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
sourcefn def<I: Object, O: Object>(&mut self, name: &str, callback: Callback<I, O>)
fn def<I: Object, O: Object>(&mut self, name: &str, callback: Callback<I, O>)
define_method
(similar to Ruby syntax def some_method
).sourcefn def_private<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
fn def_private<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
define_private_method
(similar to Ruby syntax private def some_method
).sourcefn def_self<I: Object, O: Object>(&mut self, name: &str, callback: Callback<I, O>)
fn def_self<I: Object, O: Object>(&mut self, name: &str, callback: Callback<I, O>)
define_singleton_method
(similar to Ruby def self.some_method
).sourcefn send(&self, method: &str, arguments: Option<&[AnyObject]>) -> AnyObject
fn send(&self, method: &str, arguments: Option<&[AnyObject]>) -> AnyObject
Object#send
method Read moresourcefn respond_to(&self, method: &str) -> bool
fn respond_to(&self, method: &str) -> bool
sourcefn protect_send(
&self,
method: &str,
arguments: Option<&[AnyObject]>
) -> Result<AnyObject, AnyException>
fn protect_send(
&self,
method: &str,
arguments: Option<&[AnyObject]>
) -> Result<AnyObject, AnyException>
protect_send
returns Result<AnyObject, AnyObject> Read moresourcefn protect_public_send(
&self,
method: &str,
arguments: Option<&[AnyObject]>
) -> Result<AnyObject, AnyException>
fn protect_public_send(
&self,
method: &str,
arguments: Option<&[AnyObject]>
) -> Result<AnyObject, AnyException>
protect_public_send
returns Result<AnyObject, AnyObject> Read moresourcefn to_any_object(&self) -> AnyObject
fn to_any_object(&self) -> AnyObject
AnyObject
Read more