enclave 0.1.0

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

@@ -0,0 +1,377 @@
+#include <mruby.h>
+#include <mruby/class.h>
+#include <mruby/string.h>
+#include <mruby/array.h>
+#include <mruby/proc.h>
+#include <mruby/variable.h>
+#include <mruby/internal.h>
+#include <mruby/presym.h>
+
+/*
+ * Get the name of a module/class.
+ *
+ * Returns the fully qualified name of the module/class as a frozen string.
+ * If the module/class is anonymous, returns nil.
+ *
+ * Args:
+ *   mrb:  The mruby state
+ *   self: The module/class object
+ *
+ * Returns:
+ *   String: The name of the module/class (frozen)
+ *   nil:    If the module/class is anonymous
+ */
+static mrb_value
+mod_name(mrb_state *mrb, mrb_value self)
+{
+  mrb_value name =  mrb_class_path(mrb, mrb_class_ptr(self));
+  if (mrb_string_p(name)) {
+    mrb_basic_ptr(name)->frozen = 1;
+  }
+  return name;
+}
+
+/*
+ * Check if a module/class is a singleton class.
+ *
+ * Args:
+ *   mrb:  The mruby state
+ *   self: The module/class object to check
+ *
+ * Returns:
+ *   true:  if the object is a singleton class
+ *   false: if the object is not a singleton class
+ */
+static mrb_value
+mod_singleton_class_p(mrb_state *mrb, mrb_value self)
+{
+  return mrb_bool_value(mrb_sclass_p(self));
+}
+
+/*
+ *  call-seq:
+ *     module_exec(arg...) {|var...| block } -> obj
+ *     class_exec(arg...) {|var...| block } -> obj
+ *
+ * Evaluates the given block in the context of the
+ * class/module. The method defined in the block will belong
+ * to the receiver. Any arguments passed to the method will be
+ * passed to the block. This can be used if the block needs to
+ * access instance variables.
+ *
+ *     class Thing
+ *     end
+ *     Thing.class_exec{
+ *       def hello() "Hello there!" end
+ *     }
+ *     puts Thing.new.hello()
+ */
+
+static mrb_value
+mod_module_exec(mrb_state *mrb, mrb_value self)
+{
+  return mrb_object_exec(mrb, self, mrb_class_ptr(self));
+}
+
+/* Helper structure for subclass enumeration */
+struct subclass_args {
+  struct RClass *c;   /* The parent class to find subclasses of */
+  mrb_value ary;      /* Array to collect subclasses into */
+};
+
+/*
+ * Callback function for mrb_objspace_each_objects to find direct subclasses.
+ *
+ * This function is called for each object in the object space. It checks if
+ * the object is a class whose direct superclass matches the target class.
+ *
+ * Args:
+ *   mrb:  The mruby state
+ *   obj:  The current object being examined
+ *   data: Pointer to subclass_args structure
+ *
+ * Returns:
+ *   MRB_EACH_OBJ_OK: Continue iteration
+ */
+static int
+add_subclasses(mrb_state *mrb, struct RBasic *obj, void *data)
+{
+  struct subclass_args *args = (struct subclass_args*)data;
+  if (obj->tt == MRB_TT_CLASS) {
+    struct RClass *c = (struct RClass*)obj;
+    if (mrb_class_real(c->super) == args->c) {
+      mrb_ary_push(mrb, args->ary, mrb_obj_value(obj));
+    }
+  }
+  return MRB_EACH_OBJ_OK;
+}
+
+/*
+ *  call-seq:
+ *     subclasses -> array
+ *
+ *  Returns an array of classes where the receiver is the
+ *  direct superclass of the class, excluding singleton classes.
+ *  The order of the returned array is not defined.
+ *
+ *     class A; end
+ *     class B < A; end
+ *     class C < B; end
+ *     class D < A; end
+ *
+ *     A.subclasses        #=> [D, B]
+ *     B.subclasses        #=> [C]
+ *     C.subclasses        #=> []
+ */
+static mrb_value
+class_subclasses(mrb_state *mrb, mrb_value self)
+{
+  struct RClass *c = mrb_class_ptr(self);
+  mrb_value ary = mrb_ary_new(mrb);
+
+  if (c->flags & MRB_FL_CLASS_IS_INHERITED) {
+    struct subclass_args arg = {c, ary};
+    mrb_objspace_each_objects(mrb, add_subclasses, &arg);
+  }
+  return ary;
+}
+
+/*
+ *  call-seq:
+ *     attached_object -> object
+ *
+ *  Returns the object for which the receiver is the singleton class.
+ *  Raises an TypeError if the class is not a singleton class.
+ *
+ *     class Foo; end
+ *
+ *     Foo.singleton_class.attached_object        #=> Foo
+ *     Foo.attached_object                        #=> TypeError: not a singleton class
+ *     Foo.new.singleton_class.attached_object    #=> #<Foo:0x000000010491a370>
+ *     TrueClass.attached_object                  #=> TypeError: not a singleton class
+ *     NilClass.attached_object                   #=> TypeError: not a singleton class
+ */
+static mrb_value
+class_attached_object(mrb_state *mrb, mrb_value self)
+{
+  struct RClass *c = mrb_class_ptr(self);
+  if (c->tt != MRB_TT_SCLASS) {
+    mrb_raise(mrb, E_TYPE_ERROR, "not a singleton class");
+  }
+  return mrb_obj_iv_get(mrb, (struct RObject*)c, MRB_SYM(__attached__));
+}
+
+/*
+ * Check if a class/module is an ancestor of another.
+ *
+ * This function traverses the inheritance chain of `klass` upwards to determine
+ * if `super` appears anywhere in the hierarchy. It handles both regular classes/modules
+ * and included classes (ICLASS) which represent modules included in the inheritance chain.
+ *
+ * Args:
+ *   klass: The class/module to check (potential descendant)
+ *   super: The class/module to search for (potential ancestor)
+ *
+ * Returns:
+ *   true:  if `super` is found in `klass`'s inheritance chain
+ *   false: if `super` is not an ancestor of `klass`
+ */
+static mrb_bool
+is_ancestor(struct RClass *klass, struct RClass *super)
+{
+  struct RClass *c = klass;
+  while (c) {
+    if (c->tt == MRB_TT_ICLASS) {
+      if (c->c == super) return TRUE;
+    }
+    else {
+      if (c == super) return TRUE;
+    }
+    c = c->super;
+  }
+  return FALSE;
+}
+
+/*
+ * Compare hierarchy relationship between two modules/classes.
+ *
+ * This function determines the ancestor relationship between `self` and `other`.
+ * It checks if one is an ancestor of the other by traversing the inheritance chain.
+ *
+ * Args:
+ *   mrb:   The mruby state
+ *   self:  The first module/class to compare
+ *   other: The second module/class to compare
+ *
+ * Returns:
+ *   true:  if `self` is an ancestor of `other` (self > other)
+ *   false: if `other` is an ancestor of `self` (self < other)
+ *   nil:   if there's no inheritance relationship between them
+ *
+ * Raises:
+ *   TypeError: if `other` is not a class, module, or included class
+ */
+static mrb_value
+mod_compare_hierarchy(mrb_state *mrb, mrb_value self, mrb_value other)
+{
+  if ((!mrb_class_p(self) && !mrb_module_p(self) && !mrb_iclass_p(self)) ||
+      (!mrb_class_p(other) && !mrb_module_p(other) && !mrb_iclass_p(other))) {
+    mrb_raise(mrb, E_TYPE_ERROR, "compared with non class/module");
+  }
+
+  struct RClass *self_c = mrb_class_ptr(self);
+  struct RClass *other_c = mrb_class_ptr(other);
+
+  if (is_ancestor(self_c, other_c)) {
+    return mrb_true_value();
+  }
+  if (is_ancestor(other_c, self_c)) {
+    return mrb_false_value();
+  }
+  return mrb_nil_value();
+}
+
+/*
+ *  call-seq:
+ *     mod <= other   -> true, false, or nil
+ *
+ *  Returns true if mod is a subclass of other or is the same as other.
+ *  Returns nil if there's no relationship between the two.
+ */
+static mrb_value
+mrb_mod_le(mrb_state *mrb, mrb_value self)
+{
+  mrb_value other;
+  mrb_get_args(mrb, "o", &other);
+  return mod_compare_hierarchy(mrb, self, other);
+}
+
+/*
+ *  call-seq:
+ *     mod < other   -> true, false, or nil
+ *
+ *  Returns true if mod is a subclass of other. Returns false if mod
+ *  is the same as other. Returns nil if there's no relationship between the two.
+ */
+static mrb_value
+mrb_mod_lt(mrb_state *mrb, mrb_value self)
+{
+  mrb_value other;
+  mrb_get_args(mrb, "o", &other);
+  if (mrb_obj_equal(mrb, self, other)) {
+    return mrb_false_value();
+  }
+  return mod_compare_hierarchy(mrb, self, other);
+}
+
+/*
+ *  call-seq:
+ *     mod >= other   -> true, false, or nil
+ *
+ *  Returns true if mod is an ancestor of other, or the two modules are the same.
+ *  Returns nil if there's no relationship between the two.
+ */
+static mrb_value
+mrb_mod_ge(mrb_state *mrb, mrb_value self)
+{
+  mrb_value other;
+  mrb_get_args(mrb, "o", &other);
+  return mod_compare_hierarchy(mrb, other, self);
+}
+
+/*
+ *  call-seq:
+ *     mod > other   -> true, false, or nil
+ *
+ *  Returns true if mod is an ancestor of other. Returns false if mod
+ *  is the same as other. Returns nil if there's no relationship between the two.
+ */
+static mrb_value
+mrb_mod_gt(mrb_state *mrb, mrb_value self)
+{
+  mrb_value other;
+  mrb_get_args(mrb, "o", &other);
+  if (mrb_obj_equal(mrb, self, other)) {
+    return mrb_false_value();
+  }
+  return mod_compare_hierarchy(mrb, other, self);
+}
+
+/*
+ *  call-seq:
+ *     module <=> other_module   -> -1, 0, +1, or nil
+ *
+ *  Comparison - Returns -1, 0, +1 or nil depending on whether module
+ *  includes other_module, they are the same, or if module is included by
+ *  other_module.
+ *
+ *  Returns nil if module has no relationship with other_module, if
+ *  other_module is not a module, or if the two values are incomparable.
+ */
+static mrb_value
+mrb_mod_cmp(mrb_state *mrb, mrb_value self)
+{
+  mrb_value other;
+  mrb_get_args(mrb, "o", &other);
+
+  if (mrb_obj_equal(mrb, self, other)) {
+    return mrb_fixnum_value(0);
+  }
+  if (!mrb_class_p(other) && !mrb_module_p(other) && !mrb_iclass_p(other)) {
+    return mrb_nil_value();
+  }
+
+  mrb_value cmp = mod_compare_hierarchy(mrb, self, other);
+
+  if (mrb_true_p(cmp)) {
+    return mrb_fixnum_value(-1);
+  }
+  else if (mrb_false_p(cmp)) {
+    return mrb_fixnum_value(1);
+  }
+  else {
+    return mrb_nil_value();
+  }
+}
+
+/* ---------------------------*/
+static const mrb_mt_entry mod_ext_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_mod_lt,            MRB_OPSYM(lt), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(mrb_mod_le,            MRB_OPSYM(le), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(mrb_mod_cmp,           MRB_OPSYM(cmp), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(mrb_mod_gt,            MRB_OPSYM(gt), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(mrb_mod_ge,            MRB_OPSYM(ge), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(mod_module_exec,       MRB_SYM(class_exec), MRB_ARGS_ANY()|MRB_ARGS_BLOCK()),
+  MRB_MT_ENTRY(mod_module_exec,       MRB_SYM(module_exec), MRB_ARGS_ANY()|MRB_ARGS_BLOCK()),
+  MRB_MT_ENTRY(mod_name,              MRB_SYM(name),           MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(mod_singleton_class_p, MRB_SYM_Q(singleton_class), MRB_ARGS_NONE()),
+};
+
+static const mrb_mt_entry cls_ext_rom_entries[] = {
+  MRB_MT_ENTRY(class_attached_object, MRB_SYM(attached_object), MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(class_subclasses,      MRB_SYM(subclasses),   MRB_ARGS_NONE()),
+};
+
+/*
+ * Initialize the mruby-class-ext gem.
+ *
+ * This function registers all the extension methods to the Module and Class classes.
+ * It's called automatically when the gem is loaded.
+ *
+ * Args:
+ *   mrb: The mruby state
+ */
+void
+mrb_mruby_class_ext_gem_init(mrb_state *mrb)
+{
+  struct RClass *mod = mrb->module_class;
+  struct RClass *cls = mrb->class_class;
+
+  MRB_MT_INIT_ROM(mrb, mod, mod_ext_rom_entries);
+  MRB_MT_INIT_ROM(mrb, cls, cls_ext_rom_entries);
+}
+
+void
+mrb_mruby_class_ext_gem_final(mrb_state *mrb)
+{
+}

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

@@ -0,0 +1,46 @@
+assert 'Class#subclasses' do
+  a = Class.new
+  b = Class.new(a)
+  c = Class.new(b)
+  d = Class.new(a)
+
+  a_sub = a.subclasses
+  assert_equal(2, a_sub.size)
+  assert_true(a_sub.include?(b))
+  assert_true(a_sub.include?(d))
+  assert_equal([c], b.subclasses)
+  assert_equal([], c.subclasses)
+end
+
+assert 'Class#attached_object' do
+  foo = Class.new
+  foo_s = class <<foo
+    foo_s = self
+  end
+  assert_equal(foo, foo_s.attached_object)
+  fooi = foo.new
+  fooi_s = class <<fooi
+    fooi_s = self
+  end
+  assert_equal(fooi, fooi_s.attached_object)
+  assert_raise(TypeError){foo.attached_object}
+  assert_raise(TypeError){TrueClass.attached_object}
+  assert_raise(TypeError){NilClass.attached_object}
+end
+
+assert 'Class#class_exec' do
+  c = Class.new
+  class << c
+    def index
+      12345
+    end
+  end
+  c.class_exec do
+    def index
+      54321
+    end
+  end
+
+  assert_equal 12345, c.index
+  assert_equal 54321, c.new.index
+end

data/ext/enclave/mruby/mrbgems/mruby-class-ext/test/module.rb

@@ -0,0 +1,109 @@
+assert 'Module#<' do
+  a = Class.new
+  b = Class.new(a)
+  c = Class.new(a)
+  d = Module.new
+  e = Class.new { include d }
+  f = Module.new { include d }
+
+  # compare class to class
+  assert_true b < a
+  assert_false b < b
+  assert_false a < b
+  assert_nil c < b
+
+  # compare class to module
+  assert_true e < d
+  assert_false d < e
+  assert_nil a < d
+
+  # compare module to module
+  assert_true f < d
+  assert_false f < f
+  assert_false d < f
+
+  assert_raise(TypeError) { a < Object.new }
+end
+
+assert 'Module#<=' do
+  a = Class.new
+  b = Class.new(a)
+  c = Class.new(a)
+  d = Module.new
+  e = Class.new { include d }
+  f = Module.new { include d }
+
+  # compare class to class
+  assert_true b <= a
+  assert_true b <= b
+  assert_false a <= b
+  assert_nil c <= b
+
+  # compare class to module
+  assert_true e <= d
+  assert_false d <= e
+  assert_nil a <= d
+
+  # compare module to module
+  assert_true f <= d
+  assert_true f <= f
+  assert_false d <= f
+
+  assert_raise(TypeError) { a <= Object.new }
+end
+
+assert 'Module#name' do
+  module Outer
+    class Inner; end
+    const_set :SetInner, Class.new
+  end
+
+  assert_equal 'Outer', Outer.name
+  assert_equal 'Outer::Inner', Outer::Inner.name
+  assert_equal 'Outer::SetInner', Outer::SetInner.name
+
+  outer = Module.new do
+    const_set :SetInner, Class.new
+  end
+  Object.const_set :SetOuter, outer
+
+  assert_equal 'SetOuter', SetOuter.name
+  assert_equal 'SetOuter::SetInner', SetOuter::SetInner.name
+
+  mod = Module.new
+  cls = Class.new
+
+  assert_nil mod.name
+  assert_nil cls.name
+end
+
+assert 'Module#singleton_class?' do
+  mod = Module.new
+  cls = Class.new
+  scl = (class <<cls; self; end)
+
+  assert_false mod.singleton_class?
+  assert_false cls.singleton_class?
+  assert_true scl.singleton_class?
+end
+
+assert 'Module#module_eval' do
+  mod = Module.new
+  mod.class_exec(1,2,3) do |a,b,c|
+    assert_equal([1,2,3], [a,b,c])
+    def hi
+      "hi"
+    end
+  end
+  cls = Class.new
+  cls.class_exec(42) do |x|
+    assert_equal(42, x)
+    include mod
+    def hello
+      "hello"
+    end
+  end
+  obj = cls.new
+  assert_equal("hi", obj.hi)
+  assert_equal("hello", obj.hello)
+end

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

@@ -0,0 +1,45 @@
+# mruby-cmath
+
+This mrbgem provides complex number support for mruby, offering mathematical functions that can handle complex numbers, similar to Ruby's standard `cmath` library.
+
+## Requirements
+
+This gem utilizes C99 `_Complex` features. Therefore, you will need a C compiler that supports C99 or a later version to build and use this gem.
+
+## Provided Functions
+
+The `CMath` module includes the following mathematical functions:
+
+- `exp(z)`: Computes the exponential of `z`.
+- `log(z)`: Computes the natural logarithm of `z`.
+- `log(z, b)`: Computes the logarithm of `z` with base `b`.
+- `log2(z)`: Computes the base-2 logarithm of `z`.
+- `log10(z)`: Computes the base-10 logarithm of `z`.
+- `sqrt(z)`: Computes the square root of `z`.
+- `sin(z)`: Computes the sine of `z`.
+- `cos(z)`: Computes the cosine of `z`.
+- `tan(z)`: Computes the tangent of `z`.
+- `asin(z)`: Computes the arc sine of `z`.
+- `acos(z)`: Computes the arc cosine of `z`.
+- `atan(z)`: Computes the arc tangent of `z`.
+- `sinh(z)`: Computes the hyperbolic sine of `z`.
+- `cosh(z)`: Computes the hyperbolic cosine of `z`.
+- `tanh(z)`: Computes the hyperbolic tangent of `z`.
+- `asinh(z)`: Computes the inverse hyperbolic sine of `z`.
+- `acosh(z)`: Computes the inverse hyperbolic cosine of `z`.
+- `atanh(z)`: Computes the inverse hyperbolic tangent of `z`.
+
+## Usage Example
+
+Here's a simple example of how to use `CMath` to calculate the square root of a negative number:
+
+```ruby
+# Assuming mruby is built with mruby-cmath
+
+# Calculate the square root of -4
+result = CMath.sqrt(-4)
+
+# result will be a Complex number (0+2i)
+puts result.real      # Output: 0.0
+puts result.imaginary # Output: 2.0
+```

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

@@ -0,0 +1,8 @@
+# This `mruby-cmath` gem uses C99 _Complex features
+# You need C compiler that support C99+
+MRuby::Gem::Specification.new('mruby-cmath') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'standard Math module with complex'
+  spec.add_dependency 'mruby-complex', :core => 'mruby-complex'
+end