opal 0.4.4 → 0.5.0

data/spec/filters/unsupported/time.rb

@@ -0,0 +1,21 @@
+opal_filter "Time" do
+  fails "Time.mktime handles microseconds"
+  fails "Time.mktime handles fractional microseconds as a Float"
+  fails "Time.mktime handles fractional microseconds as a Rational"
+  fails "Time.mktime ignores fractional seconds if a passed whole number of microseconds"
+  fails "Time.mktime ignores fractional seconds if a passed fractional number of microseconds"
+
+  fails "Time#strftime returns the fractional seconds digits, default is 9 digits (nanosecond) with %N"
+  fails "Time#strftime with %N formats the nanoseconds of of the second with %N"
+  fails "Time#strftime with %N formats the milliseconds of of the second with %3N"
+  fails "Time#strftime with %N formats the microseconds of of the second with %6N"
+  fails "Time#strftime with %N formats the nanoseconds of of the second with %9N"
+  fails "Time#strftime with %N formats the picoseconds of of the second with %12N"
+  fails "Time#strftime with %z formats a UTC time offset as '+0000'"
+  fails "Time#strftime with %z formats a time with fixed positive offset as '+HHMM'"
+  fails "Time#strftime with %z formats a time with fixed negative offset as '-HHMM'"
+  fails "Time#strftime with %z formats a time with fixed offset as '+/-HH:MM' with ':' specifier"
+  fails "Time#strftime with %z formats a time with fixed offset as '+/-HH:MM:SS' with '::' specifier"
+  fails "Time#strftime with %z rounds fixed offset to the nearest second"
+  fails "Time#strftime with %L formats the milliseconds of of the second"
+end

data/spec/filters/unsupported/trusted.rb

@@ -12,4 +12,30 @@ opal_filter "Object#trusted/untrusted" do
   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#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"
 end

data/spec/opal/{parser → compiler}/irb_spec.rb

@@ -1,43 +1,43 @@
 require 'spec_helper'
 
-describe Opal::Parser do
+describe Opal::Compiler do
   describe "irb parser option" do
     before do
-      @parser = Opal::Parser.new
+      @compiler = Opal::Compiler.new
     end
 
     it "creates Opal.irb_vars if it does not exist" do
       $global["Opal"].irb_vars = nil
-      opal_eval_compiled(@parser.parse "nil", :irb => true)
+      eval_js(@compiler.compile "nil", :irb => true)
 
       ($global["Opal"].irb_vars == nil).should be_false
     end
 
     it "does not create Opal.irb_vars if :irb option not passed" do
       $global["Opal"].irb_vars = nil
-      opal_eval_compiled(@parser.parse "nil")
+      eval_js(@compiler.compile "nil")
 
       ($global["Opal"].irb_vars == nil).should be_true
     end
 
     it "sets each s(:lasgn) in the top level onto irb_vars" do
-      opal_eval_compiled @parser.parse "foo = 42", :irb => true
+      eval_js @compiler.compile "foo = 42", :irb => true
       $global["Opal"].irb_vars.foo.should == 42
     end
 
     it "gets each s(:lvar) in the top level from irb_vars" do
-      opal_eval_compiled @parser.parse "foo = 3.142; bar = foo", :irb => true
+      eval_js @compiler.compile "foo = 3.142; bar = foo", :irb => true
       $global["Opal"].irb_vars.bar.should == 3.142
     end
 
     it "persists local vars between parses" do
-      opal_eval_compiled @parser.parse "foo = 'hello world'", :irb => true
-      opal_eval_compiled @parser.parse "bar = foo.upcase", :irb => true
+      eval_js @compiler.compile "foo = 'hello world'", :irb => true
+      eval_js @compiler.compile "bar = foo.upcase", :irb => true
       $global["Opal"].irb_vars.bar.should == "HELLO WORLD"
     end
 
     it "can still call top level methods" do
-      opal_eval_compiled(@parser.parse("to_s", :irb => true)).should == "main"
+      eval_js(@compiler.compile("to_s", :irb => true)).should == "main"
     end
   end
 end

data/spec/{parser → opal/parser}/call_spec.rb

