gvars 0.9.10 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6230a213eea87d923eaf4e8196bb168d3d52342023fda70adf189b336a4fea36
-  data.tar.gz: ba9b1449a5fe00221ebb389e903bf19d10d29f264351d60e7f6369318190582b
+  metadata.gz: 6cec95dcb820444abd65614b00b8d58228f257aa801c57fd258d205cdfa3cca6
+  data.tar.gz: '0343590213ebc76ede529e8e469bebd69439c62826ef134852d37870da417f16'
 SHA512:
-  metadata.gz: d0fe558f8ee687fb1c02429c52a1ccc0745c1f33c04f521dbdce03b987ab44910c274726a48f2283b01f13973489e3d71c9ceacaa93ff1f9aa3d570403bd75fd
-  data.tar.gz: e39330d0bdb1800bf58d45877da5af404f1f599e4f7f77ad8f5f02ac715da2ec97f7cce83c7b13da5cb9d70d17ccab047fb395bea894a05b200944f77bbb0d2f
+  metadata.gz: 0db69cfd69b689e2d93f5b62780c197b28929933b43d77241e89bd1658f52d676e637d1f1943a27723e8a9ba5179b3ba0bb8c9c229b768ff82e92c9431dcd560
+  data.tar.gz: 1ecd051d8c68d123131c2ef8d96917c70cb17fe6f08063c9525ba0afdca29c6dd053eb0dd3aad2a35af151c919d61d27e7fc7ba54eab7dc58660ad3b441a7790

data/README.md

