gvars 0.9.0 → 0.9.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1728504fbc5ee4dcf6e72f18a5f0aff56fa3933f97776d9e57bca20cc8301b45
-  data.tar.gz: 45fa2513e7c7fc2438dabd33d91505899e7154c8ec4d91fb03008b4f22dbbc9a
+  metadata.gz: 3f54223d6addde0cfe225b0894f2da28b43cfa6f679e786baceeee34aedf7238
+  data.tar.gz: 3fcc088c1798d3f303825e4ca5167e11b787ffde7f359101426df82b6bde96f2
 SHA512:
-  metadata.gz: 0daa5d2870632bd24be477d7e561383bf89ad66ec6efe844717ef2d1e37c9c8219c22bcc9ab644e8c291e408a41c8a5559a684ecf4f70f178a2f5966963f4261
-  data.tar.gz: 2feac652e6098336616d4dd9f9c893add9ef8745884214297392381bf1182edad60839d8229d53e6fe97d1a2abc3c9a107ce61075ce908f25e7ca037b88fd0b6
+  metadata.gz: 98c348911582069c49ad6089837708b0479575ab2d176428d4099bb9c107cef7cadc8ce2173853268b4f442abd49385f63c7888ccb611aa9a4a7f5a94af4cdbf
+  data.tar.gz: 37ef3ebeefa4f341dc70e0fc393147e6b8feadc40a29e3edc4b8f7624e5836354f47c4f6801c53fe9301b871882b9a0ed45e872a6931fa05d80f8bc3db061c6c

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,4 +1,7 @@
 #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.
 //
@@ -20,6 +23,7 @@ static char *get_global_name(VALUE *name) {
 	return namestr;
 }
 
+
 static VALUE
 gvars_f_global_variable_get(VALUE self, VALUE name)
 {
@@ -41,23 +45,300 @@ 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));
+	ID newid = rb_intern(get_global_name(&new));
 	rb_alias_variable(newid, rb_intern(get_global_name(&old)));
 	return ID2SYM(newid);
 }
 
-VALUE gvars_module;
+static VALUE
+gvars_enum_length(VALUE self, VALUE args, VALUE eobj)
+{
+	return LONG2NUM(RARRAY_LEN(rb_f_global_variables()));
+}
+
+static VALUE
+gvars_f_each(VALUE self)
+{
+	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)));
+	}
+
+	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));
+
+	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;
+}
+
+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 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
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+
+struct gvars_virtual_var {
+	VALUE backing, getter, setter;
+};
+
+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->getter);
+	rb_gc_mark(gv->setter);
+}
+
+static void gvars_virtual_var_free(void *ptr) {
+	xfree(ptr);
+}
+
+static const rb_data_type_t gvars_type = {
+	.wrap_struct_name = "gvars_var",
+	.function = {
+		.dmark = gvars_virtual_var_mark,
+		.dfree = gvars_virtual_var_free,
+		.dsize = NULL
+	},
+	.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_kw(gv->getter, rb_ary_new(), RB_NO_KEYWORDS);
+}
+
+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);
+}
+
+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);
+}
+
+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;
+}
+
+static void gvars_hooked_initial_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) {
+	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);
+}
+
+
+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);
+	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));
+		}
+	}
+
+	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_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;
+		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;
+		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 namesym = rb_str_new_cstr(name_str);
+	rb_hash_aset(hash, namesym, vp_data);
+}
+
+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");
+
+	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");
+	}
+
+	enum virtual_kind kind = GVARS_VIRTUAL_KIND_VIRTUAL;
+	rb_get_kwargs(opts_hash, keyword_ids, 0, 3, opts);
+
+	if (opts[0] != Qundef) {
+		if (opts[1] != Qundef) {
+			rb_raise(rb_eArgError, "only one of 'initial' or 'state' may be supplied");
+		}
+		backing = opts[0];
+		kind = GVARS_VIRTUAL_KIND_INITIAL;
+	} else if (opts[1] != Qundef) {
+		backing = opts[1];
+		kind = GVARS_VIRTUAL_KIND_STATE;
+	}
+
+	bool is_readonly = false;
+	if (opts[2] != Qundef && RTEST(opts[2])) { // sadly no bool expected :-/
+		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());
 
 	// 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);
 	rb_define_module_function(gvars_module, "global_variable_set", gvars_f_global_variable_set, 2);
 	rb_define_module_function(gvars_module, "alias_global_variable", gvars_f_alias_global_variable, 2);
 
-	// Don't make mixin, as it exists in Kernel
+	// 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_define_singleton_method(gvars_module, "each", gvars_f_each, 0);
+	rb_define_singleton_method(gvars_module, "to_h", gvars_f_to_h, 0);
+
+	// 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.0"
+  VERSION = '0.9.7'
 end

data/lib/gvars.rb

@@ -4,12 +4,19 @@ require_relative "gvars/version"
 require_relative "gvars/gvars"
 
 module GVars
-  class << self
-    alias get  global_variable_get
-    alias []  global_variable_get
-    alias set  global_variable_set
-    alias []= global_variable_set
-    alias alias alias_global_variable
-    alias list  global_variables
+=begin
+  # TODO: make this non-eval; unfortunately, it's not easy to fully emulate right now. maybe in the future?
+  #
+  # NOTE: THIS DOESN'T SUPPORT `$_` or regex vars!
+  module_function def global_variable_defined?(key)
+    warn "GVArs.global_variable_defined? is currently experimental", category: :experimental, uplevel: 1
+    key = Symbol === key ? key : key.to_str.to_sym
+
+    unless key.match? /\A\$[[:alpha:]_][[:alnum:]_]*\z/
+      raise NameError, format("'%s' is not allowed as a global variable name", key)
+    end
+
+    !! eval "defined? #{key}"
   end
+=end
 end

data/tmp.rb

@@ -0,0 +1,34 @@
+require 'gvars'
+p GVars::VERSION
+
+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]
+$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.0
+  version: 0.9.7
 platform: ruby
 authors:
 - Sam Westerman
@@ -25,9 +25,11 @@ files:
 - 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