opal 0.3.11 → 0.3.15

data/runtime/corelib/enumerator.rb

@@ -0,0 +1,80 @@
+# NOTE: our next/peek/rewind implementation is REALLY slow
+
+class Enumerator
+  include Enumerable
+
+  class Yielder
+    def initialize (block)
+      @block = block
+    end
+
+    def call (block)
+      @call = block
+
+      @block.call
+    end
+
+    def yield (value)
+      @call.call(value)
+    end
+
+    alias_method :<<, :yield
+  end
+
+  class Generator
+    attr_reader :enumerator
+
+    def initialize (block)
+      @yielder = Yielder.new(block)
+    end
+
+    def each (&block)
+      @yielder.call(block)
+    end
+  end
+
+  def initialize (object = nil, method = :each, *args, &block)
+    if block_given?
+      @object = Generator.new(block)
+      method  = :each
+    end
+
+    raise ArgumentError, 'wrong number of argument (0 for 1+)' unless object
+
+    @object = object
+    @method = method
+    @args   = args
+
+    @current = 0
+  end
+
+  def next
+  end
+
+  def each (&block)
+    return self unless block
+
+    @object.__send__ @method, *args, &block
+  end
+
+  def each_with_index (&block)
+    with_index &block
+  end
+
+  def with_index (offset = 0, &block)
+    return Enumerator.new(self, :with_index, offset) unless block
+  end
+
+  def with_object (object, &block)
+    return Enumerator.new(self, :with_object, object) unless block
+
+  end
+end
+
+module Kernel
+  def enum_for (method = :each, *args)
+    Enumerator.new(self, method, *args)
+  end
+
+  alias_method :to_enum, :enum_for
+end

data/runtime/corelib/error.rb

@@ -0,0 +1,25 @@
+class Exception
+  def initialize(message = '')
+    %x{
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(this);
+      }
+
+      this.message = message;
+    }
+  end
+
+  def backtrace
+    `this._bt || (this._bt = exc_backtrace(this))`
+  end
+
+  def inspect
+    "#<#{self.class}: '#{message}'>"
+  end
+
+  def message
+    `this.message`
+  end
+
+  alias_method :to_s, :message
+end

data/runtime/corelib/file.rb

@@ -0,0 +1,80 @@
+class File
+  def self.expand_path(path, base = undefined)
+    %x{
+      if (!base) {
+        if (path.charAt(0) !== '/') {
+          base = FS_CWD;
+        }
+        else {
+          base = '';
+        }
+      }
+
+      path = #{ join(base, path) };
+
+      var parts = path.split('/'), result = [], path;
+
+      // initial '/'
+      if (parts[0] === '') {
+        result.push('');
+      }
+
+      for (var i = 0, ii = parts.length; i < ii; i++) {
+        part = parts[i];
+
+        if (part === '..') {
+          result.pop();
+        }
+        else if (part === '.' || part === '') {
+
+        }
+        else {
+          result.push(part);
+        }
+      }
+
+      return result.join('/');
+    }
+  end
+
+  def self.join(*paths)
+    `paths.join('/')`
+  end
+
+  def self.dirname(path)
+    %x{
+      var dirname = PATH_RE.exec(path)[1];
+
+      if (!dirname) {
+        return '.';
+      }
+      else if (dirname === '/') {
+        return dirname;
+      }
+      else {
+        return dirname.substring(0, dirname.length - 1);
+      }
+    }
+  end
+
+  def self.extname(path)
+    %x{
+      var extname = PATH_RE.exec(path)[3];
+
+      if (!extname || extname === '.') {
+        return '';
+      }
+      else {
+        return extname;
+      }
+    }
+  end
+
+  def self.basename(path, suffix)
+    `$opal.fs.basename(path, suffix)`
+  end
+
+  def self.exist?(path)
+    `opal.loader.factories[#{ expand_path path }] ? true : false`
+  end
+end

data/runtime/corelib/hash.rb

