enclave 0.1.0

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

@@ -0,0 +1,151 @@
+##
+# Random Test
+
+assert("Random.new") do
+  r1 = Random.new(123)
+  r2 = Random.new(123)
+  r3 = Random.new(124)
+  assert_equal(r1.rand, r2.rand)
+  assert_not_equal(r1.rand, r3.rand)
+end
+
+assert("Kernel#srand") do
+  srand(234)
+  r1 = rand
+  srand(234)
+  r2 = rand
+  srand(235)
+  r3 = rand
+  assert_equal(r1, r2)
+  assert_not_equal(r1, r3)
+end
+
+assert("Random.srand") do
+  Random.srand(345)
+  r1 = rand
+  srand(345)
+  r2 = Random.rand
+  Random.srand(346)
+  r3 = rand
+  assert_equal(r1, r2)
+  assert_not_equal(r1, r3)
+end
+
+assert("Random#bytes") do
+  r = Random.new(10)
+  num = 11
+  a = r.bytes(num)
+  assert_kind_of String, a
+  assert_equal num, a.bytesize
+  b = r.bytes(num)
+  assert_kind_of String, b
+  assert_equal num, b.bytesize
+  assert_not_equal a, b
+  b = r.bytes(num / 2)
+  assert_equal num / 2, b.bytesize
+end
+
+assert("return class of Kernel#rand") do
+  assert_kind_of(Integer, rand(3))
+  assert_kind_of(Integer, rand(1.5))
+  skip unless Object.const_defined?(:Float)
+  assert_kind_of(Float, rand)
+  assert_kind_of(Float, rand(0.5))
+end
+
+assert("Array#shuffle") do
+  orig = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  ary = orig.dup
+  shuffled = ary.shuffle
+  assert_equal(orig, ary)
+  assert_not_equal(ary, shuffled)
+  assert_equal(orig, shuffled.sort)
+end
+
+assert('Array#shuffle!') do
+  orig = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  ary = orig.dup
+  assert_same(ary, ary.shuffle!)
+  assert_not_equal(orig, ary)
+  assert_equal(orig, ary.sort)
+end
+
+assert("Array#shuffle(random)") do
+  assert_raise(TypeError) do
+    # this will cause an exception due to the wrong argument
+    [1, 2].shuffle(random: "Not a Random instance")
+  end
+
+  # verify that the same seed causes the same results
+  ary = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  shuffled1 = ary.shuffle(random: Random.new(345))
+  shuffled2 = ary.shuffle(random: Random.new(345))
+  shuffled3 = ary.shuffle(random: Random.new(346))
+  assert_equal(shuffled1, shuffled2)
+  assert_not_equal(shuffled1, shuffled3)
+end
+
+assert('Array#shuffle!(random)') do
+  assert_raise(TypeError) do
+    # this will cause an exception due to the wrong argument
+    [1, 2].shuffle!(random: "Not a Random instance")
+  end
+
+  # verify that the same seed causes the same results
+  ary1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  ary1.shuffle!(random: Random.new(345))
+  ary2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  ary2.shuffle!(random: Random.new(345))
+  ary3 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  ary3.shuffle!(random: Random.new(346))
+  assert_equal(ary1, ary2)
+  assert_not_equal(ary1, ary3)
+end
+
+assert('Array#sample') do
+  100.times do
+    assert_include([0, 1, 2], [2, 1, 0].sample)
+    [2, 1, 0].sample(2).each { |sample| assert_include([0, 1, 2], sample) }
+    h = {}
+    (1..10).to_a.sample(7).each do |sample|
+      assert_not_include(h, sample)
+      h[sample] = true
+    end
+  end
+
+  assert_nil([].sample)
+  assert_equal([], [].sample(1))
+  assert_equal([], [2, 1].sample(0))
+  assert_raise(TypeError) { [2, 1].sample(true) }
+  assert_raise(ArgumentError) { [2, 1].sample(-1) }
+end
+
+assert('Array#sample(random)') do
+  assert_raise(TypeError) do
+    # this will cause an exception due to the wrong argument
+    [1, 2].sample(2, random: "Not a Random instance")
+  end
+
+  # verify that the same seed causes the same results
+  ary = (1..10).to_a
+  srand(15)
+  samples1 = ary.sample(4)
+  samples2 = ary.sample(4, random: Random.new(15))
+  samples3 = ary.sample(4, random: Random.new(16))
+  assert_equal(samples1, samples2)
+  assert_not_equal(samples1, samples3)
+end
+
+assert("Kernel#rand()") do
+  100.times {
+    assert_include(0.0..1.0, rand)
+    assert_include(0...100, rand(0...100))
+    assert_include(0...100, rand(100))
+  }
+
+  assert_equal(rand(0...0), nil)
+  assert_equal(rand(0.0...0), nil)
+  assert_equal(rand(0...0.0), nil)
+  assert_equal(rand(0.0...0.0), nil)
+  assert_equal(rand(1..0), nil)
+end

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

