enclave 0.1.0

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

@@ -0,0 +1,303 @@
+##
+# Struct ISO Test
+
+assert('Struct', '15.2.18') do
+  assert_equal Class, Struct.class
+end
+
+assert('Struct.new', '15.2.18.3.1') do
+  c = Struct.new(:m1, :m2)
+  assert_equal Struct, c.superclass
+  assert_equal [:m1, :m2], c.members
+end
+
+assert('Struct#==', '15.2.18.4.1') do
+  c = Struct.new(:m1, :m2)
+  cc1 = c.new(1,2)
+  cc2 = c.new(1,2)
+  assert_true cc1 == cc2
+
+  Struct.new(:m1, :m2) { def foo; end }
+  assert_raise(NoMethodError) { Struct.new(:m1).new.foo }
+end
+
+assert('Struct#[]', '15.2.18.4.2') do
+  c = Struct.new(:m1, :m2)
+  cc = c.new(1,2)
+  assert_equal 1, cc[:m1]
+  assert_equal 2, cc["m2"]
+  assert_equal 1, cc[0]
+  assert_equal 2, cc[-1]
+  assert_raise(TypeError) { cc[[]] }
+  assert_raise(IndexError) { cc[2] }
+  assert_raise(NameError) { cc['tama'] }
+end
+
+assert('Struct#[]=', '15.2.18.4.3') do
+  c = Struct.new(:m1, :m2)
+  cc = c.new(1,2)
+  cc[:m1] = 3
+  assert_equal 3, cc[:m1]
+  cc["m2"] = 3
+  assert_equal 3, cc["m2"]
+  cc[0] = 4
+  assert_equal 4, cc[0]
+  cc[-1] = 5
+  assert_equal 5, cc[-1]
+  assert_raise(TypeError) { cc[[]] = 3 }
+  assert_raise(IndexError) { cc[2] = 7 }
+  assert_raise(NameError) { cc['pochi'] = 8 }
+end
+
+assert('Struct#each', '15.2.18.4.4') do
+  c = Struct.new(:m1, :m2)
+  cc = c.new(1,2)
+  a = []
+  cc.each{|x|
+    a << x
+  }
+  assert_equal [1, 2], a
+end
+
+assert('Struct#each_pair', '15.2.18.4.5') do
+  c = Struct.new(:m1, :m2)
+  cc = c.new(1,2)
+  a = []
+  cc.each_pair{|k,v|
+    a << [k,v]
+  }
+  assert_equal [[:m1, 1], [:m2, 2]], a
+end
+
+assert('Struct#members', '15.2.18.4.6') do
+  c = Struct.new(:m1, :m2)
+  assert_equal [:m1, :m2], c.new(1,2).members
+end
+
+assert('Struct#select', '15.2.18.4.7') do
+  c = Struct.new(:m1, :m2)
+  assert_equal([2]) { c.new(1,2).select{|v| v % 2 == 0} }
+end
+
+assert('large struct') do
+  c = Struct.new(:m1, :m2, :m3, :m4, :m5, :m6, :m7, :m8, :m9, :m10, :m11, :m12, :m13)
+  cc = c.new(1,2,3,4,5,6,7,8,9,10,11,12,13)
+  assert_equal 1, cc.m1
+  assert_equal 2, cc.m2
+  assert_equal 3, cc.m3
+  assert_equal 4, cc.m4
+  assert_equal 5, cc.m5
+  assert_equal 6, cc.m6
+  assert_equal 7, cc.m7
+  assert_equal 8, cc.m8
+  assert_equal 9, cc.m9
+  assert_equal 10, cc.m10
+  assert_equal 13, cc.m13
+
+  cc.m13 = 'test'
+  assert_equal 'test', cc.m13
+
+  assert_raise(NoMethodError) { cc.m14 }
+end
+
+assert('wrong struct arg count') do
+  c = Struct.new(:m1)
+  assert_raise ArgumentError do
+    cc = c.new(1,2,3)
+  end
+end
+
+assert('struct dup') do
+  c = Struct.new(:m1, :m2, :m3, :m4, :m5)
+  cc = c.new(1,2,3,4,5)
+  assert_nothing_raised {
+    assert_equal(cc, cc.dup)
+  }
+end
+
+assert('struct inspect') do
+  c = Struct.new(:m1, :m2, :m3, :m4, :m5, :recur)
+  cc = c.new(1,2,3,4,5,nil)
+  cc.recur = cc
+  assert_equal "#<struct m1=1, m2=2, m3=3, m4=4, m5=5, recur=#<struct ...>>", cc.inspect
+end
+
+assert('Struct#length, Struct#size') do
+  s = Struct.new(:f1, :f2).new(0, 1)
+  assert_equal 2, s.size
+  assert_equal 2, s.length
+end
+
+assert('Struct#to_a, Struct#values') do
+  s = Struct.new(:mem1, :mem2).new('a', 'b')
+  assert_equal ['a', 'b'], s.to_a
+  assert_equal ['a', 'b'], s.values
+end
+
+assert('Struct#to_h') do
+  s = Struct.new(:white, :red, :green).new('ruuko', 'yuzuki', 'hitoe')
+  assert_equal({:white => 'ruuko', :red => 'yuzuki', :green => 'hitoe'}) { s.to_h }
+end
+
+assert('Struct#values_at') do
+  a = Struct.new(:blue, :purple).new('aki', 'io')
+  assert_equal ['aki'], a.values_at(0)
+  assert_equal ['io', 'aki'], a.values_at(1, 0)
+  assert_raise(IndexError) { a.values_at 2 }
+end
+
+assert("Struct#dig") do
+  a = Struct.new(:blue, :purple).new('aki', Struct.new(:red).new(1))
+  assert_equal 'aki', a.dig(:blue)
+  assert_equal 1, a.dig(:purple, :red)
+  assert_equal 1, a.dig(1, 0)
+end
+
+# TODO: suppress redefining Struct warning during test
+# assert("Struct.new removes existing constant") do
+#   begin
+#     assert_not_equal Struct.new("Test", :a), Struct.new("Test", :a, :b)
+#   ensure
+#     Struct.remove_const :Test
+#   end
+# end
+
+assert("Struct#initialize_copy requires struct to be the same type") do
+  begin
+    Struct.new("Test", :a)
+    a = Struct::Test.new("a")
+    Struct.__send__(:remove_const,:Test)
+    Struct.new("Test", :a, :b)
+    assert_raise(TypeError) do
+      a.__send__(:initialize_copy, Struct::Test.new("a", "b"))
+    end
+  ensure
+    Struct.__send__(:remove_const,:Test)
+  end
+end
+
+assert("Struct.new does not allow array") do
+  assert_raise(TypeError) do
+    Struct.new("Test", [:a])
+  end
+end
+
+assert("Struct.new does not allow invalid class name") do
+  assert_raise(NameError) { Struct.new("Test-", :a) }
+end
+
+assert("Struct.new generates subclass of Struct") do
+  begin
+    original_struct = Struct
+    Struct = String
+    assert_equal original_struct, original_struct.new(:foo).superclass
+  ensure
+    Struct = original_struct
+  end
+end
+
+assert 'Struct#freeze' do
+  c = Struct.new(:m)
+
+  o = c.new
+  o.m = :test
+  assert_equal :test, o.m
+
+  o.freeze
+  assert_raise(FrozenError) { o.m = :modify }
+  assert_raise(FrozenError) { o[:m] = :modify }
+  assert_equal :test, o.m
+end
+
+assert 'method visibility with Struct' do
+  c = Struct.new(:r, :g, :b) do
+    def good!
+      "GOOD!"
+    end
+
+    private
+    def bad!
+      "BAD!"
+    end
+  end
+
+  assert_equal "GOOD!" do
+    c.new.good!
+  end
+
+  assert_raise NoMethodError do
+    c.new.bad!
+  end
+end
+
+assert "Struct initialize with keyword arguments" do
+  c = Struct.new(:foo, :bar)
+
+  o = c.new(foo: 1, bar: 2)
+  assert_equal 1, o.foo
+  assert_equal 2, o.bar
+
+  o2 = c.new(bar: 1, foo: 2)
+  assert_equal 2, o2.foo
+  assert_equal 1, o2.bar
+
+  o3 = c.new(foo: :test)
+  assert_equal :test, o3.foo
+  assert_equal nil, o3.bar
+
+  o4 = c.new
+  assert_equal nil, o4.foo
+  assert_equal nil, o4.bar
+
+  assert_raise_with_message_pattern(ArgumentError, "unknown keywords: roo, baq") do
+    c.new(foo: 1, roo: nil, baq: :test)
+  end
+end
+
+assert "Struct initialize when :keyword_init is true" do
+  c = Struct.new(:foo, :bar, keyword_init: true)
+
+  o = c.new(foo: 1, bar: 2)
+  assert_equal 1, o.foo
+  assert_equal 2, o.bar
+
+  o2 = c.new
+  assert_equal nil, o2.foo
+  assert_equal nil, o2.bar
+
+  assert_raise(ArgumentError) do
+    c.new(1, 2)
+  end
+
+  assert_raise(ArgumentError) do
+    c.new({foo: 1}, {bar: 2})
+  end
+end
+
+assert "Struct initialize when :keyword_init is false" do
+  c = Struct.new(:foo, :bar, keyword_init: false)
+
+  o = c.new(1, 2)
+  assert_equal 1, o.foo
+  assert_equal 2, o.bar
+
+  o2 = c.new(foo: 1, bar: 2)
+  assert_equal({foo: 1, bar: 2}, o2.foo)
+  assert_equal nil, o2.bar
+
+  o3 = c.new
+  assert_equal nil, o3.foo
+  assert_equal nil, o3.bar
+end
+
+assert "Struct initialize when :keyword_init is non-boolean value (treat as true)" do
+  c = Struct.new(:foo, :bar, keyword_init: 12)
+
+  o = c.new(foo: 1, bar: 2)
+  assert_equal 1, o.foo
+  assert_equal 2, o.bar
+
+  assert_raise(ArgumentError) do
+    c.new(1, 2)
+  end
+end

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

