opal 0.4.3 → 0.4.4

data/spec/parser/class_spec.rb

@@ -6,11 +6,11 @@ describe "The class keyword" do
   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]]]
+    opal_parse('class A; 1; end').should == [:class, :A, nil, [:scope, [: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, [:lit, 1], [:lit, 2]]]]
+    opal_parse('class A; 1; 2; end').should == [:class, :A, nil, [:scope, [:block, [:int, 1], [:int, 2]]]]
   end
 
   it "uses nil as a placeholder when no superclass is given" do

data/spec/parser/const_spec.rb

@@ -7,7 +7,7 @@ describe "Constants" do
   end
 
   it "should be returned as s(:cdecl) on assignment" do
-    opal_parse("FOO = 1").should == [:cdecl, :FOO, [:lit, 1]]
+    opal_parse("FOO = 1").should == [:cdecl, :FOO, [:int, 1]]
     opal_parse("FOO = BAR").should == [:cdecl, :FOO, [:const, :BAR]]
   end
 end

data/spec/parser/cvar_spec.rb

@@ -6,6 +6,6 @@ describe "Class variables" do
   end
 
   it "should always be converted to s(:cvdecl) on assignment" do
-    opal_parse("@@foo = 100").should == [:cvdecl, :@@foo, [:lit, 100]]
+    opal_parse("@@foo = 100").should == [:cvdecl, :@@foo, [:int, 100]]
   end
 end

data/spec/parser/def_spec.rb

@@ -31,14 +31,14 @@ describe "The def keyword" do
 
   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]]]]
+      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]]]]
     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]]]]
+      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]]]]
     end
   end
 

data/spec/parser/gvar_spec.rb

@@ -7,7 +7,7 @@ describe "Global variables" do
   end
 
   it "should return s(:gasgn) on assignment" do
-    opal_parse("$foo = 1").should == [:gasgn, :$foo, [:lit, 1]]
-    opal_parse("$: = 1").should == [:gasgn, :$:, [:lit, 1]]
+    opal_parse("$foo = 1").should == [:gasgn, :$foo, [:int, 1]]
+    opal_parse("$: = 1").should == [:gasgn, :$:, [:int, 1]]
   end
 end

data/spec/parser/hash_spec.rb

@@ -6,12 +6,12 @@ describe "Hash literals" do
   end
 
   it "adds each assoc pair as individual args onto sexp" do
-    opal_parse("{1 => 2}").should == [:hash, [:lit, 1], [:lit, 2]]
-    opal_parse("{1 => 2, 3 => 4}").should == [:hash, [:lit, 1], [:lit, 2], [:lit, 3], [:lit, 4]]
+    opal_parse("{1 => 2}").should == [:hash, [:int, 1], [:int, 2]]
+    opal_parse("{1 => 2, 3 => 4}").should == [:hash, [:int, 1], [:int, 2], [:int, 3], [:int, 4]]
   end
 
   it "supports 1.9 style hash keys" do
-    opal_parse("{ a: 1 }").should == [:hash, [:lit, :a], [:lit, 1]]
-    opal_parse("{ a: 1, b: 2 }").should == [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]]
+    opal_parse("{ a: 1 }").should == [:hash, [:sym, :a], [:int, 1]]
+    opal_parse("{ a: 1, b: 2 }").should == [:hash, [:sym, :a], [:int, 1], [:sym, :b], [:int, 2]]
   end
 end

data/spec/parser/iasgn_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe "Instance variable assignment" do
   it "always returns an s(:iasgn)" do
-    opal_parse("@a = 1").should == [:iasgn, :@a, [:lit, 1]]
-    opal_parse("@A = 1").should == [:iasgn, :@A, [:lit, 1]]
-    opal_parse("@class = 1").should == [:iasgn, :@class, [:lit, 1]]
+    opal_parse("@a = 1").should == [:iasgn, :@a, [:int, 1]]
+    opal_parse("@A = 1").should == [:iasgn, :@A, [:int, 1]]
+    opal_parse("@class = 1").should == [:iasgn, :@class, [:int, 1]]
   end
 end

data/spec/parser/if_spec.rb

@@ -2,25 +2,25 @@ require 'spec_helper'
 
 describe "The if keyword" do
   it "should return an s(:if) with given truthy and falsy bodies" do
