script_core 0.1.1 → 0.2.0

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

@@ -1,48 +1,58 @@
 ##
 # Random Test
 
-assert("Random#srand") do
+assert("Random.new") do
   r1 = Random.new(123)
   r2 = Random.new(123)
-  r1.rand == r2.rand
+  r3 = Random.new(124)
+  assert_equal(r1.rand, r2.rand)
+  assert_not_equal(r1.rand, r3.rand)
 end
 
-assert("Kernel::srand") do
+assert("Kernel.srand") do
   srand(234)
   r1 = rand
   srand(234)
   r2 = rand
-  r1 == r2
+  srand(235)
+  r3 = rand
+  assert_equal(r1, r2)
+  assert_not_equal(r1, r3)
 end
 
-assert("Random::srand") do
+assert("Random.srand") do
   Random.srand(345)
   r1 = rand
   srand(345)
   r2 = Random.rand
-  r1 == r2
+  Random.srand(346)
+  r3 = rand
+  assert_equal(r1, r2)
+  assert_not_equal(r1, r3)
 end
 
-assert("fixnum") do
-  rand(3).class == Fixnum
-end
-
-assert("float") do
-  rand.class == Float
+assert("return class of Kernel.rand") do
+  assert_kind_of(Fixnum, rand(3))
+  assert_kind_of(Fixnum, rand(1.5))
+  assert_kind_of(Float, rand)
+  assert_kind_of(Float, rand(0.5))
 end
 
 assert("Array#shuffle") do
-  ary = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  orig = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  ary = orig.dup
   shuffled = ary.shuffle
-
-  ary == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] and shuffled != ary and 10.times { |x| ary.include? x }
+  assert_equal(orig, ary)
+  assert_not_equal(ary, shuffled)
+  assert_equal(orig, shuffled.sort)
 end
 
 assert('Array#shuffle!') do
-  ary = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-  ary.shuffle!
-
-  ary != [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] and 10.times { |x| ary.include? x }
+  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
@@ -52,12 +62,12 @@
   end
 
   # verify that the same seed causes the same results
-  ary1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-  shuffle1 = ary1.shuffle Random.new 345
-  ary2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-  shuffle2 = ary2.shuffle Random.new 345
-
-  ary1 != shuffle1 and 10.times { |x| shuffle1.include? x } and shuffle1 == shuffle2
+  ary = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  shuffled1 = ary.shuffle Random.new 345
+  shuffled2 = ary.shuffle Random.new 345
+  shuffled3 = ary.shuffle Random.new 346
+  assert_equal(shuffled1, shuffled2)
+  assert_not_equal(shuffled1, shuffled3)
 end
 
 assert('Array#shuffle!(random)') do
@@ -71,6 +81,42 @@
   ary1.shuffle! Random.new 345
   ary2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   ary2.shuffle! Random.new 345
+  ary3 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  ary3.shuffle! 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
 
-  ary1 != [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] and 10.times { |x| ary1.include? x } and ary1 == ary2
+assert('Array#sample(random)') do
+  assert_raise(TypeError) do
+    # this will cause an exception due to the wrong argument
+    [1, 2].sample(2, "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.new(15))
+  samples3 = ary.sample(4, Random.new(16))
+  assert_equal(samples1, samples2)
+  assert_not_equal(samples1, samples3)
 end

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

@@ -25,4 +25,42 @@ def first(*args)
     end
     ary
   end
+
+  def max(&block)
+    val = self.first
+    last = self.last
+    return super if block
+
+    # fast path for numerics
+    if val.kind_of?(Numeric) && last.kind_of?(Numeric)
+      raise TypeError if exclude_end? && !last.kind_of?(Fixnum)
+      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
+
+  def min(&block)
+    val = self.first
+    last = self.last
+    return super if block
+
+    # 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
 end

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

@@ -5,24 +5,16 @@
 static mrb_bool
 r_le(mrb_state *mrb, mrb_value a, mrb_value b)
 {
-  mrb_value r = mrb_funcall(mrb, a, "<=>", 1, b); /* compare result */
-  /* output :a < b => -1, a = b =>  0, a > b => +1 */
-
-  if (mrb_fixnum_p(r)) {
-    mrb_int c = mrb_fixnum(r);
-    if (c == 0 || c == -1) return TRUE;
-  }
+  mrb_int n = mrb_cmp(mrb, a, b);
 
+  if (n == 0 || n == -1) return TRUE;
   return FALSE;
 }
 
 static mrb_bool
 r_lt(mrb_state *mrb, mrb_value a, mrb_value b)
 {
-  mrb_value r = mrb_funcall(mrb, a, "<=>", 1, b);
-  /* output :a < b => -1, a = b =>  0, a > b => +1 */
-
-  return mrb_fixnum_p(r) && mrb_fixnum(r) == -1;
+  return mrb_cmp(mrb, a, b) == -1;
 }
 
 /*
@@ -106,6 +98,7 @@ range_last(mrb_state *mrb, mrb_value range)
  *    ('a'..'z').size  #=> nil
  */
 
+#ifndef MRB_WITHOUT_FLOAT
 static mrb_value
 range_size(mrb_state *mrb, mrb_value range)
 {
@@ -158,6 +151,28 @@ range_size(mrb_state *mrb, mrb_value range)
   }
   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, end;
+  mrb_int excl;
+
+  beg = RANGE_BEG(r);
+  end = RANGE_END(r);
+  excl = RANGE_EXCL(r) ? 0 : 1;
+
+  if (mrb_fixnum_p(beg) && mrb_fixnum_p(end)) {
+    mrb_int a = mrb_fixnum(beg);
+    mrb_int b = mrb_fixnum(end);
+    mrb_int c = b - a + excl;
+
+    return mrb_fixnum_value(c);
+  }
+  return mrb_nil_value();
+}
+#endif /* MRB_WITHOUT_FLOAT */
 
 void
 mrb_mruby_range_ext_gem_init(mrb_state* mrb)