@@ -0,0 +1,50 @@
+# mruby-symbol-ext
+
+This gem extends mruby's `Symbol` class with additional useful methods.
+
+## Methods
+
+Here are the methods added to the `Symbol` class:
+
+### `capitalize`
+
+- **call-seq:** `sym.capitalize  -> symbol`
+- Returns a new symbol with the first character converted to uppercase and the remainder to lowercase. Equivalent to `sym.to_s.capitalize.intern`.
+
+### `downcase`
+
+- **call-seq:** `sym.downcase  -> symbol`
+- Returns a new symbol with all characters converted to lowercase. Equivalent to `sym.to_s.downcase.intern`.
+
+### `upcase`
+
+- **call-seq:** `sym.upcase    -> symbol`
+- Returns a new symbol with all characters converted to uppercase. Equivalent to `sym.to_s.upcase.intern`.
+
+### `casecmp(other_symbol)`
+
+- **call-seq:** `sym.casecmp(other)  -> -1, 0, +1 or nil`
+- Performs a case-insensitive comparison between two symbols. Returns -1, 0, or +1 if `other_symbol` is a symbol. Returns `nil` if `other_symbol` is not a symbol.
+
+### `casecmp?(other_symbol)`
+
+- **call-seq:** `sym.casecmp?(other)  -> true, false, or nil`
+- Returns `true` if the receiver and `other_symbol` are equal after case folding, `false` if they are not equal. Returns `nil` if `other_symbol` is not a symbol.
+
+### `empty?`
+
+- **call-seq:** `sym.empty?   -> true or false`
+- Returns `true` if the symbol's string representation is empty (i.e., `:""`), `false` otherwise.
+
+### `length` / `size`
+
+- **call-seq:**
+  - `sym.length    -> integer`
+  - `sym.size      -> integer`
+- Returns the length of the symbol's string representation. `size` is an alias for `length`.
+
+### `Symbol.all_symbols` (Conditional)
+
+- **call-seq:** `Symbol.all_symbols    => array`
+- Returns an array of all symbols currently in mruby's symbol table.
+- **Note:** This method is only available if mruby is compiled with the `MRB_USE_ALL_SYMBOLS` define.

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

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

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