-    opal_parse("if 1; 2; else; 3; end").should == [:if, [:lit, 1], [:lit, 2], [:lit, 3]]
+    opal_parse("if 1; 2; else; 3; end").should == [:if, [:int, 1], [:int, 2], [:int, 3]]
   end
 
   it "uses nil as fasly body if not given else-then" do
-    opal_parse("if 1; 2; end").should == [:if, [:lit, 1], [:lit, 2], nil]
+    opal_parse("if 1; 2; end").should == [:if, [:int, 1], [:int, 2], nil]
   end
 
   it "is treats elsif parts as sub if expressions for else body" do
-    opal_parse("if 1; 2; elsif 3; 4; else; 5; end").should == [:if, [:lit, 1], [:lit, 2], [:if, [:lit, 3], [:lit, 4], [:lit, 5]]]
-    opal_parse("if 1; 2; elsif 3; 4; end").should == [:if, [:lit, 1], [:lit, 2], [:if, [:lit, 3], [:lit, 4], nil]]
+    opal_parse("if 1; 2; elsif 3; 4; else; 5; end").should == [:if, [:int, 1], [:int, 2], [:if, [:int, 3], [:int, 4], [:int, 5]]]
+    opal_parse("if 1; 2; elsif 3; 4; end").should == [:if, [:int, 1], [:int, 2], [:if, [:int, 3], [:int, 4], nil]]
   end
 
   it "returns a simple s(:if) with nil else body for prefix if statement" do
-    opal_parse("1 if 2").should == [:if, [:lit, 2], [:lit, 1], nil]
+    opal_parse("1 if 2").should == [:if, [:int, 2], [:int, 1], nil]
   end
 end
 
 describe "The ternary operator" do
   it "gets converted into an if statement with true and false parts" do
-    opal_parse("1 ? 2 : 3").should == [:if, [:lit, 1], [:lit, 2], [:lit, 3]]
+    opal_parse("1 ? 2 : 3").should == [:if, [:int, 1], [:int, 2], [:int, 3]]
   end
 end

data/spec/parser/iter_spec.rb

@@ -4,7 +4,7 @@ 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 == [:iter, [:call, nil, :a, [:arglist, [:call, nil, :b, [:arglist]]]], nil]
-      opal_parse("a 1, b do; end").should == [:iter, [:call, nil, :a, [:arglist, [:lit, 1], [:call, nil, :b, [:arglist]]]], nil]
+      opal_parse("a 1, b do; end").should == [:iter, [:call, nil, :a, [:arglist, [:int, 1], [:call, nil, :b, [:arglist]]]], nil]
     end
   end
 
@@ -40,14 +40,14 @@ describe "Iters" do
 
   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")[2].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:lit, 1]]]]]
-      opal_parse("proc do |a = 1, b = 2|; end")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :a, [:lit, 1]], [:lasgn, :b, [:lit, 2]]]]]
+      opal_parse("proc do |a = 1|; end")[2].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:int, 1]]]]]
+      opal_parse("proc do |a = 1, b = 2|; end")[2].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")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :b, [:lit, 1]]]]]
-      opal_parse("proc do |b = 1, *c|; end")[2].should == [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]], [:block, [:lasgn, :b, [:lit, 1]]]]]
-      opal_parse("proc do |b = 1, &c|; end")[2].should == [:masgn, [:array, [:lasgn, :b], [:block_pass, [:lasgn, :c]], [:block, [:lasgn, :b, [:lit, 1]]]]]
+      opal_parse("proc do |a, b = 1|; end")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :b, [:int, 1]]]]]
+      opal_parse("proc do |b = 1, *c|; end")[2].should == [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]], [:block, [:lasgn, :b, [:int, 1]]]]]
+      opal_parse("proc do |b = 1, &c|; end")[2].should == [:masgn, [:array, [:lasgn, :b], [:block_pass, [:lasgn, :c]], [:block, [:lasgn, :b, [:int, 1]]]]]
     end
   end
 

data/spec/parser/lambda_spec.rb

@@ -39,8 +39,8 @@ describe "Lambda literals" do
     end
 
     it "parses opt args" do
-      opal_parse("-> a = 1 {}")[2].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:lit, 1]]]]]
-      opal_parse("-> a = 1, b = 2 {}")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :a, [:lit, 1]], [:lasgn, :b, [:lit, 2]]]]]
+      opal_parse("-> a = 1 {}")[2].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:int, 1]]]]]
+      opal_parse("-> a = 1, b = 2 {}")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]]
     end
 
     it "parses block args" do
