enclave 0.1.0

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

@@ -0,0 +1,202 @@
+PACK_IS_LITTLE_ENDIAN = "\x01\00".unpack('S')[0] == 0x01
+
+def assert_pack tmpl, packed, unpacked
+  t = tmpl.inspect
+  assert "assert_pack" do
+    assert_equal packed, unpacked.pack(tmpl), "#{unpacked.inspect}.pack(#{t})"
+    assert_equal unpacked, packed.unpack(tmpl), "#{packed.inspect}.unpack(#{t})"
+  end
+end
+
+# pack & unpack 'm' (base64)
+assert('pack("m")') do
+  assert_pack "m", "", [""]
+  assert_pack "m", "AA==\n", ["\0"]
+  assert_pack "m", "AAA=\n", ["\0\0"]
+  assert_pack "m", "AAAA\n", ["\0\0\0"]
+  assert_pack "m", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJT\nVFVWV1hZWg==\n", ["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"]
+
+  ary = ["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"]
+  assert_equal ary, "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJT\nVFVWV1hZWg==\n".unpack("m")
+  assert_equal ary, "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWg==\n".unpack("m")
+
+  assert_equal "QQ==\n", ["A", "B"].pack("m50")
+  assert_equal ["A"], "QQ==\n".unpack("m50")
+  assert_equal "QQ==Qg==", ["A", "B"].pack("m0 m0")
+  assert_equal ["A", "B"], "QQ==Qg==".unpack("m10 m10")
+  assert_pack "m0", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWg==", ["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"]
+end
+
+# pack & unpack 'M' (Quoted-printable)
+assert('pack("M")') do
+  assert_pack "M", "123=\n", ["123"]
+  assert_pack "M", "=3D\n", ["=\n"]
+  assert_pack "M", "=E3=81=82=\n", ["あ"]
+
+  assert_equal ["123"], "123=\n".unpack("M")
+  assert_equal ["=\n"], "=3D\n".unpack("M")
+  assert_equal ["あ"], "=E3=81=82=\n".unpack("M")
+end
+
+# pack & unpack 'u' (UU-encode)
+assert('pack("u")') do
+  # Basic string test with known good values
+  assert_pack "u", "-2&5L;&\\L(%=O<FQD(0``\n`\n", ["Hello, World!"]
+
+  # Empty string test
+  assert_pack "u", "", [""]
+
+  # Binary data test with known good values
+  assert_pack "u", "%``$\"`_\\`\n`\n", ["\x00\x01\x02\x03\xFF"]
+
+  # Single character test with corrected value
+  assert_pack "u", "!00``\n`\n", ["A"]
+
+  # Test with different line lengths
+  short_data = "ABCD"
+  assert_equal [short_data], [short_data].pack("u").unpack("u")
+
+  # Test longer data (will span multiple lines)
+  long_data = "A" * 50
+  packed_long = [long_data].pack("u")
+  assert_equal [long_data], packed_long.unpack("u")
+
+  # Test that packed data ends with zero-length line for non-empty input
+  packed = ["test"].pack("u")
+  # Check if last two characters are backtick and newline
+  assert_equal "`\n", packed[-2, 2], "UU-encoded data should end with zero-length line"
+end
+
+# pack & unpack 'B'/'b'
+assert('pack("B/b")') do
+  assert_pack "b*", "\xFF\x00", ["1111111100000000"]
+  assert_pack "b*", "\x01\x02", ["1000000001000000"]
+  assert_pack "b3", "\x01", ["100"]
+
+  assert_pack "B*", "\xFF\x00", ["1111111100000000"]
+  assert_pack "B*", "\x01\x02", ["0000000100000010"]
+end
+
+# pack & unpack 'H'
+assert('pack("H")') do
+  assert_pack "H*", "01", ["3031"]
+  assert_pack "H*", "\020", ["10"]
+end
+
+assert('pack("C")') do
+  assert_pack "C*", "\x00\x01\x7F\x80\xFF", [0, 1, 127, 128, 255]
+end
+
+assert('pack("a")') do
+  assert_equal "a", ["abc"].pack("a")
+  assert_equal "abc", ["abc"].pack("a*")
+  assert_equal "abc\0", ["abc"].pack("a4")
+
+  assert_equal ["abc\0"], "abc\0".unpack("a4")
+  assert_equal ["abc "], "abc ".unpack("a4")
+end
+
+assert('pack("A")') do
+  assert_equal "a", ["abc"].pack("A")
+  assert_equal "abc", ["abc"].pack("A*")
+  assert_equal "abc ", ["abc"].pack("A4")
+
+  assert_equal ["abc"], "abc\0".unpack("A4")
+  assert_equal ["abc"], "abc ".unpack("A4")
+end
+
+# regression tests
+assert('issue #1') do
+  assert_equal "\000\001\000\002", [1, 2].pack("nn")
+end
+
+assert 'pack float' do
+  skip unless Object.const_defined?(:Float)
+  assert_pack 'e', "\x00\x00@@", [3.0]
+  assert_pack 'g', "@@\x00\x00", [3.0]
+
+  if PACK_IS_LITTLE_ENDIAN
+    assert_pack 'f', "\x00\x00@@", [3.0]
+    assert_pack 'F', "\x00\x00@@", [3.0]
+  else
+    assert_pack 'f', "@@\x00\x00", [3.0]
+    assert_pack 'F', "@@\x00\x00", [3.0]
+  end
+end
+
+assert 'pack double' do
+  skip unless Object.const_defined?(:Float)
+  assert_pack 'E', "\x00\x00\x00\x00\x00\x00\b@", [3.0]
+  assert_pack 'G', "@\b\x00\x00\x00\x00\x00\x00", [3.0]
+
+  if PACK_IS_LITTLE_ENDIAN
+    assert_pack 'd', "\x00\x00\x00\x00\x00\x00\b@", [3.0]
+    assert_pack 'D', "\x00\x00\x00\x00\x00\x00\b@", [3.0]
+  else
+    assert_pack 'd', "@\b\x00\x00\x00\x00\x00\x00", [3.0]
+    assert_pack 'D', "@\b\x00\x00\x00\x00\x00\x00", [3.0]
+  end
+end
+
+assert 'pack/unpack "i"' do
+  int_size = [0].pack('i').size
+  raise "pack('i').size is too small (#{int_size})" if int_size < 2
+
+  if PACK_IS_LITTLE_ENDIAN
+    str = "\xC7\xCF" + "\xFF" * (int_size-2)
+  else
+    str = "\xFF" * (int_size-2) + "\xCF\xC7"
+  end
+  assert_pack 'i', str, [-12345]
+end
+
+assert 'pack/unpack "I"' do
+  uint_size = [0].pack('I').size
+  raise "pack('I').size is too small (#{uint_size})" if uint_size < 2
+
+  if PACK_IS_LITTLE_ENDIAN
+    str = "\x39\x30" + "\0" * (uint_size-2)
+  else
+    str = "\0" * (uint_size-2) + "\x30\x39"
+  end
+  assert_pack 'I', str, [12345]
+end
+
+assert 'pack/unpack "w"' do
+  for x in [0,1,127,128,16383,16384,65535,65536]
+    assert_equal [x], [x].pack("w").unpack("w")
+  end
+end
+
+assert 'pack/unpack "U"' do
+  assert_equal [], "".unpack("U")
+  assert_equal [], "".unpack("U*")
+  assert_equal [65, 66], "ABC".unpack("U2")
+  assert_equal [12371, 12435, 12395, 12385, 12399, 19990, 30028], "こんにちは世界".unpack("U*")
+
+  assert_equal "", [].pack("U")
+  assert_equal "", [].pack("U*")
+  assert_equal "AB", [65, 66, 67].pack("U2")
+  assert_equal "こんにちは世界", [12371, 12435, 12395, 12385, 12399, 19990, 30028].pack("U*")
+
+  assert_equal "\000", [0].pack("U")
+
+  assert_raise(RangeError) { [-0x40000000].pack("U") }
+  assert_raise(RangeError) { [-1].pack("U") }
+  assert_raise(RangeError) { [0x40000000].pack("U") }
+end
+
+assert 'unpack1' do
+  d = 1234
+  assert_equal(d, [d].pack("i").unpack1("i"))
+  d = "foobar"
+  assert_equal(d, [d].pack("a*").unpack1("a*"))
+  assert_equal(d, [d].pack("A*").unpack1("A*"))
+  assert_equal(d, [d].pack("Z*").unpack1("Z*"))
+  assert_equal(d, [d].pack("m").unpack1("m"))
+  assert_equal(d, [d].pack("M").unpack1("M"))
+  d = "10010101"
+  assert_equal(d, [d].pack("b*").unpack1("b*"))
+  d = "f00b00"
+  assert_equal(d, [d].pack("h*").unpack1("h*"))
+end