@@ -0,0 +1,503 @@
+class Hash
+  include Enumerable
+
+  def self.[](*objs)
+    `$opal.hash.apply(null, objs)`
+  end
+
+  def self.allocate
+    `new $opal.hash()`
+  end
+
+  def self.new(defaults = undefined, &block)
+    %x{
+      var hash = new $opal.hash();
+
+      if (defaults !== undefined) {
+        hash.none = defaults;
+      }
+      else if (block !== nil) {
+        hash.proc = block;
+      }
+
+      return hash;
+    }
+  end
+
+  def ==(other)
+    %x{
+      if (this === other) {
+        return true;
+      }
+
+      if (!other.map) {
+        return false;
+      }
+
+      var map  = this.map,
+          map2 = other.map;
+
+      for (var assoc in map) {
+        if (!map2[assoc]) {
+          return false;
+        }
+
+        var obj  = map[assoc][1],
+            obj2 = map2[assoc][1];
+
+        if (#{`obj` != `obj2`}) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+  end
+
+  def [](key)
+    %x{
+      var hash = #{key.hash},
+          bucket;
+
+      if (bucket = this.map[hash]) {
+        return bucket[1];
+      }
+
+      return this.none;
+    }
+  end
+
+  def []=(key, value)
+    %x{
+      var hash       = #{key.hash};
+      this.map[hash] = [key, value];
+
+      return value;
+    }
+  end
+
+  def assoc(object)
+    %x{
+      for (var assoc in this.map) {
+        var bucket = this.map[assoc];
+
+        if (#{`bucket[0]` == `object`}) {
+          return [bucket[0], bucket[1]];
+        }
+      }
+
+      return nil;
+    }
+  end
+
+  def clear
+    %x{
+      this.map = {};
+
+      return this;
+    }
+  end
+
+  def clone
+    %x{
+      var result = new $opal.hash(),
+          map    = this.map,
+          map2   = result.map;
+
+      for (var assoc in map) {
+        map2[assoc] = [map[assoc][0], map[assoc][1]];
+      }
+
+      return result;
+    }
+  end
+
+  def default
+    `this.none`
+  end
+
+  def default=(object)
+    `this.none = object`
+  end
+
+  def default_proc
+    `this.proc`
+  end
+
+  def default_proc=(proc)
+    `this.proc = proc`
+  end
+
+  def delete(key)
+    %x{
+      var map  = this.map,
+          hash = #{key.hash},
+          result;
+
+      if (result = map[hash]) {
+        result = bucket[1];
+
+        delete map[hash];
+      }
+
+      return result;
+    }
+  end
+
+  def delete_if(&block)
+    return enum_for :delete_if unless block_given?
+
+    %x{
+      var map = this.map;
+
+      for (var assoc in map) {
+        var bucket = map[assoc],
+            value;
+
+        if ((value = $yield.call($context, null, bucket[0], bucket[1])) === $breaker) {
+          return $breaker.$v;
+        }
+
+        if (value !== false && value !== nil) {
+          delete map[assoc];
+        }
+      }
+
+      return this;
+    }
+  end
+
+  def each(&block)
+    return enum_for :each unless block_given?
+
+    %x{
+      var map = this.map;
+
+      for (var assoc in map) {
+        var bucket = map[assoc];
+
+        if ($yield.call($context, null, bucket[0], bucket[1]) === $breaker) {
+          return $breaker.$v;
+        }
+      }
+
+      return this;
+    }
+  end
+
+  def each_key(&block)
+    return enum_for :each_key unless block_given?
+
+    %x{
+      var map = this.map;
+
+      for (var assoc in map) {
+        var bucket = map[assoc];
+
+        if ($yield.call($context, null, bucket[0]) === $breaker) {
+          return $breaker.$v;
+        }
+      }
+
+      return this;
+    }
+  end
+
+  alias_method :each_pair, :each
+
+  def each_value(&block)
+    return enum_for :each_value unless block_given?
+
+    %x{
+      var map = this.map;
+
+      for (var assoc in map) {
+        var bucket = map[assoc];
+
+        if ($yield.call($context, null, bucket[1]) === $breaker) {
+          return $breaker.$v;
+        }
+      }
+
+      return this;
+    }
+  end
+
+  def empty?
+    %x{
+      for (var assoc in this.map) {
+        return false;
+      }
+
+      return true;
+    }
+  end
+
+  alias_method :eql?, :==
+
+  def fetch(key, defaults = undefined, &block)
+    %x{
+      var bucket = this.map[#{key.hash}];
+
+      if (block !== nil) {
+        var value;
+
+        if ((value = $yield.call($context, null, key)) === $breaker) {
+          return $breaker.$v;
+        }
+
+        return value;
+      }
+
+      if (defaults !== undefined) {
+        return defaults;
+      }
+
+      raise(RubyKeyError, 'key not found');
+    }
+  end
+
+  def flatten(level = undefined)
+    %x{
+      var map    = this.map,
+          result = [];
+
+      for (var assoc in map) {
+        var bucket = map[assoc],
+            key    = bucket[0],
+            value  = bucket[1];
+
+        result.push(key);
+
+        if (value.$flags & T_ARRAY) {
+          if (level === undefined || level === 1) {
+            result.push(value);
+          }
+          else {
+            result = result.concat(#{value.flatten(level - 1)});
+          }
+        }
+        else {
+          result.push(value);
+        }
+      }
+
+      return result;
+    }
+  end
+
+  def has_key?(key)
+    `!!this.map[#{key.hash}]`
+  end
+
+  def has_value?(value)
+    %x{
+      for (var assoc in this.map) {
+        if (#{`this.map[assoc][1]` == value}) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+  end
+
+  def hash
+    `this.$id`
+  end
+
+  def inspect
+    %x{
+      var inspect = [],
+          map     = this.map;
+
+      for (var assoc in map) {
+        var bucket = map[assoc];
+
+        inspect.push(#{`bucket[0]`.inspect} + '=>' + #{`bucket[1]`.inspect});
+      }
+      return '{' + inspect.join(', ') + '}';
+    }
+  end
+
+  def invert
+    %x{
+      var result = $opal.hash(),
+          map    = this.map,
+          map2   = result.map;
+
+      for (var assoc in map) {
+        var bucket = map[assoc];
+
+        map2[#{`bucket[1]`.hash}] = [bucket[0], bucket[1]];
+      }
+
+      return result;
+    }
+  end
+
+  def key(object)
+    %x{
+      for (var assoc in this.map) {
+        var bucket = this.map[assoc];
+
+        if (#{object == `bucket[1]`}) {
+          return bucket[0];
+        }
+      }
+
+      return nil;
+    }
+  end
+
+  alias_method :key?, :has_key?
+
+  def keys
+    %x{
+      var result = [];
+
+      for (var assoc in this.map) {
+        result.push(this.map[assoc][0]);
+      }
+
+      return result;
+    }
+  end
+
+  def length
+    %x{
+      var result = 0;
+
+      for (var assoc in this.map) {
+        result++;
+      }
+
+      return result;
+    }
+  end
+
+  alias_method :member?, :has_key?
+
+  def merge(other)
+    %x{
+      var result = $opal.hash(),
+          map    = this.map,
+          map2   = result.map;
+
+      for (var assoc in map) {
+        var bucket = map[assoc];
+
+        map2[assoc] = [bucket[0], bucket[1]];
+      }
+
+      map = other.map;
+
+      for (var assoc in map) {
+        var bucket = map[assoc];
+
+        map2[assoc] = [bucket[0], bucket[1]];
+      }
+
+      return result;
+    }
+  end
+
+  def merge!(other)
+    %x{
+      var map  = this.map,
+          map2 = other.map;
+
+      for (var assoc in map2) {
+        var bucket = map2[assoc];
+
+        map[assoc] = [bucket[0], bucket[1]];
+      }
+
+      return this;
+    }
+  end
+
+  def rassoc(object)
+    %x{
+      var map = this.map;
+
+      for (var assoc in map) {
+        var bucket = map[assoc];
+
+        if (#{`bucket[1]` == object}) {
+          return [bucket[0], bucket[1]];
+        }
+      }
+
+      return nil;
+    }
+  end
+
+  def replace(other)
+    %x{
+      var map = this.map = {};
+
+      for (var assoc in other.map) {
+        var bucket = other.map[assoc];
+
+        map[assoc] = [bucket[0], bucket[1]];
+      }
+
+      return this;
+    }
+  end
+
+  alias_method :size, :length
+
+  def to_a
+    %x{
+      var map    = this.map,
+          result = [];
+
+      for (var assoc in map) {
+        var bucket = map[assoc];
+
+        result.push([bucket[0], bucket[1]]);
+      }
+
+      return result;
+    }
+  end
+
+  def to_hash
+    self
+  end
+
+  def to_native
+    %x{
+      var map    = this.map,
+          result = {};
+
+      for (var assoc in map) {
+        var key   = map[assoc][0],
+            value = map[assoc][1];
+
+        result[key] = #{Opal.object?(`value`) ? `value`.to_native : `value`};
+      }
+
+      return result;
+    }
+  end
+
+  alias_method :to_s, :inspect
+
+  alias_method :update, :merge!
+
+  def values
+    %x{
+      var map    = this.map,
+          result = [];
+
+      for (var assoc in map) {
+        result.push(map[assoc][1]);
+      }
+
+      return result;
+    }
+  end
+end