opal 0.11.0.rc1 → 0.11.0

data/opal/corelib/hash.rb

@@ -229,6 +229,56 @@ class Hash
     }
   end
 
+  def compact
+    %x{
+      var hash = Opal.hash();
+
+      for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
+        key = keys[i];
+
+        if (key.$$is_string) {
+          value = self.$$smap[key];
+        } else {
+          value = key.value;
+          key = key.key;
+        }
+
+        if (value !== nil) {
+          Opal.hash_put(hash, key, value);
+        }
+      }
+
+      return hash;
+    }
+  end
+
+  def compact!
+    %x{
+      var changes_were_made = false;
+
+      for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
+        key = keys[i];
+
+        if (key.$$is_string) {
+          value = self.$$smap[key];
+        } else {
+          value = key.value;
+          key = key.key;
+        }
+
+        if (value === nil) {
+          if (Opal.hash_delete(self, key) !== undefined) {
+            changes_were_made = true;
+            length--;
+            i--;
+          }
+        }
+      }
+
+      return changes_were_made ? self : nil;
+    }
+  end
+
   def compare_by_identity
     %x{
       var i, ii, key, keys = self.$$keys, identity_hash;
@@ -1012,6 +1062,54 @@ class Hash
 
   alias to_s inspect
 
+  def transform_values(&block)
+    return enum_for(:transform_values){self.size} unless block
+
+    %x{
+      var result = Opal.hash();
+
+      for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
+        key = keys[i];
+
+        if (key.$$is_string) {
+          value = self.$$smap[key];
+        } else {
+          value = key.value;
+          key = key.key;
+        }
+
+        value = Opal.yield1(block, value);
+
+        Opal.hash_put(result, key, value);
+      }
+
+      return result;
+    }
+  end
+
+  def transform_values!(&block)
+    return enum_for(:transform_values!){self.size} unless block
+
+    %x{
+      for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
+        key = keys[i];
+
+        if (key.$$is_string) {
+          value = self.$$smap[key];
+        } else {
+          value = key.value;
+          key = key.key;
+        }
+
+        value = Opal.yield1(block, value);
+
+        Opal.hash_put(self, key, value);
+      }
+
+      return self;
+    }
+  end
+
   alias update merge!
 
   alias value? has_value?

data/opal/corelib/io.rb

@@ -70,8 +70,8 @@ STDIN  = $stdin  = IO.new
 STDOUT = $stdout = IO.new
 
 `var console = Opal.global.console`
-STDOUT.write_proc = `typeof(process) === 'object' ? function(s){process.stdout.write(s)} : function(s){console.log(s)}`
-STDERR.write_proc = `typeof(process) === 'object' ? function(s){process.stderr.write(s)} : function(s){console.warn(s)}`
+STDOUT.write_proc = `typeof(process) === 'object' && typeof(process.stdout) === 'object' ? function(s){process.stdout.write(s)} : function(s){console.log(s)}`
+STDERR.write_proc = `typeof(process) === 'object' && typeof(process.stderr) === 'object' ? function(s){process.stderr.write(s)} : function(s){console.warn(s)}`
 
 STDOUT.extend(IO::Writable)
 STDERR.extend(IO::Writable)

data/opal/corelib/kernel.rb

@@ -137,7 +137,7 @@ module Kernel
     }
   end
 
-  def clone
+  def clone(freeze: true)
     copy = self.class.allocate
 
     copy.copy_instance_variables(self)
@@ -186,8 +186,19 @@ module Kernel
       block.call
     end
 
-    status = 0 if `status === true` # it's in JS because it can be null/undef
-    `Opal.exit(status);`
+    %x{
+      if (status == null) {
+        status = 0
+      } else if (status.$$is_boolean) {
+        status = status ? 0 : 1;
+      } else if (status.$$is_numeric) {
+        status = status.$to_i();
+      } else {
+        status = 0
+      }
+
+      Opal.exit(status);
+    }
     nil
   end
 
@@ -1123,18 +1134,20 @@ module Kernel
 
   # `path` should be the full path to be found in registered modules (`Opal.modules`)
   def require_tree(path)