data/ext/enclave/mruby/mrbgems/mruby-proc-binding/README.md

@@ -0,0 +1,140 @@
+# mruby-proc-binding
+
+This mrbgem provides a `binding` method for `Proc` objects in mruby. This method returns a `Binding` object, which allows you to inspect and manipulate the lexical scope (local variables and `self`) of the `Proc` from which it was obtained.
+
+## Usage Examples
+
+Here's how you can use `mruby-proc-binding`:
+
+### Getting a Binding
+
+First, obtain a `Binding` object from a `Proc`:
+
+```ruby
+def create_proc
+  a = 10
+  b = 20
+  ->(c) { a + b + c } # A sample proc
+end
+
+my_proc = create_proc
+# Create a proc that takes one argument (c) and closes over a and b.
+# Note: For the binding to capture local variables like 'a' and 'b',
+# they must be referenced by a Proc defined in the same scope.
+# A simple `proc {}` or `->{}` might not capture them as expected
+# unless they are used within that proc.
+# To ensure 'a' and 'b' are part of the environment captured by the binding
+# from `my_proc.binding`, we ensure `my_proc` itself uses them or is defined
+# in a scope where they are present and then `binding` is called on a proc
+# that has access to this environment.
+
+# Let's define a new proc specifically for getting a binding
+# that captures the desired local variables.
+local_var_scope_proc = nil
+a_val = 1
+b_val = 2
+local_var_scope_proc = -> {
+  # 'a_val' and 'b_val' are now in this proc's lexical scope
+}
+bind = local_var_scope_proc.binding
+```
+
+### Inspecting Local Variables
+
+You can list the names of local variables within the proc's scope:
+
+```ruby
+# Continuing from the previous example:
+# Variables 'a_val', 'b_val', and 'local_var_scope_proc' are expected.
+p bind.local_variables
+# Expected output (order may vary):
+# => [:a_val, :b_val, :local_var_scope_proc, :bind]
+# Note: The binding itself and other variables defined in the
+# same scope might also be listed.
+```
+
+### Getting Local Variable Values
+
+Retrieve the value of a specific local variable:
+
+```ruby
+p bind.local_variable_get(:a_val)  # => 1
+p bind.local_variable_get(:b_val)  # => 2
+```
+
+### Setting Local Variable Values
+
+You can also modify the values of local variables within the binding's scope:
+
+```ruby
+bind.local_variable_set(:a_val, 100)
+p bind.local_variable_get(:a_val)  # => 100
+
+# This also affects evaluation within the binding
+p bind.eval("a_val + b_val")          # => 102 (100 + 2)
+```
+
+### Evaluating Code
+
+Execute arbitrary Ruby code within the binding's context:
+
+```ruby
+# Define some variables in a scope
+def get_binding_for_eval
+  x = 5
+  y = 10
+  proc {}.binding # Create a binding in this scope
+end
+
+eval_bind = get_binding_for_eval
+p eval_bind.eval("x * y")      # => 50
+p eval_bind.eval("self")       # Shows the receiver of the proc
+```
+
+### Getting Source Location
+
+If `mruby-proc-ext` is also available, you can get the source location of a proc:
+
+```ruby
+# Assuming __FILE__ is "test.rb" and this line is line 50
+my_lambda = -> { } # This proc is defined at [__FILE__, __LINE__]
+location_binding = my_lambda.binding
+
+# This requires mruby-proc-ext
+if location_binding.respond_to?(:source_location)
+  p location_binding.source_location # => ["test.rb", 50] (approximately)
+else
+  puts "Binding#source_location not available. Is mruby-proc-ext included?"
+end
+```
+
+A more robust example for capturing variables for `Proc#binding`:
+
+```ruby
+def execution_binding
+  name = "Ruby"
+  # The proc must be created in the scope where variables exist
+  # and it doesn't necessarily need to *use* them for them to be available in the binding.
+  # However, the most reliable way to ensure they are part of the environment
+  # is if the proc is created in that environment.
+  binding_proc = proc {} # This proc is created in the current scope
+  binding_proc.binding   # Returns a binding for this scope
+end
+
+b = execution_binding
+p b.local_variables.sort  # => [:b, :binding_proc, :name] (or similar)
+p b.local_variable_get(:name) # => "Ruby"
+b.local_variable_set(:name, "mruby")
+p b.eval("name") # => "mruby"
+```
+
+## Dependencies
+
+This mrbgem has the following dependencies:
+
+- **`mruby-binding`**: Provides the core `Binding` object functionality. This gem is a prerequisite.
+- **`mruby-proc-ext`**: Required for the `Binding#source_location` method. If `mruby-proc-ext` is not included in your mruby build, the `source_location` method may not be available on binding objects, or it might return `nil`.
+
+## License
+
+MIT

