opal 0.9.0.rc1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 62af1a23be47ed15ba180aab47ae2b960feb1a1d
-  data.tar.gz: 228f0b9d53bb0029c97560efb41b58417e3a1312
+  metadata.gz: 6fe130e39483fb75ec092a749d65571a4bc6ed72
+  data.tar.gz: dd168e47177f8de9d738ada116a3fef82caea16d
 SHA512:
-  metadata.gz: f2d35d332054d7da0a7c10c617d2c71b3d0f17b9f179d352d027dca887a38725fbca63b09cd963660bd82a358fc79d9fe841b353209981db8400a63e5df843cb
-  data.tar.gz: ddb2ce713af79c8414966769b9cce482ee3d3e2cb9b16177ac9f14f4df7600e4a7a5265e8cf0ea4a713be37557d9038f576a0fdc5fec6698931e3b27b84c9289
+  metadata.gz: 8a69c71365c06a89859f96ea7447e94d1ace48757680fa6022526c14c58e3700f072d3c123650476630ffc2d6f2725dc56e19869f0067bd0b791d57ca88e9682
+  data.tar.gz: f7d8b51da3dfcb0cd4c1870a5380b311ed0b0a9e1cbbc0666c7295b4951b2895a3d184877fd2119e176ce5141dc2f7966950cd2676cd0357aeb08114c86ddcd9

data/CHANGELOG.md

@@ -38,6 +38,8 @@
     * `Enumerable#chunk`
     * `Enumerable#each_cons`
     * `Enumerable#minmax`
+    * `Range#to_a`
+    * `Module` comparison methods: `#<` `#<=` `#<=>` `#>` `#>=`
 
 * Operator methods (e.g. `+`, `<`, etc.) can be handled by `method_missing`
 