@@ -83,24 +83,49 @@ end
 describe "Operator precedence" do
   it "should be raised with parentheses" do
    opal_parse("(1 + 2) + (3 - 4)").should == [:call,
-                                               [:call, [:int, 1], :+, [:arglist, [:int, 2]]],
+                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
                                                :+,
-                                               [:arglist, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]],
+                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
                                               ]
    opal_parse("(1 + 2) - (3 - 4)").should == [:call,
-                                               [:call, [:int, 1], :+, [:arglist, [:int, 2]]],
+                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
                                                :-,
-                                               [:arglist, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]],
+                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
                                               ]
    opal_parse("(1 + 2) * (3 - 4)").should == [:call,
-                                               [:call, [:int, 1], :+, [:arglist, [:int, 2]]],
+                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
                                                :*,
-                                               [:arglist, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]],
+                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
                                               ]
    opal_parse("(1 + 2) / (3 - 4)").should == [:call,
-                                               [:call, [:int, 1], :+, [:arglist, [:int, 2]]],
+                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
                                                :/,
-                                               [:arglist, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]],
+                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
                                               ]
   end
 end
+
+describe "Calls with keywords as method names" do
+
+  keywords = %w[class module defined? def undef end do if unless else elsif self true false
+                nil __LINE__ __FILE__ begin rescue ensure case when or and not return next
+                redo break super then while until yield alias]
+
+  it "should correctly parse the keyword as a method name when after a '.'" do
+    keywords.each do |kw|
+      opal_parse("self.#{kw}").should == [:call, [:self], kw.to_sym, [:arglist]]
+    end
+  end
+end
+
+describe "Calls with operators as method names" do
+  operators = %w[+ - * / & ** | ^ & <=> > >= < <= << >>]
+
+  it "should correctly parse the operator as method name after '.'" do
+    operators.each do |op|
+      opal_parse("self.#{op}").should == [:call, [:self], op.to_sym, [:arglist]]
+      opal_parse("self.#{op}(1)").should == [:call, [:self], op.to_sym, [:arglist, [:int, 1]]]
+      opal_parse("self.#{op}(1, 2)").should == [:call, [:self], op.to_sym, [:arglist, [:int, 1], [:int, 2]]]
+    end
+  end
+end

data/spec/{parser → opal/parser}/def_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe "The def keyword" do
   describe "for normal definitions" do
-    it "should return s(:defn)" do
-      opal_parse("def a; end").should == [:defn, :a, [:args], [:scope, [:block, [:nil]]]]
+    it "should return s(:def)" do
+      opal_parse("def a; end").should == [:def, nil, :a, [:args], [:scope, [:block, [:nil]]]]
     end
 
     it "adds s(:nil) on an empty body" do
@@ -12,49 +12,49 @@ describe "The def keyword" do
   end
 
   describe "for singleton definitions" do
-    it "should return s(:defs)" do
-      opal_parse("def self.a; end").should == [:defs, [:self], :a, [:args], [:scope, [:block]]]
+    it "should return s(:def)" do
+      opal_parse("def self.a; end").should == [:def, [:self], :a, [:args], [:scope, [:block, [:nil]]]]
     end
 
-    it "does not add s(:nil) on an empty body" do
-      opal_parse("def self.foo; end").last.should == [:scope, [:block]]
+    it "adds s(:nil) on an empty body" do
+      opal_parse("def self.foo; end").last.should == [:scope, [:block, [:nil]]]
     end
   end
 
   describe "with normal args" do
     it "should list all args" do
-      opal_parse("def foo(a); end")[2].should == [:args, :a]
-      opal_parse("def foo(a, b); end")[2].should == [:args, :a, :b]
-      opal_parse("def foo(a, b, c); end")[2].should == [:args, :a, :b, :c]
+      opal_parse("def foo(a); end")[3].should == [:args, :a]
+      opal_parse("def foo(a, b); end")[3].should == [:args, :a, :b]
+      opal_parse("def foo(a, b, c); end")[3].should == [:args, :a, :b, :c]
     end
   end
 
   describe "with opt args" do
     it "should list all opt args as well as block with each lasgn" do