@@ -31,8 +31,8 @@ puts $TIME.monday? #=> true
 
 # You can also provide a custom setter
 GVars.virtual(:$PWD,
-	getter: ->{ Dir.pwd },
-	setter: ->new{ Dir.chdir(new) })
+  getter: ->{ Dir.pwd },
+  setter: ->new{ Dir.chdir(new) })
 $PWD = '/tmp'
 p $PWD #=> "/private/tmp" (macOS symlinks `/tmp` to `/private/tmp`)
 ```
@@ -51,9 +51,33 @@ 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
+  state: Random.new,
+  getter: ->random{ random.rand },
+  setter: ->(value,random){ random.srand(value) }) # doesn't actually work.. `Random#srand` isn't a thing
+```
+
+## `OptParse` support
+If you've ever wanted to use `OptParse` to parse command line options _directly_ into global variables, look no further! `GVars.[]` and `GVars.[]=` act similarly to `GVars.get` and `GVars.set`, except they allow you to omit the leading `$`, and all `-` are translated to `_`:
+
+```ruby
+require 'optparse'
+require 'gvars'
+
+OptParse.new do |op|
+  op.on '--[no-]read'
+  op.on '--[no-]write'
+  op.on '--[no-]execute'
+  op.on '--timeout=SECONDS', Float
+  op.on '--cache-dir=PATH'
+
+  op.parse!(
+    %w[--read --no-execute --timeout=10 --cache-dir=/foo/bar],
+    into: GVars
+  )
+
+  p [$read, $write, $execute, $timeout, $cache_dir]
+  #=> [true, nil, false, 10.0, "/foo/bar"]
+end
 ```
 
 ## Known problems

data/ext/gvars/gvars.c

@@ -2,51 +2,82 @@
 #define dbg(...) (fprintf(stderr, "%s:%s:%d: ", __FILE__, __FUNCTION__, __LINE__), fprintf(stderr,__VA_ARGS__),fprintf(stderr,"\n"),fflush(stderr))
 
 VALUE gvars_module;
+static ID id_debug;
+
+static bool
+gvars_debug_enabled(void)
+{
+	VALUE debug_mode = rb_ivar_get(gvars_module, id_debug);
+	return debug_mode == Qnil ? ruby_debug : RTEST(debug_mode);
+}
+
+static VALUE
+gvars_f_defined_p(VALUE self)
+{
+	return gvars_debug_enabled() ? Qtrue : Qfalse;
+}
 
 // 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, bool raise) {
+static char *get_global_name(VALUE *name, bool translate) {
 	// If `name` is a symbol, get its backing string
 	if (RB_SYMBOL_P(*name)) {
 		*name = rb_sym2str(*name);
 	}
 
+	if (translate) {
+		// Convert from `-` to `_`
+		*name = rb_funcall(StringValue(*name), rb_intern("tr"), 2,
+			rb_str_new_cstr("-"), rb_str_new_cstr("_"));
+	}
+
 	char *namestr = StringValueCStr(*name);
 
 	// Ensure it starts with a dollar sign
-	if (raise && namestr[0] != '$') {
+	if (!translate && namestr[0] != '$') {
 		rb_raise(rb_eNameError, "'%s' is not allowed as a global variable name", namestr);
 	}
 
 	return namestr;
 }
 
-
 static VALUE
 gvars_f_global_variable_get(VALUE self, VALUE name)
 {
-	return rb_gv_get(get_global_name(&name, true));
+	return rb_gv_get(get_global_name(&name, false));
 }
 
 static VALUE
 gvars_f_global_variable_aref(VALUE self, VALUE name)
 {
-	return rb_gv_get(get_global_name(&name, false));
+	return rb_gv_get(get_global_name(&name, true));
 }
 
 static VALUE
 gvars_f_global_variable_set(VALUE self, VALUE name, VALUE value)
 {
-	return rb_gv_set(get_global_name(&name, true), value);
+	return rb_gv_set(get_global_name(&name, false), value);
 }
 
-
 static VALUE
 gvars_f_global_variable_aset(VALUE self, VALUE name, VALUE value)
 {
-	return rb_gv_set(get_global_name(&name, false), value);
+	char *sname = get_global_name(&name, true);
+	if (gvars_debug_enabled()) {
+		char *sname_without_dollar = sname;
+		if (sname_without_dollar[0] == '$') {
+			++sname_without_dollar;
+		}
+
+		VALUE msg = rb_sprintf("GVars: setting global $%s to: %"PRIsVALUE"\n",
+			sname_without_dollar, rb_inspect(value));
+
+		rb_io_write(rb_gv_get("$stderr"), msg);
+	}
+
+	return rb_gv_set(sname, value);
 }
 
 static VALUE
@@ -268,6 +299,7 @@ static VALUE convert_to_proc(const char *name, VALUE input, bool is_hooked) {
 
 	VALUE proc = rb_convert_type(input, T_DATA, "Proc", "to_proc");
 
+// Check_Type
 	if (NIL_P(proc) || !rb_obj_is_proc(proc)) {
 		rb_raise(rb_eTypeError, "wrong %s type %s (expected Proc)", name, rb_obj_classname(proc));
 	}
@@ -351,6 +383,7 @@ void
 Init_gvars(void)
 {
 	gvars_module = rb_define_module("GVars");
+	VALUE gvars_singleton = rb_singleton_class(gvars_module);
 	rb_ivar_set(gvars_module, rb_intern("vars"), rb_hash_new());
 
     virtual_method_keyword_ids[VIRTUAL_METHOD_KEYWORDS_GETTER] = rb_intern("getter");
@@ -359,6 +392,12 @@ Init_gvars(void)
     virtual_method_keyword_ids[VIRTUAL_METHOD_KEYWORDS_STATE] = rb_intern("state");
     virtual_method_keyword_ids[VIRTUAL_METHOD_KEYWORDS_READONLY] = rb_intern("readonly");
 
+
+    // Define debugging construct
+    id_debug = rb_intern_const("@debug");
+    rb_define_attr(gvars_singleton, "debug", 1, 1);
+    rb_define_singleton_method(gvars_module, "debug?", gvars_f_defined_p, 0);
+
 	// 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);
@@ -380,7 +419,6 @@ Init_gvars(void)
 	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, "set", "global_variable_set");
 	rb_define_alias(gvars_singleton, "alias", "alias_global_variable");

data/lib/gvars/version.rb

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

data/sig/gvars.rbs

@@ -1,6 +1,9 @@
 module GVars
   VERSION: String
 
+  attr_accessor self.debug: bool?
+  def self.debug?: () -> bool
+
   # Mixin methods
   def self?.global_variable_get: (interned name) -> untyped
   def self?.global_variable_set: [T] (interned name, T value) -> T

data/tmp.rb

@@ -1,3 +1,22 @@
+require 'optparse'
+require 'gvars'
+
+OptParse.new do |op|
+  op.on '--[no-]read'
+  op.on '--[no-]write'
+  op.on '--[no-]execute'
+  op.on '--timeout=SECONDS', Float
+  op.on '--cache-dir=PATH'
+
+  op.parse!(
+    %w[--read --no-execute --timeout=10 --cache-dir=/foo/bar],
+    into: GVars
+  )
+
+  p [$read, $write, $execute, $timeout, $cache_dir]
+end
+
+__END__
 require 'gvars'
 p GVars::VERSION
 

metadata

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