@@ -77,6 +79,10 @@
 
 * Fixed a number of syntax errors (e.g. #1224 #1225 #1227 #1231 #1233 #1226)
 
+* Fix `Array#to_n`, `Hash#to_n`, `Struct#to_n` when the object contains native objects (#1249).
+
+* Internal cleanup and lots of bugs!
+
 ## 0.8.1 2015-10-12
 
 * Use official Sprockets processor cache keys API:

data/lib/opal/parser/lexer.rb

@@ -900,7 +900,7 @@ module Opal
                (@lex_state == :expr_arg && @space_seen) or
                @lex_state == :expr_mid
               start_word  = scan(/./)
-              end_word    = { '(' => ')', '[' => ']', '{' => '}' }[start_word] || start_word
+              end_word    = { '(' => ')', '[' => ']', '{' => '}', '<' => '>' }[start_word] || start_word
               self.strterm = new_strterm2(STR_DQUOTE, end_word, start_word)
               return :tSTRING_BEG
             end

data/lib/opal/version.rb

@@ -1,5 +1,5 @@
 module Opal
   # WHEN RELEASING:
   # Remember to update RUBY_ENGINE_VERSION in opal/corelib/constants.rb too!
-  VERSION = '0.9.0.rc1'
+  VERSION = '0.9.0'
 end

data/opal/corelib/array.rb

@@ -1328,20 +1328,20 @@ class Array < `Array`
   alias map collect
 
   alias map! collect!
-  
+
   def permutation(num = undefined, &block)
     return enum_for(:permutation, num){self.size} unless block_given?
 
     %x{
       var permute, offensive, output;
-      
+
       if (num === undefined) {
         num = self.length;
       }
       else {
         num = #{ Opal.coerce_to num, Integer, :to_int }
       }
-      
+
       if (num < 0 || self.length < num) {
         // no permutations, yield nothing
       }
@@ -1359,17 +1359,17 @@ class Array < `Array`
         // this is the general case
         #{ perm = Array.new(num) }
         #{ used = Array.new(`self.length`, false) }
-      
+
         permute = function(num, perm, index, used, blk) {
           self = this;
           for(var i = 0; i < self.length; i++){
-            if(#{ !used[`i`] }) {              
+            if(#{ !used[`i`] }) {
               perm[index] = i;
               if(index < num - 1) {
                 used[i] = true;
                 permute.call(self, num, perm, index + 1, used, blk);
                 used[i] = false;
-              } 
+              }
               else {
                 output = [];
                 for (var j = 0; j < perm.length; j++) {
@@ -1380,7 +1380,7 @@ class Array < `Array`
             }
           }
         }
-        
+
         if (#{block_given?}) {
           // offensive (both definitions) copy.
           offensive = self.slice();
@@ -1394,7 +1394,7 @@ class Array < `Array`
 
     self
   end
-  
+
   def pop(count = undefined)
     if `count === undefined`
       return if `self.length === 0`
@@ -1586,28 +1586,28 @@ class Array < `Array`
       return nil;
     }
   end
-  
+
   def rotate(n=1)
     n = Opal.coerce_to n, Integer, :to_int
     %x{
       var ary, idx, firstPart, lastPart;
-      
+
       if (self.length === 1) {
         return self.slice();
       }
       if (self.length === 0) {
         return [];
       }
-      
+
       ary = self.slice();
       idx = n % ary.length;
-      
+
       firstPart = ary.slice(idx);
       lastPart = ary.slice(0, idx);
       return firstPart.concat(lastPart);
-    } 
+    }
   end
-  
+
   def rotate!(cnt=1)
     %x{
       if (self.length === 0 || self.length === 1) {
@@ -1618,7 +1618,7 @@ class Array < `Array`
     ary = rotate(cnt)
     replace ary
   end
-  
+
   class SampleRandom
     def initialize(rng)
       @rng = rng
@@ -1635,7 +1635,7 @@ class Array < `Array`
 
   def sample(count = undefined, options = undefined)
     return at Kernel.rand(`self.length`) if `count === undefined`
-    
+
     if `options === undefined`
       if (o = Opal.coerce_to? count, Hash, :to_hash)
         options = o
@@ -1663,13 +1663,13 @@ class Array < `Array`
     return `self[#{rng.rand(`self.length`)}]` unless count
 
     %x{
-      
+
       var abandon, spin, result, i, j, k, targetIndex, oldValue;
-      
-      if (count > self.length) { 
+
+      if (count > self.length) {
         count = self.length;
       }
-      
+
       switch (count) {
         case 0:
           return [];
@@ -1689,15 +1689,15 @@ class Array < `Array`
           if (self.length / count > 3) {
             abandon = false;
             spin = 0;
-            
+
             result = #{ Array.new(count) };
             i = 1;
-            
+
             result[0] = #{rng.rand(`self.length`)};
             while (i < count) {
               k = #{rng.rand(`self.length`)};
               j = 0;
-              
+
               while (j < i) {
                 while (k === result[j]) {
                   spin++;
@@ -1708,42 +1708,42 @@ class Array < `Array`
                   k = #{rng.rand(`self.length`)};
                 }
                 if (abandon) { break; }
-                  
+
                 j++;
               }
-              
+
               if (abandon) { break; }
-              
+
               result[i] = k;
-              
+
               i++;
             }
-            
+
             if (!abandon) {
               i = 0;
               while (i < count) {
                 result[i] = self[result[i]];
                 i++;
               }
-              
+
               return result;
             }
           }
-          
+
           result = self.slice();
-          
+
           for (var c = 0; c < count; c++) {
             targetIndex = #{rng.rand(`self.length`)};
             oldValue = result[c];
             result[c] = result[targetIndex];
             result[targetIndex] = oldValue;
           }
-          
+
           return count === self.length ? result : #{`result`[0, count]};
       }
     }
   end
-  
+
   def select(&block)
     return enum_for(:select){self.size} unless block_given?
 
@@ -2069,7 +2069,7 @@ class Array < `Array`
       if elem.kind_of? Range
         finish = Opal.coerce_to elem.last, Integer, :to_int
         start = Opal.coerce_to elem.first, Integer, :to_int
-        
+
         %x{
           if (start < 0) {
             start = start + self.length;

data/opal/corelib/constants.rb

@@ -1,8 +1,8 @@
 RUBY_PLATFORM       = 'opal'
 RUBY_ENGINE         = 'opal'
 RUBY_VERSION        = '2.2.3'
-RUBY_ENGINE_VERSION = '0.9.0.rc1'
-RUBY_RELEASE_DATE   = '2015-11-06'
+RUBY_ENGINE_VERSION = '0.9.0'
+RUBY_RELEASE_DATE   = '2015-12-20'
 RUBY_PATCHLEVEL     = 0
 RUBY_REVISION       = 0
 RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2015 Adam Beynon'

data/opal/corelib/module.rb

@@ -29,28 +29,66 @@ class Module
   end
 
   def <(other)
+    unless Module === other
+      raise TypeError, "compared with non class/module"
+    end
+
     # class cannot be a descendant of itself
     %x{
-      var working = self;
+      var working = self,
+          ancestors,
+          i, length;
 
       if (working === other) {
         return false;
       }
 
-      while (working) {
-        if (working === other) {
+      for (i = 0, ancestors = Opal.ancestors(self), length = ancestors.length; i < length; i++) {
+        if (ancestors[i] === other) {
           return true;
         }
+      }
 
-        working = working.$$parent;
+      for (i = 0, ancestors = Opal.ancestors(other), length = ancestors.length; i < length; i++) {
+        if (ancestors[i] === self) {
+          return false;
+        }
       }
 
-      return false;
+      return nil;
     }
   end
 
   def <=(other)
-    equal?(other) or self < other
+    equal?(other) || self < other
+  end
+
+  def >(other)
+    unless Module === other
+      raise TypeError, "compared with non class/module"
+    end
+
+    other < self
+  end
+
+  def >=(other)
+    equal?(other) || self > other
+  end
+
+  def <=>(other)
+    %x{
+      if (self === other) {
+        return 0;
+      }
+    }
+
+    unless Module === other
+      return nil
+    end
+
+    lt = self < other
+    return nil if lt.nil?
+    lt ? -1 : 1
   end
 
   def alias_method(newname, oldname)

data/opal/corelib/range.rb

@@ -38,6 +38,36 @@ class Range
   def each(&block)
     return enum_for :each unless block_given?
 
+    %x{
+      var i, limit, value;
+
+      if (#@begin.$$is_number && #@end.$$is_number) {
+        if (#@begin % 1 !== 0 || #@end % 1 !== 0) {
+          #{raise TypeError, "can't iterate from Float"}
+        }
+
+        for (i = #@begin, limit = #@end + #{@exclude ? 0 : 1}; i < limit; i++) {
+          value = block(i);
+          if (value === $breaker) { return $breaker.$v; }
+        }
+
+        return self;
+      }
+
+      if (#@begin.$$is_string && #@end.$$is_string) {
+        value = #{@begin.upto(@end, @exclude, &block)};
+
+        // The following is a bit hackish: we know that
+        // String#upto normally returns self, but may
+        // return a different value if there's a `break`
+        // statement in the supplied block. We need to
+        // propagate this `break` value here, so we
+        // test for equality with `@begin` string to
+        // determine the return value:
+        return value === #@begin ? self : value;
+      }
+    }
+
     current = @begin
     last    = @end
 

data/opal/corelib/regexp.rb

@@ -3,16 +3,16 @@ class RegexpError < StandardError; end
 class Regexp < `RegExp`
   IGNORECASE = 1
   MULTILINE = 4
-  
-  `def.$$is_regexp = true`  
+
+  `def.$$is_regexp = true`
 
   class << self
     def allocate
       allocated = super
       `#{allocated}.uninitialized = true`
-      allocated      
+      allocated
     end
-    
+
     def escape(string)
       %x{
         return string.replace(/([-[\]\/{}()*+?.^$\\| ])/g, '\\$1')
@@ -55,8 +55,8 @@ class Regexp < `RegExp`
           if (part.$$is_string) {
             quoted_validated.push(#{escape(`part`)});
           }
-          else if (part.$$is_regexp) { 
-            each_part_options = #{`part`.options};   
+          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'}
             }
@@ -69,10 +69,10 @@ class Regexp < `RegExp`
         }
       }
       # Take advantage of logic that can parse options from JS Regex
-      new(`quoted_validated`.join('|'), `options`) 
+      new(`quoted_validated`.join('|'), `options`)
     end
 
-    def new(regexp, options = undefined)      
+    def new(regexp, options = undefined)
       %x{
         if (regexp.$$is_regexp) {
           return new RegExp(regexp);
@@ -126,7 +126,7 @@ class Regexp < `RegExp`
       if (self.uninitialized) {
         #{raise TypeError, 'uninitialized Regexp'}
       }
-      
+
       if (pos === undefined) {
         pos = 0;
       } else {
@@ -154,7 +154,7 @@ class Regexp < `RegExp`
         flags += 'm';
       }
 
-      // global RegExp maintains state, so not using self/this            
+      // global RegExp maintains state, so not using self/this
       var md, re = new RegExp(source, flags + (self.ignoreCase ? 'i' : ''));
 
       while (true) {
@@ -178,13 +178,13 @@ class Regexp < `RegExp`
   def source
     `self.source`
   end
-  
+
   def options
     # Flags would be nice to use with this, but still experimental - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/flags
     %x{
       if (self.uninitialized) {
         #{raise TypeError, 'uninitialized Regexp'}
-      }      
+      }
       var result = 0;
       // should be supported in IE6 according to https://msdn.microsoft.com/en-us/library/7f5z26w4(v=vs.94).aspx
       if (self.multiline) {
@@ -192,11 +192,11 @@ class Regexp < `RegExp`
       }
       if (self.ignoreCase) {
         result |= #{IGNORECASE};
-      }      
+      }
       return result;
-    }  
+    }
   end
-  
+
   def casefold?
     `self.ignoreCase`
   end