gvars 0.9.8 → 0.9.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 837ffc167909e2abe16ff54fdcd7bfbe4cb6dc0346f1c3e9037b17933f3b89a7
-  data.tar.gz: 9e36c6847244b578e63032468c2d94e7fff4f4e05c68cd3a1c126fc257a02b7c
+  metadata.gz: 6230a213eea87d923eaf4e8196bb168d3d52342023fda70adf189b336a4fea36
+  data.tar.gz: ba9b1449a5fe00221ebb389e903bf19d10d29f264351d60e7f6369318190582b
 SHA512:
-  metadata.gz: 7e71e7a19371437156d14f1831045a6229b4fcd055cc82680309266c5ed20781ec030b78e591e38e4a7adb62633ceb98d5284ca69b8e40eb475ee4ea829ee269
-  data.tar.gz: f5cba137bad5f8d9db885f468df9bc147f89b7c0106653a409fd8aa5d32767a8fceba372b4a4c778bdf4161ae59c215dd2081cff250aeccfcf4c2c161658c1a9
+  metadata.gz: d0fe558f8ee687fb1c02429c52a1ccc0745c1f33c04f521dbdce03b987ab44910c274726a48f2283b01f13973489e3d71c9ceacaa93ff1f9aa3d570403bd75fd
+  data.tar.gz: e39330d0bdb1800bf58d45877da5af404f1f599e4f7f77ad8f5f02ac715da2ec97f7cce83c7b13da5cb9d70d17ccab047fb395bea894a05b200944f77bbb0d2f

data/README.md

@@ -5,29 +5,57 @@ Adds in missing utilities relating to global variables in Ruby.
 Ever been bothered how there's `instance_variable_get`, `binding.local_variable_get`, `class_variable_get`, even `const_get`, but no `global_variable_get`? Ever resorted to `eval("$#{name} = value")` to assign a global variable? Look no further!
 
 ## Features
-```ruby
-$foo = 34
-
-# Dynamically lookup globals
-puts GVars.get(:$foo) #=> 34
 
-# Dynamically assign globals!
+`GVars` adds support for getting, setting, and aliasing global variables dynamically. (Checking for definition is coming!)
+```ruby
+# Dynamically interact with globals:
 GVars.set(:$foo, 99)
-puts $foo #=> 99
+puts GVars.get(:$foo) #=> 99
 
-# How about dynamically `alias`ing globals?
-GBars.alias :$bar, :$foo
+GVars.alias(:$bar, :$foo)
 $bar = 12
 puts $foo #=> 12
 
-# You can also mixin `GVars` to get the methods that should be
-# defined on Kernel:
-include GVars
+# Mixin `GVars` to get methods that should've been defined
+# on `Kernel` all along
+Kernel.include GVars
 puts global_variable_get(:$bar) #=> 12
 puts global_variable_set(:$bar, 19) #=> 19
 ```
 
-Up next: virtual variables, and collection methods!
+It also supports virtual variables, which evaluate a `proc` each time:
+```ruby
+# Get the current time whenever you access `$TIME`
+GVars.virtual(:$TIME) { Time.now }
+puts $TIME.monday? #=> true
+
+# You can also provide a custom setter
+GVars.virtual(:$PWD,
+	getter: ->{ Dir.pwd },
+	setter: ->new{ Dir.chdir(new) })
+$PWD = '/tmp'
+p $PWD #=> "/private/tmp" (macOS symlinks `/tmp` to `/private/tmp`)
+```
+
+And, hooked variables:
+```ruby
+# Initial values compute their "backing" value based on the getter's
+# return value.
+GVars.hooked(:$COUNTER, initial: 0) { it + 1 }
+p [$COUNTER, $COUNTER, $COUNTER] #=> [1, 2, 3]
+
+# If you don't supply a setter, it defaults to just the backing value.
+$COUNTER = 10
+p $COUNTER #=> 11
+
+# You can also specify a state, which is given to the getter (and setter),
+# but isn't updated by the getter's return value.
+GVars.hooked(:$RAND,
+	state: Random.new,
+	getter: ->random{ random.rand },
+	setter: ->(value,random){ random.srand(value) }) # doesn't actually work.. `Random#srand` isn't a thing
+```
 
 ## Known problems
-Unfortunately, Ruby's C-level `rb_gv_get` / `rb_gv_set` methods only let you manipulate ASCII identifiers... A fix _may_ be possible, but it'll have to resort to the `eval` hack.
+1. Unfortunately, Ruby's C-level `rb_gv_get` / `rb_gv_set` methods only let you manipulate ASCII identifiers... A fix _may_ be possible, but it'll have to resort to the `eval` hack.
+2. Because `$_`, and regex variables (`$~`, ``$` ``, etc) are all local to the function they're called within, you can't actually access them from within procs; As a workaround, you can pass a string that'll be `eval`d each time, but it's not terribly efficient. I don't know if there's a better solution

