gvars 0.9.5 → 0.9.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a3f32ce689ea5b4077c4736674afc353494fafd71bec8dc0e108cc95c33424a
-  data.tar.gz: 237e9f7383637a345dde01342598ec24b01c8e4f8e953f33cde03fc164cb1ba8
+  metadata.gz: 837ffc167909e2abe16ff54fdcd7bfbe4cb6dc0346f1c3e9037b17933f3b89a7
+  data.tar.gz: 9e36c6847244b578e63032468c2d94e7fff4f4e05c68cd3a1c126fc257a02b7c
 SHA512:
-  metadata.gz: 54094ee144a422dca37c6ae607d1250829b987c33f92b38f7fb6c2b5ef6aa291a8249bb170db0330c0eac2020178ae6fb4579ee95e82f3f810561f978dc8f1d5
-  data.tar.gz: 7052348eee6adec41144417564e472575b943f03b4a9edfcf3d2a1e9e715dcde50eb3f56393c8423c42319629ba0a4a97ef0846f4b38b841fb0b063d72f0b280
+  metadata.gz: 7e71e7a19371437156d14f1831045a6229b4fcd055cc82680309266c5ed20781ec030b78e591e38e4a7adb62633ceb98d5284ca69b8e40eb475ee4ea829ee269
+  data.tar.gz: f5cba137bad5f8d9db885f468df9bc147f89b7c0106653a409fd8aa5d32767a8fceba372b4a4c778bdf4161ae59c215dd2081cff250aeccfcf4c2c161658c1a9

data/ext/gvars/extconf.rb

@@ -1,5 +1,5 @@
 require 'mkmf'
 
-# $CFLAGS << ' -g -fsanitize=undefined'
+$CFLAGS << ' -g -fsanitize=undefined'
 
 create_makefile 'gvars/gvars'

data/ext/gvars/gvars.c

@@ -1,10 +1,13 @@
 #include "ruby.h"
+#define dbg(...) (fprintf(stderr, "%s:%s:%d: ", __FILE__, __FUNCTION__, __LINE__), fprintf(stderr,__VA_ARGS__),fprintf(stderr,"\n"),fflush(stderr))
+
+VALUE gvars_module;
 
 // 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) {
+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);
@@ -13,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);
 	}
 
@@ -24,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
@@ -42,52 +58,260 @@ 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);
 }
 
 static VALUE
 gvars_enum_length(VALUE self, VALUE args, VALUE eobj)
 {
-    return LONG2NUM(RARRAY_LEN(rb_f_global_variables()));
+	return LONG2NUM(RARRAY_LEN(rb_f_global_variables()));
 }
 
 static VALUE
 gvars_f_each(VALUE self)
 {
-    RETURN_SIZED_ENUMERATOR(self, 0, 0, gvars_enum_length);
+	RETURN_SIZED_ENUMERATOR(self, 0, 0, gvars_enum_length);
 
-    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)));
-    }
+	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_new_from_args(2, key, gvars_f_global_variable_get(self, key)));
+	}
 
-    return self;
+	return self;
 }
 
 static VALUE
 gvars_f_to_h(VALUE self)
 {
-    VALUE gvars = gvars_f_global_variables(self);
-    VALUE hash = rb_hash_new_capa(RARRAY_LEN(gvars));
+	VALUE gvars = gvars_f_global_variables(self);
+	VALUE hash = rb_hash_new_capa(RARRAY_LEN(gvars));
 
-    for (long i = 0; i < RARRAY_LEN(gvars); i++) {
-    	VALUE key = RARRAY_AREF(gvars, i);
-        rb_hash_aset(hash, key, gvars_f_global_variable_get(self, key));
-    }
+	for (long i = 0; i < RARRAY_LEN(gvars); i++) {
+		VALUE key = RARRAY_AREF(gvars, i);
+		rb_hash_aset(hash, key, gvars_f_global_variable_get(self, key));
+	}
 
-    return hash;
+	return hash;
 }
 
+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 = value_ptr_size,
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
 