@@ -54,11 +54,11 @@ describe "Lambda literals" do
     end
 
     it "should be the single sexp when given one statement" do
-      opal_parse("-> { 42 }")[3].should == [:lit, 42]
+      opal_parse("-> { 42 }")[3].should == [:int, 42]
     end
 
     it "should wrap multiple statements into a s(:block)" do
-      opal_parse("-> { 42; 3.142 }")[3].should == [:block, [:lit, 42], [:lit, 3.142]]
+      opal_parse("-> { 42; 3.142 }")[3].should == [:block, [:int, 42], [:float, 3.142]]
     end
   end
-end
+end

data/spec/parser/lasgn_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe "Local assignment" do
   it "returns an s(:lasgn)" do
-    opal_parse("a = 1").should == [:lasgn, :a, [:lit, 1]]
-    opal_parse("a = 1; b = 2").should == [:block, [:lasgn, :a, [:lit, 1]], [:lasgn, :b, [:lit, 2]]]
+    opal_parse("a = 1").should == [:lasgn, :a, [:int, 1]]
+    opal_parse("a = 1; b = 2").should == [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]
   end
 end

data/spec/parser/line_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe "The __LINE__ keyword" do
   it "should always return a literal number of the current line" do
-    opal_parse("__LINE__").should == [:lit, 1]
-    opal_parse("\n__LINE__").should == [:lit, 2]
+    opal_parse("__LINE__").should == [:int, 1]
+    opal_parse("\n__LINE__").should == [:int, 2]
   end
 end

data/spec/parser/lvar_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe "An lvar" do
   describe "in any scope" do
     it "should be created when an identifier is previously assigned to" do
-      opal_parse("a = 1; a").should == [:block, [:lasgn, :a, [:lit, 1]], [:lvar, :a]]
-      opal_parse("a = 1; a; a").should == [:block, [:lasgn, :a, [:lit, 1]], [:lvar, :a], [:lvar, :a]]
+      opal_parse("a = 1; a").should == [:block, [:lasgn, :a, [:int, 1]], [:lvar, :a]]
+      opal_parse("a = 1; a; a").should == [:block, [:lasgn, :a, [:int, 1]], [:lvar, :a], [:lvar, :a]]
     end
 
     it "should not be created when no lasgn is previously used on name" do
       opal_parse("a").should == [:call, nil, :a, [:arglist]]
-      opal_parse("a = 1; b").should == [:block, [:lasgn, :a, [:lit, 1]], [:call, nil, :b, [:arglist]]]
+      opal_parse("a = 1; b").should == [:block, [:lasgn, :a, [:int, 1]], [:call, nil, :b, [:arglist]]]
     end
   end
 
@@ -20,7 +20,7 @@ describe "An lvar" do
     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, [:lit, 10]]]], [:scope, [:block, [:lvar, :b]]]]
+      opal_parse("def a(b=10); b; end").should == [:defn, :a, [:args, :b, [:block, [:lasgn, :b, [:int, 10]]]], [:scope, [:block, [:lvar, :b]]]]
     end
 
     it "should be created by a rest arg" do
@@ -32,7 +32,7 @@ describe "An lvar" do
     end
 
     it "should not be created from locals outside the def" do
-      opal_parse("a = 10; def b; a; end").should == [:block, [:lasgn, :a, [:lit, 10]], [:defn, :b, [:args], [:scope, [:block, [:call, nil, :a, [:arglist]]]]]]
+      opal_parse("a = 10; def b; a; end").should == [:block, [:lasgn, :a, [:int, 10]], [:defn, :b, [:args], [:scope, [:block, [:call, nil, :a, [:arglist]]]]]]
     end
   end
 end

data/spec/parser/masgn_spec.rb

@@ -31,7 +31,7 @@ describe "Masgn" do
 
   describe "with a single rhs argument" do
     it "should wrap rhs in an s(:to_ary)" do
-      opal_parse('a, b = 1')[2].should == [:to_ary, [:lit, 1]]
+      opal_parse('a, b = 1')[2].should == [:to_ary, [:int, 1]]
     end
   end
 end

data/spec/parser/module_spec.rb

@@ -6,11 +6,11 @@ describe "The module keyword" do
   end
 
   it "does not place single expressions into a s(:block)" do
