opal 1.1.0.rc1 → 1.2.0.beta1

data/opal/corelib/range.rb

@@ -9,7 +9,7 @@ class Range
 
   def initialize(first, last, exclude = false)
     raise NameError, "'initialize' called twice" if @begin
-    raise ArgumentError, 'bad value for range' unless first <=> last
+    raise ArgumentError, 'bad value for range' unless first <=> last || first.nil? || last.nil?
 
     @begin = first
     @end   = last
@@ -20,15 +20,35 @@ class Range
     include? value
   end
 
+  %x{
+    function is_infinite(self) {
+      if (self.begin === nil || self.end === nil ||
+          self.begin === -Infinity || self.end === Infinity ||
+          self.begin === Infinity || self.end === -Infinity) return true;
+      return false;
+    }
+  }
+
+  def count(&block)
+    if !block_given? && `is_infinite(self)`
+      return Float::INFINITY
+    end
+    super
+  end
+
+  def to_a
+    raise TypeError, 'cannot convert endless range to an array' if `is_infinite(self)`
+    super
+  end
+
   def cover?(value)
-    beg_cmp = (@begin <=> value)
-    return false unless beg_cmp && beg_cmp <= 0
-    end_cmp = (value <=> @end)
+    beg_cmp = (@begin.nil? && -1) || (@begin <=> value) || false
+    end_cmp = (@end.nil? && -1) || (value <=> @end) || false
     if @excl
       end_cmp && end_cmp < 0
     else
       end_cmp && end_cmp <= 0
-    end
+    end && beg_cmp && beg_cmp <= 0
   end
 
   def each(&block)
@@ -62,7 +82,7 @@ class Range
       raise TypeError, "can't iterate from #{current.class}"
     end
 
-    while (current <=> last) < 0
+    while @end.nil? || (current <=> last) < 0
       yield current
 
       current = current.succ
@@ -88,6 +108,7 @@ class Range
   end
 
   def first(n = undefined)
+    raise RangeError, 'cannot get the minimum of beginless range' if @begin.nil?
     return @begin if `n == null`
     super
   end
@@ -95,17 +116,19 @@ class Range
   alias include? cover?
 
   def last(n = undefined)
+    raise RangeError, 'cannot get the maximum of endless range' if @end.nil?
     return @end if `n == null`
     to_a.last(n)
   end
 
   # FIXME: currently hardcoded to assume range holds numerics
   def max
-    if block_given?
+    if @end.nil?
+      raise RangeError, 'cannot get the maximum of endless range'
+    elsif block_given?
       super
-    elsif @begin > @end
-      nil
-    elsif @excl && @begin == @end
+    elsif !@begin.nil? && (@begin > @end ||
+                           @excl && @begin == @end)
       nil
     else
       `#{@excl} ? #{@end} - 1 : #{@end}`
@@ -115,11 +138,12 @@ class Range
   alias member? cover?
 
   def min
-    if block_given?
+    if @begin.nil?
+      raise RangeError, 'cannot get the minimum of beginless range'
+    elsif block_given?
       super
-    elsif @begin > @end
-      nil
-    elsif @excl && @begin == @end
+    elsif !@end.nil? && (@begin > @end ||
+                         @excl && @begin == @end)
       nil
     else
       @begin
@@ -127,14 +151,17 @@ class Range
   end
 
   def size
+    infinity = Float::INFINITY
+
+    return 0 if (@begin == infinity && !@end.nil?) || (@end == -infinity && !@begin.nil?)
+    return infinity if `is_infinite(self)`
+    return nil unless Numeric === @begin && Numeric === @end
+
     range_begin = @begin
     range_end   = @end
     range_end  -= 1 if @excl
 
-    return nil unless Numeric === range_begin && Numeric === range_end
     return 0 if range_end < range_begin
-    infinity = Float::INFINITY
-    return infinity if [range_begin.abs, range_end.abs].include?(infinity)
 
     `Math.abs(range_end - range_begin) + 1`.to_i
   end
@@ -228,6 +255,10 @@ class Range
   def bsearch(&block)
     return enum_for(:bsearch) unless block_given?
 
+    if `is_infinite(self) && (self.begin.$$is_number || self.end.$$is_number)`
+      raise NotImplementedError, "Can't #bsearch an infinite range"
+    end
+
     unless `self.begin.$$is_number && self.end.$$is_number`
       raise TypeError, "can't do binary search for #{@begin.class}"
     end
@@ -236,11 +267,11 @@ class Range
   end
 
   def to_s
-    "#{@begin}#{@excl ? '...' : '..'}#{@end}"
+    "#{@begin || ''}#{@excl ? '...' : '..'}#{@end || ''}"
   end
 
   def inspect