@@ -0,0 +1,93 @@
+# mruby-range-ext
+
+This gem extends the functionality of Ruby's `Range` class in mruby. It provides several new methods to make working with ranges more convenient and powerful.
+
+## Methods
+
+### `first` / `first(n)`
+
+Returns the first object in the range, or an array of the first `n` elements.
+
+**Example:**
+
+```ruby
+(10..20).first     #=> 10
+(10..20).first(3)  #=> [10, 11, 12]
+```
+
+### `last` / `last(n)`
+
+Returns the last object in the range, or an array of the last `n` elements. Note that with no arguments `last` will return the object that defines the end of the range even if `exclude_end?` is true.
+
+**Example:**
+
+```ruby
+(10..20).last      #=> 20
+(10...20).last     #=> 20
+(10..20).last(3)   #=> [18, 19, 20]
+(10...20).last(3)  #=> [17, 18, 19]
+```
+
+### `max`
+
+Returns the maximum value in the range. Returns `nil` if the range is empty or excludes its end and the end is not an Integer. For non-numeric ranges or when a block is given, it delegates to `Enumerable#max`.
+
+**Example:**
+
+```ruby
+(10..20).max      #=> 20
+(10...20).max     #=> 19
+('a'..'z').max    #=> "z"
+```
+
+### `min`
+
+Returns the minimum value in the range. For non-numeric ranges or when a block is given, it delegates to `Enumerable#min`.
+
+**Example:**
+
+```ruby
+(10..20).min      #=> 10
+('a'..'z').min    #=> "a"
+```
+
+### `overlap?(other_range)`
+
+Returns `true` if `self` and `other_range` have at least one element in common.
+
+**Example:**
+
+```ruby
+(1..5).overlap?(4..6) #=> true
+(1..5).overlap?(7..9) #=> false
+```
+
+### `cover?(obj_or_range)`
+
+Returns `true` if the given object or all elements of the given range are within `self`.
+
+**Example:**
+
+```ruby
+("a".."z").cover?("c")    #=> true
+("a".."z").cover?("5")    #=> false
+("a".."z").cover?("cc")   #=> true # Note: This behavior might be surprising for strings.
+(1..5).cover?(2..4)      #=> true
+(1..5).cover?(2..7)      #=> false
+```
+
+### `size`
+
+Returns the number of elements in the range. Both the begin and the end of the Range must be Numeric, otherwise `nil` is returned. For endless ranges with an Integer beginning, it returns `Infinity`.
+
+**Example:**
+
+```ruby
+(10..20).size    #=> 11
+('a'..'z').size  #=> nil
+(1..).size       #=> Infinity
+```
+
+## License
+
+This gem is released under the MIT License.

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

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

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