data/ext/gvars/gvars.c

@@ -141,12 +141,33 @@ 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);
+
+	// If it's a string, eval it in the current context. Not great for ZJIT...
+	if (RB_TYPE_P(gv->getter, T_STRING)) {
+		return rb_funcallv(rb_binding_new(), rb_intern("eval"), 1, &gv->getter);
+	}
+
 	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);
+
+	// If it's a string, eval it in the current context. Not great for ZJIT...
+	if (RB_TYPE_P(gv->setter, T_STRING)) {
+		static VALUE virtual_setter = Qundef;
+		// Don't actually register the variable until we're doing a virtual
+		// string setter.
+		if (virtual_setter == Qundef) {
+			rb_define_variable("$__value__", &virtual_setter);
+		}
+		virtual_setter = val;
+
+		rb_funcallv(rb_binding_new(), rb_intern("eval"), 1, &gv->setter);
+		return;
+	}
+
 	rb_proc_call(gv->setter, rb_ary_new_from_args(1, val));
 }
 
@@ -227,15 +248,24 @@ gvars_define_virtual_method(VALUE self, VALUE *name, VALUE backing, VALUE getter
 }
 
 enum virtual_method_keywords {
+	VIRTUAL_METHOD_KEYWORDS_GETTER,
+	VIRTUAL_METHOD_KEYWORDS_SETTER,
+	VIRTUAL_METHOD_KEYWORDS_READONLY,
 	VIRTUAL_METHOD_KEYWORDS_INITIAL,
 	VIRTUAL_METHOD_KEYWORDS_STATE,
-	VIRTUAL_METHOD_KEYWORDS_READONLY,
-	LENGTH_OF_VIRTUAL_METHOD_KEYWORDS,
+	LENGTH_OF_VIRTUAL_METHOD_KEYWORDS_HOOKED = VIRTUAL_METHOD_KEYWORDS_STATE+1,
+	LENGTH_OF_VIRTUAL_METHOD_KEYWORDS_VIRTUAL = VIRTUAL_METHOD_KEYWORDS_READONLY+1,
 };
 
