script_core 0.1.1 → 0.2.4

data/ext/enterprise_script_service/mruby/mrbgems/mruby-enum-chain/mrblib/chain.rb

@@ -6,28 +6,30 @@ module Enumerable
   def chain(*args)
     Enumerator::Chain.new(self, *args)
   end
+end
 
+class Enumerator
   def +(other)
-    Enumerator::Chain.new(self, other)
+    Chain.new(self, other)
   end
-end
 
-class Enumerator
   class Chain
     include Enumerable
 
     def initialize(*args)
-      @enums = args
-    end
-
-    def initialize_copy(orig)
-      @enums = orig.__copy_enums
+      @enums = args.freeze
+      @pos = -1
     end
 
     def each(&block)
-      return to_enum unless block_given?
+      return to_enum unless block
 
-      @enums.each { |e| e.each(&block) }
+      i = 0
+      while i < @enums.size
+        @pos = i
+        @enums[i].each(&block)
+        i += 1
+      end
 
       self
     end
@@ -40,21 +42,21 @@ def size
     end
 
     def rewind
-      @enums.reverse_each do |e|
+      while 0 <= @pos && @pos < @enums.size
+        e = @enums[@pos]
         e.rewind if e.respond_to?(:rewind)
+        @pos -= 1
       end
 
       self
     end
 
-    def inspect
-      "#<#{self.class}: #{@enums.inspect}>"
+    def +(other)
+      self.class.new(self, other)
     end
 
-    def __copy_enums
-      @enums.each_with_object([]) do |e, a|
-        a << e.clone
-      end
+    def inspect
+      "#<#{self.class}: #{@enums.inspect}>"
     end
   end
 end

data/ext/enterprise_script_service/mruby/mrbgems/mruby-enum-chain/test/enum_chain.rb

@@ -12,9 +12,9 @@
   assert_raise(NoMethodError) { c.chain }
 end
 
-assert("Enumerable#+") do
+assert("Enumerator#+") do
   a = [].each
-  b = {}.reverse_each
+  b = {}.each
   c = Object.new # not has #each method
 
   assert_kind_of Enumerator::Chain, a + b
@@ -24,7 +24,7 @@
   assert_raise(NoMethodError) { c + a }
 end
 
-assert("Enumerator.new") do
+assert("Enumerator::Chain.new") do
   a = []
   b = {}
   c = Object.new # not has #each method
@@ -46,13 +46,13 @@
   assert_kind_of Enumerator, aa.each
   assert_equal [1, 2, 3, 1, 2, 3], aa.each.to_a
 
-  aa = a.chain(a.reverse_each)
+  aa = a.chain(6..9)
   assert_kind_of Enumerator, aa.each
-  assert_equal [1, 2, 3, 3, 2, 1], aa.each.to_a
+  assert_equal [1, 2, 3, 6, 7, 8, 9], aa.each.to_a
 
-  aa = a.chain(a.reverse_each, a)
+  aa = a.chain((-3..-2).each_with_index, a)
   assert_kind_of Enumerator, aa.each
-  assert_equal [1, 2, 3, 3, 2, 1, 1, 2, 3], aa.each.to_a
+  assert_equal [1, 2, 3, [-3, 0], [-2, 1], 1, 2, 3], aa.each.to_a
 
   aa = a.chain(Object.new)
   assert_kind_of Enumerator, aa.each
@@ -65,12 +65,44 @@
   aa = a.chain(a)
   assert_equal 6, aa.size
 
-  aa = a.chain(a.reverse_each)
+  aa = a.chain(3..4)
   assert_nil aa.size
 
-  aa = a.chain(a.reverse_each, a)
+  aa = a.chain(3..4, a)
   assert_nil aa.size
 
   aa = a.chain(Object.new)
   assert_nil aa.size
 end