-    opal_parse('module A; 1; end').should == [:module, :A, [:scope, [:lit, 1]]]
+    opal_parse('module A; 1; end').should == [:module, :A, [:scope, [: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, [:lit, 1], [:lit, 2]]]]
+    opal_parse('module A; 1; 2; end').should == [:module, :A, [:scope, [:block, [:int, 1], [:int, 2]]]]
   end
 
   it "should accept just a constant for the module name" do

data/spec/parser/not_spec.rb

@@ -3,25 +3,25 @@ require 'spec_helper'
 describe "The not keyword" do
   it "returns s(:not) with the single argument" do
     opal_parse("not self").should == [:not, [:self]]
-    opal_parse("not 42").should == [:not, [:lit, 42]]
+    opal_parse("not 42").should == [:not, [:int, 42]]
   end
 end
 
 describe "The '!' expression" do
   it "returns s(:not) with the single argument" do
     opal_parse("!self").should == [:not, [:self]]
-    opal_parse("!42").should == [:not, [:lit, 42]]
+    opal_parse("!42").should == [:not, [:int, 42]]
   end
 end
 
 describe "The '!=' expression" do
   it "rewrites as !(lhs == rhs)" do
-    opal_parse("1 != 2").should == [:not, [:call, [:lit, 1], :==, [:arglist, [:lit, 2]]]]
+    opal_parse("1 != 2").should == [:not, [:call, [:int, 1], :==, [:arglist, [:int, 2]]]]
   end
 end
 
 describe "The '!~' expression" do
   it "rewrites as !(lhs =~ rhs)" do
-    opal_parse("1 !~ 2").should == [:not, [:call, [:lit, 1], :=~, [:arglist, [:lit, 2]]]]
+    opal_parse("1 !~ 2").should == [:not, [:call, [:int, 1], :=~, [:arglist, [:int, 2]]]]
   end
 end

data/spec/parser/op_asgn1_spec.rb

@@ -10,7 +10,7 @@ describe "op_asgn1" do
   end
 
   it "returns an arglist for args inside braces" do
-    opal_parse("self[:foo] += 1")[2].should == [:arglist, [:lit, :foo]]
+    opal_parse("self[:foo] += 1")[2].should == [:arglist, [:sym, :foo]]
   end
 
   it "only uses the operator, not with '=' appended" do
@@ -18,6 +18,6 @@ describe "op_asgn1" do
   end
 
   it "uses a simple sexp, not an arglist" do
-    opal_parse("self[:foo] += 1")[4].should == [:lit, 1]
+    opal_parse("self[:foo] += 1")[4].should == [:int, 1]
   end
 end

data/spec/parser/op_asgn2_spec.rb

@@ -18,6 +18,6 @@ describe "op_asgn2" do
   end
 
   it "uses a simple sexp, not an arglist" do
-    opal_parse("self.foo += 1")[4].should == [:lit, 1]
+    opal_parse("self.foo += 1")[4].should == [:int, 1]
   end
-end
+end

data/spec/parser/or_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe "The or statement" do
   it "should always return s(:or)" do
-    opal_parse("1 or 2").should == [:or, [:lit, 1], [:lit, 2]]
+    opal_parse("1 or 2").should == [:or, [:int, 1], [:int, 2]]
   end
 end
 
 describe "The || expression" do
   it "should always return s(:or)" do
-    opal_parse("1 || 2").should == [:or, [:lit, 1], [:lit, 2]]
+    opal_parse("1 || 2").should == [:or, [:int, 1], [:int, 2]]
   end
 end