-VALUE gvars_module;
+
+struct gvars_virtual_var {
+	VALUE backing, getter, setter;
+};
+
+static void gvars_virtual_var_mark(void *ptr) {
+	struct gvars_virtual_var *gv = ptr;
+	rb_gc_mark(gv->backing);
+	rb_gc_mark(gv->getter);
+	rb_gc_mark(gv->setter);
+}
+
+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",
+	.function = {
+		.dmark = gvars_virtual_var_mark,
+		.dfree = RUBY_DEFAULT_FREE,
+		.dsize = gvars_virtual_var_size,
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+
+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(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(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(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);
+	return gv->backing = rb_proc_call(gv->getter, rb_ary_new_from_args(1, gv->backing));
+}
+
+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_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(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);
+	gv->backing = backing;
+	gv->getter = getter;
+	gv->setter = setter;
+	return gvar_ty;
+}
+
+enum virtual_kind {
+	GVARS_VIRTUAL_KIND_VIRTUAL,
+	GVARS_VIRTUAL_KIND_INITIAL,
+	GVARS_VIRTUAL_KIND_STATE,
+};
+
+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, 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);
+	*vp->value = gvars_virtual_var_alloc(backing, getter, setter);
+
+	rb_gvar_getter_t *getter_meth;
+	rb_gvar_setter_t *setter_meth;
+
+	switch (kind) {
+	case GVARS_VIRTUAL_KIND_VIRTUAL:
+		getter_meth = gvars_virtual_var_getter;
+		setter_meth = setter == Qnil ? rb_gvar_readonly_setter : gvars_virtual_var_setter;
+		break;
+
+	case GVARS_VIRTUAL_KIND_STATE:
+	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");
+	}
+
+
+	rb_define_hooked_variable(name_str, vp->value, getter_meth, setter_meth);
+
+	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, getter, setter, opts_hash, opts[LENGTH_OF_VIRTUAL_METHOD_KEYWORDS];
+
+	switch (rb_scan_args(argc, argv, "12:", &name, &getter, &setter, &opts_hash)) {
+	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");
+	}
+
+	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, virtual_method_keyword_ids, 0, LENGTH_OF_VIRTUAL_METHOD_KEYWORDS, opts);
+
+	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[VIRTUAL_METHOD_KEYWORDS_INITIAL];
+		kind = GVARS_VIRTUAL_KIND_INITIAL;
+	} else if (opts[VIRTUAL_METHOD_KEYWORDS_STATE] != Qundef) {
+		backing = opts[VIRTUAL_METHOD_KEYWORDS_STATE];
+		kind = GVARS_VIRTUAL_KIND_STATE;
+	} else {
+		backing = Qnil;
+	}
+
+ 	// 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");
+		}
+
+		setter = Qnil;
+		is_readonly = true;
+	}
+
+	gvars_define_virtual_method(self, &name, backing, getter, setter, kind, is_readonly);
+
+	return name; //TODO: ID2SYM(id)
+}
 
 void
 Init_gvars(void)
 {
 	gvars_module = rb_define_module("GVars");
+	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);
@@ -97,17 +321,22 @@ Init_gvars(void)
 	// Don't make it an instance method, as it exists in Kernel
 	rb_define_singleton_method(gvars_module, "global_variables", gvars_f_global_variables, 0);
 
+	// Don't make it an instance method, cause we don't want it included
+	rb_define_singleton_method(gvars_module, "define_virtual_method", gvars_f_define_virtual_method, -1);
+
 	// Enumerable methods
- 	rb_extend_object(gvars_module, rb_mEnumerable);
+	rb_extend_object(gvars_module, rb_mEnumerable);
 	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/gb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+version = nil
+File.open File.join __dir__, 'lib', 'gvars', 'version.rb' do |f|
+  f.read =~ /VERSION = '(.*)'/ and (version = $1; break)
+end
+
+fail "cant find version" unless version
+system('gem build gvars') && system("gem install ./gvars-#{version}.gem")

data/lib/gvars/version.rb

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

data/tmp.rb

@@ -0,0 +1,73 @@
+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" }
+  # $foo
+  # p($foo)
+  # p GVars.instance_variable_get(:@vars)
+  GC.start
+end
+
+GVars.virtual(:$foo1) { "hello" }; fail unless 'hello' == $foo1
+GVars.virtual(:$foo2, proc{ "hello" }); fail unless 'hello' == $foo2
+GVars.virtual(:$foo3, proc{ "hello" }, proc { it + 1 }); fail unless ['hello', 3, 'hello'] == [$foo3, $foo3 = 3, $foo3]
+
+GVars.virtual(:$bar1, initial: 0) { it + 1 }; fail unless [1, 2, 3] == [$bar1, $bar1, $bar1]
+$bar1 = 10
+fail unless 11 == $bar1
+
+GVars.virtual(:$bar2, state: 'a') { it.succ!.dup }
+fail unless ['b', 'c', 'd'] == [$bar2, $bar2, $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}"})
+
+# 100.times do
+# $foo
+# $bar
+# $baz
+# GC.start
+# end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gvars
 version: !ruby/object:Gem::Version
-  version: 0.9.5
+  version: 0.9.8
 platform: ruby
 authors:
 - Sam Westerman
@@ -24,10 +24,11 @@ files:
 - Rakefile
 - ext/gvars/extconf.rb
 - ext/gvars/gvars.c
-- ext/gvars/gvars.c-old
+- gb
 - lib/gvars.rb
 - lib/gvars/version.rb
 - sig/gvars.rbs
+- tmp.rb
 homepage: https://github.com/sampersand/gvars
 licenses:
 - MIT

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);
-}