opal 1.3.2 → 1.4.0.alpha1

data/opal/corelib/enumerator/arithmetic_sequence.rb

@@ -0,0 +1,177 @@
+class ::Enumerator
+  class self::ArithmeticSequence < self
+    `Opal.prop(self.$$prototype, '$$is_arithmetic_seq', true)`
+
+    `var inf = Infinity`
+
+    # @private
+    def initialize(range, step = undefined, creation_method = :step)
+      @creation_method = creation_method
+      if range.is_a? ::Array
+        @step_arg1, @step_arg2, @topfx, @bypfx = *range
+        @receiver_num = step
+        @step = 1
+
+        @range = if @step_arg2
+                   @step = @step_arg2
+                   (@receiver_num..@step_arg1)
+                 elsif @step_arg1
+                   (@receiver_num..@step_arg1)
+                 else
+                   (@receiver_num..nil)
+                 end
+      else
+        @skipped_arg = true unless step
+        @range, @step = range, step || 1
+      end
+
+      @object = self
+
+      ::Kernel.raise ArgumentError, "step can't be 0" if @step == 0
+      unless @step.respond_to? :to_int
+        ::Kernel.raise ArgumentError, "no implicit conversion of #{@step.class} " \
+                                      'into Integer'
+      end
+    end
+
+    attr_reader :step
+
+    def begin
+      @range.begin
+    end
+
+    def end
+      @range.end
+    end
+
+    def exclude_end?
+      @range.exclude_end?
+    end
+
+    # @private
+    def _lesser_than_end?(val)
+      end_ = self.end || `inf`
+      if step > 0
+        exclude_end? ? val < end_ : val <= end_
+      else
+        exclude_end? ? val > end_ : val >= end_
+      end
+    end
+
+    # @private
+    def _greater_than_begin?(val)
+      begin_ = self.begin || -`inf`
+      if step > 0
+        val > begin_
+      else
+        val < begin_
+      end
+    end
+
+    def first(count = undefined)
+      iter = self.begin || -`inf`
+
+      return _lesser_than_end?(iter) ? iter : nil unless count
+
+      out = []
+
+      while _lesser_than_end?(iter) && count > 0
+        out << iter
+        iter += step
+        count -= 1
+      end
+
+      out
+    end
+
+    def each(&block)
+      return self unless block_given?
+
+      case self.begin
+      when nil
+        ::Kernel.raise TypeError, "nil can't be coerced into Integer"
+      end
+
+      iter = self.begin || -`inf`
+
+      while _lesser_than_end?(iter)
+        yield iter
+        iter += step
+      end
+      self
+    end
+
+    def last(count = undefined)
+      case self.end
+      when `inf`, -`inf`
+        ::Kernel.raise ::FloatDomainError, self.end
+      when nil
+        ::Kernel.raise ::RangeError, 'cannot get the last element of endless arithmetic sequence'
+      end
+
+      iter = self.end - ((self.end - self.begin) % step)
+      iter -= step unless _lesser_than_end?(iter)
+
+      return _greater_than_begin?(iter) ? iter : nil unless count
+
+      out = []
+
+      while _greater_than_begin?(iter) && count > 0
+        out << iter
+        iter -= step
+        count -= 1
+      end
+
+      out.reverse
+    end
+
+    def size
+      step_sign = step > 0 ? 1 : -1
+
+      if !_lesser_than_end?(self.begin)
+        0
+      elsif [-`inf`, `inf`].include?(step)
+        1
+      elsif [-`inf` * step_sign, nil].include?(self.begin) ||
+            [`inf` * step_sign, nil].include?(self.end)
+        `inf`
+      else
+        iter = self.end - ((self.end - self.begin) % step)
+        iter -= step unless _lesser_than_end?(iter)
+        ((iter - self.begin) / step).abs.to_i + 1
+      end
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        self.begin == other.begin &&
+        self.end == other.end &&
+        step == other.step &&
+        exclude_end? == other.exclude_end?
+    end
+
+    def hash
+      [self.begin, self.end, step, exclude_end?].hash
+    end
+
+    def inspect
+      if @receiver_num
+        args = if @step_arg2
+                 "(#{@topfx}#{@step_arg1.inspect}, #{@bypfx}#{@step_arg2.inspect})"
+               elsif @step_arg1
+                 "(#{@topfx}#{@step_arg1.inspect})"
+               end
+
+        "(#{@receiver_num.inspect}.#{@creation_method}#{args})"
+      else
+        args = unless @skipped_arg
+                 "(#{@step})"
+               end
+        "((#{@range.inspect}).#{@creation_method}#{args})"
+      end
+    end
+
+    alias === ==
+    alias eql? ==
+  end
+end

