opal 0.3.11 → 0.3.15

data/spec/builder/build_source_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+class BuildSourceTest < Opal::Builder
+  attr_reader :files
+
+  def initialize
+    @files = []
+  end
+
+  def build_file(base, source)
+    @files << [base, source]
+  end
+end
+
+build_source_dir = File.expand_path '../fixtures/build_source', __FILE__
+
+describe "Builder#build_source" do
+  it "should only build ruby sources" do
+    Dir.chdir(build_source_dir) do
+      b = BuildSourceTest.new
+      b.build_source '.', 'foo'
+
+      b.files.size.should == 2
+      b.files.include?(['foo', 'a.rb']).should be_true
+      b.files.include?(['foo', 'b.rb']).should be_true
+    end
+  end
+
+  it "should recursively go into directories to find ruby sources" do
+    Dir.chdir(build_source_dir) do
+      b = BuildSourceTest.new
+      b.build_source '.', 'bar'
+
+      b.files.size.should == 3
+      b.files.include?(['bar', 'a.rb']).should be_true
+      b.files.include?(['bar/wow', 'b.rb']).should be_true
+      b.files.include?(['bar/wow/cow', 'c.rb']).should be_true
+    end
+  end
+
+  it "should be able to handle top level files" do
+    Dir.chdir(build_source_dir) do
+      b = BuildSourceTest.new
+      b.build_source '.', 'adam.rb'
+      b.files.should == [['.', 'adam.rb']]
+
+      b2 = BuildSourceTest.new
+      b2.build_source '.', 'charles.js'
+      b2.files.should == []
+    end
+  end
+end

data/spec/builder/output_path_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Builder#output_path" do
+  describe "with an output dir" do
+    it "should return output dir joined with source when base is '.'" do
+      b = Opal::Builder.new '', :out => 'build'
+
+      b.output_path('.', 'foo.rb').should == 'build/foo.js'
+      b.output_path('.', 'bar.rb').should == 'build/bar.js'
+    end
+
+    it "returns the parts joined but with first part of base removed" do
+      b = Opal::Builder.new '', :out => 'build'
+
+      b.output_path('lib', 'foo.rb').should == 'build/foo.js'
+      b.output_path('lib/foo', 'bar.rb').should == 'build/foo/bar.js'
+      b.output_path('lib/foo/bar', 'baz.rb').should == 'build/foo/bar/baz.js'
+    end
+  end
+
+  describe "without an output dir" do
+    it "should return base and source joined with .js extname" do
+      b = Opal::Builder.new '', :out => ''
+      b.output_path('.', 'foo.rb').should == 'foo.js'
+      b.output_path('lib', 'foo.rb').should == 'lib/foo.js'
+      b.output_path('lib/foo', 'bar.rb').should == 'lib/foo/bar.js'
+    end 
+
+    it "supports '.' as output dir" do
+      b = Opal::Builder.new '', :out => '.'
+      b.output_path('.', 'foo.rb').should == 'foo.js'
+      b.output_path('lib', 'foo.rb').should == 'lib/foo.js'
+      b.output_path('lib/foo', 'bar.rb').should == 'lib/foo/bar.js'
+    end
+
+    it "supports nil as output dir" do
+      b = Opal::Builder.new '', :out => nil
+      b.output_path('.', 'foo.rb').should == 'foo.js'
+      b.output_path('lib', 'foo.rb').should == 'lib/foo.js'
+      b.output_path('lib/foo', 'bar.rb').should == 'lib/foo/bar.js'
+    end
+
+    it "supports false as output dir" do
+      b = Opal::Builder.new '', :out => false
+      b.output_path('.', 'foo.rb').should == 'foo.js'
+      b.output_path('lib', 'foo.rb').should == 'lib/foo.js'
+      b.output_path('lib/foo', 'bar.rb').should == 'lib/foo/bar.js'
+    end
+  end
+end

data/spec/grammar/alias_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The alias keyword" do
+  describe "with fitem" do
+    it "should return an s(:alias) with s(:lit)" do
+      opal_parse("alias a b").should == [:alias, [:lit, :a], [:lit, :b]]
+      opal_parse("alias == equals").should == [:alias, [:lit, :==], [:lit, :equals]]
+    end
+
+    it "should accept symbols as names" do
+      opal_parse("alias :foo :bar").should == [:alias, [:lit, :foo], [:lit, :bar]]
+    end
+  end
+
+  describe "with gvar" do
+    it "should return a s(:valias) with two gvars as arguments" do
+      opal_parse("alias $foo $bar").should == [:valias, :$foo, :$bar]
+    end
+  end
+
+  describe "with gvar and nth ref" do
+    it "should return a s(:valias) with two values as arguments" do
+      opal_parse("alias $foo $1").should == [:valias, :$foo, :"$1"]
+    end
+  end
+end

