opal 0.9.4 → 0.10.0.beta1

data/opal/corelib/string.rb

@@ -359,11 +359,7 @@ class String < `String`
 
     %x{
       for (var i = 0, length = self.length; i < length; i++) {
-        var value = Opal.yield1(block, self.charAt(i));
-
-        if (value === $breaker) {
-          return $breaker.$v;
-        }
+        Opal.yield1(block, self.charAt(i));
       }
     }
 
@@ -374,17 +370,10 @@ class String < `String`
     return enum_for :each_line, separator unless block_given?
 
     %x{
-      var value;
-
       if (separator === nil) {
-        value = Opal.yield1(block, self);
+        Opal.yield1(block, self);
 
-        if (value === $breaker) {
-          return value.$v;
-        }
-        else {
-          return self;
-        }
+        return self;
       }
 
       separator = #{Opal.coerce_to(`separator`, String, :to_str)}
@@ -394,11 +383,7 @@ class String < `String`
       if (separator.length === 0) {
         for (a = self.split(/(\n{2,})/), i = 0, n = a.length; i < n; i += 2) {
           if (a[i] || a[i + 1]) {
-            value = Opal.yield1(block, (a[i] || "") + (a[i + 1] || ""));
-
-            if (value === $breaker) {
-              return value.$v;
-            }
+            Opal.yield1(block, (a[i] || "") + (a[i + 1] || ""));
           }
         }
 
@@ -411,18 +396,10 @@ class String < `String`
 
       for (i = 0, length = splitted.length; i < length; i++) {
         if (i < length - 1 || trailing) {
-          value = Opal.yield1(block, splitted[i] + separator);
-
-          if (value === $breaker) {
-            return value.$v;
-          }
+          Opal.yield1(block, splitted[i] + separator);
         }
         else {
-          value = Opal.yield1(block, splitted[i]);
-
-          if (value === $breaker) {
-            return value.$v;
-          }
+          Opal.yield1(block, splitted[i]);
         }
       }
     }
@@ -533,16 +510,11 @@ class String < `String`
 
   def include?(other)
     %x{
-      if (other.$$is_string) {
-        return self.indexOf(other) !== -1;
+      if (!other.$$is_string) {
+        #{other = Opal.coerce_to(other, String, :to_str)}
       }
+      return self.indexOf(other) !== -1;
     }
-
-    unless other.respond_to? :to_str
-      raise TypeError, "no implicit conversion of #{other.class} into String"
-    end
-
-    `self.indexOf(#{other.to_str}) !== -1`
   end
 
   def index(search, offset = undefined)
@@ -1032,6 +1004,10 @@ class String < `String`
         return result;
       }
 
+      if (limit >= result.length) {
+        return result;
+      }
+
       i = 0;
       while (match !== null) {
         i++;
@@ -1041,7 +1017,6 @@ class String < `String`
         }
         match = pattern.exec(string);
       }
-
       result.splice(limit - 1, result.length - 1, string.slice(index));
       return result;
     }
@@ -1339,8 +1314,8 @@ class String < `String`
           in_range = false;
           for (i = 0; i < to_length; i++) {
             ch = to_chars[i];
-            if (last_from == null) {
-              last_from = ch;
+            if (last_to == null) {
+              last_to = ch;
               to_chars_expanded.push(ch);
             }
             else if (ch === '-') {
@@ -1356,7 +1331,7 @@ class String < `String`
               }
             }
             else if (in_range) {
-              start = last_from.charCodeAt(0);
+              start = last_to.charCodeAt(0);
               end = ch.charCodeAt(0);
               if (start > end) {
                 #{raise ArgumentError, "invalid range \"#{`String.fromCharCode(start)`}-#{`String.fromCharCode(end)`}\" in string transliteration"}
@@ -1366,7 +1341,7 @@ class String < `String`
               }
               to_chars_expanded.push(ch);
               in_range = null;
-              last_from = null;
+              last_to = null;
             }
             else {
               to_chars_expanded.push(ch);
@@ -1575,7 +1550,7 @@ class String < `String`
     return enum_for :upto, stop, excl unless block_given?
     stop = Opal.coerce_to(stop, String, :to_str)
     %x{
-      var a, b, s = self.toString(), value;
+      var a, b, s = self.toString();
 
       if (s.length === 1 && stop.length === 1) {
 
@@ -1587,8 +1562,7 @@ class String < `String`
             break;
           }
 
-          value = block(String.fromCharCode(a));
-          if (value === $breaker) { return $breaker.$v; }
+          block(String.fromCharCode(a));
 
           a += 1;
         }
@@ -1603,8 +1577,7 @@ class String < `String`
             break;
           }
 
-          value = block(a.toString());
-          if (value === $breaker) { return $breaker.$v; }
+          block(a.toString());
 
           a += 1;
         }