data/opal/corelib/enumerator/chain.rb

@@ -0,0 +1,42 @@
+class ::Enumerator
+  class self::Chain < self
+    def initialize(*enums)
+      @enums = enums
+      @iterated = []
+      @object = self
+    end
+
+    def each(*args, &block)
+      return to_enum(:each, *args) { size } unless block_given?
+
+      @enums.each do |enum|
+        @iterated << enum
+        enum.each(*args, &block)
+      end
+
+      self
+    end
+
+    def size(*args)
+      accum = 0
+      @enums.each do |enum|
+        size = enum.size(*args)
+        return size if [nil, ::Float::INFINITY].include? size
+        accum += size
+      end
+      accum
+    end
+
+    def rewind
+      @iterated.reverse_each do |enum|
+        enum.rewind if enum.respond_to? :rewind
+      end
+      @iterated = []
+      self
+    end
+
+    def inspect
+      "#<Enumerator::Chain: #{@enums.inspect}>"
+    end
+  end
+end

data/opal/corelib/enumerator/generator.rb

@@ -0,0 +1,35 @@
+# helpers: breaker
+
+class Enumerator
+  class Generator
+    include ::Enumerable
+
+    def initialize(&block)
+      ::Kernel.raise ::LocalJumpError, 'no block given' unless block
+
+      @block = block
+    end
+
+    def each(*args, &block)
+      yielder = Yielder.new(&block)
+
+      %x{
+        try {
+          args.unshift(#{yielder});
+
+          Opal.yieldX(#{@block}, args);
+        }
+        catch (e) {
+          if (e === $breaker) {
+            return $breaker.$v;
+          }
+          else {
+            throw e;
+          }
+        }
+      }
+
+      self
+    end
+  end
+end

data/opal/corelib/enumerator/lazy.rb

@@ -0,0 +1,243 @@
+# helpers: truthy, coerce_to, yield1, yieldX
+
+class ::Enumerator
+  class self::Lazy < self
+    class self::StopLazyError < ::Exception; end
+
+    def self.for(object, *)
+      lazy = super
+      `lazy.enumerator = object`
+      lazy
+    end
+
+    def initialize(object, size = nil, &block)
+      unless block_given?
+        ::Kernel.raise ::ArgumentError, 'tried to call lazy new without a block'
+      end
+
+      @enumerator = object
+
+      super size do |yielder, *each_args|
+        object.each(*each_args) do |*args|
+          %x{
+            args.unshift(#{yielder});
+
+            $yieldX(block, args);
+          }
+        end
+      rescue StopLazyError
+        nil
+      end
+    end
+
+    def lazy
+      self
+    end
+
+    def collect(&block)
+      unless block
+        ::Kernel.raise ::ArgumentError, 'tried to call lazy map without a block'
+      end
+
+      Lazy.new(self, enumerator_size) do |enum, *args|
+        %x{
+          var value = $yieldX(block, args);
+
+          #{enum.yield `value`};
+        }
+      end
+    end
+
+    def collect_concat(&block)
+      unless block
+        ::Kernel.raise ::ArgumentError, 'tried to call lazy map without a block'
+      end
+
+      Lazy.new(self, nil) do |enum, *args|
+        %x{
+          var value = $yieldX(block, args);
+
+          if (#{`value`.respond_to? :force} && #{`value`.respond_to? :each}) {
+            #{`value`.each { |v| enum.yield v }}
+          }
+          else {
+            var array = #{::Opal.try_convert `value`, ::Array, :to_ary};
+
+            if (array === nil) {
+              #{enum.yield `value`};
+            }
+            else {
+              #{`value`.each { |v| enum.yield v }};
+            }
+          }
+        }
+      end
+    end
+
+    def drop(n)
+      n = `$coerce_to(#{n}, #{::Integer}, 'to_int')`
+
+      if n < 0
+        ::Kernel.raise ::ArgumentError, 'attempt to drop negative size'
+      end
+
+      current_size = enumerator_size
+      set_size     = if ::Integer === current_size
+                       n < current_size ? n : current_size
+                     else
+                       current_size
+                     end
+
+      dropped = 0
+      Lazy.new(self, set_size) do |enum, *args|
+        if dropped < n
+          dropped += 1
+        else
+          enum.yield(*args)
+        end
+      end
+    end
+
+    def drop_while(&block)
+      unless block
+        ::Kernel.raise ::ArgumentError, 'tried to call lazy drop_while without a block'
+      end
+
+      succeeding = true
+      Lazy.new(self, nil) do |enum, *args|
+        if succeeding
+          %x{
+            var value = $yieldX(block, args);
+
+            if (!$truthy(value)) {
+              succeeding = false;
+
+              #{enum.yield(*args)};
+            }
+          }
+        else
+          enum.yield(*args)
+        end
+      end
+    end
+
+    def enum_for(method = :each, *args, &block)
+      self.class.for(self, method, *args, &block)
+    end
+
+    def find_all(&block)
+      unless block
+        ::Kernel.raise ::ArgumentError, 'tried to call lazy select without a block'
+      end
+
+      Lazy.new(self, nil) do |enum, *args|
+        %x{
+          var value = $yieldX(block, args);
+
+          if ($truthy(value)) {
+            #{enum.yield(*args)};
+          }
+        }
+      end
+    end
+
+    def grep(pattern, &block)
+      if block
+        Lazy.new(self, nil) do |enum, *args|
+          %x{
+            var param = #{::Opal.destructure(args)},
+                value = #{pattern === `param`};
+
+            if ($truthy(value)) {
+              value = $yield1(block, param);
+
+              #{enum.yield `$yield1(block, param)`};
+            }
+          }
+        end
+      else
+        Lazy.new(self, nil) do |enum, *args|
+          %x{
+            var param = #{::Opal.destructure(args)},
+                value = #{pattern === `param`};
+
+            if ($truthy(value)) {
+              #{enum.yield `param`};
+            }
+          }
+        end
+      end
+    end
+
+    def reject(&block)
+      unless block
+        ::Kernel.raise ::ArgumentError, 'tried to call lazy reject without a block'
+      end
+
+      Lazy.new(self, nil) do |enum, *args|
+        %x{
+          var value = $yieldX(block, args);
+
+          if (!$truthy(value)) {
+            #{enum.yield(*args)};
+          }
+        }
+      end
+    end
+
+    def take(n)
+      n = `$coerce_to(#{n}, #{::Integer}, 'to_int')`
+
+      if n < 0
+        ::Kernel.raise ::ArgumentError, 'attempt to take negative size'
+      end
+
+      current_size = enumerator_size
+      set_size     = if ::Integer === current_size
+                       n < current_size ? n : current_size
+                     else
+                       current_size
+                     end
+
+      taken = 0
+      Lazy.new(self, set_size) do |enum, *args|
+        if taken < n
+          enum.yield(*args)
+          taken += 1
+        else
+          ::Kernel.raise StopLazyError
+        end
+      end
+    end
+
+    def take_while(&block)
+      unless block
+        ::Kernel.raise ::ArgumentError, 'tried to call lazy take_while without a block'
+      end
+
+      Lazy.new(self, nil) do |enum, *args|
+        %x{
+          var value = $yieldX(block, args);
+
+          if ($truthy(value)) {
+            #{enum.yield(*args)};
+          }
+          else {
+            #{::Kernel.raise StopLazyError};
+          }
+        }
+      end
+    end
+
+    def inspect
+      "#<#{self.class}: #{@enumerator.inspect}>"
+    end
+
+    alias force to_a
+    alias filter find_all
+    alias flat_map collect_concat
+    alias map collect
+    alias select find_all
+    alias to_enum enum_for
+  end
+end

data/opal/corelib/enumerator/yielder.rb

@@ -0,0 +1,36 @@
+# helpers: breaker
+
+class Enumerator
+  class Yielder
+    def initialize(&block)
+      @block = block
+      # rubocop:disable Lint/Void
+      self
+      # rubocop:enable Lint/Void
+    end
+
+    def yield(*values)
+      %x{
+        var value = Opal.yieldX(#{@block}, values);
+
+        if (value === $breaker) {
+          throw $breaker;
+        }
+
+        return value;
+      }
+    end
+
+    def <<(value)
+      self.yield(value)
+
+      self
+    end
+
+    def to_proc
+      proc do |*values|
+        self.yield(*values)
+      end
+    end
+  end
+end