opal 0.5.2 → 0.5.4

data/spec/filters/bugs/basic_object.rb

@@ -1,4 +1,3 @@
 opal_filter "BasicObject" do
   fails "BasicObject#instance_eval evaluates strings"
-  fails "BasicObject#instance_exec passes arguments to the block"
 end

data/spec/filters/bugs/string.rb

@@ -1,37 +1,42 @@
 opal_filter "String" do
+  fails "String#capitalize is locale insensitive (only upcases a-z and only downcases A-Z)"
+
+  fails "String#center with length, padding raises an ArgumentError if padstr is empty"
+  fails "String#center with length, padding raises a TypeError when padstr can't be converted to a string"
+  fails "String#center with length, padding calls #to_str to convert padstr to a String"
+  fails "String#center with length, padding raises a TypeError when length can't be converted to an integer"
+  fails "String#center with length, padding calls #to_int to convert length to an integer"
   fails "String#center with length, padding pads with whitespace if no padstr is given"
   fails "String#center with length, padding returns a new string of specified length with self centered and padded with padstr"
 
-  fails "String#lines should split on the default record separator and return enumerator if not block is given"
+  fails "String#downcase is locale insensitive (only replaces A-Z)"
 
-  fails "String#upcase is locale insensitive (only replaces a-z)"
-  fails "String#size returns the length of self"
-  fails "String#length returns the length of self"
+  fails "String#end_with? converts its argument using :to_str"
+  fails "String#end_with? returns true if other is empty"
 
-  fails "String#index with Regexp converts start_offset to an integer via to_int"
+  fails "String#index raises a TypeError if passed a Symbol"
+  # we need regexp rewriting for these
   fails "String#index with Regexp supports \\G which matches at the given start offset"
   fails "String#index with Regexp starts the search at the given offset"
   fails "String#index with Regexp returns the index of the first match of regexp"
-  fails "String#index calls #to_int to convert the second argument"
-  fails "String#index calls #to_str to convert the first argument"
-  fails "String#index raises a TypeError if passed a Symbol"
 
+  fails "String#intern does not special case certain operators"
   fails "String#intern special cases +(binary) and -(binary)"
-  fails "String#to_sym special cases +(binary) and -(binary)"
+
+  fails "String#length returns the length of self"
+
+  fails "String#lines should split on the default record separator and return enumerator if not block is given"
+
+  fails "String#size returns the length of self"
 
   fails "String#start_with? ignores arguments not convertible to string"
   fails "String#start_with? converts its argument using :to_str"
-  fails "String#end_with? converts its argument using :to_str"
-  fails "String#end_with? returns true if other is empty"
-  fails "String#downcase is locale insensitive (only replaces A-Z)"
-  fails "String#intern does not special case certain operators"
+
   fails "String#to_sym does not special case certain operators"
-  fails "String#capitalize is locale insensitive (only upcases a-z and only downcases A-Z)"
-  fails "String#center with length, padding raises an ArgumentError if padstr is empty"
-  fails "String#center with length, padding raises a TypeError when padstr can't be converted to a string"
-  fails "String#center with length, padding calls #to_str to convert padstr to a String"
-  fails "String#center with length, padding raises a TypeError when length can't be converted to an integer"
-  fails "String#center with length, padding calls #to_int to convert length to an integer"
-  fails "String#chomp when passed an Object raises a TypeError if #to_str does not return a String"
-  fails "String#chomp when passed no argument returns a copy of the String when it is not modified"
+  fails "String#to_sym special cases +(binary) and -(binary)"
+
+  fails "String#upcase is locale insensitive (only replaces a-z)"
+
+  # 1.9.3 => 2.0
+  fails "String#end_with? ignores arguments not convertible to string"
 end

data/spec/filters/unsupported/enumerator.rb

@@ -10,4 +10,7 @@ opal_filter "Enumerator as generator" do
   fails "Enumerator#rewind does nothing if the object doesn't have a #rewind method"
   fails "Enumerator#rewind works with peek to reset the position"
   fails "Enumerator#rewind calls the enclosed object's rewind method if one exists"
+
+  # 1.9.3 => 2.0
+  fails "Enumerator.new ignores block if arg given"
 end

data/spec/filters/unsupported/float.rb

@@ -1,4 +1,5 @@
 opal_filter "Float" do
   fails "Array#inspect represents a recursive element with '[...]'"
   fails "Array#to_s represents a recursive element with '[...]'"
+  fails "Array#eql? returns false if any corresponding elements are not #eql?"
 end

data/spec/filters/unsupported/immutable_strings.rb