data/ext/enterprise_script_service/mruby/mrbgems/mruby-range-ext/test/range.rb

@@ -10,6 +10,8 @@
 assert('Range#first') do
   assert_equal 10, (10..20).first
   assert_equal [10, 11, 12], (10..20).first(3)
+
+  skip unless Object.const_defined?(:Float)
   assert_equal [0, 1, 2], (0..Float::INFINITY).first(3)
 end
 
@@ -23,10 +25,118 @@
 assert('Range#size') do
   assert_equal 42, (1..42).size
   assert_equal 41, (1...42).size
+  assert_nil ('a'..'z').size
+
+  skip unless Object.const_defined?(:Float)
   assert_equal 6, (1...6.3).size
   assert_equal 5, (1...6.0).size
   assert_equal 5, (1.1...6).size
   assert_equal 15, (1.0..15.9).size
   assert_equal Float::INFINITY, (0..Float::INFINITY).size
-  assert_nil ('a'..'z').size
+end
+
+assert('Range#max') do
+  # returns the maximum value in the range when called with no arguments
+  assert_equal 10, (1..10).max
+  assert_equal 9, (1...10).max
+  assert_equal 536870911, (0...2**29).max
+
+  # returns nil when the endpoint is less than the start point
+  assert_equal nil, (100..10).max
+
+  # returns nil when the endpoint equals the start point and the range is exclusive
+  assert_equal nil, (5...5).max
+
+  # returns the endpoint when the endpoint equals the start point and the range is inclusive
+  assert_equal 5, (5..5).max
+
+  skip unless Object.const_defined?(:Float)
+
+  # returns the maximum value in the Float range when called with no arguments
+  assert_equal 908.1111, (303.20..908.1111).max
+
+  # raises TypeError when called on an exclusive range and a non Integer value
+  assert_raise(TypeError) { (303.20...908.1111).max }
+
+  # returns nil when the endpoint is less than the start point in a Float range
+  assert_equal nil, (3003.20..908.1111).max
+end
+
+assert('Range#max given a block') do
+  # passes each pair of values in the range to the block
+  acc = []
+  (1..10).max do |a, b|
+    acc << a
+    acc << b
+    a
+  end
+  (1..10).each do |value|
+    assert_true acc.include?(value)
+  end
+
+  # passes each pair of elements to the block in reversed order
+  acc = []
+  (1..5).max do |a, b|
+    acc << [a, b]
+    a
+  end
+  assert_equal [[2, 1], [3, 2], [4, 3], [5, 4]], acc
+
+  # returns the element the block determines to be the maximum
+  assert_equal 1, ((1..3).max { |_a, _b| -3 })
+
+  # returns nil when the endpoint is less than the start point
+  assert_equal nil, ((100..10).max { |x, y| x <=> y })
+  assert_equal nil, ((5...5).max { |x, y| x <=> y })
+end
+
+assert('Range#min') do
+  # returns the minimum value in the range when called with no arguments
+  assert_equal 1, (1..10).min
+  assert_equal 1, (1...10).min
+
+  # returns nil when the start point is greater than the endpoint
+  assert_equal nil, (100..10).min
+
+  # returns nil when the endpoint equals the start point and the range is exclusive
+  assert_equal nil, (5...5).max
+
+  # returns the endpoint when the endpoint equals the start point and the range is inclusive
+  assert_equal 5, (5..5).max
+
+  skip unless Object.const_defined?(:Float)
+
+  # returns the minimum value in the Float range when called with no arguments
+  assert_equal 303.20, (303.20..908.1111).min
+
+  # returns nil when the start point is greater than the endpoint in a Float range
+  assert_equal nil, (3003.20..908.1111).max
+end
+
+assert('Range#min given a block') do
+  # passes each pair of values in the range to the block
+  acc = []
+  (1..10).min do |a, b|
+    acc << a
+    acc << b
+    a
+  end
+  (1..10).each do |value|
+    assert_true acc.include?(value)
+  end
+
+  # passes each pair of elements to the block in reversed order
+  acc = []
+  (1..5).min do |a, b|
+    acc << [a, b]
+    a
+  end
+  assert_equal [[2, 1], [3, 1], [4, 1], [5, 1]], acc
+
+  # returns the element the block determines to be the minimum
+  assert_equal 3, ((1..3).min { |_a, _b| -3 })
+
+  # returns nil when the start point is greater than the endpoint
+  assert_equal nil, ((100..10).min { |x, y| x <=> y })
+  assert_equal nil, ((5...5).min { |x, y| x <=> y })
 end