data/ext/enclave/mruby/mrbgems/mruby-proc-binding/mrbgem.rake

@@ -0,0 +1,10 @@
+MRuby::Gem::Specification.new('mruby-proc-binding') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'Proc#binding method'
+
+  spec.add_dependency('mruby-binding', :core => 'mruby-binding')
+  spec.add_dependency('mruby-proc-ext', :core => 'mruby-proc-ext')
+  spec.add_test_dependency('mruby-eval', :core => 'mruby-eval')
+  spec.add_test_dependency('mruby-compiler', :core => 'mruby-compiler')
+end

data/ext/enclave/mruby/mrbgems/mruby-proc-binding/src/proc_binding.c

@@ -0,0 +1,76 @@
+#include <mruby.h>
+#include <mruby/presym.h>
+#include <mruby/proc.h>
+#include <mruby/variable.h>
+
+/* provided by mruby-proc-ext */
+mrb_value mrb_proc_source_location(mrb_state *mrb, const struct RProc *p);
+
+/* provided by mruby-binding */
+mrb_value mrb_binding_new(mrb_state *mrb, const struct RProc *proc, mrb_value recv, struct REnv *env);
+
+/*
+ * call-seq:
+ *   prc.binding -> binding
+ *
+ * Returns a Binding object, which is the execution context that the proc
+ * was defined in. The returned binding retains the context in which the
+ * proc was created, including local variables, methods, and constants.
+ *
+ *   def fred(param)
+ *     proc {}
+ *   end
+ *
+ *   b = fred(99).binding
+ *   b.eval("param")   #=> 99
+ *   b.eval("param = 1")
+ *   b.eval("param")   #=> 1
+ *
+ *   # Local variables in the binding's scope
+ *   p = proc { |x| x + 1 }
+ *   a, b, c = 1, 2, 3
+ *   bind = p.binding
+ *   bind.local_variables  #=> [:a, :b, :bind, :c, :p]
+ */
+static mrb_value
+mrb_proc_binding(mrb_state *mrb, mrb_value procval)
+{
+  const struct RProc *proc = mrb_proc_ptr(procval);
+  struct REnv *env;
+  mrb_value receiver;
+
+  if (!proc || MRB_PROC_CFUNC_P(proc) || !proc->upper || MRB_PROC_CFUNC_P(proc->upper)) {
+    env = NULL;
+    proc = NULL;
+    receiver = mrb_nil_value();
+  }
+  else {
+    env = MRB_PROC_ENV(proc);
+    mrb_assert(env);
+    proc = proc->upper;
+    receiver = MRB_ENV_LEN(env) > 0 ? env->stack[0] : mrb_nil_value();
+  }
+
+  mrb_value binding = mrb_binding_new(mrb, proc, receiver, env);
+  mrb_iv_set(mrb, binding, MRB_SYM(source_location), mrb_proc_source_location(mrb, mrb_proc_ptr(procval)));
+  return binding;
+}
+
+/*
+ * Initializes the mruby-proc-binding gem by adding the binding method
+ * to the Proc class. This allows any proc object to return its execution
+ * context as a Binding object.
+ *
+ * The binding method takes no arguments and returns a Binding object
+ * that captures the lexical environment where the proc was created.
+ */
+void
+mrb_mruby_proc_binding_gem_init(mrb_state *mrb)
+{
+  mrb_define_method_id(mrb, mrb->proc_class, MRB_SYM(binding), mrb_proc_binding, MRB_ARGS_NONE());
+}
+
+void
+mrb_mruby_proc_binding_gem_final(mrb_state *mrb)
+{
+}

