Changeset 439 for EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-enumerator

Timestamp:

Jul 9, 2020, 8:51:43 AM (4 years ago)

Author:

coas-nagasima

Message:

mrubyを2.1.1に更新

Location:

EcnlProtoTool/trunk/mruby-2.1.1

Files:

• . (moved) (moved from EcnlProtoTool/trunk/mruby-1.3.0 )
• mrbgems/mruby-enumerator/mrbgem.rake (modified) (1 diff)
• mrbgems/mruby-enumerator/mrblib/enumerator.rb (modified) (15 diffs)
• mrbgems/mruby-enumerator/test/enumerator.rb (modified) (11 diffs)

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-enumerator/mrbgem.rake

@@ -3 +3 @@
   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

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-enumerator/mrblib/enumerator.rb

@@ -90 +90 @@
 
   ##
-  # @overload initialize(size = nil, &block)
   # @overload initialize(obj, method = :each, *args)
   #
@@ -110 +109 @@
   #     p fib.take(10) # => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
   #
-  def initialize(obj=nil, meth=:each, *args, &block)
-    if block_given?
+  # In the second, deprecated, form, a generated Enumerator iterates over the
+  # given object using the given method with the given arguments passed. This
+  # form is left only for internal use.
+  #
+  # Use of this form is discouraged.  Use Kernel#enum_for or Kernel#to_enum
+  # instead.
+  def initialize(obj=NONE, meth=:each, *args, &block)
+    if block
       obj = Generator.new(&block)
-    else
-      raise ArgumentError unless obj
+    elsif obj == NONE
+      raise ArgumentError, "wrong number of arguments (given 0, expected 1+)"
     end
 
     @obj = obj
     @meth = meth
-    @args = args.dup
+    @args = args
     @fib = nil
     @dst = nil
@@ -126 +131 @@
     @stop_exc = false
   end
-  attr_accessor :obj, :meth, :args, :fib
-  private :obj, :meth, :args, :fib
+  attr_accessor :obj, :meth, :args
+  attr_reader :fib
 
   def initialize_copy(obj)
@@ -152 +157 @@
   # +offset+:: the starting index to use
   #
-  def with_index(offset=0)
-    return to_enum :with_index, offset unless block_given?
-    offset = if offset.nil?
-      0
-    elsif offset.respond_to?(:to_int)
-      offset.to_int
+  def with_index(offset=0, &block)
+    return to_enum :with_index, offset unless block
+
+    if offset.nil?
+      offset = 0
     else
-      raise TypeError, "no implicit conversion of #{offset.class} into Integer"
+      offset = offset.__to_int
     end
 
@@ -165 +169 @@
     enumerator_block_call do |*i|
       n += 1
-      yield i.__svalue, n
+      block.call i.__svalue, n
     end
   end
@@ -210 +214 @@
   #   # => foo:2
   #
-  def with_object(object)
-    return to_enum(:with_object, object) unless block_given?
+  def with_object(object, &block)
+    return to_enum(:with_object, object) unless block
 
     enumerator_block_call do |i|
-      yield [i,object]
+      block.call [i,object]
     end
     object
@@ -220 +224 @@
 
   def inspect
-    return "#<#{self.class}: uninitialized>" unless @obj
-
     if @args && @args.size > 0
       args = @args.join(", ")
-      "#<#{self.class}: #{@obj}:#{@meth}(#{args})>"
+      "#<#{self.class}: #{@obj.inspect}:#{@meth}(#{args})>"
     else
-      "#<#{self.class}: #{@obj}:#{@meth}>"
+      "#<#{self.class}: #{@obj.inspect}:#{@meth}>"
     end
   end
@@ -242 +244 @@
   # === 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
@@ -278 +281 @@
       obj.args = args
     end
-    return obj unless block_given?
+    return obj unless block
     enumerator_block_call(&block)
   end
@@ -539 +542 @@
   class Yielder
     def initialize(&block)
-      raise LocalJumpError, "no block given" unless block_given?
+      raise LocalJumpError, "no block given" unless block
 
       @proc = block
@@ -553 +556 @@
     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
 
@@ -560 +603 @@
   #   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
@@ -586 +624 @@
   # 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
@@ -593 +631 @@
   #         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|
@@ -613 +648 @@
     Enumerator.new self, meth, *args
   end
-  alias :enum_for :to_enum
+  alias enum_for to_enum
 end
 
 module Enumerable
   # use Enumerator to use infinite sequence
-  def zip(*arg)
-    ary = []
-    arg = arg.map{|a|a.each}
-    i = 0
-    self.each do |*val|
-      a = []
-      a.push(val.__svalue)
-      idx = 0
-      while idx < arg.size
-        begin
-          a.push(arg[idx].next)
-        rescue StopIteration
-          a.push(nil)
+  def zip(*args, &block)
+    args = args.map do |a|
+      if a.respond_to?(:each)
+        a.to_enum(:each)
+      else
+        raise TypeError, "wrong argument type #{a.class} (must respond to :each)"
+      end
+    end
+
+    result = block ? nil : []
+
+    each do |*val|
+      tmp = [val.__svalue]
+      args.each do |arg|
+        v = if arg.nil?
+          nil
+        else
+          begin
+            arg.next
+          rescue StopIteration
+            nil
+          end
         end