-    path = File.expand_path(path)
-    path = '' if path == '.'
-
     %x{
+      var result = [];
+
+      path = #{File.expand_path(path)}
+      path = Opal.normalize(path);
+      if (path === '.') path = '';
       for (var name in Opal.modules) {
         if (#{`name`.start_with?(path)}) {
-          Opal.require(name);
+          result.push([name, Opal.require(name)]);
         }
       }
-    }
 
-    nil
+      return result;
+    }
   end
 
   alias send        __send__
@@ -1155,8 +1168,12 @@ module Kernel
       if (seconds < 0) {
         #{raise ArgumentError, "time interval must be positive"}
       }
-      var t = new Date();
-      while (new Date() - t <= seconds * 1000);
+      var get_time = Opal.global.performance ?
+        function() {return performance.now()} :
+        function() {return new Date()}
+
+      var t = get_time();
+      while (get_time() - t <= seconds * 1000);
       return seconds;
     }
   end

data/opal/corelib/marshal/read_buffer.rb

@@ -1,3 +1,6 @@
+# https://github.com/ruby/ruby/blob/trunk/doc/marshal.rdoc
+# https://github.com/ruby/ruby/blob/trunk/marshal.c
+
 module Marshal
   class ReadBuffer
     %x{
@@ -15,7 +18,7 @@ module Marshal
       }
     }
 
-    attr_reader :version, :buffer, :index, :user_class, :extended, :object_cache, :symbols_cache
+    attr_reader :version, :buffer, :index, :object_cache, :symbols_cache
 
     def initialize(input)
       @buffer = `stringToBytes(#{input.to_s})`
@@ -28,7 +31,6 @@ module Marshal
       @version = "#{major}.#{minor}"
       @object_cache = []
       @symbols_cache = []
-      @extended = []
       @ivars = []
     end
 
@@ -36,7 +38,7 @@ module Marshal
       @buffer.length
     end
 
-    def read(cache: true, ivar_index: nil)
+    def read(cache: true)
       code = read_char
       # The first character indicates the type of the object
       result = case code
@@ -48,56 +50,48 @@ module Marshal
         false
       when 'i'
         read_fixnum
-      when 'e'
-        read_extended
-        object = read
-        apply_extends(object)
-        object
-      when 'C'
-        read_user_class
-        read
-      when 'o'
-        read_object
-      when 'd'
-        raise NotImplementedError, 'Data type cannot be demarshaled'
-      when 'u'
-        raise NotImplementedError, 'UserDef type cannot be demarshaled yet' # read_userdef
-      when 'U'
-        read_usrmarshal
       when 'f'
         read_float
       when 'l'
         read_bignum
       when '"'
-        read_string(cache: cache)
-      when '/'
-        read_regexp
+        read_string
+      when ':'
+        read_symbol
+      when ';'
+        read_cached_symbol
       when '['
         read_array
       when '{'
         read_hash
       when '}'
-        raise NotImplementedError, 'Hashdef type cannot be demarshaled yet' # read_hashdef
+        read_hashdef
+      when '/'
+        read_regexp
       when 'S'
         read_struct
-      when 'M'
-        raise NotImplementedError, 'ModuleOld type cannot be demarshaled yet' # read_module_old
       when 'c'
         read_class
       when 'm'
         read_module
-      when ':'
-        read_symbol
-      when ';'
-        symbols_cache[read_fixnum]
-      when 'I'
-        ivar_index = @ivars.length
-        @ivars << true
-        object = read(cache: cache, ivar_index: ivar_index)
-        set_ivars(object) if @ivars.pop
-        object
+      when 'o'
+        read_object
       when '@'
-        object_cache[read_fixnum]
+        read_cached_object
+      when 'e'
+        read_extended_object
+      when 'I'
+        read_primitive_with_ivars
+      when 'C'
+        read_user_class
+      when 'u'
+        read_user_defined
+      when 'U'
+        read_user_marshal
+      when 'M'
+        raise NotImplementedError, 'ModuleOld type cannot be demarshaled yet' # read_module_old
+      when 'd'
+        raise NotImplementedError, 'Data type cannot be demarshaled'
       else
         raise ArgumentError, "dump format error"
       end
@@ -117,25 +111,6 @@ module Marshal
       `String.fromCharCode(#{read_byte})`
     end
 