-static ID virtual_method_keyword_ids[LENGTH_OF_VIRTUAL_METHOD_KEYWORDS];
+static ID virtual_method_keyword_ids[LENGTH_OF_VIRTUAL_METHOD_KEYWORDS_HOOKED];
+
+static VALUE convert_to_proc(const char *name, VALUE input, bool is_hooked) {
+	// Convert getter to a proc, unless it's a string (to support the "always eval" case)
+	if (RB_TYPE_P(input, T_STRING) && !is_hooked) {
+		// Virtual functions can be strings, which are evaluated.
+		return input;
+	}
 
-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)) {
@@ -246,43 +276,45 @@ static VALUE convert_to_proc(const char *name, VALUE input) {
 }
 
 static VALUE
-gvars_f_define_virtual_method(int argc, VALUE *argv, VALUE self)
+gvars_f_define_virtual_method_foo(int argc, VALUE *argv, VALUE self, bool is_hooked)
 {
-	VALUE name, backing, getter, setter, opts_hash, opts[LENGTH_OF_VIRTUAL_METHOD_KEYWORDS];
+	VALUE name, backing, getter, setter, opts_hash, opts[LENGTH_OF_VIRTUAL_METHOD_KEYWORDS_HOOKED] = {
+		Qundef, Qundef, Qundef, Qundef, Qundef };
 
-	switch (rb_scan_args(argc, argv, "12:", &name, &getter, &setter, &opts_hash)) {
-	case 1:
-		getter = (rb_need_block(), rb_block_proc());
-		setter = Qnil;
-		break;
+	rb_scan_args(argc, argv, "10:", &name, &opts_hash);
+	rb_get_kwargs(opts_hash, virtual_method_keyword_ids, 0,
+		(is_hooked ? LENGTH_OF_VIRTUAL_METHOD_KEYWORDS_HOOKED : LENGTH_OF_VIRTUAL_METHOD_KEYWORDS_VIRTUAL),
+		opts);
 
-	case 2:
-		setter = Qnil;
+	getter = opts[VIRTUAL_METHOD_KEYWORDS_GETTER];
+	setter = opts[VIRTUAL_METHOD_KEYWORDS_SETTER];
 
-	case 3:
-		if (rb_block_given_p()) {
-			rb_warn("given block not used");
-		}
-		break;
-	default:
-		rb_bug("oops");
+	if (getter == Qundef) {
+		getter = (rb_need_block(), rb_block_proc());
+	} else {
+		if (rb_block_given_p()) rb_warn("block parameter unused when getter is supplied");
+		getter = convert_to_proc("getter", getter, is_hooked);
 	}
 
-	getter = convert_to_proc("getter", getter);
-	if (!NIL_P(setter)) setter = convert_to_proc("setter", setter);
+	if (setter == Qundef) {
+		setter = Qnil;
+	} else {
+		setter = convert_to_proc("setter", setter, is_hooked);
+	}
 
 	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");
+			rb_raise(rb_eArgError, "exactly 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 if (is_hooked) {
+		rb_raise(rb_eArgError, "exactly one of 'initial' or 'state' may be supplied");
 	} else {
 		backing = Qnil;
 	}
@@ -301,6 +333,18 @@ gvars_f_define_virtual_method(int argc, VALUE *argv, VALUE self)
 	gvars_define_virtual_method(self, &name, backing, getter, setter, kind, is_readonly);
 
 	return name; //TODO: ID2SYM(id)
+
+}
+static VALUE
+gvars_f_define_virtual_method(int argc, VALUE *argv, VALUE self)
+{
+	return gvars_f_define_virtual_method_foo(argc, argv, self, false);
+}
+
+static VALUE
+gvars_f_define_hooked_method(int argc, VALUE *argv, VALUE self)
+{
+	return gvars_f_define_virtual_method_foo(argc, argv, self, true);
 }
 
 void
@@ -309,6 +353,8 @@ 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_GETTER] = rb_intern("getter");
+    virtual_method_keyword_ids[VIRTUAL_METHOD_KEYWORDS_SETTER] = rb_intern("setter");
     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");
@@ -323,6 +369,7 @@ Init_gvars(void)
 
 	// 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);
+	rb_define_singleton_method(gvars_module, "define_hooked_method", gvars_f_define_hooked_method, -1);
 
 	// Enumerable methods
 	rb_extend_object(gvars_module, rb_mEnumerable);
@@ -339,4 +386,5 @@ Init_gvars(void)
 	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");
+	rb_define_alias(gvars_singleton, "hooked", "define_hooked_method");
 }

data/lib/gvars/version.rb

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

data/tmp.rb

@@ -2,6 +2,40 @@ require 'gvars'
 p GVars::VERSION
 
 require 'optparse'
+trace_var :$timeout do p it end
+
+GVars.virtual(:$hello,
+  getter: '[Regexp.last_match[1], $~]',
+  setter: 'puts("assigned: #{$__value__}")')
+
+def foo
+  /(a)/ =~ 'heallo'
+  p $hello
+  $hello = 9
+end
+
+foo
+["a", #<MatchData "a" 1:"a">]
+assigned: 9
+
+
+__END__
+GVars.virtual(:$timeout,
+  getter: ->{ 'hello' },
+  setter: ->val { puts "setting: #{val}" },
+  readonly: false)
+
+GVars.hooked(:$COUNTER,
+  getter: :succ.to_proc,
+  setter: nil)
+  setter: ->val { puts "setting: #{val}" },
+  initial: 10)
+
+p $timeout1
+p $timeout1
+
+__END__
+
 OptParse.new do |op|
   op.on '--timeout=X', 'the timeout'
   op.parse %w[--timeout 34.5], into: GVars

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gvars
 version: !ruby/object:Gem::Version
-  version: 0.9.8
+  version: 0.9.10
 platform: ruby
 authors:
 - Sam Westerman