@@ -0,0 +1,72 @@
+class Symbol
+  include Comparable
+
+  alias intern to_sym
+
+  ##
+  # call-seq:
+  #   sym.capitalize  -> symbol
+  #
+  # Same as `sym.to_s.capitalize.intern`.
+
+  def capitalize
+    (self.to_s.capitalize! || self).to_sym
+  end
+
+  ##
+  # call-seq:
+  #   sym.downcase  -> symbol
+  #
+  # Same as `sym.to_s.downcase.intern`.
+
+  def downcase
+    (self.to_s.downcase! || self).to_sym
+  end
+
+  ##
+  # call-seq:
+  #   sym.upcase    -> symbol
+  #
+  # Same as `sym.to_s.upcase.intern`.
+
+  def upcase
+    (self.to_s.upcase! || self).to_sym
+  end
+
+  ##
+  # call-seq:
+  #   sym.casecmp(other)  -> -1, 0, +1 or nil
+  #
+  # Case-insensitive version of `Symbol#<=>`.
+
+  def casecmp(other)
+    return nil unless other.kind_of?(Symbol)
+    lhs =  self.to_s; lhs.upcase!
+    rhs = other.to_s.upcase
+    lhs <=> rhs
+  end
+
+  ##
+  # call-seq:
+  #   sym.casecmp?(other)  -> true, false, or nil
+  #
+  # Returns true if sym and other_sym are equal after case folding,
+  # false if they are not equal, and nil if other_sym is not a string.
+
+  def casecmp?(sym)
+    c = self.casecmp(sym)
+    return nil if c.nil?
+    return c == 0
+  end
+
+  #
+  # call-seq:
+  #   sym.empty?   -> true or false
+  #
+  # Returns that _sym_ is :"" or not.
+
+  def empty?
+    self.length == 0
+  end
+
+end

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