data/spec/parser/parse_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Opal::Parser do
+  it "parses operators before \n in command calls" do
+    [:<<, :>>, :|, :^, :&, :<=>, :==, :===, :=~, :>, :>=, :<, :<=, :<<, :>>, :%, :**].each do |mid|
+      opal_parse("self #{mid}\nself").should == [:call, [:self], mid, [:arglist, [:self]]]
+    end
+  end
+
+  it "should parse simple ruby values" do
+    opal_eval('3.142').should == 3.142
+    opal_eval('123e1').should == 1230.0
+    opal_eval('123E+10').should == 1230000000000.0
+    opal_eval('123e-9').should == 0.000000123
+    opal_eval('false').should == false
+    opal_eval('true').should == true
+    opal_eval('nil').should == nil
+  end
+
+  it "should parse ruby strings" do
+    opal_eval('"hello world"').should == "hello world"
+    opal_eval('"hello #{100}"').should == "hello 100"
+  end
+
+  it "should parse method calls" do
+    opal_eval("[1, 2, 3, 4].inspect").should == "[1, 2, 3, 4]"
+    opal_eval("[1, 2, 3, 4].map { |a| a + 42 }").should == [43, 44, 45, 46]
+  end
+
+  it "should parse constant lookups" do
+    opal_eval("Object").should == Object
+    opal_eval("Array").should == Array
+    opal_eval("Opal::Parser").should == Opal::Parser
+  end
+
+  it "should parse class and module definitions" do
+    opal_eval("class ParserModuleDefinition; end")
+    opal_eval <<-STR
+      class ParserClassDefinition
+        CONSTANT = 500
+
+        def foo
+          500
+        end
+
+        def self.bar
+          42
+        end
+      end
+    STR
+
+    ParserClassDefinition.bar.should == 42
+    ParserClassDefinition.new.foo.should == 500
+  end
+
+  describe "multiline comments" do
+    it "parses multiline comments and ignores them" do
+      opal_parse("=begin\nfoo\n=end\n100").should == [:int, 100]
+    end
+
+    it "raises an exception if not closed before end of file" do
+      lambda { opal_parse("=begin\nfoo\nbar") }.should raise_error(Exception, /embedded document meets end of file/)
+    end
+
+  end
+end

data/spec/parser/parser_spec.rb

@@ -1,47 +1,41 @@
-describe "Opal::Parser" do
-  it "should parse simple ruby values" do
-    opal_eval('3.142').should == 3.142
-    opal_eval('123e1').should == 1230.0
-    opal_eval('123E+10').should == 1230000000000.0
-    opal_eval('123e-9').should == 0.000000123
-    opal_eval('false').should == false
-    opal_eval('true').should == true
-    opal_eval('nil').should == nil
-  end
+require 'spec_helper'
 
-  it "should parse ruby strings" do
-    opal_eval('"hello world"').should == "hello world"
-    opal_eval('"hello #{100}"').should == "hello 100"
-  end
+describe Opal::Parser do
+  before { @parser = Opal::Parser.new }
 
-  it "should parse method calls" do
-    opal_eval("[1, 2, 3, 4].inspect").should == "[1, 2, 3, 4]"
-    opal_eval("[1, 2, 3, 4].map { |a| a + 42 }").should == [43, 44, 45, 46]
-  end
+  describe "extract parser options" do
+    it "should return a hash" do
+      @parser.extract_parser_options("").should be_kind_of(Hash)
+    end
 
-  it "should parse constant lookups" do
-    opal_eval("Object").should == Object
-    opal_eval("Array").should == Array
-    opal_eval("Opal::Parser").should == Opal::Parser
-  end
+    it "extracts options when first line starts with '# opal:'" do
+      @parser.extract_parser_options("# opal: foo, bar, baz").keys.should == [:foo, :bar, :baz]
+    end
+
+    it "converts any '-' in option name to '_'" do
+      @parser.extract_parser_options("# opal: foo, bar-ba, baz-ba").keys.should == [:foo, :bar_ba, :baz_ba]
+    end
+
+    it "sets extracted options as true" do
+      @parser.extract_parser_options("# opal: foo, bar").should == { :foo => true, :bar => true }
+    end
 
-  it "should parse class and module definitions" do
-    opal_eval("class ParserModuleDefinition; end")
-    opal_eval <<-STR
-      class ParserClassDefinition
-        CONSTANT = 500
+    it "removes prefix of 'no-' or 'no_' from options" do
+      @parser.extract_parser_options("# opal: no-foo, no_bar").keys.should == [:foo, :bar]
+    end
 
-        def foo
-          500
-        end
+    it "sets extracted no_ options as false" do
+      @parser.extract_parser_options("# opal: no-foo, no_bar").should == { :foo => false, :bar => false }
+    end
 
-        def self.bar
-          42
-        end
-      end
-    STR
+    it "can have a mixture of false and true options" do
+      @parser.extract_parser_options("# opal: no-foo, bar").should == { :foo => false, :bar => true }
+    end
 
-    ParserClassDefinition.bar.should == 42
-    ParserClassDefinition.new.foo.should == 500
+    it "only extracts options on first line, if present" do
+      @parser.extract_parser_options("# hello world").should == {}
+      @parser.extract_parser_options("# hello world\n# opal: foo").should == {}
+      @parser.extract_parser_options("# opal:    ").should == {}
+    end
   end
 end