enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-object-ext/README.md

@@ -0,0 +1,144 @@
+# mruby-object-ext
+
+This mrbgem provides several extension methods to core objects in mruby, enhancing their functionality and providing useful utilities for common programming patterns.
+
+## Core Extension Methods
+
+This gem extends core mruby objects with the following methods:
+
+### `Kernel#yield_self` (aliased as `then`)
+
+Yields the receiver (self) to the given block and returns the result of the block. This is useful for chaining operations in a readable way.
+
+**Signature:**
+
+```ruby
+obj.yield_self {|current_obj| ... } > an_object
+obj.then       {|current_obj| ... } -> an_object
+```
+
+**Example:**
+
+```ruby
+result = "hello"
+  .yield_self {|s| s.upcase }
+  .then       {|s| s + " WORLD" }
+
+puts result #=> "HELLO WORLD"
+
+# Another example with a different data type
+(1..5)
+  .yield_self {|range| range.to_a }
+  .then       {|arr| arr.select(&:even?) }
+  .then       {|evens| evens.map {|n| n * n } }
+  .then       {|squares| puts squares.inspect } #=> [4, 16]
+```
+
+### `Kernel#tap`
+
+Yields the receiver (self) to the given block and then returns the receiver itself. This method is primarily used for "tapping into" a method chain to perform operations on intermediate results without affecting the final result of the chain.
+
+**Signature:**
+
+```ruby
+obj.tap {|current_obj| ... } -> obj
+```
+
+**Example:**
+
+```ruby
+(1..10)
+  .to_a
+  .tap {|arr| puts "Array: #{arr.inspect}" }
+  .select(&:even?)
+  .tap {|evens| puts "Evens: #{evens.inspect}" }
+  .map {|n| n * n }
+  .tap {|squares| puts "Squares: #{squares.inspect}" }
+# Output:
+# Array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+# Evens: [2, 4, 6, 8, 10]
+# Squares: [4, 16, 36, 64, 100]
+```
+
+### `Kernel#itself`
+
+Returns the receiver (self). While simple, it can be useful in certain chaining or meta-programming scenarios.
+
+**Signature:**
+
+```ruby
+obj.itself -> obj
+```
+
+**Example:**
+
+```ruby
+string = "my string"
+puts string.itself.object_id == string.object_id #=> true
+
+# Can be useful with methods expecting a callable
+data = { a: 1, b: 2 }
+transformed_data = data.transform_values(&:itself) # No change if values are already what you want
+puts transformed_data #=> {:a=>1, :b=>2} (in mruby hash output format)
+```
+
+### `BasicObject#instance_exec`
+
+Executes the given block within the context of the receiver (obj). This means that inside the block, `self` is set to `obj`, giving the code access to `obj`'s instance variables and private methods. Arguments passed to `instance_exec` are passed as block parameters.
+
+**Signature:**
+
+```ruby
+obj.instance_exec(arg...) {|var...| block } -> result_of_block
+```
+
+**Example:**
+
+```ruby
+class MyClass
+  def initialize(value)
+    @secret = value
+  end
+
+  def reveal_secret(multiplier, &block)
+    # self here is MyClass instance
+    instance_exec(multiplier, &block)
+  end
+end
+
+instance = MyClass.new(10)
+result = instance.reveal_secret(5) {|m| @secret * m }
+puts result #=> 50
+
+# Example without a class context
+num = 42
+num.instance_exec("Number is: ") {|prefix| puts prefix + self.to_s } #=> Number is: 42
+```
+
+## `NilClass` Extensions
+
+This gem also adds convenient type conversion methods to `NilClass`:
+
+- **`nil.to_a`**: Returns an empty Array (`[]`).
+
+  ```ruby
+  p nil.to_a #=> []
+  ```
+
+- **`nil.to_f`**: Returns `0.0`.
+
+  ```ruby
+  p nil.to_f #=> 0.0
+  ```
+
+- **`nil.to_h`**: Returns an empty Hash (`{}`).
+
+  ```ruby
+  p nil.to_h #=> {}
+  ```
+
+- **`nil.to_i`**: Returns `0`.
+
+  ```ruby
+  p nil.to_i #=> 0
+  ```