+
+assert("Enumerator::Chain#rewind") do
+  rewound = nil
+  e1 = [1, 2]
+  e2 = (4..6)
+  (class << e1; self end).define_method(:rewind) { rewound << self }
+  (class << e2; self end).define_method(:rewind) { rewound << self }
+  c = e1.chain(e2)
+
+  rewound = []
+  c.rewind
+  assert_equal [], rewound
+
+  rewound = []
+  c.each{break c}.rewind
+  assert_equal [e1], rewound
+
+  rewound = []
+  c.each{}.rewind
+  assert_equal [e2, e1], rewound
+end
+
+assert("Enumerator::Chain#+") do
+  a = [].chain
+  b = {}.chain
+  c = Object.new # not has #each method
+
+  assert_kind_of Enumerator::Chain, a + b
+  assert_kind_of Enumerator::Chain, a + c
+  assert_kind_of Enumerator::Chain, b + a
+  assert_kind_of Enumerator::Chain, b + c
+end

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

@@ -811,10 +811,6 @@ def to_h(&blk)
     h
   end
 
-  def nil.to_h
-    {}
-  end
-
   def uniq(&block)
     hash = {}
     if block
@@ -830,4 +826,34 @@ def uniq(&block)
     end
     hash.values
   end
+
+  def filter_map(&blk)
+    return to_enum(:filter_map) unless blk
+
+    ary = []
+    self.each do |x|
+      x = blk.call(x)
+      ary.push x if x
+    end
+    ary
+  end
+
+  alias filter select
+
+  ##
+  # call-seq:
+  #   enum.tally -> a_hash
+  #
+  # Tallys the collection.  Returns a hash where the keys are the
+  # elements and the values are numbers of elements in the collection
+  # that correspond to the key.
+  #
+  #    ["a", "b", "c", "b"].tally #=> {"a"=>1, "b"=>2, "c"=>1}
+  def tally
+    hash = {}
+    self.each do |x|
+      hash[x] = (hash[x]||0)+1
+    end
+    hash
+  end
 end

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

@@ -186,8 +186,13 @@ def each
   h = c.new.to_h
   assert_equal Hash, h.class
   assert_equal h0, h
-  # mruby-enum-ext also provides nil.to_h
-  assert_equal Hash.new, nil.to_h
-
   assert_equal({1=>4,3=>8}, c.new.to_h{|k,v|[k,v*2]})
 end
+
+assert("Enumerable#filter_map") do
+  assert_equal [4, 8, 12, 16, 20], (1..10).filter_map{|i| i * 2 if i%2==0}
+end
+
+assert("Enumerable#tally") do
+  assert_equal({"a"=>1, "b"=>2, "c"=>1}, ["a", "b", "c", "b"].tally)
+end

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

@@ -2,6 +2,5 @@
   spec.license = 'MIT'
   spec.author  = 'mruby developers'
   spec.add_dependency('mruby-fiber', :core => 'mruby-fiber')
-  spec.add_dependency 'mruby-enum-ext', :core => 'mruby-enum-ext'
   spec.summary = 'Enumerator class'
 end

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

@@ -89,7 +89,6 @@ class Enumerator
   include Enumerable
 
   ##
-  # @overload initialize(size = nil, &block)
   # @overload initialize(obj, method = :each, *args)
   #
   # Creates a new Enumerator object, which can be used as an
@@ -244,9 +243,10 @@ def inspect
   #
   # === Examples
   #
-  #   "Hello, world!".scan(/\w+/)                     #=> ["Hello", "world"]
-  #   "Hello, world!".to_enum(:scan, /\w+/).to_a      #=> ["Hello", "world"]
-  #   "Hello, world!".to_enum(:scan).each(/\w+/).to_a #=> ["Hello", "world"]
+  #   Array.new(3)                     #=> [nil, nil, nil]
+  #   Array.new(3) { |i| i }           #=> [0, 1, 2]
+  #   Array.to_enum(:new, 3).to_a      #=> [0, 1, 2]
+  #   Array.to_enum(:new).each(3).to_a #=> [0, 1, 2]
   #
   #   obj = Object.new
   #
@@ -555,6 +555,46 @@ def << *args
       self
     end
   end