@@ -1616,8 +1589,7 @@ class String < `String`
             break;
           }
 
-          value = block(s);
-          if (value === $breaker) { return $breaker.$v; }
+          block(s);
 
           s = #{`s`.succ};
         }

data/opal/corelib/struct.rb

@@ -3,31 +3,42 @@ require 'corelib/enumerable'
 class Struct
   include Enumerable
 
-  def self.new(name = undefined, *args, &block)
-    return super unless self == Struct
+  def self.new(const_name, *args, &block)
+    if const_name
+      begin
+        const_name = Opal.const_name!(const_name)
+      rescue TypeError, NameError
+        args.unshift(const_name)
+        const_name = nil
+      end
+    end
 
-    if name[0] == name[0].upcase
-      Struct.const_set(name, new(*args))
-    else
-      args.unshift name
+    args.map do |arg|
+      Opal.coerce_to!(arg, String, :to_str)
+    end
 
-      Class.new(self) {
-        args.each { |arg| define_struct_attribute arg }
+    klass = Class.new(self) do
+      args.each { |arg| define_struct_attribute(arg) }
 
-        class_eval(&block) if block
+      class << self
+        def new(*args)
+          instance = allocate
+          `#{instance}.$$data = {};`
+          instance.initialize(*args)
+          instance
+        end
 
-        class << self
-          def new(*args)
-            instance = allocate
-            `#{instance}.$$data = {};`
-            instance.initialize(*args)
-            instance
-          end
+        alias [] new
+      end
+    end
 
-          alias [] new
-        end
-      }
+    klass.module_eval(&block) if block
+
+    if const_name
+      Struct.const_set(const_name, klass)
     end
+
+    klass
   end
 
   def self.define_struct_attribute(name)
@@ -43,7 +54,7 @@ class Struct
 
     define_method "#{name}=" do |value|
       `self.$$data[name] = value`
-    end    
+    end
   end
 
   def self.members
@@ -63,7 +74,11 @@ class Struct
   end
 
   def initialize(*args)