data/spec/grammar/and_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The and statement" do
+  it "should always return s(:and)" do
+    opal_parse("1 and 2").should == [:and, [:lit, 1], [:lit, 2]]
+  end
+end
+
+describe "The && expression" do
+  it "should always return s(:and)" do
+    opal_parse("1 && 2").should == [:and, [:lit, 1], [:lit, 2]]
+  end
+end

data/spec/grammar/array_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Arrays" do
+  it "should parse empty arrays as s(:array)" do
+    opal_parse("[]").should == [:array]
+  end
+
+  it "should append regular args onto end of array sexp" do
+    opal_parse("[1]").should == [:array, [:lit, 1]]
+    opal_parse("[1, 2]").should == [:array, [:lit, 1], [:lit, 2]]
+    opal_parse("[1, 2, 3]").should == [:array, [:lit, 1], [:lit, 2], [:lit, 3]]
+  end
+
+  it "should return a single item s(:array) with given splat if no norm args" do
+    opal_parse("[*1]").should == [:array, [:splat, [:lit, 1]]]
+  end
+
+  it "should allow splats combined with any number of norm args" do
+    opal_parse("[1, *2]").should == [:array, [:lit, 1], [:splat, [:lit, 2]]]
+    opal_parse("[1, 2, *3]").should == [:array, [:lit, 1], [:lit, 2], [:splat, [:lit, 3]]]
+  end
+end

