rutie 0.14.0

The tie between Ruby and Rust.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use crate::{
    rubysys::{encoding, symbol},
    types::{c_char, c_long, Id, Value},
    util,
};

pub fn value_to_str<'a>(value: Value) -> &'a str {
    let ptr = sym_to_ptr(value);

    unsafe { util::cstr_to_str(ptr) }
}

pub fn value_to_string(value: Value) -> String {
    let ptr = sym_to_ptr(value);

    unsafe { util::cstr_to_string(ptr) }
}

pub fn id_to_sym(id: Id) -> Value {
    unsafe { symbol::rb_id2sym(id) }
}

fn sym_to_ptr(value: Value) -> *const c_char {
    let id = sym_to_id(value);

    id_to_name(id)
}

fn sym_to_id(sym: Value) -> Id {
    unsafe { symbol::rb_sym2id(sym) }
}

fn id_to_name(id: Id) -> *const c_char {
    unsafe { symbol::rb_id2name(id) }
}

pub fn internal_id(string: &str) -> Id {
    let str = string.as_ptr() as *const c_char;
    let len = string.len() as c_long;

    unsafe { symbol::rb_intern2(str, len) }
}

pub fn id_to_string(id: Id) -> String {
    unsafe { util::cstr_to_string(id_to_name(id)) }
}

pub fn sym_to_str(symbol: Value) -> Value {
    unsafe { symbol::rb_sym2str(symbol) }
}

// The symbol for the String `name`, or `None` (creating nothing) if no such
// symbol exists yet.
pub fn check_symbol(name: Value) -> Option<Value> {
    let mut name = name;
    let id = unsafe { symbol::rb_check_id(&mut name) };

    if id == 0 {
        None
    } else {
        Some(id_to_sym(id))
    }
}

pub fn to_symbol(name: Value) -> Value {
    unsafe { symbol::rb_to_symbol(name) }
}

pub fn is_const_name(symbol: Value) -> bool {
    util::c_int_to_bool(unsafe { symbol::rb_is_const_id(sym_to_id(symbol)) })
}

pub fn is_instance_variable_name(symbol: Value) -> bool {
    util::c_int_to_bool(unsafe { symbol::rb_is_instance_id(sym_to_id(symbol)) })
}

pub fn is_class_variable_name(symbol: Value) -> bool {
    util::c_int_to_bool(unsafe { symbol::rb_is_class_id(sym_to_id(symbol)) })
}

// Raises `EncodingError` for bytes that are invalid in `enc`.
pub fn intern_with_encoding(name: &[u8], enc: Value) -> Value {
    let (ptr, len) = (name.as_ptr() as *const c_char, name.len() as c_long);

    unsafe { id_to_sym(symbol::rb_intern3(ptr, len, encoding::rb_to_encoding(enc))) }
}

// The existing symbol, or `nil`; raises `EncodingError` for invalid bytes.
pub fn check_symbol_with_encoding(name: &[u8], enc: Value) -> Value {
    let (ptr, len) = (name.as_ptr() as *const c_char, name.len() as c_long);

    unsafe { symbol::rb_check_symbol_cstr(ptr, len, encoding::rb_to_encoding(enc)) }
}

pub fn is_symbol_name(name: &[u8], enc: Value) -> bool {
    let (ptr, len) = (name.as_ptr() as *const c_char, name.len() as c_long);

    util::c_int_to_bool(unsafe {
        symbol::rb_enc_symname2_p(ptr, len, encoding::rb_to_encoding(enc))
    })
}

// Raises `NameError` for names without a setter form (operators, ...).
pub fn attrset(symbol: Value) -> Value {
    unsafe { id_to_sym(symbol::rb_id_attrset(sym_to_id(symbol))) }
}

pub fn is_attrset_name(symbol: Value) -> bool {
    util::c_int_to_bool(unsafe { symbol::rb_is_attrset_id(sym_to_id(symbol)) })
}

pub fn is_global_name(symbol: Value) -> bool {
    util::c_int_to_bool(unsafe { symbol::rb_is_global_id(sym_to_id(symbol)) })
}

pub fn is_local_name(symbol: Value) -> bool {
    util::c_int_to_bool(unsafe { symbol::rb_is_local_id(sym_to_id(symbol)) })
}

pub fn is_junk_name(symbol: Value) -> bool {
    util::c_int_to_bool(unsafe { symbol::rb_is_junk_id(sym_to_id(symbol)) })
}

pub fn all_symbols() -> Value {
    unsafe { symbol::rb_sym_all_symbols() }
}

pub fn last_line() -> Value {
    unsafe { symbol::rb_lastline_get() }
}

pub fn set_last_line(value: Value) {
    unsafe { symbol::rb_lastline_set(value) }
}