gvars 0.9.7 → 0.9.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f54223d6addde0cfe225b0894f2da28b43cfa6f679e786baceeee34aedf7238
-  data.tar.gz: 3fcc088c1798d3f303825e4ca5167e11b787ffde7f359101426df82b6bde96f2
+  metadata.gz: 837ffc167909e2abe16ff54fdcd7bfbe4cb6dc0346f1c3e9037b17933f3b89a7
+  data.tar.gz: 9e36c6847244b578e63032468c2d94e7fff4f4e05c68cd3a1c126fc257a02b7c
 SHA512:
-  metadata.gz: 98c348911582069c49ad6089837708b0479575ab2d176428d4099bb9c107cef7cadc8ce2173853268b4f442abd49385f63c7888ccb611aa9a4a7f5a94af4cdbf
-  data.tar.gz: 37ef3ebeefa4f341dc70e0fc393147e6b8feadc40a29e3edc4b8f7624e5836354f47c4f6801c53fe9301b871882b9a0ed45e872a6931fa05d80f8bc3db061c6c
+  metadata.gz: 7e71e7a19371437156d14f1831045a6229b4fcd055cc82680309266c5ed20781ec030b78e591e38e4a7adb62633ceb98d5284ca69b8e40eb475ee4ea829ee269
+  data.tar.gz: f5cba137bad5f8d9db885f468df9bc147f89b7c0106653a409fd8aa5d32767a8fceba372b4a4c778bdf4161ae59c215dd2081cff250aeccfcf4c2c161658c1a9

data/ext/gvars/gvars.c

@@ -7,7 +7,7 @@ VALUE gvars_module;
 //
 // for checking, it makes that `name` starts with `$`. This isn't really required, as ruby supports
 // globals that don't start with `$` (but doesn't expose any methods to interact with them)