data/ext/enclave/mruby/mrbgems/mruby-proc-binding/test/proc_binding.c

@@ -0,0 +1,14 @@
+#include <mruby.h>
+#include <mruby/compile.h>
+
+static mrb_value
+proc_in_c(mrb_state *mrb, mrb_value self)
+{
+  return mrb_load_string(mrb, "proc { |a, b| a + b }");
+}
+
+void
+mrb_mruby_proc_binding_gem_test(mrb_state *mrb)
+{
+  mrb_define_method(mrb, mrb->object_class, "proc_in_c", proc_in_c, MRB_ARGS_NONE());
+}

data/ext/enclave/mruby/mrbgems/mruby-proc-binding/test/proc_binding.rb

@@ -0,0 +1,22 @@
+assert "Proc#binding" do
+  block = ->(i) {}
+  a, b, c = 1, 2, 3
+  bind = block.binding
+  assert_equal([:a, :b, :bind, :block, :c], bind.local_variables.sort)
+  assert_equal(1, bind.local_variable_get(:a))
+  assert_equal(5, bind.eval("b + c"))
+  bind.local_variable_set(:x, 9)
+  assert_equal(9, bind.local_variable_get(:x))
+end
+
+assert("Binding#source_location after Proc#binding") do
+  skip unless -> {}.source_location
+
+  block, source_location = -> {}, [__FILE__, __LINE__]
+  assert_equal source_location, block.binding.source_location
+end
+
+assert "Proc#binding and .eval from C" do
+  bind = proc_in_c.binding
+  assert_nothing_raised { bind.eval("self") }
+end

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