@@ -6,4 +6,19 @@ opal_filter "immutable strings" do
   fails "Time#strftime formats time according to the directives in the given format string"
   fails "Time#strftime with %z formats a local time with positive UTC offset as '+HHMM'"
   fails "Time#strftime with %z formats a local time with negative UTC offset as '-HHMM'"
+
+  fails "String#chomp when passed no argument returns a copy of the String when it is not modified"
+
+  fails "String#chop returns a new string when applied to an empty string"
+
+  fails "String#chop! removes the final character"
+  fails "String#chop! removes the final carriage return"
+  fails "String#chop! removes the final newline"
+  fails "String#chop! removes the final carriage return, newline"
+  fails "String#chop! removes the carrige return, newline if they are the only characters"
+  fails "String#chop! does not remove more than the final carriage return, newline"
+  fails "String#chop! returns self if modifications were made"
+  fails "String#chop! returns nil when called on an empty string"
+  fails "String#chop! raises a RuntimeError on a frozen instance that is modified"
+  fails "String#chop! raises a RuntimeError on a frozen instance that would not be modified"
 end

data/spec/filters/unsupported/tainted.rb

@@ -1,58 +1,72 @@
 opal_filter 'tainted' do
-  fails "Array#clear keeps tainted status"
-  fails "Array#compact! keeps tainted status even if all elements are removed"
-  fails "Array#delete_at keeps tainted status"
-  fails "Array#delete_if keeps tainted status"
-  fails "Array#delete keeps tainted status"
-  fails "Array#shift passed a number n as an argument keeps taint status"
-  fails "Array#shift passed a number n as an argument returns an untainted array even if the array is tainted"
-  fails "Array#pop passed a number n as an argument keeps taint status"
-  fails "Array#pop passed a number n as an argument returns an untainted array even if the array is tainted"
-  fails "Array#pop keeps taint status"
-  fails "Array#+ does not get infected even if an original array is tainted"
+  fails "Kernel#to_s returns a tainted result if self is tainted"
+
+  fails "Array#* with a string with a tainted separator taints the result if the array has two or more elements"
+  fails "Array#* with a string with a tainted separator does not taint the result if the array has only one element"
+  fails "Array#* with a string with a tainted separator does not taint the result if the array is empty"
   fails "Array#* with an integer copies the taint status of the original array if the passed count is not 0"
   fails "Array#* with an integer copies the taint status of the original array even if the array is empty"
   fails "Array#* with an integer copies the taint status of the original array even if the passed count is 0"
-  fails "Array#compact does not keep tainted status even if all elements are removed"
-  fails "Array#map! keeps tainted status"
-  fails "Array#map does not copy tainted status"
+
+  fails "Array#+ does not get infected even if an original array is tainted"
+
+  fails "Array#clear keeps tainted status"
+
   fails "Array#clone copies taint status from the original"
-  fails "Array#collect! keeps tainted status"
+
   fails "Array#collect does not copy tainted status"
+
+  fails "Array#collect! keeps tainted status"
+
+  fails "Array#compact does not keep tainted status even if all elements are removed"
+
+  fails "Array#compact! keeps tainted status even if all elements are removed"
+
   fails "Array#concat keeps tainted status"
   fails "Array#concat keeps the tainted status of elements"
+
+  fails "Array#delete keeps tainted status"
+
+  fails "Array#delete_at keeps tainted status"
+
+  fails "Array#delete_if keeps tainted status"
+
   fails "Array#dup copies taint status from the original"
+
   fails "Array#inspect taints the result if an element is tainted"
   fails "Array#inspect does not taint the result if the Array is tainted but empty"
   fails "Array#inspect taints the result if the Array is non-empty and tainted"
-  fails "Array#to_s taints the result if an element is tainted"
-  fails "Array#to_s does not taint the result if the Array is tainted but empty"
-  fails "Array#to_s taints the result if the Array is non-empty and tainted"
+
   fails "Array#join with a tainted separator taints the result if the array has two or more elements"
   fails "Array#join with a tainted separator does not taint the result if the array has only one element"
   fails "Array#join with a tainted separator does not taint the result if the array is empty"
   fails "Array#join taints the result if the result of coercing an element is tainted"
   fails "Array#join does not taint the result if the Array is tainted but empty"
   fails "Array#join taints the result if the Array is tainted and non-empty"
-  fails "Array#* with a string with a tainted separator taints the result if the array has two or more elements"
-  fails "Array#* with a string with a tainted separator does not taint the result if the array has only one element"
-  fails "Array#* with a string with a tainted separator does not taint the result if the array is empty"
 