@@ -0,0 +1,79 @@
+#include <mruby.h>
+#include <mruby/array.h>
+#include <mruby/class.h>
+#include <mruby/string.h>
+#include <mruby/internal.h>
+#include <mruby/presym.h>
+
+/*
+ *  call-seq:
+ *     Symbol.all_symbols    => array
+ *
+ *  Returns an array of all the symbols currently in Ruby's symbol
+ *  table.
+ *
+ *     Symbol.all_symbols.size    #=> 903
+ *     Symbol.all_symbols[1,20]   #=> [:floor, :ARGV, :Binding, :symlink,
+ *                                     :chown, :EOFError, :$;, :String,
+ *                                     :LOCK_SH, :"setuid?", :$<,
+ *                                     :default_proc, :compact, :extend,
+ *                                     :Tms, :getwd, :$=, :ThreadGroup,
+ *                                     :wait2, :$>]
+ */
+#ifdef MRB_USE_ALL_SYMBOLS
+static mrb_value
+mrb_sym_all_symbols(mrb_state *mrb, mrb_value self)
+{
+  mrb_value ary = mrb_ary_new_capa(mrb, mrb->symidx);
+
+  for (mrb_sym i=1; i<=MRB_PRESYM_MAX; i++) {
+    mrb_ary_push(mrb, ary, mrb_symbol_value(i));
+  }
+  mrb_sym lim = mrb->symidx + 1;
+  for (mrb_sym i=1; i<lim; i++) {
+    mrb_ary_push(mrb, ary, mrb_symbol_value(i+MRB_PRESYM_MAX));
+  }
+
+  return ary;
+}
+#endif
+
+/*
+ * call-seq:
+ *   sym.length    -> integer
+ *
+ * Same as `sym.to_s.length`.
+ */
+static mrb_value
+mrb_sym_length(mrb_state *mrb, mrb_value self)
+{
+  mrb_int len;
+#ifdef MRB_UTF8_STRING
+  mrb_int byte_len;
+  const char *name = mrb_sym_name_len(mrb, mrb_symbol(self), &byte_len);
+  len = mrb_utf8_strlen(name, byte_len);
+#else
+  mrb_sym_name_len(mrb, mrb_symbol(self), &len);
+#endif
+  return mrb_fixnum_value(len);
+}
+
+static const mrb_mt_entry symbol_ext_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_sym_length, MRB_SYM(length), MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(mrb_sym_length, MRB_SYM(size), MRB_ARGS_NONE()),
+};
+
+void
+mrb_mruby_symbol_ext_gem_init(mrb_state* mrb)
+{
+  struct RClass *s = mrb->symbol_class;
+#ifdef MRB_USE_ALL_SYMBOLS
+  mrb_define_class_method_id(mrb, s, MRB_SYM(all_symbols), mrb_sym_all_symbols, MRB_ARGS_NONE());
+#endif
+  MRB_MT_INIT_ROM(mrb, s, symbol_ext_rom_entries);
+}
+
+void
+mrb_mruby_symbol_ext_gem_final(mrb_state* mrb)
+{
+}

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