-    "#{@begin.inspect}#{@excl ? '...' : '..'}#{@end.inspect}"
+    "#{@begin && @begin.inspect}#{@excl ? '...' : '..'}#{@end && @end.inspect}"
   end
 
   def marshal_load(args)

data/opal/corelib/runtime.js

@@ -533,7 +533,7 @@
   Opal.klass = function(scope, superclass, name) {
     var bridged;
 
-    if (scope == null) {
+    if (scope == null || scope == '::') {
       // Global scope
       scope = _Object;
     } else if (!scope.$$is_class && !scope.$$is_module) {
@@ -542,9 +542,20 @@
     }
 
     // If the superclass is not an Opal-generated class then we're bridging a native JS class
-    if (superclass != null && !superclass.hasOwnProperty('$$is_class')) {
-      bridged = superclass;
-      superclass = _Object;
+    if (
+      superclass != null && (!superclass.hasOwnProperty || (
+        superclass.hasOwnProperty && !superclass.hasOwnProperty('$$is_class')
+      ))
+    ) {
+      if (superclass.constructor && superclass.constructor.name == "Function") {
+        bridged = superclass;
+        superclass = _Object;
+      } else {
+        throw Opal.TypeError.$new("superclass must be a Class (" + (
+          (superclass.constructor && (superclass.constructor.name || superclass.constructor.$$name)) ||
+          typeof(superclass)
+        ) + " given)");
+      }
     }
 
     var klass = find_existing_class(scope, name);
@@ -643,7 +654,7 @@
   Opal.module = function(scope, name) {
     var module;
 
-    if (scope == null) {
+    if (scope == null || scope == '::') {
       // Global scope
       scope = _Object;
     } else if (!scope.$$is_class && !scope.$$is_module) {
@@ -884,6 +895,31 @@
     return value;
   };
 
+  // Gets class variable with specified +name+ from provided +module+
+  //
+  // @param module [Module]
+  // @param name [String]
+  Opal.class_variable_get = function(module, name, tolerant) {
+    if ($has_own.call(module.$$cvars, name))
+      return module.$$cvars[name];
+
+    var ancestors = Opal.ancestors(module),
+      i, length = ancestors.length;
+
+    for (i = 0; i < length; i++) {
+      var ancestor = ancestors[i];
+
+      if ($has_own.call(ancestor.$$cvars, name)) {
+        return ancestor.$$cvars[name];
+      }
+    }
+
+    if (!tolerant)
+      throw Opal.NameError.$new('uninitialized class variable '+name+' in '+module.$name());
+
+    return nil;
+  }
+
   function isRoot(proto) {
     return proto.hasOwnProperty('$$iclass') && proto.hasOwnProperty('$$root');
   }
@@ -997,10 +1033,10 @@
       // because there are no intermediate classes between `parent` and `next ancestor`.
       // It doesn't break any prototypes of other objects as we don't change class references.
 
-      var proto = includer.$$prototype, parent = proto, module_iclass = Object.getPrototypeOf(parent);
+      var parent = includer.$$prototype, module_iclass = Object.getPrototypeOf(parent);
 
       while (module_iclass != null) {
-        if (isRoot(module_iclass) && module_iclass.$$module === module) {
+        if (module_iclass.$$module === module && isRoot(module_iclass)) {
           break;
         }
 
@@ -1008,15 +1044,23 @@
         module_iclass = Object.getPrototypeOf(module_iclass);
       }
 
-      var next_ancestor = Object.getPrototypeOf(module_iclass);
+      if (module_iclass) {
+        // module has been directly included
+        var next_ancestor = Object.getPrototypeOf(module_iclass);
 
-      // skip non-root iclasses (that were recursively included)
-      while (next_ancestor.hasOwnProperty('$$iclass') && !isRoot(next_ancestor)) {
-        next_ancestor = Object.getPrototypeOf(next_ancestor);
-      }
+        // skip non-root iclasses (that were recursively included)
+        while (next_ancestor.hasOwnProperty('$$iclass') && !isRoot(next_ancestor)) {
+          next_ancestor = Object.getPrototypeOf(next_ancestor);
+        }
 
-      start_chain_after = parent;
-      end_chain_on = next_ancestor;
+        start_chain_after = parent;
+        end_chain_on = next_ancestor;
+      } else {
+        // module has not been directly included but was in ancestor chain because it was included by another module
+        // include it directly
+        start_chain_after = includer.$$prototype;
+        end_chain_on = Object.getPrototypeOf(includer.$$prototype);
+      }
     }
 
     $set_proto(start_chain_after, chain.first);
@@ -2439,29 +2483,46 @@
 
   // Sets the encoding on a string, will treat string literals as frozen strings
   // raising a FrozenError.
-  // @param str [String] the string on which the encoding should be set.
+  //
+  // @param str [String] the string on which the encoding should be set
   // @param name [String] the canonical name of the encoding
-  Opal.set_encoding = function(str, name) {
-    if (typeof str === 'string')
+  // @param type [String] possible values are either `"encoding"`, `"internal_encoding"`, or `undefined
+  Opal.set_encoding = function(str, name, type) {
+    if (typeof type === "undefined") type = "encoding";
+    if (typeof str === 'string' || str.$$frozen === true)
       throw Opal.FrozenError.$new("can't modify frozen String");
 
-    var encoding = Opal.encodings[name];
+    var encoding = Opal.find_encoding(name);
 
-    if (encoding === str.encoding) { return str; }
+    if (encoding === str[type]) { return str; }
 
-    str.encoding = encoding;
+    str[type] = encoding;
 
     return str;
   };
 
+  // Fetches the encoding for the given name or raises ArgumentError.
+  Opal.find_encoding = function(name) {
+    var register = Opal.encodings;
+    var encoding = register[name] || register[name.toUpperCase()];
+    if (!encoding) throw Opal.ArgumentError.$new("unknown encoding name - " + name);
+    return encoding;
+  }
+
   // @returns a String object with the encoding set from a string literal
   Opal.enc = function(str, name) {
     var dup = new String(str);
-    Opal.set_encoding(dup, name);
+    dup = Opal.set_encoding(dup, name);
     dup.internal_encoding = dup.encoding;
     return dup
   }
 
+  // @returns a String object with the internal encoding set to Binary
+  Opal.binary = function(str) {
+    var dup = new String(str);
+    return Opal.set_encoding(dup, "binary", "internal_encoding");
+  }
+
 
   // Initialization
   // --------------

data/opal/corelib/string.rb

@@ -29,18 +29,26 @@ class String < `String`
     Opal.coerce_to?(what, String, :to_str)
   end
 
-  def self.new(str = '')
-    str = `$coerce_to(str, #{String}, 'to_str')`
-    `new self.$$constructor(str)`
-  end
-
-  def initialize(str = undefined)
+  def self.new(*args)
     %x{
-      if (str === undefined) {
-        return self;
-      }
+      var str = args[0] || "";
+      var opts = args[args.length-1];
+      str = $coerce_to(str, #{String}, 'to_str');
+      if (opts && opts.$$is_hash) {
+        if (opts.$$smap.encoding) str = str.$force_encoding(opts.$$smap.encoding);
+      }
+      str = new self.$$constructor(str);
+      if (!str.$initialize.$$pristine) #{`str`.initialize(*args)};
+      return str;
     }
-    raise NotImplementedError, 'Mutable strings are not supported in Opal.'
+  end
+
+  # Our initialize method does nothing, the string value setup is being
+  # done by String.new. Therefore not all kinds of subclassing will work.
+  # As a rule of thumb, when subclassing String, either make sure to override
+  # .new or make sure that the first argument given to a constructor is
+  # a string we want our subclass-string to hold.
+  def initialize(str = undefined, encoding: nil, capacity: nil)
   end
 
   def %(data)
@@ -92,7 +100,14 @@ class String < `String`
   def +(other)
     other = `$coerce_to(#{other}, #{String}, 'to_str')`
 
-    `self + #{other.to_s}`
+    %x{
+      if (other == "" && self.$$class === Opal.String) return #{self};
+      if (self == "" && other.$$class === Opal.String) return #{other};
+      var out = self + other;
+      if (self.encoding === out.encoding && other.encoding === out.encoding) return out;
+      if (self.encoding.name === "UTF-8" || other.encoding.name === "UTF-8") return out;
+      return Opal.enc(out, self.encoding);
+    }
   end
 
   def <=>(other)
@@ -240,7 +255,7 @@ class String < `String`
   alias byteslice []
 
   def b
-    force_encoding('binary')
+    `new String(#{self})`.force_encoding('binary')
   end
 
   def capitalize
@@ -289,12 +304,6 @@ class String < `String`
     }
   end
 
-  def chars(&block)
-    return each_char.to_a unless block
-
-    each_char(&block)
-  end
-
   def chomp(separator = $/)
     return self if `separator === nil || self.length === 0`
 
@@ -416,18 +425,6 @@ class String < `String`
     `self.$$cast(self.toLowerCase())`
   end
 
-  def each_char(&block)
-    return enum_for(:each_char) { size } unless block_given?
-
-    %x{
-      for (var i = 0, length = self.length; i < length; i++) {
-        Opal.yield1(block, self.charAt(i));
-      }
-    }
-
-    self
-  end
-
   def each_line(separator = $/, &block)
     return enum_for :each_line, separator unless block_given?
 
@@ -645,7 +642,13 @@ class String < `String`
             '\\': '\\\\'
           },
           escaped = self.replace(escapable, function (chr) {
-            return meta[chr] || '\\u' + ('0000' + chr.charCodeAt(0).toString(16).toUpperCase()).slice(-4);
+            if (meta[chr]) return meta[chr];
+            chr = chr.charCodeAt(0);
+            if (chr <= 0xff && (self.encoding["$binary?"]() || self.internal_encoding["$binary?"]())) {
+              return '\\x' + ('00' + chr.toString(16).toUpperCase()).slice(-2);
+            } else {
+              return '\\u' + ('0000' + chr.toString(16).toUpperCase()).slice(-4);
+            }
           });
       return '"' + escaped.replace(/\#[\$\@\{]/g, '\\$&') + '"';
     }
@@ -660,10 +663,6 @@ class String < `String`
     block ? self : e.to_a
   end
 
-  def length
-    `self.length`
-  end
-
   def ljust(width, padstr = ' ')
     width  = `$coerce_to(#{width}, #{Integer}, 'to_int')`
     padstr = `$coerce_to(#{padstr}, #{String}, 'to_str')`.to_s
@@ -694,17 +693,10 @@ class String < `String`
 
   def ascii_only?
     # non-ASCII-compatible encoding must return false
-    # NOTE: Encoding::UTF_16LE is also non-ASCII-compatible encoding,
-    # but since the default encoding in JavaScript is UTF_16LE,
-    # we cannot return false otherwise the following will (incorrectly) return false: "hello".ascii_only?
-    # In other words, we cannot tell the difference between:
-    # - "hello".force_encoding("UTF-16LE")
-    # - "hello"
-    # The problem is that "ascii_only" should return false in the first case and true in the second case.
-    if encoding == Encoding::UTF_16BE
-      return false
-    end
-    `/^[\x00-\x7F]*$/.test(self)`
+    %x{
+      if (!self.encoding.ascii) return false;
+      return /^[\x00-\x7F]*$/.test(self);
+    }
   end
 
   def match(pattern, pos = undefined, &block)
@@ -845,7 +837,14 @@ class String < `String`
   end
 
   def ord
-    `self.charCodeAt(0)`
+    %x{
+      if (typeof self.codePointAt === "function") {
+        return self.codePointAt(0);
+      }
+      else {
+        return self.charCodeAt(0);
+      }
+    }
   end
 
   def partition(sep)
@@ -1022,8 +1021,6 @@ class String < `String`
     }
   end
 
-  alias size length
-
   alias slice []
 
   def split(pattern = undefined, limit = undefined)
@@ -1141,10 +1138,22 @@ class String < `String`
   def start_with?(*prefixes)
     %x{
       for (var i = 0, length = prefixes.length; i < length; i++) {
-        var prefix = $coerce_to(prefixes[i], #{String}, 'to_str').$to_s();
+        if (prefixes[i].$$is_regexp) {
+          var regexp = prefixes[i];
+          var match = regexp.exec(self);
 
-        if (self.indexOf(prefix) === 0) {
-          return true;
+          if (match != null && match.index === 0) {
+            #{$~ = MatchData.new(`regexp`, `match`)};
+            return true;
+          } else {
+            #{$~ = nil}
+          }
+        } else {
+          var prefix = $coerce_to(prefixes[i], #{String}, 'to_str').$to_s();
+
+          if (self.indexOf(prefix) === 0) {
+            return true;
+          }
         }
       }
 
@@ -1841,6 +1850,31 @@ class String < `String`
   def unpack1(format)
     raise "To use String#unpack1, you must first require 'corelib/string/unpack'."
   end
+
+  def freeze
+    %x{
+      if (typeof self === 'string') return self;
+      self.$$frozen = true;
+      return self;
+    }
+  end
+
+  alias +@ dup
+
+  def -@
+    %x{
+      if (typeof self === 'string') return self;
+      if (self.$$frozen === true) return self;
+      if (self.encoding.name == 'UTF-8' && self.internal_encoding.name == 'UTF-8') return self.toString();
+      return self.$dup().$freeze();
+    }
+  end
+
+  def frozen?
+    `typeof self === 'string' || self.$$frozen === true`
+  end
+
+  Opal.pristine self, :initialize
 end
 
 Symbol = String