-      opal_parse("def foo(a = 1); end")[2].should == [:args, :a, [:block, [:lasgn, :a, [:int, 1]]]]
-      opal_parse("def foo(a = 1, b = 2); end")[2].should == [:args, :a, :b, [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]
+      opal_parse("def foo(a = 1); end")[3].should == [:args, :a, [:block, [:lasgn, :a, [:int, 1]]]]
+      opal_parse("def foo(a = 1, b = 2); end")[3].should == [:args, :a, :b, [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]
     end
 
     it "should list lasgn block after all other args" do
-      opal_parse("def foo(a, b = 1); end")[2].should == [:args, :a, :b, [:block, [:lasgn, :b, [:int, 1]]]]
-      opal_parse("def foo(b = 1, *c); end")[2].should == [:args, :b, :"*c", [:block, [:lasgn, :b, [:int, 1]]]]
-      opal_parse("def foo(b = 1, &block); end")[2].should == [:args, :b, :"&block", [:block, [:lasgn, :b, [:int, 1]]]]
+      opal_parse("def foo(a, b = 1); end")[3].should == [:args, :a, :b, [:block, [:lasgn, :b, [:int, 1]]]]
+      opal_parse("def foo(b = 1, *c); end")[3].should == [:args, :b, :"*c", [:block, [:lasgn, :b, [:int, 1]]]]
+      opal_parse("def foo(b = 1, &block); end")[3].should == [:args, :b, :"&block", [:block, [:lasgn, :b, [:int, 1]]]]
     end
   end
 
   describe "with rest args" do
     it "should list rest args in place as a symbol with '*' prefix" do
-      opal_parse("def foo(*a); end")[2].should == [:args, :"*a"]
+      opal_parse("def foo(*a); end")[3].should == [:args, :"*a"]
     end
 
     it "uses '*' as an arg name for rest args without a name" do
-      opal_parse("def foo(*); end")[2].should == [:args, :"*"]
+      opal_parse("def foo(*); end")[3].should == [:args, :"*"]
     end
   end
 
   describe "with block arg" do
     it "should list block argument with the '&' prefix" do
-      opal_parse("def foo(&a); end")[2].should == [:args, :"&a"]
+      opal_parse("def foo(&a); end")[3].should == [:args, :"&a"]
     end
   end
 end

data/spec/opal/parser/heredoc_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe "Heredocs" do
+
+  it "parses as a s(:str)" do
+    opal_parse("a = <<-FOO\nbar\nFOO")[2].should == [:str, "bar\n"]
+  end
+
+  it "allows start marker to be wrapped in quotes" do
+    opal_parse("a = <<-'FOO'\nbar\nFOO")[2].should == [:str, "bar\n"]
+    opal_parse("a = <<-\"FOO\"\nbar\nFOO")[2].should == [:str, "bar\n"]
+  end
+
+  it "does not parse EOS unless beginning of line" do
+    opal_parse("<<-FOO\ncontentFOO\nFOO").should == [:str, "contentFOO\n"]
+  end
+
+  it "does not parse EOS unless end of line" do
+    opal_parse("<<-FOO\nsome FOO content\nFOO").should == [:str, "some FOO content\n"]
+  end
+
+  it "parses postfix code as if it appeared after heredoc" do
+    opal_parse("<<-FOO.class\ncode\nFOO").should == [:call, [:str, "code\n"], :class, [:arglist]]
+    opal_parse("bar(<<-FOO, 1, 2, 3)\ncode\nFOO").should == [:call, nil, :bar,
+                                                              [:arglist, [:str, "code\n"],
+                                                                         [:int, 1],
+                                                                         [:int, 2],
+                                                                         [:int, 3]]]
+  end
+end

data/spec/opal/parser/iter_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe "Iters" do
+  describe "Iter on a command" do
+    it "the outer command call gets the iter" do
+      opal_parse("a b do; end").should == [:call, nil, :a, [:arglist, [:call, nil, :b, [:arglist]]], [:iter, nil]]
+      opal_parse("a 1, b do; end").should == [:call, nil, :a, [:arglist, [:int, 1], [:call, nil, :b, [:arglist]]], [:iter, nil]]
+    end
+  end
+
+  describe "with no args" do
+    it "has 'nil' as the args part of sexp" do
+      opal_parse("proc do; end")[4][1].should == nil
+    end
+  end
+
+  describe "with empty || args" do
+    it "should have args set to 0" do
+      opal_parse("proc do ||; end")[4][1].should == 0
+    end
+  end
+
+  describe "with normal args" do
+    it "adds a single s(:lasgn) for 1 norm arg" do
+      opal_parse("proc do |a|; end")[4][1].should == [:lasgn, :a]
+    end
+
+    it "lists multiple norm args inside a s(:masgn)" do
+      opal_parse("proc do |a, b|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
+      opal_parse("proc do |a, b, c|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:lasgn, :c]]]
+    end
+  end
+
+  describe "with splat arg" do
+    it "adds a s(:masgn) for the s(:splat) even if its the only arg" do
+      opal_parse("proc do |*a|; end")[4][1].should == [:masgn, [:array, [:splat, [:lasgn, :a]]]]
+      opal_parse("proc do |a, *b|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]]]
+    end
+  end
+
+  describe "with opt args" do
+    it "adds a s(:block) arg to end of s(:masgn) for each lasgn" do
+      opal_parse("proc do |a = 1|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:int, 1]]]]]
+      opal_parse("proc do |a = 1, b = 2|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]]
+    end
+
+    it "should add lasgn block after all other args" do
+      opal_parse("proc do |a, b = 1|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :b, [:int, 1]]]]]
+      opal_parse("proc do |b = 1, *c|; end")[4][1].should == [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]], [:block, [:lasgn, :b, [:int, 1]]]]]
+      opal_parse("proc do |b = 1, &c|; end")[4][1].should == [:masgn, [:array, [:lasgn, :b], [:block_pass, [:lasgn, :c]], [:block, [:lasgn, :b, [:int, 1]]]]]
+    end
+  end
+
+  describe "with block arg" do
+    it "should add block arg with s(:block_pass) wrapping s(:lasgn) prefix" do
+      opal_parse("proc do |&a|; end")[4][1].should == [:masgn, [:array, [:block_pass, [:lasgn, :a]]]]
+    end
+  end
+end

data/spec/opal/parser/lambda_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe "Lambda literals" do
+  it "should parse with either do/end construct or curly braces" do
+    opal_parse("-> {}").first.should == :call
+    opal_parse("-> do; end").first.should == :call
+  end
+
+  it "should parse as a call to 'lambda' with the lambda body as a block" do
+    opal_parse("-> {}").should == [:call, nil, :lambda, [:arglist], [:iter, nil]]
+  end
+
+  describe "with no args" do
+    it "should accept no args" do
+      opal_parse("-> {}")[4][1].should == nil
+    end
+  end
+
+  describe "with normal args" do
+    it "adds a single s(:lasgn) for 1 norm arg" do
+      opal_parse("->(a) {}")[4][1].should == [:lasgn, :a]
+    end
+
+    it "lists multiple norm args inside a s(:masgn)" do
+      opal_parse("-> (a, b) {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
+      opal_parse("-> (a, b, c) {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:lasgn, :c]]]
+    end
+  end
+
+  describe "with optional braces" do
+    it "parses normal args" do
+      opal_parse("-> a {}")[4][1].should == [:lasgn, :a]
+      opal_parse("-> a, b {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
+    end
+
+    it "parses splat args" do
+      opal_parse("-> *a {}")[4][1].should == [:masgn, [:array, [:splat, [:lasgn, :a]]]]
+      opal_parse("-> a, *b {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]]]
+    end
+
+    it "parses opt args" do
+      opal_parse("-> a = 1 {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:int, 1]]]]]
+      opal_parse("-> a = 1, b = 2 {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]]
+    end
+
+    it "parses block args" do
+      opal_parse("-> &a {}")[4][1].should == [:masgn, [:array, [:block_pass, [:lasgn, :a]]]]
+    end
+  end
+
+  describe "with body statements" do
+    it "should be nil when no statements given" do
+      opal_parse("-> {}")[4][2].should == nil
+    end
+
+    it "should be the single sexp when given one statement" do
+      opal_parse("-> { 42 }")[4][2].should == [:int, 42]
+    end
+
+    it "should wrap multiple statements into a s(:block)" do
+      opal_parse("-> { 42; 3.142 }")[4][2].should == [:block, [:int, 42], [:float, 3.142]]
+    end
+  end
+end

data/spec/{parser → 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 == [:defn, :a, [:args, :b], [:scope, [:block, [:lvar, :b]]]]
-      opal_parse("def a(b, c); c; end").should == [:defn, :a, [:args, :b, :c], [:scope, [:block, [:lvar, :c]]]]
+      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]]]]
     end
 
     it "should be created by an opt arg" do
-      opal_parse("def a(b=10); b; end").should == [:defn, :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]]]], [:scope, [:block, [:lvar, :b]]]]
     end
 
     it "should be created by a rest arg" do
-      opal_parse("def a(*b); b; end").should == [:defn, :a, [:args, :"*b"], [:scope, [:block, [:lvar, :b]]]]
+      opal_parse("def a(*b); b; end").should == [:def, nil, :a, [:args, :"*b"], [:scope, [:block, [:lvar, :b]]]]
     end
 
     it "should be created by a block arg" do
-      opal_parse("def a(&b); b; end").should == [:defn, :a, [:args, :"&b"], [:scope, [:block, [:lvar, :b]]]]
+      opal_parse("def a(&b); b; end").should == [:def, nil, :a, [:args, :"&b"], [:scope, [: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]], [:defn, :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], [:scope, [:block, [:call, nil, :a, [:arglist]]]]]]
     end
   end
 end