@@ -0,0 +1,155 @@
+class Range
+  ##
+  # call-seq:
+  #    rng.first    -> obj
+  #    rng.first(n) -> an_array
+  #
+  # Returns the first object in the range, or an array of the first `n`
+  # elements.
+  #
+  #   (10..20).first     #=> 10
+  #   (10..20).first(3)  #=> [10, 11, 12]
+  #
+  def first(*args)
+    raise RangeError, "cannot get the first element of beginless range" if self.begin.nil?
+    return self.begin if args.empty?
+
+    raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 1)" unless args.length == 1
+    nv = args[0]
+    n = nv.__to_int
+    raise ArgumentError, "negative array size (or size too big)" unless 0 <= n
+    ary = []
+    each do |i|
+      break if n <= 0
+      ary.push(i)
+      n -= 1
+    end
+    ary
+  end
+
+  ##
+  # call-seq:
+  #    rng.last    -> obj
+  #    rng.last(n) -> an_array
+  #
+  # Returns the last object in the range,
+  # or an array of the last `n` elements.
+  #
+  # Note that with no arguments `last` will return the object that defines
+  # the end of the range even if #exclude_end? is `true`.
+  #
+  #   (10..20).last      #=> 20
+  #   (10...20).last     #=> 20
+  #   (10..20).last(3)   #=> [18, 19, 20]
+  #   (10...20).last(3)  #=> [17, 18, 19]
+  def last(*args)
+    raise RangeError, "cannot get the last element of endless range" if self.end.nil?
+    return self.end if args.empty?
+
+    raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 1)" unless args.length == 1
+    nv = args[0]
+    n = nv.__to_int
+    raise ArgumentError, "negative array size (or size too big)" unless 0 <= n
+    return self.to_a.last(nv)
+  end
+
+  ##
+  # call-seq:
+  #    rng.max                   -> obj
+  #    rng.max {|a,b| block }    -> obj
+  #
+  # Returns the maximum value in the range. Returns nil if the range is empty
+  # or excludes its end and the end is not an Integer. For non-numeric ranges
+  # or when a block is given, it delegates to Enumerable#max.
+  #
+  #   (10..20).max      #=> 20
+  #   (10...20).max     #=> 19
+  #   ('a'..'z').max    #=> "z"
+  #
+  def max(&block)
+    val = self.begin
+    last = self.end
+    return super(&block) if block
+
+    raise RangeError, "cannot get the maximum of endless range" if last.nil?
+
+    # fast path for numerics
+    if val.kind_of?(Numeric) && last.kind_of?(Numeric)
+      raise TypeError if exclude_end? && !last.kind_of?(Integer)
+      return nil if val > last
+      return nil if val == last && exclude_end?
+
+      max = last
+      max -= 1 if exclude_end?
+      return max
+    end
+
+    # delegate to Enumerable
+    super()
+  end
+
+  ##
+  # call-seq:
+  #    rng.min                   -> obj
+  #    rng.min {|a,b| block }    -> obj
+  #
+  # Returns the minimum value in the range. For non-numeric ranges or when
+  # a block is given, it delegates to Enumerable#min.
+  #
+  #   (10..20).min      #=> 10
+  #   ('a'..'z').min    #=> "a"
+  #
+  def min(&block)
+    val = self.begin
+    last = self.end
+    if block
+      raise RangeError, "cannot get the minimum of endless range with custom comparison method" if last.nil?
+      return super(&block)
+    end
+    return val if last.nil?
+
+    # fast path for numerics
+    if val.kind_of?(Numeric) && last.kind_of?(Numeric)
+      return nil if val > last
+      return nil if val == last && exclude_end?
+
+      min = val
+      return min
+    end
+
+    # delegate to Enumerable
+    super()
+  end
+
+  ##
+  # call-seq:
+  #    rng.overlap?(other_range) -> true or false
+  #
+  # Returns true if self and other_range have at least one element in common,
+  # false otherwise.
+  #
+  #   (1..5).overlap?(4..6) #=> true
+  #   (1..5).overlap?(7..9) #=> false
+  #
+  def overlap?(other)
+    raise TypeError, "argument must be a range" unless other.kind_of?(Range)
+
+    self_begin = self.begin
+    other_end = other.end
+    other_excl = other.exclude_end?
+
+    return false if __empty_range?(self_begin, other_end, other_excl)
+
+    other_begin = other.begin
+    self_end = self.end
+    self_excl = self.exclude_end?
+
+    return false if __empty_range?(other_begin, self_end, self_excl)
+    return true if self_begin == other_begin
+
+    return false if __empty_range?(self_begin, self_end, self_excl)
+    return false if __empty_range?(other_begin, other_end, other_excl)
+
+    true
+  end
+end

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