@@ -0,0 +1,107 @@
+# mruby-proc-ext
+
+This mrbgem extends the functionality of the `Proc` class in mruby, providing additional methods for common operations and introspection.
+
+## Features
+
+This gem adds the following methods to the `Proc` class:
+
+- **`===`**: Alias for `Proc#call`. Allows procs to be used in `case` statements.
+
+  ```ruby
+  upcase_proc = ->(s) { s.upcase }
+  case "hello"
+  when upcase_proc
+    # this won't match directly, but demonstrates usage if proc returned boolean
+  end
+  # More practically:
+  is_even = ->(n) { n % 2 == 0 }
+  puts "4 is even" if is_even === 4 # => true
+  ```
+
+- **`yield`**: Alias for `Proc#call`.
+
+  ```ruby
+  add_one = ->(x) { x + 1 }
+  puts add_one.yield(5) # => 6
+  ```
+
+- **`to_proc`**: Returns `self`. Useful for methods expecting a proc.
+
+  ```ruby
+  p = Proc.new { |x| x * 2 }
+  [1, 2, 3].map(&p.to_proc) # => [2, 4, 6]
+  ```
+
+- **`curry(arity=self.arity)`**: Returns a curried proc.
+
+  ```ruby
+  adder = ->(a, b, c) { a + b + c }
+  curried_adder = adder.curry
+  add5 = curried_adder.call(2, 3)
+  puts add5.call(4) # => 9
+
+  mul = ->(x,y) { x * y }
+  mul_by_5 = mul.curry.call(5)
+  puts mul_by_5.call(3) # => 15
+  ```
+
+- **`<< (composition)`**: Returns a new proc that represents the composition of two procs (g << f is g(f(x))).
+
+  ```ruby
+  add_one = ->(x) { x + 1 }
+  double_it = ->(x) { x * 2 }
+  composed_proc = double_it << add_one # double_it(add_one(x))
+  puts composed_proc.call(5) # => double_it(6) => 12
+  ```
+
+- **`>> (composition)`**: Returns a new proc that represents the composition of two procs (f >> g is g(f(x))).
+
+  ```ruby
+  add_one = ->(x) { x + 1 }
+  double_it = ->(x) { x * 2 }
+  composed_proc = add_one >> double_it # double_it(add_one(x))
+  puts composed_proc.call(5) # => double_it(6) => 12
+  ```
+
+- **`lambda?`**: Returns `true` if the proc is a lambda, `false` otherwise.
+
+  ```ruby
+  my_lambda = -> {}
+  my_proc = Proc.new {}
+  puts my_lambda.lambda? # => true
+  puts my_proc.lambda?  # => false
+  ```
+
+- **`source_location`**: Returns an array containing the source filename and line number where the proc was defined, or `nil` if this information is not available.
+
+  ```ruby
+  # Assuming this code is in "test.rb" at line 5
+  my_proc = Proc.new {}
+  p my_proc.source_location # => ["test.rb", 5] (if debug info enabled)
+  ```
+
+- **`inspect`**: Returns a string containing a human-readable representation of the proc, including its source location (if available) and whether it's a lambda.
+
+  ```ruby
+  my_lambda = ->(x) { x * 2 }
+  # Might output: #<Proc:0x... test.rb:1 (lambda)>
+  puts my_lambda.inspect
+  ```
+
+- **`parameters`**: Returns an array of arrays, describing the parameters accepted by the proc. Each inner array contains the parameter type (`:req`, `:opt`, `:rest`, `:key`, `:keyrest`, `:block`) and its name.
+
+  ```ruby
+  prc = ->(a, b=20, *rest, keyparam:, &blk) { }
+  p prc.parameters
+  # => [[:req, :a], [:opt, :b], [:rest, :rest], [:keyreq, :keyparam], [:block, :blk]]
+  ```
+
+This gem also adds:
+
+- **`Kernel#proc`**: Creates a new proc from a block. This is similar to `Proc.new` but ensures the created proc is not a lambda.
+
+  ```ruby
+  p1 = proc { |a| a }
+  puts p1.lambda? # => false
+  ```

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

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