opal 0.8.0.beta1 → 0.8.0.rc1

data/opal/corelib/enumerable.rb

@@ -943,7 +943,7 @@ module Enumerable
     return enum_for :partition unless block_given?
 
     %x{
-      var truthy = [], falsy = [];
+      var truthy = [], falsy = [], result;
 
       self.$each.$$p = function() {
         var param = #{Opal.destructure(`arguments`)},

data/opal/corelib/enumerator.rb

@@ -59,7 +59,7 @@ class Enumerator
     return enum_for :with_index, offset unless block
 
     %x{
-      var result, index = 0;
+      var result, index = offset;
 
       self.$each.$$p = function() {
         var param = #{Opal.destructure(`arguments`)},
@@ -79,7 +79,7 @@ class Enumerator
         return result;
       }
 
-      return nil;
+      return self.object;
     }
   end
 

data/opal/corelib/hash.rb

@@ -363,7 +363,7 @@ class Hash
     %x{
       var _map = self.map,
           smap = self.smap,
-          keys = self.keys;
+          keys = self.keys, key, map, khash;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         key = keys[i];
@@ -613,7 +613,7 @@ class Hash
 
         var key, value,
             inspect = [],
-            keys = self.keys
+            keys = self.keys,
             id = self.$object_id(),
             counter = 0;
 
@@ -820,7 +820,7 @@ class Hash
       var keys = self.keys,
           _map = self.map,
           smap = self.smap,
-          key, khash, value;
+          key, khash, value, map;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         key = keys[i]
@@ -967,7 +967,7 @@ class Hash
           smap = self.smap,
           keys = self.keys,
           result = nil,
-          key, khash, value, object;
+          key, khash, value, object, map;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         key = keys[i];
@@ -1039,7 +1039,7 @@ class Hash
           _map = self.map,
           smap = self.smap,
           result = [],
-          map, key;
+          map, key, khash;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         key = keys[i];
@@ -1096,7 +1096,7 @@ class Hash
           smap = self.smap,
           keys = self.keys,
           result = [],
-          map, khash;
+          map, khash, key;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         key = keys[i];

data/opal/corelib/kernel.rb

@@ -116,7 +116,9 @@ module Kernel
     initialize_copy(other)
   end
 
-  def define_singleton_method(name, &body)
+  def define_singleton_method(name, body = nil, &block)
+    body ||= block
+
     unless body
       raise ArgumentError, "tried to create Proc object without a block"
     end
@@ -180,8 +182,8 @@ module Kernel
 
   def format(format_string, *args)
     if args.length == 1 && args[0].respond_to?(:to_ary)
-      args = args[0].to_ary
-      args = args.to_a
+      ary = Opal.coerce_to?(args[0], Array, :to_ary)
+      args = ary.to_a unless ary.nil?
     end
 
     %x{

data/opal/corelib/module.rb

@@ -198,7 +198,7 @@ class Module
     raise NameError, "wrong constant name #{name}" unless name =~ /^[A-Z]\w*$/
 
     %x{
-      scopes = [self.$$scope];
+      var scopes = [self.$$scope];
 
       if (inherit || self === Opal.Object) {
         var parent = self.$$super;
@@ -278,18 +278,24 @@ class Module
     value
   end
 
-  def define_method(name, method = nil, &block)
-    unless method || block
-      raise ArgumentError, 'tried to create Proc object without a block'
+  def define_method(name, method = undefined, &block)
+    if `method === undefined && !#{block_given?}`
+      raise ArgumentError, "tried to create a Proc object without a block"
     end
 
-    if method
-      if Proc === method
-        block = method
-      else
-        raise TypeError, "wrong argument type #{method.class} (expected Proc/Method)"
-      end
-    end
+    block ||= case method
+              when Proc
+                method
+              when Method
+                method.to_proc
+              when UnboundMethod
+                lambda do |*args|
+                  bound = method.bind(self)
+                  bound.call *args
+                end
+              else
+                raise TypeError, "wrong argument type #{block.class} (expected Proc/Method)"
+              end
 
     %x{
       var id = '$' + name;
@@ -536,7 +542,7 @@ class Module
   end
 
   def to_s
-    name || "#<#{`self.$$is_mod ? 'Module' : 'Class'`}:0x#{__id__.to_s(16)}>"
+    `self.$$name` || "#<#{`self.$$is_mod ? 'Module' : 'Class'`}:0x#{__id__.to_s(16)}>"
   end
 
   def undef_method(symbol)

data/opal/corelib/regexp.rb

@@ -1,5 +1,9 @@
+class RegexpError < StandardError; end
 class Regexp
-  `def.$$is_regexp = true`
+  IGNORECASE = 1
+  MULTILINE = 4
+  
+  `def.$$is_regexp = true`  
 
   class << self
     def escape(string)
@@ -23,11 +27,77 @@ class Regexp
     alias quote escape
 
     def union(*parts)
-      `new RegExp(parts.join(''))`
+      %x{
+        var is_first_part_array, quoted_validated, part, options, each_part_options;
+        if (parts.length == 0) {
+          return /(?!)/;
+        }
+        // cover the 2 arrays passed as arguments case
+        is_first_part_array = parts[0].$$is_array;
+        if (parts.length > 1 && is_first_part_array) {
+          #{raise TypeError, 'no implicit conversion of Array into String'}
+        }        
+        // deal with splat issues (related to https://github.com/opal/opal/issues/858)
+        if (is_first_part_array) {
+          parts = parts[0];
+        }
+        options = undefined;
+        quoted_validated = [];
+        for (var i=0; i < parts.length; i++) {
+          part = parts[i];
+          if (part.$$is_string) {
+            quoted_validated.push(#{escape(`part`)});
+          }
+          else if (part.$$is_regexp) { 
+            each_part_options = #{`part`.options};   
+            if (options != undefined && options != each_part_options) {
+              #{raise TypeError, 'All expressions must use the same options'}
+            }
+            options = each_part_options;
+            quoted_validated.push('('+part.source+')');
+          }
+          else {
+            quoted_validated.push(#{escape(`part`.to_str)});
+          }
+        }
+      }
+      # Take advantage of logic that can parse options from JS Regex
+      new(`quoted_validated`.join('|'), `options`) 
     end
 
-    def new(regexp, options = undefined)
-      `new RegExp(regexp, options)`
+    def new(regexp, options = undefined)      
+      %x{
+        // Play nice with IE8
+        if (regexp.$$is_string && regexp.substr(regexp.length-1, 1) == "\\") {
+          #{raise RegexpError, "too short escape sequence: /#{regexp}/"}
+        }
+        
+        if (options == undefined || #{!options}) {
+          options = undefined;
+        }
+        
+        if (options != undefined) {
+          if (regexp.$$is_regexp) {
+            // options are already in regex
+            options = undefined;
+          }
+          else if (options.$$is_number) {
+            var result = '';
+            if (#{IGNORECASE} & options) {
+              result += 'i';
+            }
+            if (#{MULTILINE} & options) {
+              result += 'm';
+            }
+            options = result;
+          }
+          else {
+            options = 'i';
+          }
+        }       
+        
+        return new RegExp(regexp, options);
+      }
     end
   end
 
@@ -70,6 +140,7 @@ class Regexp
         }
       }
 
+      // global RegExp maintains state, so not using self/this
       var md, re = new RegExp(self.source, 'gm' + (self.ignoreCase ? 'i' : ''));
 
       while (true) {
@@ -93,6 +164,41 @@ class Regexp
   def source
     `self.source`
   end
+  
+  def options
+    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/flags is still experimental
+    # we need the flags and source does not give us that
+    %x{
+      var as_string, text_flags, result, text_flag;
+      as_string = self.toString();
+      if (as_string == "/(?:)/") {
+        #{raise TypeError, 'uninitialized Regexp'}
+      }
+      text_flags = as_string.replace(self.source, '').match(/\w+/);
+      result = 0;
+      // may have no flags
+      if (text_flags == null) {
+        return result;
+      }
+      // first match contains all of our flags
+      text_flags = text_flags[0];
+      for (var i=0; i < text_flags.length; i++) {
+        text_flag = text_flags[i];
+        switch(text_flag) {
+          case 'i':
+            result |= #{IGNORECASE};
+            break;
+          case 'm':
+            result |= #{MULTILINE};
+            break;
+          default:
+            #{raise "RegExp flag #{`text_flag`} does not have a match in Ruby"}
+        }
+      }
+      
+      return result;
+    }  
+  end
 
   alias to_s source
 end

data/opal/corelib/runtime.js

@@ -155,7 +155,7 @@
     }
     else if (typeof(superklass) === 'function') {
       // passed native constructor as superklass, so bridge it as ruby class
-      return bridge_class(id, superklass);
+      return bridge_class(id, superklass, base);
     }
     else {
       // if class doesnt exist, create a new one with given superclass
@@ -560,14 +560,22 @@
    *
    * @param [String] name the name of the ruby class to create
    * @param [Function] constructor native javascript constructor to use
+   * @param [Object] base where the bridge class is being created. If none is supplied, the top level scope (Opal) will be used
    * @return [Class] returns new ruby class
    */
-  function bridge_class(name, constructor) {
+  function bridge_class(name, constructor, base) {
     var klass = boot_class_object(ObjectClass, constructor);
 
     klass.$$name = name;
 
-    create_scope(Opal, klass, name);
+    if (base === undefined) {
+      base = Opal;
+    }
+    else {
+      base = base.$$scope;
+    }
+
+    create_scope(base, klass, name);
     bridged_classes.push(klass);
 
     var object_methods = BasicObjectClass.$$methods.concat(ObjectClass.$$methods);
@@ -1155,7 +1163,7 @@
         keys = [],
         _map = {},
         smap = {},
-        key, obj, length, khash;
+        key, obj, length, khash, map;
 
     hash.map   = _map;
     hash.smap  = smap;

data/opal/corelib/string.rb

@@ -952,127 +952,83 @@ class String
   alias slice []
   alias slice! <<
 
-  def split(pattern = $; || ' ', limit = undefined)
+  def split(pattern = undefined, limit = undefined)
     %x{
-      if (pattern === nil || pattern === undefined) {
-        pattern = #{$;};
-      }
-
-      var result = [];
-      if (limit !== undefined) {
-        limit = #{Opal.coerce_to!(limit, Integer, :to_int)};
-      }
-
       if (self.length === 0) {
         return [];
       }
 
-      if (limit === 1) {
-        return [self];
+      if (limit === undefined) {
+        limit = 0;
+      } else {
+        limit = #{Opal.coerce_to!(limit, Integer, :to_int)};
+        if (limit === 1) {
+          return [self];
+        }
       }
 
-      if (pattern && pattern.$$is_regexp) {
-        var pattern_str = pattern.toString();
+      if (pattern === undefined || pattern === nil) {
+        pattern = #{$; || ' '};
+      }
 
-        /* Opal and JS's repr of an empty RE. */
-        var blank_pattern = (pattern_str.substr(0, 3) == '/^/') ||
-                  (pattern_str.substr(0, 6) == '/(?:)/');
+      var result = [],
+          string = self.toString(),
+          index = 0,
+          match,
+          i;
 
-        /* This is our fast path */
-        if (limit === undefined || limit === 0) {
-          result = self.split(blank_pattern ? /(?:)/ : pattern);
+      if (pattern.$$is_regexp) {
+        pattern = new RegExp(pattern.source, 'gm' + (pattern.ignoreCase ? 'i' : ''));
+      } else {
+        pattern = #{Opal.coerce_to(pattern, String, :to_str).to_s};
+        if (pattern === ' ') {
+          pattern = /\s+/gm;
+          string = string.replace(/^\s+/, '');
+        } else {
+          pattern = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gm');
         }
-        else {
-          /* RegExp.exec only has sane behavior with global flag */
-          if (! pattern.global) {
-            pattern = eval(pattern_str + 'g');
-          }
-
-          var match_data;
-          var prev_index = 0;
-          pattern.lastIndex = 0;
-
-          while ((match_data = pattern.exec(self)) !== null) {
-            var segment = self.slice(prev_index, match_data.index);
-            result.push(segment);
-
-            prev_index = pattern.lastIndex;
-
-            if (match_data[0].length === 0) {
-              if (blank_pattern) {
-                /* explicitly split on JS's empty RE form.*/
-                pattern = /(?:)/;
-              }
-
-              result = self.split(pattern);
-              /* with "unlimited", ruby leaves a trail on blanks. */
-              if (limit !== undefined && limit < 0 && blank_pattern) {
-                result.push('');
-              }
-
-              prev_index = undefined;
-              break;
-            }
+      }
 
-            if (limit !== undefined && limit > 1 && result.length + 1 == limit) {
-              break;
-            }
-          }
+      result = string.split(pattern);
 
-          if (prev_index !== undefined) {
-            result.push(self.slice(prev_index, self.length));
-          }
-        }
+      while ((i = result.indexOf(undefined)) !== -1) {
+        result.splice(i, 1);
       }
-      else {
-        var splitted = 0, start = 0, lim = 0;
 
-        if (pattern === nil || pattern === undefined) {
-          pattern = ' '
-        } else {
-          pattern = #{Opal.try_convert(pattern, String, :to_str).to_s};
+      if (limit === 0) {
+        while (result[result.length - 1] === '') {
+          result.length -= 1;
         }
+        return result;
+      }
 
-        var string = (pattern == ' ') ? self.replace(/[\r\n\t\v]\s+/g, ' ')
-                                      : self;
-        var cursor = -1;
-        while ((cursor = string.indexOf(pattern, start)) > -1 && cursor < string.length) {
-          if (splitted + 1 === limit) {
-            break;
-          }
-
-          if (pattern == ' ' && cursor == start) {
-            start = cursor + 1;
-            continue;
-          }
-
-          result.push(string.substr(start, pattern.length ? cursor - start : 1));
-          splitted++;
-
-          start = cursor + (pattern.length ? pattern.length : 1);
-        }
+      match = pattern.exec(string);
 
-        if (string.length > 0 && (limit < 0 || string.length > start)) {
-          if (string.length == start) {
+      if (limit < 0) {
+        if (match !== null && match[0] === '' && pattern.source.indexOf('(?=') === -1) {
+          for (i = 0; i < match.length; i++) {
             result.push('');
           }
-          else {
-            result.push(string.substr(start, string.length));
-          }
         }
+        return result;
       }
 
-      if (limit === undefined || limit === 0) {
-        while (result[result.length-1] === '') {
-          result.length = result.length - 1;
-        }
+      if (match !== null && match[0] === '') {
+        result.splice(limit - 1, result.length - 1, result.slice(limit - 1).join(''));
+        return result;
       }
 
-      if (limit > 0) {
-        var tail = result.slice(limit - 1).join('');
-        result.splice(limit - 1, result.length - 1, tail);
+      i = 0;
+      while (match !== null) {
+        i++;
+        index = pattern.lastIndex;
+        if (i + 1 === limit) {
+          break;
+        }
+        match = pattern.exec(string);
       }
 
+      result.splice(limit - 1, result.length - 1, string.slice(index));
       return result;
     }
   end