+
+  ##
+  # call-seq:
+  #    Enumerator.produce(initial = nil) { |val| } -> enumerator
+  #
+  # Creates an infinite enumerator from any block, just called over and
+  # over.  Result of the previous iteration is passed to the next one.
+  # If +initial+ is provided, it is passed to the first iteration, and
+  # becomes the first element of the enumerator; if it is not provided,
+  # first iteration receives +nil+, and its result becomes first
+  # element of the iterator.
+  #
+  # Raising StopIteration from the block stops an iteration.
+  #
+  # Examples of usage:
+  #
+  #   Enumerator.produce(1, &:succ)   # => enumerator of 1, 2, 3, 4, ....
+  #
+  #   Enumerator.produce { rand(10) } # => infinite random number sequence
+  #
+  #   ancestors = Enumerator.produce(node) { |prev| node = prev.parent or raise StopIteration }
+  #   enclosing_section = ancestors.find { |n| n.type == :section }
+  def Enumerator.produce(init=NONE, &block)
+    raise ArgumentError, "no block given" if block.nil?
+    Enumerator.new do |y|
+      if init == NONE
+        val = nil
+      else
+        val = init
+        y.yield(val)
+      end
+      begin
+        while true
+          y.yield(val = block.call(val))
+        end
+      rescue StopIteration
+        # do nothing
+      end
+    end
+  end
 end
 
 module Kernel
@@ -562,15 +602,10 @@ module Kernel
   # call-seq:
   #   obj.to_enum(method = :each, *args)                 -> enum
   #   obj.enum_for(method = :each, *args)                -> enum
-  #   obj.to_enum(method = :each, *args) {|*args| block} -> enum
-  #   obj.enum_for(method = :each, *args){|*args| block} -> enum
   #
   # Creates a new Enumerator which will enumerate by calling +method+ on
   # +obj+, passing +args+ if any.
   #
-  # If a block is given, it will be used to calculate the size of
-  # the enumerator without the need to iterate it (see Enumerator#size).
-  #
   # === Examples
   #
   #   str = "xyz"
@@ -588,17 +623,14 @@ module Kernel
   # It is typical to call to_enum when defining methods for
   # a generic Enumerable, in case no block is passed.
   #
-  # Here is such an example, with parameter passing and a sizing block:
+  # Here is such an example with parameter passing:
   #
   #     module Enumerable
   #       # a generic method to repeat the values of any enumerable
   #       def repeat(n)
   #         raise ArgumentError, "#{n} is negative!" if n < 0
   #         unless block_given?
-  #           return to_enum(__method__, n) do # __method__ is :repeat here
-  #             sz = size     # Call size and multiply by n...
-  #             sz * n if sz  # but return nil if size itself is nil
-  #           end
+  #           return to_enum(__method__, n) # __method__ is :repeat here
   #         end
   #         each do |*val|
   #           n.times { yield *val }

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

@@ -6,6 +6,17 @@ def foo *a
   end
 end
 
+def assert_take(exp, enumerator)
+  result = []
+  n = exp.size
+  enumerator.each do |v|
+    result << v
+    n -= 1
+    break if n == 0
+  end if n > 0
+  assert_equal exp, result
+end
+
 assert 'Enumerator.class' do
   assert_equal Class, Enumerator.class
 end
@@ -19,7 +30,7 @@ def foo *a
   assert_equal [:x,:y,:z], [:x,:y,:z].each.map{|i| i}.sort
   assert_equal [[:x,1],[:y,2]], {x:1, y:2}.each.map{|i| i}.sort
   assert_equal [1,2,3], @obj.to_enum(:foo, 1,2,3).to_a
-  assert_equal [1,2,3], Enumerator.new { |y| i = 0; loop { y << (i += 1) } }.take(3)
+  assert_take [1,2,3], Enumerator.new { |y| i = 0; loop { y << (i += 1) } }
   assert_raise(ArgumentError) { Enumerator.new }
 
   # examples
@@ -30,7 +41,7 @@ def foo *a
       a, b = b, a + b
     end
   end
-  assert_equal [1,1,2,3,5,8,13,21,34,55], fib.take(10)
+  assert_take [1,1,2,3,5,8,13,21,34,55], fib
 end
 
 assert 'Enumerator#initialize_copy' do
@@ -549,3 +560,41 @@ def (o = Object.new).each
 
   assert_raise(TypeError) { [1].zip(1) }
 end
