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

Formats the value using the given formatter. Read more

Performs the conversion.

Performs the conversion.

Performs the conversion.

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

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.

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

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

This method tests for !=.

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Performs the conversion.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.