-        idx += 1
+        tmp.push(v)
       end
-      ary.push(a)
-      i += 1
-    end
-    ary
+      if result.nil?
+        block.call(tmp)
+      else
+        result.push(tmp)
+      end
+    end
+
+    result
   end
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-enumerator/test/enumerator.rb

@@ -7 +7 @@
 end
 
-assert 'Enumerator' do
+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
 
-assert 'Enumerator' do
+assert 'Enumerator.superclass' do
   assert_equal Object, Enumerator.superclass
 end
@@ -20 +31 @@
   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(@obj, :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 }
-  enum = @obj.to_enum
-  assert_raise(NoMethodError) { enum.each {} }
 
   # examples
@@ -34 +42 @@
     end
   end
-  assert_equal fib.take(10), [1,1,2,3,5,8,13,21,34,55]
+  assert_take [1,1,2,3,5,8,13,21,34,55], fib
 end
 
@@ -54 +62 @@
   @obj.to_enum(:foo, 1, 2, 3).with_index(10).with_index(20) { |*i| a << i }
   assert_equal [[[1, 10], 20], [[2, 11], 21], [[3, 12], 22]], a
-end
-
-assert 'Enumerator#with_index nonnum offset' do
-  s = Object.new
-  def s.to_int; 1 end
-  assert_equal([[1,1],[2,2],[3,3]], @obj.to_enum(:foo, 1, 2, 3).with_index(s).to_a)
 end
 
@@ -100 +102 @@
 assert 'Enumerator#inspect' do
   e = (0..10).each
-  assert_equal("#<Enumerator: 0..10:each>", e.inspect)
-  e = Enumerator.new("FooObject", :foo, 1)
-  assert_equal("#<Enumerator: FooObject:foo(1)>", e.inspect)
-  e = Enumerator.new("FooObject", :foo, 1, 2, 3)
-  assert_equal("#<Enumerator: FooObject:foo(1, 2, 3)>", e.inspect)
+  assert_equal('#<Enumerator: 0..10:each>', e.inspect)
+  e = 'FooObject'.enum_for(:foo, 1)
+  assert_equal('#<Enumerator: "FooObject":foo(1)>', e.inspect)
+  e = 'FooObject'.enum_for(:foo, 1, 2, 3)
+  assert_equal('#<Enumerator: "FooObject":foo(1, 2, 3)>', e.inspect)
+  e = nil.enum_for(:to_s)
+  assert_equal('#<Enumerator: nil:to_s>', e.inspect)
 end
 
@@ -426 +430 @@
 
 assert 'Kernel#to_enum' do
+  e = nil
   assert_equal Enumerator, [].to_enum.class
-  assert_raise(ArgumentError){ nil.to_enum }
+  assert_nothing_raised { e = [].to_enum(:_not_implemented_) }
+  assert_raise(NoMethodError) { e.first }
 end
 
@@ -510 +516 @@
 assert 'Hash#select' do
   h = {1=>2,3=>4,5=>6}
-  hret = h.select.with_index {|a,b| a[1] == 4}
+  hret = h.select.with_index {|a,_b| a[1] == 4}
   assert_equal({3=>4}, hret)
   assert_equal({1=>2,3=>4,5=>6}, h)
@@ -517 +523 @@
 assert 'Hash#select!' do
   h = {1=>2,3=>4,5=>6}
-  hret = h.select!.with_index {|a,b| a[1] == 4}
+  hret = h.select!.with_index {|a,_b| a[1] == 4}
   assert_equal h, hret
   assert_equal({3=>4}, h)
@@ -524 +530 @@
 assert 'Hash#reject' do
   h = {1=>2,3=>4,5=>6}
-  hret = h.reject.with_index {|a,b| a[1] == 4}
+  hret = h.reject.with_index {|a,_b| a[1] == 4}
   assert_equal({1=>2,5=>6}, hret)
   assert_equal({1=>2,3=>4,5=>6}, h)
@@ -531 +537 @@
 assert 'Hash#reject!' do
   h = {1=>2,3=>4,5=>6}
-  hret = h.reject!.with_index {|a,b| a[1] == 4}
+  hret = h.reject!.with_index {|a,_b| a[1] == 4}
   assert_equal h, hret
   assert_equal({1=>2,5=>6}, h)
@@ -545 +551 @@
   assert_equal [1,2,3,4,5], c
 end
+
+assert 'Enumerable#zip' do
+  assert_equal [[1, 10], [2, 11], [3, 12]], [1,2,3].zip(10..Float::INFINITY)
+
+  ret = []
+  assert_equal nil, [1,2,3].zip(10..Float::INFINITY) { |i| ret << i }
+  assert_equal [[1, 10], [2, 11], [3, 12]], ret
+
+  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