@@ -0,0 +1,236 @@
+#include <mruby.h>
+#include <mruby/range.h>
+#include <mruby/class.h>
+#include <mruby/internal.h>
+#include <mruby/presym.h>
+
+static mrb_bool
+r_less(mrb_state *mrb, mrb_value a, mrb_value b, mrb_bool excl)
+{
+  switch (mrb_cmp(mrb, a, b)) {
+  case -2:                      /* failure */
+  case 1:
+    return FALSE;
+  case 0:
+    return !excl;
+  case -1:
+  default:                      /* just in case */
+    return TRUE;
+  }
+}
+
+/*
+ *  call-seq:
+ *     rng.cover?(obj)   -> true or false
+ *     rng.cover?(range) -> true or false
+ *
+ *  Returns true if the given argument is within self, false otherwise.
+ *
+ *  With non-range argument object, evaluates with <= and <.
+ *
+ *  For range self with included end value (exclude_end? == false),
+ *  evaluates thus:
+ *
+ *    self.begin <= object <= self.end
+ *
+ *     ("a".."z").cover?("c")    #=> true
+ *     ("a".."z").cover?("5")    #=> false
+ *     ("a".."z").cover?("cc")   #=> true
+ */
+static mrb_value
+range_cover(mrb_state *mrb, mrb_value range)
+{
+  struct RRange *r = mrb_range_ptr(mrb, range);
+  mrb_value val = mrb_get_arg1(mrb);
+  mrb_value beg = RANGE_BEG(r);
+  mrb_value end = RANGE_END(r);
+
+  if (mrb_nil_p(beg) && mrb_nil_p(end)) return mrb_true_value();
+
+  if (mrb_range_p(val)) {
+    struct RRange *r2 = mrb_range_ptr(mrb, val);
+    mrb_value beg2 = RANGE_BEG(r2);
+    mrb_value end2 = RANGE_END(r2);
+
+    /* range.cover?(nil..nil) => true */
+    if (mrb_nil_p(beg2) && mrb_nil_p(end2)) return mrb_true_value();
+
+    /* (a..b).cover?(c..d) */
+    if (mrb_nil_p(end)) {       /* a.. */
+      /* (a..).cover?(c..) => true */
+      if (mrb_nil_p(end2)) return mrb_bool_value(mrb_cmp(mrb, beg, beg2) != -2);
+      /* (a..).cover?(c..d) where d<a => false */
+      if (r_less(mrb, end2, beg, RANGE_EXCL(r2))) return mrb_false_value();
+      return mrb_true_value();
+    }
+    else if (mrb_nil_p(beg)) {  /* ..b */
+      /* (..b).cover?(..d) => true */
+      if (mrb_nil_p(beg2)) return mrb_bool_value(mrb_cmp(mrb, end, end2) != -2);
+      /* (..b).cover?(c..d) where b<c => false */
+      if (r_less(mrb, end, beg2, RANGE_EXCL(r))) return mrb_false_value();
+      return mrb_true_value();
+    }
+    else {                      /* a..b */
+      /* (a..b).cover?(c..) => (c<b) */
+      if (mrb_nil_p(end2))
+        return mrb_bool_value(r_less(mrb, beg2, end, RANGE_EXCL(r)));
+      /* (a..b).cover?(..d) => (a<d) */
+      if (mrb_nil_p(beg2))
+        return mrb_bool_value(r_less(mrb, beg, end2, RANGE_EXCL(r2)));
+      /* (a..b).cover?(c..d) where (b<c) => false */
+      if (r_less(mrb, end, beg2, RANGE_EXCL(r))) return mrb_false_value();
+      /* (a..b).cover?(c..d) where (d<a) => false */
+      if (r_less(mrb, end2, beg, RANGE_EXCL(r2))) return mrb_false_value();
+      return mrb_true_value();
+    }
+  }
+
+  if (mrb_nil_p(beg) || r_less(mrb, beg, val, FALSE)) {
+    if (mrb_nil_p(end)) {
+      return mrb_true_value();
+    }
+    if (r_less(mrb, val, end, RANGE_EXCL(r)))
+      return mrb_true_value();
+  }
+  return mrb_false_value();
+}
+
+/*
+ *  call-seq:
+ *     rng.size                   -> num
+ *
+ *  Returns the number of elements in the range. Both the begin and the end of
+ *  the Range must be Numeric, otherwise nil is returned.
+ *
+ *    (10..20).size    #=> 11
+ *    ('a'..'z').size  #=> nil
+ */
+
+#ifndef MRB_NO_FLOAT
+static mrb_value
+range_size(mrb_state *mrb, mrb_value range)
+{
+  struct RRange *r = mrb_range_ptr(mrb, range);
+  mrb_value beg = RANGE_BEG(r);
+  mrb_value end = RANGE_END(r);
+
+  if (mrb_float_p(beg)) {
+    mrb_raise(mrb, E_TYPE_ERROR, "can't iterate from Float");
+  }
+  if (mrb_nil_p(beg)) {
+    mrb_raise(mrb, E_TYPE_ERROR, "can't iterate from nil");
+  }
+  if (mrb_integer_p(beg) && mrb_nil_p(end)) {
+    return mrb_float_value(mrb, INFINITY);
+  }
+
+  mrb_bool excl = RANGE_EXCL(r);
+  mrb_float beg_f, end_f;
+  mrb_bool num_p = TRUE;
+
+  if (mrb_integer_p(beg)) {
+    beg_f = (mrb_float)mrb_integer(beg);
+  }
+  else if (mrb_float_p(beg)) {
+    beg_f = mrb_float(beg);
+  }
+  else {
+    num_p = FALSE;
+  }
+  if (mrb_integer_p(end)) {
+    end_f = (mrb_float)mrb_integer(end);
+  }
+  else if (mrb_float_p(end)) {
+    end_f = mrb_float(end);
+  }
+  else {
+    num_p = FALSE;
+  }
+  if (num_p) {
+    mrb_float n = end_f - beg_f;
+    mrb_float err = (fabs(beg_f) + fabs(end_f) + fabs(end_f-beg_f)) * MRB_FLOAT_EPSILON;
+
+    if (err>0.5) err=0.5;
+    if (excl) {
+      if (n<=0) return mrb_fixnum_value(0);
+      if (n<1)
+        n = 0;
+      else
+        n = floor(n - err);
+    }
+    else {
+      if (n<0) return mrb_fixnum_value(0);
+      n = floor(n + err);
+    }
+    if (isinf(n+1))
+      return mrb_float_value(mrb, INFINITY);
+    return mrb_fixnum_value((mrb_int)n+1);
+  }
+  return mrb_nil_value();
+}
+#else
+static mrb_value
+range_size(mrb_state *mrb, mrb_value range)
+{
+  struct RRange *r = mrb_range_ptr(mrb, range);
+
+  mrb_value beg = RANGE_BEG(r);
+  mrb_value end = RANGE_END(r);
+  if (mrb_nil_p(beg)) {
+    mrb_raise(mrb, E_TYPE_ERROR, "can't iterate from nil");
+  }
+  if (mrb_integer_p(beg) && mrb_nil_p(end)) {
+    return mrb_nil_value();
+  }
+
+  mrb_int excl = RANGE_EXCL(r) ? 0 : 1;
+  if (mrb_integer_p(beg) && mrb_integer_p(end)) {
+    mrb_int a = mrb_integer(beg);
+    mrb_int b = mrb_integer(end);
+    mrb_int c = b - a + excl;
+
+    return mrb_int_value(mrb, c);
+  }
+  return mrb_nil_value();
+}
+#endif /* MRB_NO_FLOAT */
+
+/*
+ * Internal helper method to check if a range would be empty given
+ * the specified begin, end, and exclude_end parameters.
+ * Returns true if the range would be empty, false otherwise.
+ * Used internally by overlap? and other range methods.
+ */
+
+static mrb_value
+range_empty_p(mrb_state *mrb, mrb_value range)
+{
+  mrb_value b, e;
+  mrb_bool excl;
+
+  mrb_get_args(mrb, "oob", &b, &e, &excl);
+  if (mrb_nil_p(b) || mrb_nil_p(e))
+    return mrb_false_value();
+
+  mrb_int comp = mrb_cmp(mrb, b, e);
+  return mrb_bool_value(comp == -2 || comp > 0 || (comp == 0 && excl));
+}
+
+static const mrb_mt_entry range_ext_rom_entries[] = {
+  MRB_MT_ENTRY(range_cover,   MRB_SYM_Q(cover), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(range_size,    MRB_SYM(size),          MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(range_empty_p, MRB_SYM_Q(__empty_range), MRB_ARGS_REQ(3)),
+};
+
+void
+mrb_mruby_range_ext_gem_init(mrb_state* mrb)
+{
+  struct RClass *s = mrb->range_class;
+
+  MRB_MT_INIT_ROM(mrb, s, range_ext_rom_entries);
+}
+
+void
+mrb_mruby_range_ext_gem_final(mrb_state* mrb)
+{
+}