-static char *get_global_name(VALUE *name) {
+static char *get_global_name(VALUE *name, bool raise) {
 	// If `name` is a symbol, get its backing string
 	if (RB_SYMBOL_P(*name)) {
 		*name = rb_sym2str(*name);
@@ -16,7 +16,7 @@ static char *get_global_name(VALUE *name) {
 	char *namestr = StringValueCStr(*name);
 
 	// Ensure it starts with a dollar sign
-	if (namestr[0] != '$') {
+	if (raise && namestr[0] != '$') {
 		rb_raise(rb_eNameError, "'%s' is not allowed as a global variable name", namestr);
 	}
 
@@ -27,13 +27,26 @@ static char *get_global_name(VALUE *name) {
 static VALUE
 gvars_f_global_variable_get(VALUE self, VALUE name)
 {
-	return rb_gv_get(get_global_name(&name));
+	return rb_gv_get(get_global_name(&name, true));
+}
+
+static VALUE
+gvars_f_global_variable_aref(VALUE self, VALUE name)
+{
+	return rb_gv_get(get_global_name(&name, false));
 }
 
 static VALUE
 gvars_f_global_variable_set(VALUE self, VALUE name, VALUE value)
 {
-	return rb_gv_set(get_global_name(&name), value);
+	return rb_gv_set(get_global_name(&name, true), value);
+}
+
+
+static VALUE
+gvars_f_global_variable_aset(VALUE self, VALUE name, VALUE value)
+{
+	return rb_gv_set(get_global_name(&name, false), value);
 }
 
 static VALUE
@@ -45,8 +58,8 @@ gvars_f_global_variables(VALUE self)
 static VALUE
 gvars_f_alias_global_variable(VALUE self, VALUE new, VALUE old)
 {
-	ID newid = rb_intern(get_global_name(&new));
-	rb_alias_variable(newid, rb_intern(get_global_name(&old)));
+	ID newid = rb_intern(get_global_name(&new, true));
+	rb_alias_variable(newid, rb_intern(get_global_name(&old, true)));
 	return ID2SYM(newid);
 }
 
@@ -64,7 +77,7 @@ gvars_f_each(VALUE self)
 	VALUE gvars = gvars_f_global_variables(self);
 	for (long i = 0; i < RARRAY_LEN(gvars); i++) {
 		VALUE key = RARRAY_AREF(gvars, i);
-		rb_yield(rb_ary_new3(2, key, gvars_f_global_variable_get(self, key)));
+		rb_yield(rb_ary_new_from_args(2, key, gvars_f_global_variable_get(self, key)));
 	}
 
 	return self;
@@ -87,12 +100,13 @@ gvars_f_to_h(VALUE self)
 struct value_ptr { VALUE *value; };
 static void value_ptr_mark(void *ptr) { rb_gc_mark(*((struct value_ptr *) ptr)->value); }
 static void value_ptr_free(void *ptr) { ruby_xfree(((struct value_ptr *) ptr)->value); }
+static size_t value_ptr_size(const void *ptr) { return sizeof(struct value_ptr); }
 static const rb_data_type_t value_ptr_data_type = {
 	.wrap_struct_name = "gvars/value_ptr",
 	.function = {
 		.dmark = value_ptr_mark,
 		.dfree = value_ptr_free,
-		.dsize = NULL // todo: not 0
+		.dsize = value_ptr_size,
 	},
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY
 };
@@ -104,21 +118,21 @@ struct gvars_virtual_var {
 
 static void gvars_virtual_var_mark(void *ptr) {
 	struct gvars_virtual_var *gv = ptr;
-	if (gv->backing != Qundef) rb_gc_mark(gv->backing);
+	rb_gc_mark(gv->backing);
 	rb_gc_mark(gv->getter);
 	rb_gc_mark(gv->setter);
 }
 
-static void gvars_virtual_var_free(void *ptr) {
-	xfree(ptr);
+static size_t gvars_virtual_var_size(const void *ptr) {
+	return sizeof(struct gvars_virtual_var);
 }
 
 static const rb_data_type_t gvars_type = {
-	.wrap_struct_name = "gvars_var",
+	.wrap_struct_name = "gvars/var",
 	.function = {
 		.dmark = gvars_virtual_var_mark,
-		.dfree = gvars_virtual_var_free,
-		.dsize = NULL
+		.dfree = RUBY_DEFAULT_FREE,
+		.dsize = gvars_virtual_var_size,
 	},
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY
 };
@@ -127,61 +141,39 @@ static const rb_data_type_t gvars_type = {
 static VALUE gvars_virtual_var_getter(ID id, VALUE *data) {
 	struct gvars_virtual_var *gv;
 	TypedData_Get_Struct(*data, struct gvars_virtual_var, &gvars_type, gv);
-
-	return rb_proc_call_kw(gv->getter, rb_ary_new(), RB_NO_KEYWORDS);
+	return rb_proc_call(gv->getter, rb_ary_new());
 }
 
 static void gvars_virtual_var_setter(VALUE val, ID id, VALUE *data) {
 	struct gvars_virtual_var *gv;
 	TypedData_Get_Struct(*data, struct gvars_virtual_var, &gvars_type, gv);
-
-	rb_proc_call_kw(gv->setter, rb_ary_new3(1, val), RB_NO_KEYWORDS);
+	rb_proc_call(gv->setter, rb_ary_new_from_args(1, val));
 }
 
 static VALUE gvars_hooked_state_var_getter(ID id, VALUE *data) {
 	struct gvars_virtual_var *gv;
 	TypedData_Get_Struct(*data, struct gvars_virtual_var, &gvars_type, gv);
-
-	return rb_proc_call_kw(gv->getter, rb_ary_new3(1, gv->backing), RB_NO_KEYWORDS);
-}
-
-static void gvars_hooked_state_var_setter_noproc(VALUE val, ID id, VALUE *data) {
-	struct gvars_virtual_var *gv;
-	TypedData_Get_Struct(*data, struct gvars_virtual_var, &gvars_type, gv);
-
-	gv->backing = val;
-}
-
-static void gvars_hooked_state_var_setter_proc(VALUE val, ID id, VALUE *data) {
-	struct gvars_virtual_var *gv;
-	TypedData_Get_Struct(*data, struct gvars_virtual_var, &gvars_type, gv);
-
-	gv->backing = rb_proc_call_kw(gv->setter, rb_ary_new3(2, val, gv->backing), RB_NO_KEYWORDS);
+	return rb_proc_call(gv->getter, rb_ary_new_from_args(1, gv->backing));
 }
 
 static VALUE gvars_hooked_initial_var_getter(ID id, VALUE *data) {
 	struct gvars_virtual_var *gv;
 	TypedData_Get_Struct(*data, struct gvars_virtual_var, &gvars_type, gv);
-
-	gv->backing = rb_proc_call_kw(gv->getter, rb_ary_new3(1, gv->backing), RB_NO_KEYWORDS);
-	return gv->backing;
+	return gv->backing = rb_proc_call(gv->getter, rb_ary_new_from_args(1, gv->backing));
 }
 
-static void gvars_hooked_initial_var_setter_noproc(VALUE val, ID id, VALUE *data) {
+static void gvars_hooked_var_setter_noproc(VALUE val, ID id, VALUE *data) {
 	struct gvars_virtual_var *gv;
 	TypedData_Get_Struct(*data, struct gvars_virtual_var, &gvars_type, gv);
-
 	gv->backing = val;
 }
 
-static void gvars_hooked_initial_var_setter_proc(VALUE val, ID id, VALUE *data) {
+static void gvars_hooked_var_setter_proc(VALUE val, ID id, VALUE *data) {
 	struct gvars_virtual_var *gv;
 	TypedData_Get_Struct(*data, struct gvars_virtual_var, &gvars_type, gv);
-
-	gv->backing = rb_proc_call_kw(gv->setter, rb_ary_new3(2, val, gv->backing), RB_NO_KEYWORDS);
+	gv->backing = rb_proc_call(gv->setter, rb_ary_new_from_args(2, val, gv->backing));
 }
 
-
 static VALUE gvars_virtual_var_alloc(VALUE backing, VALUE getter, VALUE setter) {
 	struct gvars_virtual_var *gv;
 	VALUE gvar_ty = TypedData_Make_Struct(rb_cObject, struct gvars_virtual_var, &gvars_type, gv);
@@ -200,23 +192,7 @@ enum virtual_kind {
 static void
 gvars_define_virtual_method(VALUE self, VALUE *name, VALUE backing, VALUE getter, VALUE setter, enum virtual_kind kind, int readonly_special)
 {
-	char *name_str = get_global_name(name);
-	VALUE getter_proc, setter_proc;
-
-	getter_proc = rb_convert_type(getter, T_DATA, "Proc", "to_proc");
-	if (NIL_P(getter_proc) || !rb_obj_is_proc(getter_proc)) {
-		rb_raise(rb_eTypeError, "wrong getter type %s (expected Proc)", rb_obj_classname(getter_proc));
-	}
-
-	if (NIL_P(setter)) {
-		setter_proc = Qnil;
-	} else {
-		setter_proc = rb_convert_type(setter, T_DATA, "Proc", "to_proc");
-		if (NIL_P(setter_proc) || !rb_obj_is_proc(setter_proc)) {
-			rb_raise(rb_eTypeError, "wrong setter type %s (expected Proc)", rb_obj_classname(setter_proc));
-		}
-	}
-
+	char *name_str = get_global_name(name, true);
 	struct value_ptr *vp;
 	VALUE vp_data = TypedData_Make_Struct(rb_cObject, struct value_ptr, &value_ptr_data_type, vp);
 	vp->value = RB_ALLOC(VALUE);
@@ -228,40 +204,51 @@ gvars_define_virtual_method(VALUE self, VALUE *name, VALUE backing, VALUE getter
 	switch (kind) {
 	case GVARS_VIRTUAL_KIND_VIRTUAL:
 		getter_meth = gvars_virtual_var_getter;
-		setter_meth = setter_proc == Qnil ? rb_gvar_readonly_setter : gvars_virtual_var_setter;
-		break;
-
-	case GVARS_VIRTUAL_KIND_INITIAL:
-		getter_meth = gvars_hooked_initial_var_getter;
-		setter_meth = setter_proc == Qnil ? gvars_hooked_initial_var_setter_noproc : gvars_hooked_initial_var_setter_proc;
+		setter_meth = setter == Qnil ? rb_gvar_readonly_setter : gvars_virtual_var_setter;
 		break;
 
 	case GVARS_VIRTUAL_KIND_STATE:
-		getter_meth = gvars_hooked_state_var_getter;
-		setter_meth = setter_proc == Qnil ? gvars_hooked_state_var_setter_noproc : gvars_hooked_state_var_setter_proc;
+	case GVARS_VIRTUAL_KIND_INITIAL:
+		getter_meth = kind == GVARS_VIRTUAL_KIND_INITIAL ? gvars_hooked_initial_var_getter : gvars_hooked_state_var_getter;
+		if (readonly_special) setter_meth = rb_gvar_readonly_setter;
+		else setter_meth = setter == Qnil ? gvars_hooked_var_setter_noproc : gvars_hooked_var_setter_proc;
 		break;
 
 	default:
 		rb_bug("oops");
 	}
 
-	if (readonly_special) setter_meth = rb_gvar_readonly_setter;
 
 	rb_define_hooked_variable(name_str, vp->value, getter_meth, setter_meth);
 
-	VALUE hash = rb_iv_get(gvars_module, "@vars");
+	VALUE hash = rb_iv_get(gvars_module, "vars");
 	VALUE namesym = rb_str_new_cstr(name_str);
 	rb_hash_aset(hash, namesym, vp_data);
 }
 
+enum virtual_method_keywords {
+	VIRTUAL_METHOD_KEYWORDS_INITIAL,
+	VIRTUAL_METHOD_KEYWORDS_STATE,
+	VIRTUAL_METHOD_KEYWORDS_READONLY,
+	LENGTH_OF_VIRTUAL_METHOD_KEYWORDS,
+};
+
+static ID virtual_method_keyword_ids[LENGTH_OF_VIRTUAL_METHOD_KEYWORDS];
+
+static VALUE convert_to_proc(const char *name, VALUE input) {
+	VALUE proc = rb_convert_type(input, T_DATA, "Proc", "to_proc");
+
+	if (NIL_P(proc) || !rb_obj_is_proc(proc)) {
+		rb_raise(rb_eTypeError, "wrong %s type %s (expected Proc)", name, rb_obj_classname(proc));
+	}
+
+	return proc;
+}
+
 static VALUE
 gvars_f_define_virtual_method(int argc, VALUE *argv, VALUE self)
 {
-	VALUE name, backing = Qundef, getter, setter, opts_hash, opts[3];
-    ID keyword_ids[3];
-    keyword_ids[0] = rb_intern("initial");
-    keyword_ids[1] = rb_intern("state");
-    keyword_ids[2] = rb_intern("readonly");
+	VALUE name, backing, getter, setter, opts_hash, opts[LENGTH_OF_VIRTUAL_METHOD_KEYWORDS];
 
 	switch (rb_scan_args(argc, argv, "12:", &name, &getter, &setter, &opts_hash)) {
 	case 1:
@@ -281,22 +268,28 @@ gvars_f_define_virtual_method(int argc, VALUE *argv, VALUE self)
 		rb_bug("oops");
 	}
 
+	getter = convert_to_proc("getter", getter);
+	if (!NIL_P(setter)) setter = convert_to_proc("setter", setter);
+
 	enum virtual_kind kind = GVARS_VIRTUAL_KIND_VIRTUAL;
-	rb_get_kwargs(opts_hash, keyword_ids, 0, 3, opts);
+	rb_get_kwargs(opts_hash, virtual_method_keyword_ids, 0, LENGTH_OF_VIRTUAL_METHOD_KEYWORDS, opts);
 
-	if (opts[0] != Qundef) {
-		if (opts[1] != Qundef) {
+	if (opts[VIRTUAL_METHOD_KEYWORDS_INITIAL] != Qundef) {
+		if (opts[VIRTUAL_METHOD_KEYWORDS_STATE] != Qundef) {
 			rb_raise(rb_eArgError, "only one of 'initial' or 'state' may be supplied");
 		}
-		backing = opts[0];
+		backing = opts[VIRTUAL_METHOD_KEYWORDS_INITIAL];
 		kind = GVARS_VIRTUAL_KIND_INITIAL;
-	} else if (opts[1] != Qundef) {
-		backing = opts[1];
+	} else if (opts[VIRTUAL_METHOD_KEYWORDS_STATE] != Qundef) {
+		backing = opts[VIRTUAL_METHOD_KEYWORDS_STATE];
 		kind = GVARS_VIRTUAL_KIND_STATE;
+	} else {
+		backing = Qnil;
 	}
 
-	bool is_readonly = false;
-	if (opts[2] != Qundef && RTEST(opts[2])) { // sadly no bool expected :-/
+ 	// sadly no bool expected :-/
+	bool is_readonly = opts[VIRTUAL_METHOD_KEYWORDS_READONLY] != Qundef && RTEST(opts[VIRTUAL_METHOD_KEYWORDS_READONLY]);
+	if (is_readonly) {
 		if (setter != Qnil) {
 			rb_raise(rb_eArgError, "'readonly: true' may not be supplied when a setter proc is supplied");
 		}
@@ -314,7 +307,11 @@ void
 Init_gvars(void)
 {
 	gvars_module = rb_define_module("GVars");
-	rb_ivar_set(gvars_module, rb_intern("@vars"), rb_hash_new());
+	rb_ivar_set(gvars_module, rb_intern("vars"), rb_hash_new());
+
+    virtual_method_keyword_ids[VIRTUAL_METHOD_KEYWORDS_INITIAL] = rb_intern("initial");
+    virtual_method_keyword_ids[VIRTUAL_METHOD_KEYWORDS_STATE] = rb_intern("state");
+    virtual_method_keyword_ids[VIRTUAL_METHOD_KEYWORDS_READONLY] = rb_intern("readonly");
 
 	// Define module-level functions that can be used as mixins
 	rb_define_module_function(gvars_module, "global_variable_get", gvars_f_global_variable_get, 1);
@@ -332,12 +329,13 @@ Init_gvars(void)
 	rb_define_singleton_method(gvars_module, "each", gvars_f_each, 0);
 	rb_define_singleton_method(gvars_module, "to_h", gvars_f_to_h, 0);
 
+	rb_define_singleton_method(gvars_module, "[]", gvars_f_global_variable_aref, 1);
+	rb_define_singleton_method(gvars_module, "[]=", gvars_f_global_variable_aset, 2);
+
 	// Aliases
 	VALUE gvars_singleton = rb_singleton_class(gvars_module);
 	rb_define_alias(gvars_singleton, "get", "global_variable_get");
-	rb_define_alias(gvars_singleton, "[]", "global_variable_get");
 	rb_define_alias(gvars_singleton, "set", "global_variable_set");
-	rb_define_alias(gvars_singleton, "[]=", "global_variable_set");
 	rb_define_alias(gvars_singleton, "alias", "alias_global_variable");
 	rb_define_alias(gvars_singleton, "list", "global_variables");
 	rb_define_alias(gvars_singleton, "virtual", "define_virtual_method");

data/lib/gvars/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GVars
-  VERSION = '0.9.7'
+  VERSION = '0.9.8'
 end

data/tmp.rb

@@ -1,6 +1,27 @@
 require 'gvars'
 p GVars::VERSION
 
+require 'optparse'
+OptParse.new do |op|
+  op.on '--timeout=X', 'the timeout'
+  op.parse %w[--timeout 34.5], into: GVars
+end
+
+p $timeout
+
+__END__
+h = {}
+GVars.virtual(:$-e, &h.method(:[]).curry(1).<<(:$-e))
+# GVars.virtual(:$-e,) { $-W.to_s }
+# $-v = false
+# p $-e
+# $-v = true
+# p $-e
+# $-v = nil
+p $-e
+
+exit
+
 100.times do
   GVars.virtual(:$foo) { p "bar" }
   # GVars.virtual(:$foo) { p "foo" }
@@ -20,8 +41,26 @@ fail unless 11 == $bar1
 
 GVars.virtual(:$bar2, state: 'a') { it.succ!.dup }
 fail unless ['b', 'c', 'd'] == [$bar2, $bar2, $bar2]
-$bar2 = 10
-fail unless 11 == $bar2
+
+
+GVars.virtual(:$lol) { @x = 3 }
+class Thing
+  def doit
+    $lol
+    p @x
+  end
+end
+Thing.new.doit
+p @x
+      trace_var :$bar, proc {|v| puts "$_ is now '#{v}'" }
+      $bar = 2
+      $bar = 3
+      trace_var :$_, proc {|v| puts "$_ is now '#{v}'" }
+    $_ = "hello"
+      $_ = ' there'
+
+# $bar2 = 10
+# fail unless 11 == $bar2
 
 # GVars.virtual(:$bar, proc{ p "bar" })
 # GVars.virtual(:$baz, proc{ p "bar" }, proc { p "baz: #{_1}"})

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gvars
 version: !ruby/object:Gem::Version
-  version: 0.9.7
+  version: 0.9.8
 platform: ruby
 authors:
 - Sam Westerman
@@ -24,7 +24,6 @@ files:
 - Rakefile
 - ext/gvars/extconf.rb
 - ext/gvars/gvars.c
-- ext/gvars/gvars.c-old
 - gb
 - lib/gvars.rb
 - lib/gvars/version.rb

data/ext/gvars/gvars.c-old

@@ -1,147 +0,0 @@
-#include "ruby.h"
-
-// Converts `name` to a global variable name, ensures it's valid, and returns it.
-//
-// for checking, it makes that `name` starts with `$`. This isn't really required, as ruby supports
-// globals that don't start with `$` (but doesn't expose any methods to interact with them)
-static char *get_global_name(VALUE *name) {
-	// printf("spot1\n");
-	if (RB_SYMBOL_P(*name)) *name = rb_sym2str(*name);
-	// printf("spot2\n");
-	char *namestr = StringValueCStr(*name);
-	// printf("spot3\n");
-
-	if (namestr[0] != '$') {
-		rb_raise(rb_eNameError, "'%s' is not allowed as a global variable name", namestr);
-	}
-
-	return namestr;
-}
-
-static VALUE
-gvars_f_get(VALUE self, VALUE name)
-{
-	// extern VALUE rb_gvars_get(ID);
-	return rb_gvars_get(rb_intern(get_global_name(&name)));
-}
-
-static VALUE
-gvars_f_set(VALUE self, VALUE name, VALUE value)
-{
-	return rb_gv_set(get_global_name(&name), value);
-}
-
-static VALUE
-gvars_f_defined_p(VALUE self, VALUE name)
-{
-	extern VALUE rb_gvar_defined(ID);
-	return rb_gvar_defined(rb_check_id(&name));
-}
-
-static VALUE
-gvars_list(VALUE self)
-{
-	return rb_f_global_variables();
-}
-
-static VALUE
-gvars_f_alias(VALUE self, VALUE new, VALUE old)
-{
-    ID newid = rb_intern(get_global_name(&new));
-	rb_alias_variable(newid, rb_intern(get_global_name(&old)));
-	return ID2SYM(newid);
-}
-
-struct hooked_var {
-	VALUE getter, setter;
-};
-
-static VALUE hooked_var_getter(ID id, VALUE *data) {
-	struct hooked_var *bv = (struct hooked_var *)data;
-	return rb_proc_call_kw(bv->getter, rb_ary_new3(1, rb_id2str(id)), RB_NO_KEYWORDS);
-}
-
-static void hooked_var_setter(VALUE val, ID id, VALUE *data) {
-	struct hooked_var *bv = (struct hooked_var *)data;
-	rb_proc_call_kw(bv->setter, rb_ary_new3(2, rb_id2str(id), val), RB_NO_KEYWORDS);
-}
-
-static VALUE
-gvars_define_virtual_global(int argc, VALUE *argv, VALUE self)
-{
-	VALUE name, getter, setter;
-
-	switch (rb_scan_args(argc, argv, "12", &name, &getter, &setter)) {
-	case 1:
-		getter = (rb_need_block(), rb_block_proc());
-		setter = Qnil;
-		break;
-
-	case 2:
-		setter = Qnil;
-
-	case 3:
-        if (rb_block_given_p()) {
-            rb_warn("given block not used");
-        }
-		break;
-	default:
-		rb_bug("oops");
-	}
-
-	char *name_str = get_global_name(&name);
-
-	VALUE getter_proc, setter_proc;
-
-	getter_proc = rb_convert_type(getter, T_DATA, "Proc", "to_proc");
-	if (NIL_P(getter_proc) || !rb_obj_is_proc(getter_proc)) {
-		rb_raise(rb_eTypeError, "wrong getter type %s (expected Proc)", rb_obj_classname(getter_proc));
-	}
-
-	if (NIL_P(setter)) {
-		setter_proc = Qnil;
-	} else {
-		setter_proc = rb_convert_type(setter, T_DATA, "Proc", "to_proc");
-		if (NIL_P(setter_proc) || !rb_obj_is_proc(setter_proc)) {
-			rb_raise(rb_eTypeError, "wrong setter type %s (expected Proc)", rb_obj_classname(setter_proc));
-		}
-	}
-
-	// todo: not just leak memory here lol
-	struct hooked_var *hv = (struct hooked_var *)malloc(sizeof(struct hooked_var));
-	hv->getter = getter_proc;
-	hv->setter = setter_proc;
-
-	rb_define_hooked_variable(name_str, (VALUE *)hv, hooked_var_getter, setter_proc == Qnil ? rb_gvar_readonly_setter : hooked_var_setter);
-	extern void rb_gvar_ractor_local(const char *);
-	rb_gvar_ractor_local(name_str);
-	return name; //TODO: ID2SYM(id)
-}
-
-VALUE gvars_module;
-
-void
-Init_gvars(void)
-{
-	gvars_module = rb_define_module("GVars");
-
-	// Define module-level functions that can be used as mixins
-	rb_define_module_function(gvars_module, "global_variable_get", gvars_f_get, 1);
-	rb_define_module_function(gvars_module, "global_variable_set", gvars_f_set, 2);
-	// rb_define_module_function(gvars_module, "global_variable_defined?", gvars_f_defined_p, 1);
-	rb_define_module_function(gvars_module, "alias_global_variable", gvars_f_alias, 2);
-
-	// Don't make mixin, as it exists in Kernel
-	rb_define_singleton_method(gvars_module, "global_variables", gvars_list, 0);
-
-	// aliases at top-level
-	rb_define_alias(rb_singleton_class(gvars_module), "get", "global_variable_get");
-	rb_define_alias(rb_singleton_class(gvars_module), "set", "global_variable_set");
-	// rb_define_alias(rb_singleton_class(gvars_module), "defined?", "global_variable_defined?");
-	rb_define_alias(rb_singleton_class(gvars_module), "alias", "alias_global_variable");
-	rb_define_alias(rb_singleton_class(gvars_module), "list", "global_variables");
-	rb_define_alias(rb_singleton_class(gvars_module), "[]", "global_variable_get");
-	rb_define_alias(rb_singleton_class(gvars_module), "[]=", "global_variable_set");
-
-	// rb_define_singleton_method(gvars_module, "virtual", gvars_define_virtual_global, -1);
-}