data/spec/grammar/attrasgn_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Attribute assignments" do
+  it "should return a s(:attrasgn) for simple assignments" do
+    opal_parse('self.foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:lit, 1]]]
+    opal_parse('bar.foo = 1').should == [:attrasgn, [:call, nil, :bar, [:arglist]], :foo=, [:arglist, [:lit, 1]]]
+    opal_parse('@bar.foo = 1').should == [:attrasgn, [:ivar, :@bar], :foo=, [:arglist, [:lit, 1]]]
+  end
+
+  it "accepts both '.' and '::' for method call operators" do
+    opal_parse('self.foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:lit, 1]]]
+    opal_parse('self::foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:lit, 1]]]
+  end
+
+  it "can accept a constant as assignable name when using '.'" do
+    opal_parse('self.FOO = 1').should == [:attrasgn, [:self], :FOO=, [:arglist, [:lit, 1]]]
+  end
+
+  describe "when setting element reference" do
+    it "uses []= as the method call" do
+      opal_parse('self[1] = 2').should == [:attrasgn, [:self], :[]=, [:arglist, [:lit, 1], [:lit, 2]]]
+    end
+
+    it "supports multiple arguments inside brackets" do
+      opal_parse('self[1, 2] = 3').should == [:attrasgn, [:self], :[]=, [:arglist, [:lit, 1], [:lit, 2], [:lit, 3]]]
+    end
+  end
+end

data/spec/grammar/begin_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The begin keyword" do
+  it "should be removed when used without a resuce or enusre body" do
+    opal_parse('begin; 1; end').should == [:lit, 1]
+    opal_parse('begin; 1; 2; end').should == [:block, [:lit, 1], [:lit, 2]]
+  end
+
+  describe "with 'rescue' bodies" do
+    it "should create a s(:rescue) sexp" do
+      opal_parse('begin; 1; rescue; 2; end').should == [:rescue, [:lit, 1], [:resbody, [:array], [:lit, 2]]]
+    end
+
+    it "allows multiple rescue bodies" do
+      opal_parse('begin 1; rescue; 2; rescue; 3; end').should == [:rescue, [:lit, 1], [:resbody, [:array], [:lit, 2]], [:resbody, [:array], [:lit, 3]]]
+    end
+
+    it "accepts a list of classes used to match against the exception" do
+      opal_parse('begin 1; rescue Klass; 2; end').should == [:rescue, [:lit, 1], [:resbody, [:array, [:const, :Klass]], [:lit, 2]]]
+    end
+
+    it "accepts an identifier to assign exception to" do
+      opal_parse('begin 1; rescue => a; 2; end').should == [:rescue, [:lit, 1], [:resbody, [:array, [:lasgn, :a, [:gvar, :$!]]], [:lit, 2]]]
+      opal_parse('begin 1; rescue Klass => a; 2; end').should == [:rescue, [:lit, 1], [:resbody, [:array, [:const, :Klass],[:lasgn, :a, [:gvar, :$!]]], [:lit, 2]]]
+    end
+
+    it "accepts an ivar to assign exception to" do
+      opal_parse('begin 1; rescue => @a; 2; end').should == [:rescue, [:lit, 1], [:resbody, [:array, [:iasgn, :@a, [:gvar, :$!]]], [:lit, 2]]]
+      opal_parse('begin 1; rescue Klass => @a; 2; end').should == [:rescue, [:lit, 1], [:resbody, [:array, [:const, :Klass],[:iasgn, :@a, [:gvar, :$!]]], [:lit, 2]]]
+    end
+  end
+
+  describe "with an 'ensure' block" do
+    it "should propagate into single s(:ensure) statement when no rescue block given" do
+      opal_parse('begin; 1; ensure; 2; end').should == [:ensure, [:lit, 1], [:lit, 2]]
+    end
+  end
+end

data/spec/grammar/block_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Block statements" do
+  it "should return the direct expression if only one expresssion in block" do
+    opal_parse("42").should == [:lit, 42]
+  end
+
+  it "should return an s(:block) with all expressions appended for > 1 expression" do
+    opal_parse("42; 43").should == [:block, [:lit, 42], [:lit, 43]]
+    opal_parse("42; 43\n44").should == [:block, [:lit, 42], [:lit, 43], [:lit, 44]]
+  end
+end

data/spec/grammar/break_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The break keyword" do
+  it "should return s(:break) when given no args" do
+    opal_parse("break").should == [:break]
+  end
+
+  it "returns s(:break) with a single arg not wrapped in s(:array)" do
+    opal_parse("break 1").should == [:break, [:lit, 1]]
+    opal_parse("break *1").should == [:break, [:splat, [:lit, 1]]]
+  end
+
+  it "returns s(:break) with an s(:array) for args size > 1" do
+    opal_parse("break 1, 2").should == [:break, [:array, [:lit, 1], [:lit, 2]]]
+    opal_parse("break 1, *2").should == [:break, [:array, [:lit, 1], [:splat, [:lit, 2]]]]
+  end
+end

data/spec/grammar/call_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Method calls" do
+  it "should use 'nil' for calls without a receiver" do
+    opal_parse("foo").should == [:call, nil, :foo, [:arglist]]
+    opal_parse("foo()").should == [:call, nil, :foo, [:arglist]]
+  end
+
+  it "should always have an arglist when not passed any arguments" do
+    opal_parse("foo").should == [:call, nil, :foo, [:arglist]]
+    opal_parse("self.foo").should == [:call, [:self], :foo, [:arglist]]
+    opal_parse("foo()").should == [:call, nil, :foo, [:arglist]]
+    opal_parse("self.foo()").should == [:call, [:self], :foo, [:arglist]]
+  end
+
+  it "appends all arguments onto arglist" do
+    opal_parse("foo 1").should == [:call, nil, :foo, [:arglist, [:lit, 1]]]
+    opal_parse("foo 1, 2").should == [:call, nil, :foo, [:arglist, [:lit, 1], [:lit, 2]]]
+    opal_parse("foo 1, *2").should == [:call, nil, :foo, [:arglist, [:lit, 1], [:splat, [:lit, 2]]]]
+  end
+end
+
+describe "Operator calls" do
+  it "should become regular calls with operator as method" do
+    opal_parse("1 + 2").should == [:call, [:lit, 1], :+, [:arglist, [:lit, 2]]]
+    opal_parse("1 - 2").should == [:call, [:lit, 1], :-, [:arglist, [:lit, 2]]]
+    opal_parse("1 / 2").should == [:call, [:lit, 1], :/, [:arglist, [:lit, 2]]]
+    opal_parse("1 * 2").should == [:call, [:lit, 1], :*, [:arglist, [:lit, 2]]]
+    opal_parse("1 % 2").should == [:call, [:lit, 1], :%, [:arglist, [:lit, 2]]]
+    opal_parse("1 ** 2").should == [:call, [:lit, 1], :**, [:arglist, [:lit, 2]]]
+
+    opal_parse("+self").should == [:call, [:self], :+@, [:arglist]]
+    opal_parse("-self").should == [:call, [:self], :-@, [:arglist]]
+
+    opal_parse("1 | 2").should == [:call, [:lit, 1], :|, [:arglist, [:lit, 2]]]
+    opal_parse("1 ^ 2").should == [:call, [:lit, 1], :^, [:arglist, [:lit, 2]]]
+    opal_parse("1 & 2").should == [:call, [:lit, 1], :&, [:arglist, [:lit, 2]]]
+    opal_parse("1 <=> 2").should == [:call, [:lit, 1], :<=>, [:arglist, [:lit, 2]]]
+
+    opal_parse("1 < 2").should == [:call, [:lit, 1], :<, [:arglist, [:lit, 2]]]
+    opal_parse("1 <= 2").should == [:call, [:lit, 1], :<=, [:arglist, [:lit, 2]]]
+    opal_parse("1 > 2").should == [:call, [:lit, 1], :>, [:arglist, [:lit, 2]]]
+    opal_parse("1 >= 2").should == [:call, [:lit, 1], :>=, [:arglist, [:lit, 2]]]
+
+    opal_parse("1 == 2").should == [:call, [:lit, 1], :==, [:arglist, [:lit, 2]]]
+    opal_parse("1 === 2").should == [:call, [:lit, 1], :===, [:arglist, [:lit, 2]]]
+    opal_parse("1 =~ 2").should == [:call, [:lit, 1], :=~, [:arglist, [:lit, 2]]]
+
+    opal_parse("~1").should == [:call, [:lit, 1], :~, [:arglist]]
+    opal_parse("1 << 2").should == [:call, [:lit, 1], :<<, [:arglist, [:lit, 2]]]
+    opal_parse("1 >> 2").should == [:call, [:lit, 1], :>>, [:arglist, [:lit, 2]]]
+  end
+
+  it "optimizes +@ and -@ on numerics" do
+    opal_parse("+1").should == [:lit, 1]
+    opal_parse("-1").should == [:lit, -1]
+  end
+end

data/spec/grammar/class_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+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]]
+  end
+
+  it "does not place single expressions into a s(:block)" do
+    opal_parse('class A; 1; end').should == [:class, :A, nil, [:scope, [:lit, 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, [:lit, 1], [:lit, 2]]]]
+  end
+
+  it "uses nil as a placeholder when no superclass is given" do
+    opal_parse('class A; end')[2].should == nil
+  end
+
+  it "reflects the given superclass" do
+    opal_parse('class A < B; end')[2].should == [:const, :B]
+  end
+
+  it "should accept just a constant for the class name" do
+    opal_parse('class A; end')[1].should == :A
+  end
+
+  it "should accept a prefix constant for the class name" do
+    opal_parse('class ::A; end')[1].should == [:colon3, :A]
+  end
+
+  it "should accept a nested constant for the class name" do
+    opal_parse('class A::B; end')[1].should == [:colon2, [:const, :A], :B]
+  end
+end

data/spec/grammar/const_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Constants" do
+  it "should always become a s(:const)" do
+    opal_parse("FOO").should == [:const, :FOO]
+    opal_parse("BAR").should == [:const, :BAR]
+  end
+
+  it "should be returned as s(:cdecl) on assignment" do
+    opal_parse("FOO = 1").should == [:cdecl, :FOO, [:lit, 1]]
+    opal_parse("FOO = BAR").should == [:cdecl, :FOO, [:const, :BAR]]
+  end
+end

data/spec/grammar/cvar_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Class variables" do
+  it "should always be returned as s(:cvar)" do
+    opal_parse("@@foo").should == [:cvar, :@@foo]
+  end
+
+  it "should always be converted to s(:cvdecl) on assignment" do
+    opal_parse("@@foo = 100").should == [:cvdecl, :@@foo, [:lit, 100]]
+  end
+end

data/spec/grammar/def_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+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]]]]
+    end
+
+    it "adds s(:nil) on an empty body" do
+      opal_parse("def foo; end").last.should == [:scope, [:block, [:nil]]]
+    end
+  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]]]
+    end
+
+    it "does not add s(:nil) on an empty body" do
+      opal_parse("def self.foo; end").last.should == [:scope, [:block]]
+    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]
+    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, [:lit, 1]]]]
+      opal_parse("def foo(a = 1, b = 2); end")[2].should == [:args, :a, :b, [:block, [:lasgn, :a, [:lit, 1]], [:lasgn, :b, [:lit, 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, [:lit, 1]]]]
+      opal_parse("def foo(b = 1, *c); end")[2].should == [:args, :b, :"*c", [:block, [:lasgn, :b, [:lit, 1]]]]
+      opal_parse("def foo(b = 1, &block); end")[2].should == [:args, :b, :"&block", [:block, [:lasgn, :b, [:lit, 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"]
+    end
+
+    it "uses '*' as an arg name for rest args without a name" do
+      opal_parse("def foo(*); end")[2].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"]
+    end
+  end
+end