data/ext/enclave/mruby/mrbgems/mruby-object-ext/mrbgem.rake

@@ -0,0 +1,5 @@
+MRuby::Gem::Specification.new('mruby-object-ext') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'extensional methods shared by all objects'
+end

data/ext/enclave/mruby/mrbgems/mruby-object-ext/mrblib/object.rb

@@ -0,0 +1,33 @@
+module Kernel
+  # call-seq:
+  #   obj.yield_self {|_obj|...} -> an_object
+  #   obj.then {|_obj|...}       -> an_object
+  #
+  # Yields *obj* and returns the result.
+  #
+  #   'my string'.yield_self {|s|s.upcase} #=> "MY STRING"
+  #
+  def yield_self(&block)
+    return to_enum(:yield_self) unless block
+    block.call(self)
+  end
+  alias then yield_self
+
+  ##
+  #  call-seq:
+  #     obj.tap{|x|...}    -> obj
+  #
+  #  Yields `x` to the block, and then returns `x`.
+  #  The primary purpose of this method is to "tap into" a method chain,
+  #  in order to perform operations on intermediate results within the chain.
+  #
+  #  (1..10)                .tap {|x| puts "original: #{x.inspect}"}
+  #    .to_a                .tap {|x| puts "array: #{x.inspect}"}
+  #    .select {|x| x%2==0} .tap {|x| puts "evens: #{x.inspect}"}
+  #    .map { |x| x*x }     .tap {|x| puts "squares: #{x.inspect}"}
+  #
+  def tap
+    yield self
+    self
+  end
+end

data/ext/enclave/mruby/mrbgems/mruby-object-ext/src/object.c