-  fails "Hash#reject taints the resulting hash"
+  fails "Array#pop passed a number n as an argument keeps taint status"
+  fails "Array#pop passed a number n as an argument returns an untainted array even if the array is tainted"
+  fails "Array#pop keeps taint status"
 
-  fails "Kernel#to_s returns a tainted result if self is tainted"
+  fails "Array#map! keeps tainted status"
+  fails "Array#map does not copy tainted status"
 
-  fails "String#upcase taints result when self is tainted"
-  fails "String#to_s taints the result when self is tainted"
-  fails "String#to_str taints the result when self is tainted"
-  fails "String#swapcase taints resulting string when self is tainted"
-  fails "String#reverse taints the result if self is tainted"
+  fails "Array#shift passed a number n as an argument keeps taint status"
+  fails "Array#shift passed a number n as an argument returns an untainted array even if the array is tainted"
+
+  fails "Array#to_s taints the result if an element is tainted"
+  fails "Array#to_s does not taint the result if the Array is tainted but empty"
+  fails "Array#to_s taints the result if the Array is non-empty and tainted"
+
+  fails "Hash#reject taints the resulting hash"
 
-  fails "Pathname.new is tainted if path is tainted"
-  fails "String#downcase taints result when self is tainted"
   fails "String#capitalize taints resulting string when self is tainted"
+
+  fails "String#downcase taints result when self is tainted"
+
   fails "String#center with length, padding when padding is tainted and self is untainted returns a tainted string if and only if length is longer than self"
   fails "String#center with length, padding taints result when self or padstr is tainted"
+
   fails "String#chomp when passed a String does not taint the result when the argument is tainted"
   fails "String#chomp when passed a String taints the result if self is tainted"
   fails "String#chomp when passed '\\n' taints the result if self is tainted"
@@ -60,4 +74,18 @@ opal_filter 'tainted' do
   fails "String#chomp when passed nil taints the result if self is tainted"
   fails "String#chomp when passed nil returns a copy of the String"
   fails "String#chomp when passed no argument taints the result if self is tainted"
+
+  fails "String#chop taints result when self is tainted"
+
+  fails "String#reverse taints the result if self is tainted"
+
+  fails "String#swapcase taints resulting string when self is tainted"
+
+  fails "String#to_s taints the result when self is tainted"
+
+  fails "String#to_str taints the result when self is tainted"
+
+  fails "String#upcase taints result when self is tainted"
+
+  fails "Pathname.new is tainted if path is tainted"
 end

data/spec/filters/unsupported/trusted.rb

@@ -1,41 +1,61 @@
 opal_filter "Object#trusted/untrusted" do
-  fails "Array#pop passed a number n as an argument keeps untrusted status"
-  fails "Array#pop passed a number n as an argument returns a trusted array even if the array is untrusted"
-  fails "Array#pop keeps untrusted status"
+  fails "Kernel#to_s returns an untrusted result if self is untrusted"
+
   fails "Array#+ does not infected even if an original array is untrusted"
+
   fails "Array#* with an integer copies the untrusted status of the original array if the passed count is not 0"
   fails "Array#* with an integer copies the untrusted status of the original array even if the array is empty"
   fails "Array#* with an integer copies the untrusted status of the original array even if the passed count is 0"
+  fails "Array#* with a string with an untrusted separator untrusts the result if the array has two or more elements"
+  fails "Array#* with a string with an untrusted separator does not untrust the result if the array has only one element"
+  fails "Array#* with a string with an untrusted separator does not untrust the result if the array is empty"
+
   fails "Array#delete keeps untrusted status"
+
   fails "Array#delete_if keeps untrusted status"
+
   fails "Array#delete_at keeps untrusted status"
-  fails "Array#compact! keeps untrusted status even if all elements are removed"
-  fails "Array#compact does not keep untrusted status even if all elements are removed"
+
   fails "Array#clear keeps untrusted status"
-  fails "Array#map does not copy untrusted status"
+
   fails "Array#clone copies untrusted status from the original"
-  fails "Array#collect! keeps untrusted status"
+
   fails "Array#collect does not copy untrusted status"
+
+  fails "Array#compact does not keep untrusted status even if all elements are removed"
+
+  fails "Array#compact! keeps untrusted status even if all elements are removed"
+
+  fails "Array#collect! keeps untrusted status"
+
   fails "Array#concat keeps untrusted status"
   fails "Array#concat is not infected untrustedness by the other"
   fails "Array#concat keeps the untrusted status of elements"
