opal 0.6.0 → 0.6.1

data/opal/corelib/module.rb

@@ -271,7 +271,7 @@ class Module
       self._proto[jsid] = block;
       $opal.donate(self, [jsid]);
 
-      return null;
+      return name;
     }
   end
 
@@ -304,6 +304,20 @@ class Module
     self
   end
 
+  def include?(mod)
+    %x{
+      for (var cls = self; cls; cls = cls.parent) {
+        for (var i = 0; i != cls.__inc__.length; i++) {
+          var mod2 = cls.__inc__[i];
+          if (mod === mod2) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+  end
+
   def instance_method(name)
     %x{
       var meth = self._proto['$' + name];

data/opal/corelib/runtime.js

@@ -602,6 +602,24 @@
     return block.apply(null, args);
   };
 
+  // Finds the corresponding exception match in candidates.  Each candidate can
+  // be a value, or an array of values.  Returns null if not found.
+  Opal.$rescue = function(exception, candidates) {
+    for (var i = 0; i != candidates.length; i++) {
+      var candidate = candidates[i];
+      if (candidate._isArray) {
+        var subresult;
+        if (subresult = Opal.$rescue(exception, candidate)) {
+          return subresult;
+        }
+      }
+      else if (candidate['$==='](exception)) {
+        return candidate;
+      }
+    }
+    return null;
+  };
+
   Opal.is_a = function(object, klass) {
     if (object.__meta__ === klass) {
       return true;
@@ -762,7 +780,14 @@
         var args = arguments[0];
 
         for (var i = 0, length = args.length; i < length; i++) {
-          var key = args[i][0], obj = args[i][1];
+          var pair = args[i];
+
+          if (pair.length !== 2) {
+            throw Opal.ArgumentError.$new("value not of length 2: " + pair.$inspect());
+          }
+
+          var key = pair[0],
+              obj = pair[1];
 
           if (assocs[key] == null) {
             keys.push(key);
@@ -780,7 +805,12 @@
       }
     }
     else {
-      for (var i = 0, length = arguments.length; i < length; i++) {
+      var length = arguments.length;
+      if (length % 2 !== 0) {
+        throw Opal.ArgumentError.$new("odd number of arguments for Hash");
+      }
+
+      for (var i = 0; i < length; i++) {
         var key = arguments[i],
             obj = arguments[++i];
 

data/opal/corelib/string.rb

@@ -599,71 +599,126 @@ class String
 
   def split(pattern = $; || ' ', 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 (pattern && pattern._isRegexp) {
-          return self.split(pattern, limit);
-        } else {
-          result = [],
-          splitted = start = lim = 0,
-          splat = #{Opal.try_convert(pattern, String, :to_str).to_s};
+        var pattern_str = pattern.toString();
 
-          if (undefined !== limit) {
-            lim = #{Opal.try_convert(limit, Integer, :to_int)};
-          }
+        /* Opal and JS's repr of an empty RE. */
+        var blank_pattern = (pattern_str.substr(0, 3) == '/^/') ||
+                  (pattern_str.substr(0, 6) == '/(?:)/');
 
-          if (pattern === nil) {
-            if (#{$;} === undefined || #{$;} === nil) {
-              splat = ' ';
-            }
-            else {
-              splat = #{$;};
-            }
+        /* This is our fast path */
+        if (limit === undefined || limit === 0) {
+          result = self.split(blank_pattern ? /(?:)/ : pattern);
+        }
+        else {
+          /* RegExp.exec only has sane behavior with global flag */
+          if (! pattern.global) {
+            pattern = eval(pattern_str + 'g');
           }
 
-          if (lim == 1) {
-            if (self.length == 0) {
-              return [];
-            }
-            else {
-              return [self];
-            }
-          }
+          var match_data;
+          var prev_index = 0;
+          pattern.lastIndex = 0;
 
-          string = (splat == ' ') ? self.replace(/[\r\n\t\v]\s+/g, ' ')
-                                  : self;
+          while ((match_data = pattern.exec(self)) !== null) {
+            var segment = self.slice(prev_index, match_data.index);
+            result.push(segment);
 
-          while ((cursor = string.indexOf(splat, start)) > -1 && cursor < string.length) {
-            if (splitted + 1 == lim) {
+            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 (splat == ' ' && cursor == start) {
-              start = cursor + 1;
-              continue;
+            if (limit !== undefined && limit > 1 && result.length + 1 == limit) {
+              break;
             }
+          }
 
-            result.push(string.substr(start, splat.length ? cursor - start : 1));
-            splitted++;
+          if (prev_index !== undefined) {
+            result.push(self.slice(prev_index, self.length));
+          }
+        }
+      }
+      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};
+        }
 
-            start = cursor + (splat.length ? splat.length : 1);
+        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 (string.length > 0 && (limit || lim < 0 || string.length > start)) {
-            if (string.length == start) {
-              result.push('');
-            }
-            else {
-              result.push(string.substr(start, string.length));
-            }
+          if (pattern == ' ' && cursor == start) {
+            start = cursor + 1;
+            continue;
           }
 
-          if (limit === undefined || lim == 0) {
-            while (result.length > 0 && result[result.length - 1].length == 0) {
-              result.pop();
-            }
+          result.push(string.substr(start, pattern.length ? cursor - start : 1));
+          splitted++;
+
+          start = cursor + (pattern.length ? pattern.length : 1);
+        }
+
+        if (string.length > 0 && (limit < 0 || string.length > start)) {
+          if (string.length == start) {
+            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 (limit > 0) {
+        var tail = result.slice(limit - 1).join('');
+        result.splice(limit - 1, result.length - 1, tail);
+      }
+
+      return result;
     }
   end
 
@@ -825,14 +880,9 @@ class String
   end
 
   def to_proc
-    %x{
-      var name = '$' + self;
-
-      return function(arg) {
-        var meth = arg[name];
-        return meth ? meth.call(arg) : arg.$method_missing(name);
-      };
-    }
+    proc do |recv, *args|
+      recv.send(self, *args)
+    end
   end
 
   def to_s

data/opal/corelib/variables.rb

@@ -19,6 +19,6 @@ $SAFE    = 0
 
 RUBY_PLATFORM       = 'opal'
 RUBY_ENGINE         = 'opal'
-RUBY_VERSION        = '2.0.0'
-RUBY_ENGINE_VERSION = '0.6.0'
-RUBY_RELEASE_DATE   = '2014-03-05'
+RUBY_VERSION        = '2.1.1'
+RUBY_ENGINE_VERSION = '0.6.1'
+RUBY_RELEASE_DATE   = '2014-04-15'

data/spec/cli/fixtures/sprockets_file.js.rb

@@ -0,0 +1,3 @@
+require 'opal'
+require 'native'
+puts 'sprockets!'

data/spec/cli/parser/literal_spec.rb

@@ -94,6 +94,11 @@ describe Opal::Parser do
       parsed("{ a: 1 }").should == [:hash, [:sym, :a], [:int, 1]]
       parsed("{ a: 1, b: 2 }").should == [:hash, [:sym, :a], [:int, 1], [:sym, :b], [:int, 2]]
     end
+
+    it "parses hash arrows without spaces around arguments" do
+      parsed("{1=>2}").should == [:hash, [:int, 1], [:int, 2]]
+      parsed("{:foo=>2}").should == [:hash, [:sym, :foo], [:int, 2]]
+    end
   end
 
   describe "parsing regexps" do

data/spec/cli/sprockets/environment_spec.rb

@@ -0,0 +1,14 @@
+require 'cli/spec_helper'
+require 'opal/sprockets/environment'
+
+describe Opal::Environment do
+  let(:env) { described_class.new }
+  let(:logical_path) { 'sprockets_file' }
+
+  before { env.append_path File.expand_path('../../fixtures/', __FILE__) }
+
+  it 'compiles Ruby to JS' do
+    expect(env[logical_path].source).to include('$puts(')
+    expect(env[logical_path+'.js'].source).to include('$puts(')
+  end
+end

data/spec/cli/sprockets/erb_spec.rb

@@ -0,0 +1,25 @@
+require 'cli/spec_helper'
+require 'opal/sprockets/erb'
+
+describe Opal::ERB::Processor do
+  let(:pathname) { Pathname("/Code/app/mylib/opal/foo.#{ext}") }
+  let(:_context) { double('_context', :logical_path => "foo.#{ext}", :pathname => pathname) }
+  let(:required_assets) { [] }
+  let(:template) { described_class.new { |t| %Q{<a href="<%= url %>"><%= name %></a>} } }
+  before { _context.stub(:require_asset) {|asset| required_assets << asset } }
+
+  let(:ext) { 'opalerb' }
+
+  it "is registered for '.opalerb' files" do
+    expect(Tilt["test.#{ext}"]).to eq(described_class)
+  end
+
+  it 'renders the template' do
+    expect(template.render(_context)).to include('"<a href=\""')
+  end
+
+  it 'implicitly requires "erb"' do
+    template.render(_context)
+    expect(required_assets).to eq(['erb'])
+  end
+end

data/spec/cli/sprockets/processor_spec.rb

@@ -0,0 +1,28 @@
+require 'cli/spec_helper'
+require 'opal/sprockets/processor'
+
+describe Opal::Processor do
+  let(:pathname) { Pathname("/Code/app/mylib/opal/foo.#{ext}") }
+  let(:_context) { double('_context', :logical_path => "foo.#{ext}", :pathname => pathname, :resolve => pathname.expand_path) }
+
+  %w[rb js.rb opal js.opal].each do |ext|
+    let(:ext) { ext }
+
+    describe %Q{with extension ".#{ext}"} do
+      it "is registered for '.#{ext}' files" do
+        expect(Tilt["test.#{ext}"]).to eq(described_class)
+      end
+
+      it "compiles and evaluates the template on #render" do
+        template = described_class.new { |t| "puts 'Hello, World!'\n" }
+        expect(template.render(_context)).to include('"Hello, World!"')
+      end
+
+      it "can be rendered more than once" do
+        template = described_class.new(_context) { |t| "puts 'Hello, World!'\n" }
+        3.times { expect(template.render(_context)).to include('"Hello, World!"') }
+      end
+    end
+  end
+
+end

data/spec/{opal/filters → filters}/bugs/array.rb

@@ -130,17 +130,29 @@ opal_filter "Array" do
   fails "Array#rotate does not mutate the receiver"
   fails "Array#rotate returns a copy of the array when its length is one or zero"
 
-  fails "Array#sample raises a RangeError if the value is equal to the Array size"
-  fails "Array#sample raises a RangeError if the value is less than zero"
-  fails "Array#sample calls #to_int on the Object returned by #rand"
-  fails "Array#sample ignores an Object passed for the RNG if it does not define #rand"
   fails "Array#sample calls #rand on the Object passed by the :random key in the arguments Hash"
-  fails "Array#sample calls #to_int on the first argument and #to_hash on the second when passed Objects"
   fails "Array#sample calls #to_hash to convert the passed Object"
-  fails "Array#sample raises ArgumentError when passed a negative count"
+  fails "Array#sample calls #to_int on the Object returned by #rand"
+  fails "Array#sample calls #to_int on the first argument and #to_hash on the second when passed Objects"
   fails "Array#sample calls #to_int to convert the count when passed an Object"
   fails "Array#sample does not return the same value if the Array has unique values"
+  fails "Array#sample ignores an Object passed for the RNG if it does not define #rand"
+  fails "Array#sample raises ArgumentError when passed a negative count"
+  fails "Array#sample raises a RangeError if the value is equal to the Array size"
+  fails "Array#sample raises a RangeError if the value is less than zero"
   fails "Array#sample returns at most the number of elements in the Array"
+  fails "Array#sample when the object returned by #rand is not a Fixnum but responds to #to_int calls #to_int on the Object"
+  fails "Array#sample when the object returned by #rand is not a Fixnum but responds to #to_int raises a RangeError if the value is equal to the Array size"
+  fails "Array#sample when the object returned by #rand is not a Fixnum but responds to #to_int raises a RangeError if the value is less than zero"
+  fails "Array#sample with options calls #rand on the Object passed by the :random key in the arguments Hash"
+  fails "Array#sample with options calls #to_hash to convert the passed Object"
+  fails "Array#sample with options calls #to_int on the first argument and #to_hash on the second when passed Objects"
+  fails "Array#sample with options ignores an Object passed for the RNG if it does not define #rand"
+  fails "Array#sample with options when the object returned by #rand is a Fixnum raises a RangeError if the value is equal to the Array size"
+  fails "Array#sample with options when the object returned by #rand is a Fixnum raises a RangeError if the value is less than zero"
+  fails "Array#sample with options when the object returned by #rand is a Fixnum uses the fixnum as index"
+
+  fails "Array#select returns a new array of elements for which block is true"
 
   fails "Array#shuffle attempts coercion via #to_hash"
   fails "Array#shuffle is not destructive"
@@ -154,11 +166,12 @@ opal_filter "Array" do
 
   fails "Array#shuffle! returns the same values, in a usually different order"
 
-  fails "Array#slice! does not expand array with negative indices out of bounds"
-  fails "Array#slice! does not expand array with indices out of bounds"
   fails "Array#slice! calls to_int on range arguments"
-  fails "Array#slice! removes and return elements in range"
   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#sort_by! makes some modification even if finished sorting when it would break in the given block"
   fails "Array#sort_by! returns the specified value when it would break in the given block"
@@ -170,7 +183,9 @@ opal_filter "Array" do
 
   fails "Array#uniq compares elements based on the value returned from the block"
   fails "Array#uniq compares elements with matching hash codes with #eql?"
+  fails "Array#uniq handles nil and false like any other values"
   fails "Array#uniq uses eql? semantics"
+  fails "Array#uniq yields items in order"
 
   fails "Array#uniq! compares elements based on the value returned from the block"
 
@@ -179,6 +194,11 @@ opal_filter "Array" do
   fails "Array#values_at returns an array of elements in the ranges when passes ranges"
   fails "Array#values_at calls to_int on arguments of ranges when passes ranges"
   fails "Array#values_at does not return subclass instance on Array subclasses"
+  fails "Array#values_at when passed ranges returns an array of elements in the ranges"
+  fails "Array#values_at when passed ranges calls to_int on arguments of ranges"
+  fails "Array#values_at when passed a range fills with nil if the index is out of the range"
+  fails "Array#values_at when passed a range on an empty array fills with nils if the index is out of the range"
+
 
   fails "Array#zip calls #to_ary to convert the argument to an Array"
   fails "Array#zip uses #each to extract arguments' elements when #to_ary fails"