-    def set_ivars(obj)
-      data = read_hash(cache: false)
-
-      data.each do |ivar, value|
-        case ivar
-        when :E then # encodings are not supported
-        when :encoding # encodings are not supported
-        else
-          if ivar.start_with?('@')
-            obj.instance_variable_set(ivar, value)
-          end
-        end
-      end
-
-      if obj.respond_to?(:marshal_load)
-        obj.marshal_load(data)
-      end
-    end
-
     # Reads and returns a fixnum from an input stream
     #
     def read_fixnum
@@ -171,12 +146,48 @@ module Marshal
       }
     end
 
+    # Reads and returns Float from an input stream
+    #
+    # @example
+    #   123.456
+    # Is encoded as
+    #   'f', '123.456'
+    #
+    def read_float
+      s = read_string(cache: false)
+      result = if s == "nan"
+        0.0 / 0
+      elsif s == "inf"
+        1.0 / 0
+      elsif s == "-inf"
+        -1.0 / 0
+      else
+        s.to_f
+      end
+      @object_cache << result
+      result
+    end
+
+    # Reads and returns Bignum from an input stream
+    #
+    def read_bignum
+      sign = read_char == '-' ? -1 : 1
+      size = read_fixnum * 2
+      result = 0
+      (0...size).each do |exp|
+        result += (read_char.ord) * 2 ** (exp * 8)
+      end
+      result = result.to_i * sign
+      @object_cache << result
+      result
+    end
+
     # Reads and returns a string from an input stream
     # Sometimes string shouldn't be cached using
     # an internal object cache, for a:
     #  + class/module name
-    #  + float
-    #  + regexp
+    #  + string representation of float
+    #  + string representation of regexp
     #
     def read_string(cache: true)
       length = read_fixnum
@@ -212,15 +223,30 @@ module Marshal
       }
     end
 
+    # Reads a symbol that was previously cache by its link
+    #
+    # @example
+    #   [:a, :a, :b, :b, :c, :c]
+    # Is encoded as
+    #   '[', 6, :a, @0, :b, @1, :c, @2
+    #
+    def read_cached_symbol
+      symbols_cache[read_fixnum]
+    end
+
     # Reads and returns an array from an input stream
     #