@@ -0,0 +1,55 @@
+##
+# Symbol(Ext) Test
+
+if Symbol.respond_to?(:all_symbols)
+  assert('Symbol.all_symbols') do
+    foo = [:__symbol_test_1, :__symbol_test_2, :__symbol_test_3].sort
+    symbols = Symbol.all_symbols.select{|sym|sym.to_s.include? '__symbol_test'}.sort
+    assert_equal foo, symbols
+  end
+end
+
+%w[size length].each do |n|
+  assert("Symbol##{n}") do
+    assert_equal 5, :hello.__send__(n)
+    assert_equal 4, :"aA\0b".__send__(n)
+    if __ENCODING__ == "UTF-8"
+      assert_equal 8, :"こんにちは世界!".__send__(n)
+      assert_equal 4, :"aあ\0b".__send__(n)
+    else
+      assert_equal 22, :"こんにちは世界!".__send__(n)
+      assert_equal 6, :"aあ\0b".__send__(n)
+    end
+  end
+end
+
+assert("Symbol#capitalize") do
+  assert_equal :Hello, :hello.capitalize
+  assert_equal :Hello, :HELLO.capitalize
+  assert_equal :Hello, :Hello.capitalize
+end
+
+assert("Symbol#downcase") do
+  assert_equal :hello, :hEllO.downcase
+  assert_equal :hello, :hello.downcase
+end
+
+assert("Symbol#upcase") do
+  assert_equal :HELLO, :hEllO.upcase
+  assert_equal :HELLO, :HELLO.upcase
+end
+
+assert("Symbol#casecmp") do
+  assert_equal 0, :HELLO.casecmp(:hEllO)
+  assert_equal 1, :HELLO.casecmp(:hEllN)
+  assert_equal(-1, :HELLO.casecmp(:hEllP))
+  assert_nil :HELLO.casecmp("hEllO")
+end
+
+assert("Symbol#empty?") do
+  assert_false :'a'.empty?
+end
+
+assert('Symbol#intern') do
+  assert_equal :test, :test.intern
+end