@@ -0,0 +1,128 @@
+#include <mruby.h>
+#include <mruby/array.h>
+#include <mruby/class.h>
+#include <mruby/hash.h>
+#include <mruby/proc.h>
+#include <mruby/internal.h>
+#include <mruby/presym.h>
+
+/*
+ *  call-seq:
+ *     nil.to_a    -> []
+ *
+ *  Always returns an empty array.
+ */
+
+static mrb_value
+nil_to_a(mrb_state *mrb, mrb_value obj)
+{
+  return mrb_ary_new(mrb);
+}
+
+#ifndef MRB_NO_FLOAT
+/*
+ *  call-seq:
+ *     nil.to_f    -> 0.0
+ *
+ *  Always returns zero.
+ */
+
+static mrb_value
+nil_to_f(mrb_state *mrb, mrb_value obj)
+{
+  return mrb_float_value(mrb, 0.0);
+}
+#endif
+
+/*
+ *  call-seq:
+ *     nil.to_h    -> {}
+ *
+ *  Always returns an empty hash.
+ */
+
+static mrb_value
+nil_to_h(mrb_state *mrb, mrb_value obj)
+{
+  return mrb_hash_new(mrb);
+}
+
+/*
+ *  call-seq:
+ *     nil.to_i    -> 0
+ *
+ *  Always returns zero.
+ */
+
+static mrb_value
+nil_to_i(mrb_state *mrb, mrb_value obj)
+{
+  return mrb_fixnum_value(0);
+}
+
+/*
+ *  Document-method: Kernel#itself
+ *
+ *  call-seq:
+ *     obj.itself -> an_object
+ *
+ *  Returns *obj*.
+ *
+ *      string = 'my string' #=> "my string"
+ *      string.itself.object_id == string.object_id #=> true
+ *
+ */
+
+/*
+ *  call-seq:
+ *     obj.instance_exec(arg...) {|var...| block }                       -> obj
+ *
+ *  Executes the given block within the context of the receiver
+ *  (_obj_). In order to set the context, the variable `self` is set
+ *  to _obj_ while the code is executing, giving the code access to
+ *  _obj_'s instance variables.  Arguments are passed as block parameters.
+ *
+ *     class KlassWithSecret
+ *       def initialize
+ *         @secret = 99
+ *       end
+ *     end
+ *     k = KlassWithSecret.new
+ *     k.instance_exec(5) {|x| @secret+x }   #=> 104
+ */
+
+static mrb_value
+obj_instance_exec(mrb_state *mrb, mrb_value self)
+{
+  return mrb_object_exec(mrb, self, mrb_singleton_class_ptr(mrb, self));
+}
+
+static const mrb_mt_entry nil_ext_rom_entries[] = {
+  MRB_MT_ENTRY(nil_to_a, MRB_SYM(to_a), MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(nil_to_h, MRB_SYM(to_h), MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(nil_to_i, MRB_SYM(to_i), MRB_ARGS_NONE()),
+#ifndef MRB_NO_FLOAT
+  MRB_MT_ENTRY(nil_to_f, MRB_SYM(to_f), MRB_ARGS_NONE()),
+#endif
+};
+
+static const mrb_mt_entry bob_ext_rom_entries[] = {
+  MRB_MT_ENTRY(obj_instance_exec, MRB_SYM(instance_exec), MRB_ARGS_ANY()|MRB_ARGS_BLOCK()),
+};
+
+void
+mrb_mruby_object_ext_gem_init(mrb_state* mrb)
+{
+  struct RClass * n = mrb->nil_class;
+
+  MRB_MT_INIT_ROM(mrb, n, nil_ext_rom_entries);
+
+  mrb_define_method_id(mrb, mrb->kernel_module, MRB_SYM(itself), mrb_obj_itself, MRB_ARGS_NONE());
+
+  MRB_MT_INIT_ROM(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), bob_ext_rom_entries);
+}
+
+void
+mrb_mruby_object_ext_gem_final(mrb_state* mrb)
+{
+}

data/ext/enclave/mruby/mrbgems/mruby-object-ext/test/nil.rb

@@ -0,0 +1,16 @@
+assert('NilClass#to_a') do
+  assert_equal [], nil.to_a
+end
+
+assert('NilClass#to_f') do
+  skip unless Object.const_defined?(:Float)
+  assert_equal 0.0, nil.to_f
+end
+
+assert('NilClass#to_h') do
+  assert_equal Hash.new, nil.to_h
+end
+
+assert('NilClass#to_i') do
+  assert_equal 0, nil.to_i
+end

data/ext/enclave/mruby/mrbgems/mruby-object-ext/test/object.rb

@@ -0,0 +1,67 @@
+assert('Object#instance_exec') do
+  class KlassWithSecret
+    def initialize
+      @secret = 99
+    end
+  end
+  k = KlassWithSecret.new
+  assert_equal 104, k.instance_exec(5) {|x| @secret+x }
+end
+
+assert('Object#tap') do
+  ret = []
+  (1..10)                 .tap {|x| ret << "original: #{x.inspect}"}
+     .to_a                .tap {|x| ret << "array: #{x.inspect}"}
+     .select {|x| x%2==0} .tap {|x| ret << "evens: #{x.inspect}"}
+     .map { |x| x*x }     .tap {|x| ret << "squares: #{x.inspect}"}
+
+  assert_equal [
+    "original: 1..10",
+    "array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]",
+    "evens: [2, 4, 6, 8, 10]",
+    "squares: [4, 16, 36, 64, 100]"
+  ], ret
+  assert_equal(:tap_ok, Class.new {def m; tap{return :tap_ok}; end}.new.m)
+end
+
+assert('instance_exec on primitives with class and module definition') do
+  begin
+    class A
+      1.instance_exec do
+        class B
+        end
+      end
+    end
+
+    assert_kind_of Class, A::B
+  ensure
+    Object.__send__(:remove_const,:A)
+  end
+
+  begin
+    class A
+      1.instance_exec do
+        module B
+        end
+      end
+    end
+
+    assert_kind_of Module, A::B
+  ensure
+    Object.__send__(:remove_const,:A)
+  end
+end
+
+assert('argument forwarding via instance_exec') do
+  assert_equal [[], {}, nil], instance_exec { |*args, **kw, &blk| [args, kw, blk] }
+  assert_equal [[1, 2, 3], {}, nil], instance_exec(1, 2, 3) { |*args, **kw, &blk| [args, kw, blk] }
+  assert_equal [[], { a: 1 }, nil], instance_exec(a: 1) { |*args, **kw, &blk| [args, kw, blk] }
+end
+
+assert('argument forwarding via instance_exec from c') do
+  assert_equal [[], {}, nil], instance_exec_from_c { |*args, **kw, &blk| [args, kw, blk] }
+  assert_equal [[1, 2, 3], {}, nil], instance_exec_from_c(1, 2, 3) { |*args, **kw, &blk| [args, kw, blk] }
+
+  # currently there is no easy way to call a method from C passing keyword arguments
+  #assert_equal [[], { a: 1 }, nil], instance_exec_from_c(a: 1) { |*args, **kw, &blk| [args, kw, blk] }
+end

data/ext/enclave/mruby/mrbgems/mruby-object-ext/test/object_ext.c

@@ -0,0 +1,17 @@
+#include <mruby.h>
+
+static mrb_value
+obj_instance_exec_from_c(mrb_state *mrb, mrb_value self)
+{
+  mrb_int argc;
+  const mrb_value *argv;
+  mrb_value blk;
+  mrb_get_args(mrb, "*&!", &argv, &argc, &blk);
+  return mrb_funcall_with_block(mrb, self, mrb_intern_lit(mrb, "instance_exec"), argc, argv, blk);
+}
+
+void
+mrb_mruby_object_ext_gem_test(mrb_state *mrb)
+{
+  mrb_define_method(mrb, mrb->kernel_module, "instance_exec_from_c", obj_instance_exec_from_c, MRB_ARGS_ANY());
+}

data/ext/enclave/mruby/mrbgems/mruby-objectspace/README.md

@@ -0,0 +1,59 @@
+# mruby-objectspace
+
+This mrbgem provides the `ObjectSpace` module for mruby, allowing introspection of live objects within the mruby environment.
+
+## Purpose
+
+The `ObjectSpace` module offers methods to count and iterate over objects currently allocated by the mruby interpreter. This can be useful for debugging, memory profiling, or understanding the internal state of your mruby application.
+
+## Functionality
+
+### `ObjectSpace.count_objects([result_hash]) -> Hash`
+
+Counts all objects currently alive in the mruby process, categorized by their types.
+
+- **`result_hash` (optional `Hash`):** If provided, this hash will be cleared and populated with the results. This can be useful to avoid allocating a new hash during sensitive operations like memory profiling, potentially reducing probe effect.
+
+- **Returns:** A `Hash` where keys are symbols representing object types (e.g., `:T_OBJECT`, `:T_CLASS`, `:T_STRING`) or, in some cases, internal type integers. The values are the counts of objects for each type. The hash also includes special keys:
+  - `:TOTAL`: The total number of objects (including free slots).
+  - `:FREE`: The number of free (unallocated) object slots.
+
+**Example of the returned hash structure:**
+
+```ruby
+{
+  :TOTAL=>10000,
+  :FREE=>3011,
+  :T_OBJECT=>6,
+  :T_CLASS=>404,
+  :T_STRING=>500,
+  # ... other types
+}
+```
+
+### `ObjectSpace.each_object([module]) {|obj| ... } -> Fixnum`
+
+Iterates over each live object in the mruby process, calling the provided block once for each object.
+
+- **`module` (optional `Module` or `Class`):** If this argument is provided, the block will only be called for objects that are instances of the given `module` or one of its subclasses.
+
+- **Block (`{|obj| ... }`):** A block that will be executed with each object (`obj`) found.
+
+- **Returns:** A `Fixnum` representing the total number of objects iterated over.
+
+**Example Usage:**
+
+```ruby
+# Iterate over all objects
+total_objects = ObjectSpace.each_object do |obj|
+  # Do something with obj
+  p obj
+end
+puts "Total objects found: #{total_objects}"
+
+# Iterate only over Array objects
+array_count = ObjectSpace.each_object(Array) do |arr|
+  p arr
+end
+puts "Found #{array_count} Arrays."
+```

data/ext/enclave/mruby/mrbgems/mruby-objectspace/mrbgem.rake

@@ -0,0 +1,5 @@
+MRuby::Gem::Specification.new('mruby-objectspace') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'ObjectSpace class'
+end

data/ext/enclave/mruby/mrbgems/mruby-objectspace/src/mruby_objectspace.c

@@ -0,0 +1,188 @@
+#include <mruby.h>
+#include <mruby/gc.h>
+#include <mruby/hash.h>
+#include <mruby/class.h>
+#include <mruby/object.h>
+#include <mruby/numeric.h>
+#include <mruby/string.h>
+#include <mruby/array.h>
+#include <mruby/variable.h>
+#include <mruby/proc.h>
+#include <mruby/value.h>
+#include <mruby/range.h>
+#include <mruby/presym.h>
+
+struct os_count_struct {
+  mrb_int total;
+  mrb_int freed;
+  mrb_int counts[MRB_TT_MAXDEFINE+1];
+};
+
+static int
+os_count_object_type(mrb_state *mrb, struct RBasic *obj, void *data)
+{
+  struct os_count_struct *obj_count;
+  obj_count = (struct os_count_struct*)data;
+
+  obj_count->total++;
+
+  if (mrb_object_dead_p(mrb, obj)) {
+    obj_count->freed++;
+  }
+  else {
+    obj_count->counts[obj->tt]++;
+  }
+  return MRB_EACH_OBJ_OK;
+}
+
+/*
+ *  call-seq:
+ *     ObjectSpace.count_objects([result_hash]) -> hash
+ *
+ *  Counts objects for each type.
+ *
+ *  It returns a hash, such as:
+ *  {
+ *    :TOTAL=>10000,
+ *    :FREE=>3011,
+ *    :T_OBJECT=>6,
+ *    :T_CLASS=>404,
+ *    # ...
+ *  }
+ *
+ *  If the optional argument `result_hash` is given,
+ *  it is overwritten and returned. This is intended to avoid probe effect.
+ *
+ */
+
+static mrb_value
+os_count_objects(mrb_state *mrb, mrb_value self)
+{
+  struct os_count_struct obj_count = { 0 };
+  mrb_int i;
+  mrb_value hash;
+
+  if (mrb_get_args(mrb, "|H", &hash) == 0) {
+    hash = mrb_hash_new(mrb);
+  }
+
+  if (!mrb_hash_empty_p(mrb, hash)) {
+    mrb_hash_clear(mrb, hash);
+  }
+
+  mrb_objspace_each_objects(mrb, os_count_object_type, &obj_count);
+
+  mrb_hash_set(mrb, hash, mrb_symbol_value(MRB_SYM(TOTAL)), mrb_fixnum_value(obj_count.total));
+  mrb_hash_set(mrb, hash, mrb_symbol_value(MRB_SYM(FREE)), mrb_fixnum_value(obj_count.freed));
+
+  for (i = MRB_TT_FALSE; i < MRB_TT_MAXDEFINE; i++) {
+    mrb_value type;
+    switch (i) {
+#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
+      COUNT_TYPE(T_INTEGER);
+      COUNT_TYPE(T_FLOAT);
+      COUNT_TYPE(T_CPTR);
+      COUNT_TYPE(T_OBJECT);
+      COUNT_TYPE(T_CLASS);
+      COUNT_TYPE(T_MODULE);
+      COUNT_TYPE(T_ICLASS);
+      COUNT_TYPE(T_SCLASS);
+      COUNT_TYPE(T_PROC);
+      COUNT_TYPE(T_ARRAY);
+      COUNT_TYPE(T_HASH);
+      COUNT_TYPE(T_STRING);
+      COUNT_TYPE(T_RANGE);
+      COUNT_TYPE(T_EXCEPTION);
+      COUNT_TYPE(T_ENV);
+      COUNT_TYPE(T_DATA);
+      COUNT_TYPE(T_FIBER);
+      COUNT_TYPE(T_STRUCT);
+      COUNT_TYPE(T_ISTRUCT);
+      COUNT_TYPE(T_BREAK);
+      COUNT_TYPE(T_COMPLEX);
+      COUNT_TYPE(T_RATIONAL);
+      COUNT_TYPE(T_BIGINT);
+#undef COUNT_TYPE
+    default:
+      type = mrb_fixnum_value(i); break;
+    }
+    if (obj_count.counts[i])
+      mrb_hash_set(mrb, hash, type, mrb_fixnum_value(obj_count.counts[i]));
+  }
+
+  return hash;
+}
+
+struct os_each_object_data {
+  struct RClass *target_module;
+  mrb_int count;
+  mrb_value block;
+};
+
+static int
+os_each_object_cb(mrb_state *mrb, struct RBasic *obj, void *ud)
+{
+  struct os_each_object_data *d = (struct os_each_object_data*)ud;
+
+  /* filter dead objects */
+  if (mrb_object_dead_p(mrb, obj)) {
+    return MRB_EACH_OBJ_OK;
+  }
+
+  /* filter internal objects */
+  switch (obj->tt) {
+  case MRB_TT_FREE: case MRB_TT_ENV:
+  case MRB_TT_BREAK: case MRB_TT_ICLASS:
+    return MRB_EACH_OBJ_OK;
+  default:
+    break;
+  }
+
+  /* filter half baked (or internal) objects */
+  if (!obj->c) return MRB_EACH_OBJ_OK;
+
+  /* filter class kind if target module defined */
+  if (d->target_module && !mrb_obj_is_kind_of(mrb, mrb_obj_value(obj), d->target_module)) {
+    return MRB_EACH_OBJ_OK;
+  }
+
+  mrb_yield(mrb, d->block, mrb_obj_value(obj));
+  ++d->count;
+  return MRB_EACH_OBJ_OK;
+}
+
+/*
+ *  call-seq:
+ *     ObjectSpace.each_object([module]) {|obj| ... } -> fixnum
+ *
+ *  Calls the block once for each object in this Ruby process.
+ *  Returns the number of objects found.
+ *  If the optional argument `module` is given,
+ *  calls the block for only those classes or modules
+ *  that match (or are a subclass of) `module`.
+ *
+ *  If no block is given, ArgumentError is raised.
+ *
+ */
+
+static mrb_value
+os_each_object(mrb_state *mrb, mrb_value self)
+{
+  struct os_each_object_data d = {0};
+  mrb_get_args(mrb, "&!|c", &d.block, &d.target_module);
+  mrb_objspace_each_objects(mrb, os_each_object_cb, &d);
+  return mrb_fixnum_value(d.count);
+}
+
+void
+mrb_mruby_objectspace_gem_init(mrb_state *mrb)
+{
+  struct RClass *os = mrb_define_module(mrb, "ObjectSpace");
+  mrb_define_class_method(mrb, os, "count_objects", os_count_objects, MRB_ARGS_OPT(1));
+  mrb_define_class_method(mrb, os, "each_object", os_each_object, MRB_ARGS_OPT(1));
+}
+
+void
+mrb_mruby_objectspace_gem_final(mrb_state *mrb)
+{
+}