+
+assert 'Enumerator.produce' do
+  assert_raise(ArgumentError) { Enumerator.produce }
+
+  # Without initial object
+  passed_args = []
+  enum = Enumerator.produce {|obj| passed_args << obj; (obj || 0).succ }
+  assert_equal Enumerator, enum.class 
+  assert_take [1, 2, 3], enum
+  assert_equal [nil, 1, 2], passed_args
+
+  # With initial object
+  passed_args = []
+  enum = Enumerator.produce(1) {|obj| passed_args << obj; obj.succ }
+  assert_take [1, 2, 3], enum
+  assert_equal [1, 2], passed_args
+
+  # Raising StopIteration
+  words = %w[The quick brown fox jumps over the lazy dog]
+  enum = Enumerator.produce { words.shift or raise StopIteration }
+  assert_equal %w[The quick brown fox jumps over the lazy dog], enum.to_a
+
+  # Raising StopIteration
+  object = [[[["abc", "def"], "ghi", "jkl"], "mno", "pqr"], "stuv", "wxyz"]
+  enum = Enumerator.produce(object) {|obj|
+    obj.respond_to?(:first) or raise StopIteration
+    obj.first
+  }
+  assert_nothing_raised {
+    assert_equal [
+      [[[["abc", "def"], "ghi", "jkl"], "mno", "pqr"], "stuv", "wxyz"],
+      [[["abc", "def"], "ghi", "jkl"], "mno", "pqr"],
+      [["abc", "def"], "ghi", "jkl"],
+      ["abc", "def"],
+      "abc",
+    ], enum.to_a
+  }
+end

data/ext/enterprise_script_service/mruby/mrbgems/mruby-error/src/exception.c

@@ -8,6 +8,7 @@ mrb_protect(mrb_state *mrb, mrb_func_t body, mrb_value data, mrb_bool *state)
   struct mrb_jmpbuf *prev_jmp = mrb->jmp;
   struct mrb_jmpbuf c_jmp;
   mrb_value result = mrb_nil_value();
+  mrb_int ai = mrb_gc_arena_save(mrb);
 
   if (state) { *state = FALSE; }
 
@@ -22,6 +23,7 @@ mrb_protect(mrb_state *mrb, mrb_func_t body, mrb_value data, mrb_bool *state)
     if (state) { *state = TRUE; }
   } MRB_END_EXC(&c_jmp);
 
+  mrb_gc_arena_restore(mrb, ai);
   mrb_gc_protect(mrb, result);
   return result;
 }
@@ -32,6 +34,7 @@ mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_func_t ensure,
   struct mrb_jmpbuf *prev_jmp = mrb->jmp;
   struct mrb_jmpbuf c_jmp;
   mrb_value result;
+  mrb_int ai = mrb_gc_arena_save(mrb);
 
   MRB_TRY(&c_jmp) {
     mrb->jmp = &c_jmp;
@@ -39,11 +42,15 @@ mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_func_t ensure,
     mrb->jmp = prev_jmp;
   } MRB_CATCH(&c_jmp) {
     mrb->jmp = prev_jmp;
+    mrb_gc_arena_restore(mrb, ai);
     ensure(mrb, e_data);
     MRB_THROW(mrb->jmp); /* rethrow catched exceptions */
   } MRB_END_EXC(&c_jmp);
 
+  mrb_gc_arena_restore(mrb, ai);
+  mrb_gc_protect(mrb, result);
   ensure(mrb, e_data);
+  mrb_gc_arena_restore(mrb, ai);
   mrb_gc_protect(mrb, result);
   return result;
 }
@@ -64,6 +71,7 @@ mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_fun
   mrb_value result;
   mrb_bool error_matched = FALSE;
   mrb_int i;
+  mrb_int ai = mrb_gc_arena_save(mrb);
 
   MRB_TRY(&c_jmp) {
     mrb->jmp = &c_jmp;
@@ -82,9 +90,11 @@ mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_fun
     if (!error_matched) { MRB_THROW(mrb->jmp); }
 
     mrb->exc = NULL;
+    mrb_gc_arena_restore(mrb, ai);
     result = rescue(mrb, r_data);
   } MRB_END_EXC(&c_jmp);
 
+  mrb_gc_arena_restore(mrb, ai);
   mrb_gc_protect(mrb, result);
   return result;
 }