data/ext/enterprise_script_service/mruby/mrbgems/mruby-rational/mrbgem.rake

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

data/ext/enterprise_script_service/mruby/mrbgems/mruby-rational/mrblib/rational.rb

@@ -0,0 +1,117 @@
+class Rational < Numeric
+  def inspect
+    "(#{to_s})"
+  end
+
+  def to_s
+    "#{numerator}/#{denominator}"
+  end
+
+  def *(rhs)
+    if rhs.is_a? Rational
+      Rational(numerator * rhs.numerator, denominator * rhs.denominator)
+    elsif rhs.is_a? Integer
+      Rational(numerator * rhs, denominator)
+    elsif rhs.is_a? Numeric
+      numerator * rhs / denominator
+    end
+  end
+
+  def +(rhs)
+    if rhs.is_a? Rational
+      Rational(numerator * rhs.denominator + rhs.numerator * denominator, denominator * rhs.denominator)
+    elsif rhs.is_a? Integer
+      Rational(numerator + rhs * denominator, denominator)
+    elsif rhs.is_a? Numeric
+      (numerator + rhs * denominator) / denominator
+    end
+  end
+
+  def -(rhs)
+    if rhs.is_a? Rational
+      Rational(numerator * rhs.denominator - rhs.numerator * denominator, denominator * rhs.denominator)
+    elsif rhs.is_a? Integer
+      Rational(numerator - rhs * denominator, denominator)
+    elsif rhs.is_a? Numeric
+      (numerator - rhs * denominator) / denominator
+    end
+  end
+
+  def /(rhs)
+    if rhs.is_a? Rational
+      Rational(numerator * rhs.denominator, denominator * rhs.numerator)
+    elsif rhs.is_a? Integer
+      Rational(numerator, denominator * rhs)
+    elsif rhs.is_a? Numeric
+      numerator / rhs / denominator
+    end
+  end
+
+  def <=>(rhs)
+    if rhs.is_a?(Integral)
+      return numerator <=> rhs if denominator == 1
+      rhs = Rational(rhs)
+    end
+
+    case rhs
+    when Rational
+      (numerator * rhs.denominator - denominator * rhs.numerator) <=> 0
+    when Numeric
+      (rhs <=> self)&.-@
+    else
+      nil
+    end
+  end
+
+  def ==(rhs)
+    return true if self.equal?(rhs)
+    if rhs.is_a?(Integral) && denominator == 1
+      return numerator == rhs
+    end
+    if rhs.is_a?(Rational)
+      numerator * rhs.denominator == denominator * rhs.numerator
+    else
+      rhs == self
+    end
+  end
+end
+
+class Numeric
+  def to_r
+    Rational(self, 1)
+  end
+end
+
+module Kernel
+  def Rational(numerator, denominator = 1)
+    a = numerator
+    b = denominator
+    a, b = b, a % b until b == 0
+    Rational._new(numerator.div(a), denominator.div(a))
+  end
+
+  [:+, :-, :*, :/, :<=>, :==, :<, :<=, :>, :>=].each do |op|
+    Fixnum.instance_eval do
+      original_operator_name = "__original_operator_#{op}_rational"
+      alias_method original_operator_name, op
+      define_method op do |rhs|
+        if rhs.is_a? Rational
+          Rational(self).__send__(op, rhs)
+        else
+          __send__(original_operator_name, rhs)
+        end
+      end
+    end
+    Float.instance_eval do
+      original_operator_name = "__original_operator_#{op}_rational"
+      alias_method original_operator_name, op
+      define_method op do |rhs|
+        if rhs.is_a? Rational
+          rhs = rhs.to_f
+        end
+        __send__(original_operator_name, rhs)
+      end
+    end if Object.const_defined?(:Float)
+  end
+end
+