+
   fails "Array#dup copies untrusted status from the original"
-  fails "Array#map! keeps untrusted status"
+
   fails "Array#inspect untrusts the result if an element is untrusted"
   fails "Array#inspect does not untrust the result if the Array is untrusted but empty"
   fails "Array#inspect untrusts the result if the Array is untrusted"
-  fails "Array#to_s untrusts the result if an element is untrusted"
-  fails "Array#to_s does not untrust the result if the Array is untrusted but empty"
-  fails "Array#to_s untrusts the result if the Array is untrusted"
+
   fails "Array#join with an untrusted separator untrusts the result if the array has two or more elements"
   fails "Array#join with an untrusted separator does not untrust the result if the array has only one element"
   fails "Array#join with an untrusted separator does not untrust the result if the array is empty"
   fails "Array#join untrusts the result if the result of coercing an element is untrusted"
   fails "Array#join does not untrust the result if the Array is untrusted but empty"
   fails "Array#join untrusts the result if the Array is untrusted and non-empty"
-  fails "Array#* with a string with an untrusted separator untrusts the result if the array has two or more elements"
-  fails "Array#* with a string with an untrusted separator does not untrust the result if the array has only one element"
-  fails "Array#* with a string with an untrusted separator does not untrust the result if the array is empty"
 
-  fails "Kernel#to_s returns an untrusted result if self is untrusted"
+  fails "Array#map does not copy untrusted status"
+
+  fails "Array#pop passed a number n as an argument keeps untrusted status"
+  fails "Array#pop passed a number n as an argument returns a trusted array even if the array is untrusted"
+  fails "Array#pop keeps untrusted status"
+
+  fails "Array#map! keeps untrusted status"
+
+  fails "Array#to_s untrusts the result if an element is untrusted"
+  fails "Array#to_s does not untrust the result if the Array is untrusted but empty"
+  fails "Array#to_s untrusts the result if the Array is untrusted"
+
+  fails "String#chop untrusts result when self is untrusted"
 end

data/spec/opal/parser/class_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
 describe "The class keyword" do
-  it "returns a plain s(:scope) when given an empty body" do
-    opal_parse('class A; end').should == [:class, :A, nil, [:scope]]
+  it "returns an empty s(:block) when given an empty body" do
+    opal_parse('class A; end').should == [:class, :A, nil, [:block]]
   end
 
   it "does not place single expressions into a s(:block)" do
-    opal_parse('class A; 1; end').should == [:class, :A, nil, [:scope, [:int, 1]]]
+    opal_parse('class A; 1; end').should == [:class, :A, nil, [:int, 1]]
   end
 
   it "adds multiple body expressions into a s(:block)" do
-    opal_parse('class A; 1; 2; end').should == [:class, :A, nil, [:scope, [:block, [:int, 1], [:int, 2]]]]
+    opal_parse('class A; 1; 2; end').should == [:class, :A, nil, [:block, [:int, 1], [:int, 2]]]
   end
 
   it "uses nil as a placeholder when no superclass is given" do

data/spec/opal/parser/def_spec.rb

@@ -3,21 +3,21 @@ require 'spec_helper'
 describe "The def keyword" do
   describe "for normal definitions" do
     it "should return s(:def)" do
-      opal_parse("def a; end").should == [:def, nil, :a, [:args], [:scope, [:block, [:nil]]]]
+      opal_parse("def a; end").should == [:def, nil, :a, [:args], [:block, [:nil]]]
     end
 
     it "adds s(:nil) on an empty body" do
-      opal_parse("def foo; end").last.should == [:scope, [:block, [:nil]]]
+      opal_parse("def foo; end").last.should == [:block, [:nil]]
     end
   end
 
   describe "for singleton definitions" do
     it "should return s(:def)" do
-      opal_parse("def self.a; end").should == [:def, [:self], :a, [:args], [:scope, [:block, [:nil]]]]
+      opal_parse("def self.a; end").should == [:def, [:self], :a, [:args], [:block, [:nil]]]
     end
 
     it "adds s(:nil) on an empty body" do
-      opal_parse("def self.foo; end").last.should == [:scope, [:block, [:nil]]]
+      opal_parse("def self.foo; end").last.should == [:block, [:nil]]
     end
   end
 

data/spec/opal/parser/lvar_spec.rb

@@ -15,24 +15,24 @@ describe "An lvar" do
 
   describe "inside a def" do
     it "should created by a norm arg" do