-    members.each_with_index {|name, index|
+    if args.length > self.class.members.length
+      raise ArgumentError, "struct size differs"
+    end
+
+    self.class.members.each_with_index {|name, index|
       self[name] = args[index]
     }
   end
@@ -71,17 +86,17 @@ class Struct
   def members
     self.class.members
   end
-  
+
   def hash
     Hash.new(`self.$$data`).hash
   end
 
   def [](name)
     if Integer === name
-      raise IndexError, "offset #{name} too small for struct(size:#{members.size})" if name < -members.size
-      raise IndexError, "offset #{name} too large for struct(size:#{members.size})" if name >= members.size
+      raise IndexError, "offset #{name} too small for struct(size:#{self.class.members.size})" if name < -self.class.members.size
+      raise IndexError, "offset #{name} too large for struct(size:#{self.class.members.size})" if name >= self.class.members.size
 
-      name = members[name]
+      name = self.class.members[name]
     elsif String === name
       %x{
         if(!self.$$data.hasOwnProperty(name)) {
@@ -98,12 +113,12 @@ class Struct
 
   def []=(name, value)
     if Integer === name
-      raise IndexError, "offset #{name} too small for struct(size:#{members.size})" if name < -members.size
-      raise IndexError, "offset #{name} too large for struct(size:#{members.size})" if name >= members.size
+      raise IndexError, "offset #{name} too small for struct(size:#{self.class.members.size})" if name < -self.class.members.size
+      raise IndexError, "offset #{name} too large for struct(size:#{self.class.members.size})" if name >= self.class.members.size
 
-      name = members[name]
+      name = self.class.members[name]
     elsif String === name
-      raise NameError.new("no member '#{name}' in struct", name) unless members.include?(name.to_sym)
+      raise NameError.new("no member '#{name}' in struct", name) unless self.class.members.include?(name.to_sym)
     else
       raise TypeError, "no implicit conversion of #{name.class} into Integer"
     end
@@ -187,25 +202,25 @@ class Struct
   def each
     return enum_for(:each){self.size} unless block_given?
 
-    members.each { |name| yield self[name] }
+    self.class.members.each { |name| yield self[name] }
     self
   end
 
   def each_pair
     return enum_for(:each_pair){self.size} unless block_given?
 
-    members.each { |name| yield [name, self[name]] }
+    self.class.members.each { |name| yield [name, self[name]] }
     self
   end
 
   def length
-    members.length
+    self.class.members.length
   end
 
   alias size length
 
   def to_a
-    members.map { |name| self[name] }
+    self.class.members.map { |name| self[name] }
   end
 
   alias values to_a
@@ -213,7 +228,7 @@ class Struct
   def inspect
     result = "#<struct "
 
-    if self.class == Struct
+    if Struct === self && self.class.name
       result += "#{self.class} "
     end
 
@@ -229,7 +244,7 @@ class Struct
   alias to_s inspect
 
   def to_h
-    members.inject({}) {|h, name| h[name] = self[name]; h}
+    self.class.members.inject({}) {|h, name| h[name] = self[name]; h}
   end
 
   def values_at(*args)

data/opal/corelib/unsupported.rb

@@ -1,6 +1,19 @@
 %x{
   var warnings = {};
 
+  function handle_unsupported_feature(message) {
+    switch (Opal.config.unsupported_features_severity) {
+    case 'error':
+      #{Kernel.raise NotImplementedError, `message`}
+      break;
+    case 'warning':
+      warn(message)
+      break;
+    default: // ignore
+      // noop
+    }
+  }
+
   function warn(string) {
     if (warnings[string]) {
       return;
@@ -91,22 +104,12 @@ module Kernel
   `var ERROR = "Object freezing is not supported by Opal";`
 
   def freeze
-    if `OPAL_CONFIG.freezing`
-      `warn(ERROR)`
-    else
-      raise NotImplementedError, `ERROR`
-    end
-
+    `handle_unsupported_feature(ERROR)`
     self
   end
 
   def frozen?
-    if `OPAL_CONFIG.freezing`
-      `warn(ERROR)`
-    else
-      raise NotImplementedError, `ERROR`
-    end
-
+    `handle_unsupported_feature(ERROR)`
     false
   end
 end
@@ -115,32 +118,17 @@ module Kernel
   `var ERROR = "Object tainting is not supported by Opal";`
 
   def taint
-    if `OPAL_CONFIG.tainting`
-      `warn(ERROR)`
-    else
-      raise NotImplementedError, `ERROR`
-    end
-
+    `handle_unsupported_feature(ERROR)`
     self
   end
 
   def untaint
-    if `OPAL_CONFIG.tainting`
-      `warn(ERROR)`
-    else
-      raise NotImplementedError, `ERROR`
-    end
-
+    `handle_unsupported_feature(ERROR)`
     self
   end
 
   def tainted?
-    if `OPAL_CONFIG.tainting`
-      `warn(ERROR)`
-    else
-      raise NotImplementedError, `ERROR`
-    end
-
+    `handle_unsupported_feature(ERROR)`
     false
   end
 end

data/opal/opal.rb

@@ -1,7 +1,6 @@
 require 'opal/base'
 require 'opal/mini'
 
-require 'corelib/array/inheritance'
 require 'corelib/string/inheritance'
 require 'corelib/string/encoding'
 require 'corelib/math'

data/opal/opal/mini.rb

@@ -15,3 +15,4 @@ require 'corelib/method'
 require 'corelib/regexp'
 
 require 'corelib/variables'
+require 'opal/regexp_anchors'

data/spec/README.md

@@ -1,8 +1,10 @@
 # Opal specs overview
 
-* **rubyspecs** (file) a whitelist of RubySpec files to be ran
-* **rubyspec** RubySpec examples (submodule)
-* **stdlib** `rubysl-*` examples (submodules)
-* **filters** The list of MSpec/RubySpec examples that are either bugs or unsupported
+* **ruby** the Ruby Spec Suite examples (submodule)
+* **ruby_specs** (file) a whitelist of the Ruby Spec Suite files to be ran
+* **filters** The list of the Ruby Spec Suite examples that are either bugs or unsupported
 * **opal** opal additions/special behaviour in the runtime/corelib
 * **lib** specs for opal lib (parser, lexer, grammar, compiler etc)
+* **mspec** the MSpec library that runs the ruby spec
+* **mspec-opal** Opal specific patches to the MSpec library
+* **support** misc. utilities

data/spec/filters/bugs/array.rb

@@ -3,51 +3,9 @@ opal_filter "Array" do
   fails "Array#flatten with a non-Array object in the Array calls #method_missing if defined"
   fails "Array#join raises a NoMethodError if an element does not respond to #to_str, #to_ary, or #to_s"
   fails "Array#partition returns in the left array values for which the block evaluates to true"
-  fails "Array#permutation when no block is given returned Enumerator size with an array size greater than 0 returns the descending factorial of array size and given length"
-  fails "Array#permutation when no block is given returned Enumerator size with an array size greater than 0 returns the descending factorial of array size with array size when there's no param"
-  fails "Array#permutation when no block is given returned Enumerator size with an empty array returns 1 when the given length is 0"
-  fails "Array#permutation when no block is given returned Enumerator size with an empty array returns 1 when there's param"
   fails "Array#rassoc calls elem == obj on the second element of each contained array"
   fails "Array#rassoc does not check the last element in each contained but speficically the second"
-  fails "Array#repeated_combination accepts sizes larger than the original array"
-  fails "Array#repeated_combination generates from a defensive copy, ignoring mutations"
-  fails "Array#repeated_combination returns an enumerator when no block is provided"
-  fails "Array#repeated_combination returns self when a block is given"
-  fails "Array#repeated_combination when no block is given returned Enumerator size returns 0 when the combination_size is < 0"
-  fails "Array#repeated_combination when no block is given returned Enumerator size returns 1 when the combination_size is 0"
-  fails "Array#repeated_combination when no block is given returned Enumerator size returns the binomial coeficient between combination_size and array size + combination_size -1"
-  fails "Array#repeated_combination yields [] when length is 0"
-  fails "Array#repeated_combination yields a partition consisting of only singletons"
-  fails "Array#repeated_combination yields nothing for negative length and return self"
-  fails "Array#repeated_combination yields nothing when the array is empty and num is non zero"
-  fails "Array#repeated_combination yields the expected repeated_combinations"
-  fails "Array#repeated_permutation allows permutations larger than the number of elements"
-  fails "Array#repeated_permutation does not yield when called on an empty Array with a nonzero argument"
-  fails "Array#repeated_permutation generates from a defensive copy, ignoring mutations"
-  fails "Array#repeated_permutation handles duplicate elements correctly"
-  fails "Array#repeated_permutation returns an Enumerator of all repeated permutations of given length when called without a block"
-  fails "Array#repeated_permutation returns an Enumerator which works as expected even when the array was modified"
-  fails "Array#repeated_permutation truncates Float arguments"
-  fails "Array#repeated_permutation when no block is given returned Enumerator size returns 0 when combination_size is < 0"
-  fails "Array#repeated_permutation when no block is given returned Enumerator size returns array size ** combination_size"
-  fails "Array#repeated_permutation yields all repeated_permutations to the block then returns self when called with block but no arguments"
-  fails "Array#repeated_permutation yields the empty repeated_permutation ([[]]) when the given length is 0"
   fails "Array#select returns a new array of elements for which block is true"
-  fails "Array#slice! calls to_int on range arguments"
-  fails "Array#slice! calls to_int on start and length arguments"
-  fails "Array#slice! does not expand array with indices out of bounds"
-  fails "Array#slice! does not expand array with negative indices out of bounds"
-  fails "Array#slice! removes and return elements in range"
-  fails "Array#slice! removes and returns elements in end-exclusive ranges"
-  fails "Array#slice! returns nil if length is negative"
-  fails "Array#sort_by! completes when supplied a block that always returns the same result"
-  fails "Array#sort_by! makes some modification even if finished sorting when it would break in the given block"
-  fails "Array#sort_by! raises a RuntimeError on a frozen array"
-  fails "Array#sort_by! raises a RuntimeError on an empty frozen array"
-  fails "Array#sort_by! returns an Enumerator if not given a block"
-  fails "Array#sort_by! returns the specified value when it would break in the given block"
-  fails "Array#sort_by! sorts array in place by passing each element to the given block"
-  fails "Array#sort_by! when no block is given returned Enumerator size returns the enumerable size"
   fails "Array#uniq! properly handles recursive arrays"
   fails "Array#zip fills nil when the given enumereator is shorter than self"
   fails "Array.[] can unpack 2 or more nested referenced array"