+    # @example
+    #   [100, 200, 300]
+    # is encoded as
+    #   '[', 3, 100, 200, 300
+    #
     def read_array
       result = []
       @object_cache << result
       length = read_fixnum
       %x{
         if (length > 0) {
-
           while (result.length < length) {
             result.push(#{read});
           }
@@ -236,6 +262,11 @@ module Marshal
     #  + hash of instance variables
     #  + hash of struct attributes
     #
+    # @example
+    #   {100 => 200, 300 => 400}
+    # is encoded as
+    #   '{', 2, 100, 200, 300, 400
+    #
     def read_hash(cache: true)
       result = {}
 
@@ -257,34 +288,61 @@ module Marshal
       }
     end
 
-    # Returns a constant by passed const_name,
-    #  re-raises Marshal-specific error when it's missing
+    # Reads and returns a hash with default value
     #
-    def safe_const_get(const_name)
-      begin
-        Object.const_get(const_name)
-      rescue NameError
-        raise ArgumentError, "undefined class/module #{const_name}"
-      end
+    # @example
+    #   Hash.new(:default).merge(100 => 200)
+    # is encoded as
+    #   '}', 1, 100, 200, :default
+    #
+    def read_hashdef
+      hash = read_hash
+      default_value = read
+      hash.default = default_value
+      hash
     end
 
-    # Reads and saves a user class from an input stream
-    #  Used for cases like String/Array subclasses
+    # Reads and returns Regexp from an input stream
     #
-    def read_user_class
-      @user_class = read(cache: false)
+    # @example
+    #   r = /regexp/mix
+    # is encoded as
+    #   '/', 'regexp', r.options.chr
+    #
+    def read_regexp
+      string = read_string(cache: false)
+      options = read_byte
+
+      result = Regexp.new(string, options)
+      @object_cache << result
+      result
     end
 
-    # Constantizes and resets saved user class
+    # Reads and returns a Struct from an input stream
     #
-    def get_user_class
-      klass = safe_const_get(@user_class)
-      @user_class = nil
-      klass
+    # @example
+    #   Point = Struct.new(:x, :y)
+    #   Point.new(100, 200)
+    # is encoded as
+    #   'S', :Point, {:x => 100, :y => 200}
+    #
+    def read_struct
+      klass_name = read(cache: false)
+      klass = safe_const_get(klass_name)
+      attributes = read_hash(cache: false)
+      args = attributes.values_at(*klass.members)
+      result = klass.new(*args)
+      @object_cache << result
+      result
     end
 
     # Reads and returns a Class from an input stream
     #
+    # @example
+    #   String
+    # is encoded as
+    #   'c', 'String'
+    #
     def read_class
       klass_name = read_string(cache: false)
       result = safe_const_get(klass_name)
@@ -297,6 +355,11 @@ module Marshal
 
     # Reads and returns a Module from an input stream
     #
+    # @example
+    #   Kernel
+    # is encoded as
+    #   'm', 'Kernel'
+    #
     def read_module
       mod_name = read_string(cache: false)
       result = safe_const_get(mod_name)
@@ -309,119 +372,194 @@ module Marshal
 
     # Reads and returns an abstract object from an input stream
     #
+    # @example
+    #   obj = Object.new
+    #   obj.instance_variable_set(:@ivar, 100)
+    #   obj
+    # is encoded as
+    #   'o', :Object, {:@ivar => 100}
+    #
+    # The only exception is a Range class (and its subclasses)
+    # For some reason in MRI isntances of this class have instance variables
+    # - begin
+    # - end
+    # - excl
+    # without '@' perfix.
+    #
     def read_object
       klass_name = read(cache: false)
       klass = safe_const_get(klass_name)
-      result = if @ivars.last
-        data = read_hash(cache: false)
-        load_object(klass, data)
-      else
-        object = klass.allocate
-        set_ivars(object)
-        object
+
+      object = klass.allocate
+      @object_cache << object
+
+      ivars = read_hash(cache: false)
+      ivars.each do |name, value|
+        if name[0] == '@'
+          object.instance_variable_set(name, value)
+        else
+          # MRI allows an object to have ivars that do not start from '@'
+          # https://github.com/ruby/ruby/blob/ab3a40c1031ff3a0535f6bcf26de40de37dbb1db/range.c#L1225
+          `object[name] = value`
+        end
       end
-      @object_cache << result
-      result
-    end
 
-    # Loads an instance of passed klass using
-    #  default marshal hooks
-    #
-    def load_object(klass, args)
-      return klass._load(args) if klass.respond_to?(:_load)
-      instance = klass.allocate
-      instance.marshal_load(args) if instance.respond_to?(:marshal_load)
-      instance
+      object
     end
 
-    # Reads and returns a Struct from an input stream
+    # Reads an object that was cached previously by its link
     #
-    def read_struct
-      klass_name = read(cache: false)
-      klass = safe_const_get(klass_name)
-      args = read_hash(cache: false)
-      result = load_object(klass, args)
-      @object_cache << result
-      result
+    # @example
+    #   obj1 = Object.new
+    #   obj2 = Object.new
+    #   obj3 = Object.new
+    #   [obj1, obj1, obj2, obj2, obj3, obj3]
+    # is encoded as
+    #   [obj1, @1, obj2, @2, obj3, @3]
+    #
+    # NOTE: array itself is cached as @0, that's why obj1 is cached a @1, obj2 is @2, etc.
+    #
+    def read_cached_object
+      object_cache[read_fixnum]
     end
 
-    # Reads and saves a Module from an input stream
-    #  that was extending marshalled object
+    # Reads an object that was dynamically extended before marshaling like
     #
-    def read_extended
-      @extended << read
+    # @example
+    #   M1 = Module.new
+    #   M2 = Module.new
+    #   obj = Object.new
+    #   obj.extend(M1)
+    #   obj.extend(M2)
+    #   obj
+    # is encoded as
+    #   'e', :M2, :M1, obj
+    #
+    def read_extended_object
+      mod = safe_const_get(read)
+      object = read
+      object.extend(mod)
+      object
     end
 
-    # Applies all saved extending modules
-    #  on the passed object
+    # Reads a primitive object with instance variables
+    # (classes that have their own marshalling rules, like Array/Hash/Regexp/etc)
+    #
+    # @example
+    #   arr = [100, 200, 300]
+    #   arr.instance_variable_set(:@ivar, :value)
+    #   arr
+    # is encoded as
+    #   'I', [100, 200, 300], {:@ivar => value}
     #
-    def apply_extends(object)
-      @extended.reverse_each do |e|
-        mod = safe_const_get(e)
-        object.extend(mod)
+    def read_primitive_with_ivars
+      object = read
+
+      primitive_ivars = read_hash(cache: false)
+
+      if primitive_ivars.any? && object.is_a?(String)
+        object = `new String(object)`
       end
-      @extended = []
-    end
 
-    # Reads and returns Bignum from an input stream
-    #
-    def read_bignum
-      sign = read_char == '-' ? -1 : 1
-      size = read_fixnum * 2
-      result = 0
-      (0...size).each do |exp|
-        result += (read_char.ord) * 2 ** (exp * 8)
+      primitive_ivars.each do |name, value|
+        if name != 'E'
+          object.instance_variable_set(name, value)
+        end
       end
-      result = result.to_i * sign
-      @object_cache << result
-      result
+
+      object
     end
 
-    # Reads and returns Float from an input stream
+    # Reads and User Class (instance of String/Regexp/Array/Hash subclass)
     #
-    def read_float
-      s = read_string(cache: false)
-      result = if s == "nan"
-        0.0 / 0
-      elsif s == "inf"
-        1.0 / 0
-      elsif s == "-inf"
-        -1.0 / 0
+    # @example
+    #   UserArray = Class.new(Array)
+    #   UserArray[100, 200, 300]
+    # is encoded as
+    #   'C', :UserArray, [100, 200, 300]
+    #
+    def read_user_class
+      klass_name = read(cache: false)
+      klass = safe_const_get(klass_name)
+      value = read(cache: false)
+
+      result = if klass < Hash
+        klass[value]
       else
-        s.to_f
+        klass.new(value)
       end
+
       @object_cache << result
+
       result
     end
 
-    # Reads and returns Regexp from an input stream
+    # Reads a 'User Defined' object that has '_dump/self._load' methods
     #
-    def read_regexp
-      args = [read_string(cache: false), read_byte]
+    # @example
+    #   class UserDefined
+    #     def _dump(level)
+    #       '_dumped'
+    #     end
+    #   end
+    #
+    #   UserDefined.new
+    # is encoded as
+    #   'u', :UserDefined, '_dumped'
+    #
+    # To load it back UserDefined._load' must be used.
+    #
+    def read_user_defined
+      klass_name = read(cache: false)
+      klass = safe_const_get(klass_name)
+      data = read_string(cache: false)
+      result = klass._load(data)
 
-      result = if @user_class
-        load_object(get_user_class, args)
-      else
-        load_object(Regexp, args)
-      end
       @object_cache << result
+
       result
     end
 
-    # Reads and returns an abstract object from an input stream
-    #  when the class of this object has custom marshalling rules
+    # Reads a 'User Marshal' object that has 'marshal_dump/marshal_load' methods
+    #
+    # @example
+    #   class UserMarshal < Struct.new(:a, :b)
+    #     def marshal_dump
+    #       [a, b]
+    #     end
+    #
+    #     def marshal_load(data)
+    #       self.a, self.b = data
+    #     end
+    #   end
     #
-    def read_usrmarshal
-      klass_name = read
+    #   UserMarshal.new(100, 200)
+    # is encoded as
+    #   'U', :UserMarshal, [100, 200]
+    #
+    # To load it back `UserMarshal.allocate` and `UserMarshal#marshal_load` must be called
+    #
+    def read_user_marshal
+      klass_name = read(cache: false)
       klass = safe_const_get(klass_name)
+
       result = klass.allocate
       @object_cache << result
-      data = read
-      unless result.respond_to?(:marshal_load)
-        raise TypeError, "instance of #{klass} needs to have method `marshal_load'"
-      end
+
+      data = read(cache: false)
       result.marshal_load(data)
       result
     end
+
+    # Returns a constant by passed const_name,
+    #  re-raises Marshal-specific error when it's missing
+    #
+    def safe_const_get(const_name)
+      begin
+        Object.const_get(const_name)
+      rescue NameError
+        raise ArgumentError, "undefined class/module #{const_name}"
+      end
+    end
   end
 end