-      opal_parse("def a(b); b; end").should == [:def, nil, :a, [:args, :b], [:scope, [:block, [:lvar, :b]]]]
-      opal_parse("def a(b, c); c; end").should == [:def, nil, :a, [:args, :b, :c], [:scope, [:block, [:lvar, :c]]]]
+      opal_parse("def a(b); b; end").should == [:def, nil, :a, [:args, :b], [:block, [:lvar, :b]]]
+      opal_parse("def a(b, c); c; end").should == [:def, nil, :a, [:args, :b, :c], [:block, [:lvar, :c]]]
     end
 
     it "should be created by an opt arg" do
-      opal_parse("def a(b=10); b; end").should == [:def, nil, :a, [:args, :b, [:block, [:lasgn, :b, [:int, 10]]]], [:scope, [:block, [:lvar, :b]]]]
+      opal_parse("def a(b=10); b; end").should == [:def, nil, :a, [:args, :b, [:block, [:lasgn, :b, [:int, 10]]]], [:block, [:lvar, :b]]]
     end
 
     it "should be created by a rest arg" do
-      opal_parse("def a(*b); b; end").should == [:def, nil, :a, [:args, :"*b"], [:scope, [:block, [:lvar, :b]]]]
+      opal_parse("def a(*b); b; end").should == [:def, nil, :a, [:args, :"*b"], [:block, [:lvar, :b]]]
     end
 
     it "should be created by a block arg" do
-      opal_parse("def a(&b); b; end").should == [:def, nil, :a, [:args, :"&b"], [:scope, [:block, [:lvar, :b]]]]
+      opal_parse("def a(&b); b; end").should == [:def, nil, :a, [:args, :"&b"], [:block, [:lvar, :b]]]
     end
 
     it "should not be created from locals outside the def" do
-      opal_parse("a = 10; def b; a; end").should == [:block, [:lasgn, :a, [:int, 10]], [:def, nil, :b, [:args], [:scope, [:block, [:call, nil, :a, [:arglist]]]]]]
+      opal_parse("a = 10; def b; a; end").should == [:block, [:lasgn, :a, [:int, 10]], [:def, nil, :b, [:args], [:block, [:call, nil, :a, [:arglist]]]]]
     end
   end
 end

data/spec/opal/parser/module_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
 describe "The module keyword" do
-  it "returns a plain s(:scope) when given an empty body" do
-    opal_parse('module A; end').should == [:module, :A, [:scope]]
+  it "returns an empty s(:block) when given an empty body" do
+    opal_parse('module A; end').should == [:module, :A, [:block]]
   end
 
   it "does not place single expressions into a s(:block)" do
-    opal_parse('module A; 1; end').should == [:module, :A, [:scope, [:int, 1]]]
+    opal_parse('module A; 1; end').should == [:module, :A, [:int, 1]]
   end
 
   it "adds multiple body expressions into a s(:block)" do
-    opal_parse('module A; 1; 2; end').should == [:module, :A, [:scope, [:block, [:int, 1], [:int, 2]]]]
+    opal_parse('module A; 1; 2; end').should == [:module, :A, [:block, [:int, 1], [:int, 2]]]
   end
 
   it "should accept just a constant for the module name" do

data/spec/opal/parser/sclass_spec.rb

@@ -6,11 +6,11 @@ describe "Singleton classes" do
   end
 
   it "does not place single expressions into an s(:block)" do
-    opal_parse('class << A; 1; end')[2].should == [:scope, [:int, 1]]
+    opal_parse('class << A; 1; end')[2].should == [:int, 1]
   end
 
   it "adds multiple body expressions into a s(:block)" do
-    opal_parse('class << A; 1; 2; end')[2].should == [:scope, [:block, [:int, 1], [:int, 2]]]
+    opal_parse('class << A; 1; 2; end')[2].should == [:block, [:int, 1], [:int, 2]]
   end
 
   it "should accept any expressions for singleton part" do

data/spec/stdlib/native/exposure_spec.rb

@@ -0,0 +1,33 @@
+require 'native'
+
+describe 'Native exposure' do
+  describe Class do
+    describe '#native_alias' do
+      it 'exposes a method to javascript' do
+        c = Class.new do
+          def ruby_method
+            :ruby
+          end
+
+          native_alias :rubyMethod, :ruby_method
+        end
+
+        `#{c.new}.rubyMethod()`.should == :ruby
+      end
+    end
+
+    describe '#native_class' do
+      it 'exposes a Class on the JS global object' do
+        c = Class.new do
+          def self.name
+            'Pippo'
+          end
+
+          native_class
+        end
+
+        `Pippo`.should == c
+      end
+    end
+  end
+end