gvars 0.1.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e3985d26424ff4d447445b3d10b132cb45a578272a14b0f9439a70a1da22030
-  data.tar.gz: e18ec85c05f64b05b22dd0623330bac0146376df4ec25daf3ba74d6157e9d93c
+  metadata.gz: 1728504fbc5ee4dcf6e72f18a5f0aff56fa3933f97776d9e57bca20cc8301b45
+  data.tar.gz: 45fa2513e7c7fc2438dabd33d91505899e7154c8ec4d91fb03008b4f22dbbc9a
 SHA512:
-  metadata.gz: 3ee1ae6ceea846f070549ce145715d4091a012979f2830f5cd425e701dd493f9ca15eaf46a084099ee4964436e508f114fab4f274d350f522a08466a874b2156
-  data.tar.gz: 758bce3ec8a248e43ec6273b026aa4e384ee260575d05a2150fb3a72c0e815600080f77ea68d5a9fbe6fbf7d830820ccbad6453d7fd5b956841fff4e880bb83e
+  metadata.gz: 0daa5d2870632bd24be477d7e561383bf89ad66ec6efe844717ef2d1e37c9c8219c22bcc9ab644e8c291e408a41c8a5559a684ecf4f70f178a2f5966963f4261
+  data.tar.gz: 2feac652e6098336616d4dd9f9c893add9ef8745884214297392381bf1182edad60839d8229d53e6fe97d1a2abc3c9a107ce61075ce908f25e7ca037b88fd0b6

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2025 SamW
+Copyright (c) 2026 Sam Westerman
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,39 +1,33 @@
-# Gvars
+# GVars
 
-TODO: Delete this and the text below, and describe your gem
+Adds in missing utilities relating to global variables in Ruby.
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/gvars`. To experiment with that code, run `bin/console` for an interactive prompt.
+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!
 
-## Installation
+## Features
+```ruby
+$foo = 34
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+# Dynamically lookup globals
+puts GVars.get(:$foo) #=> 34
 
-Install the gem and add to the application's Gemfile by executing:
+# Dynamically assign globals!
+GVars.set(:$foo, 99)
+puts $foo #=> 99
 
-```bash
-bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
-```
-
-If bundler is not being used to manage dependencies, install the gem by executing:
+# How about dynamically `alias`ing globals?
+GBars.alias :$bar, :$foo
+$bar = 12
+puts $foo #=> 12
 
-```bash
-gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+# You can also mixin `GVars` to get the methods that should be
+# defined on Kernel:
+include GVars
+puts global_variable_get(:$bar) #=> 12
+puts global_variable_set(:$bar, 19) #=> 19
 ```
 
-## Usage
-
-TODO: Write usage instructions here
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/gvars.
-
-## License
+Up next: virtual variables, and collection methods!
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+## 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.

data/Rakefile

@@ -1,8 +1,25 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "minitest/test_task"
+require 'bundler/gem_tasks'
+require 'rake/extensiontask'
+require 'minitest/test_task'
+
+task default: [:compile]
+
+Rake::ExtensionTask.new('gvars') do |ext|
+  ext.lib_dir = 'lib/gvars'
+end
 
 Minitest::TestTask.create
 
 task default: :test
+
+desc 'clean compiled files'
+task :clean do
+  require 'fileutils'
+  FileUtils.rm_rf 'ext/gvars/Makefile'
+  FileUtils.rm_rf 'ext/gvars/gvars.so'
+  FileUtils.rm_rf 'ext/gvars/gvars.bundle'
+  FileUtils.rm_rf 'lib/gvars/gvars.so'
+  FileUtils.rm_rf 'lib/gvars/gvars.bundle'
+end

data/ext/gvars/extconf.rb

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

data/ext/gvars/gvars.c

@@ -0,0 +1,63 @@
+#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) {
+	// If `name` is a symbol, get its backing string
+	if (RB_SYMBOL_P(*name)) {
+		*name = rb_sym2str(*name);
+	}
+
+	char *namestr = StringValueCStr(*name);
+
+	// Ensure it starts with a dollar sign
+	if (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));
+}
+
+static VALUE
+gvars_f_global_variable_set(VALUE self, VALUE name, VALUE value)
+{
+	return rb_gv_set(get_global_name(&name), value);
+}
+
+static VALUE
+gvars_f_global_variables(VALUE self)
+{
+	return rb_f_global_variables();
+}
+
+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)));
+	return ID2SYM(newid);
+}
+
+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_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
+	rb_define_singleton_method(gvars_module, "global_variables", gvars_f_global_variables, 0);
+}

data/ext/gvars/gvars.c-old

@@ -0,0 +1,147 @@
+#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);
+}

data/lib/gvars/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module Gvars
-  VERSION = "0.1.0"
+module GVars
+  VERSION = "0.9.0"
 end

data/lib/gvars.rb

@@ -1,8 +1,15 @@
 # frozen_string_literal: true
 
 require_relative "gvars/version"
+require_relative "gvars/gvars"
 
-module Gvars
-  class Error < StandardError; end
-  # Your code goes here...
+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
+  end
 end

data/sig/gvars.rbs

@@ -1,4 +1,17 @@
-module Gvars
+module GVars
   VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+
+  # Mixin methods
+  def self?.global_variable_get: (interned name) -> untyped
+  def self?.global_variable_set: [T] (interned name, T value) -> T
+  def self?.alias_global_variable: (interned to_set, interned original) -> Symbol
+
+  def self.global_variables: () -> Array[Symbol]
+
+  alias self.get self.global_variable_get
+  alias self.[] self.global_variable_get
+  alias self.set self.global_variable_set
+  alias self.[]= self.global_variable_set
+  alias self.list self.global_variables
+  alias self.alias self.alias_global_variable
 end

metadata

@@ -1,24 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: gvars
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.9.0
 platform: ruby
 authors:
-- SamW
-bindir: exe
+- Sam Westerman
+bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: 'TO DO: Write a longer description or delete this line.'
+description: |
+  Provides methods for manupulating global variables, as well as defining custom "hooked"
+  variables
 email:
 - mail@sampersand.me
 executables: []
-extensions: []
+extensions:
+- ext/gvars/extconf.rb
 extra_rdoc_files: []
 files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- ext/gvars/extconf.rb
+- ext/gvars/gvars.c
+- ext/gvars/gvars.c-old
 - lib/gvars.rb
 - lib/gvars/version.rb
 - sig/gvars.rbs
@@ -40,7 +46,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.0.dev
+rubygems_version: 4.0.3
 specification_version: 4
-summary: Provides helper methods for global variables
+summary: Provides utility methods for interacting with global variables
 test_files: []