rapid-core 0.1

data/spec/rapid/template/base_spec.rb

@@ -0,0 +1,290 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Rapid::Template::Base do
+  
+  describe "pull" do
+    
+    def pull erb, content
+      @template = Rapid::Template::Base.new(erb)
+      @result = @template.pull content
+    end
+    
+    describe "static" do
+      
+      it "should not pull anything from a line without ERB" do
+        pull %(hi hey), %(hi hey)
+        @result.should == {}
+      end
+      
+      it "should pull multiple line static content" do
+        pull "--color\n--format documentation\n\n", "--color\n--format documentation\n\n"
+        @result.should == {}
+      end
+      
+      it "should error when trailing text is not matched" do
+        lambda { pull %(bar hi), "bar hi more text" }.should raise_error(Rapid::NotMatchingTemplateError)
+      end
+      
+      it "should match even when spacing isn't perfect in the project content" do
+        pull %(hi hey), "\nhi hey"
+        @result.should == {}
+      end
+      
+      it "should match even when spacing isn't perfect in the ERB" do
+        pull %(\nhi hey), "hi hey"
+        @result.should == {}
+      end
+      
+      it "should pull regardless of the ending newline" do
+        pull "hi hey\n", "hi hey\n"
+        @result.should == {}
+      end
+      
+      # it "should pull regardless of too many ending newlines" do
+      #   pull "hi hey\n\n", "hi hey"
+      #   @result.should == {}
+      #   
+      #   pull "hi hey", "hi hey\n\n"
+      #   @result.should == {}
+      # end
+      
+    end
+    
+    describe "variables" do
+      
+      it "should pull a variable out when it's the entire line" do
+        pull %(<%= name %>), %(Dan)
+        @result.should == {"name" => "Dan"}
+      end
+      
+      it "should pull a variable out when it's the entire file" do
+        pull "<%= name %>", "foo\nbar\nbaz\n"
+        @result.should == {"name" => "foo\nbar\nbaz\n"}
+      end
+      
+      it "should pull blank" do
+        pull %(class Foo\n  <%= foo %>\nend), "class Foo\n  \nend"
+        @result.should == {'foo' => ''}
+      end
+      
+      it "should pull the same variable out of the same code" do
+        pull %(role :app, "<%= deploy.production.domain %>"\nrole :db, "<%= deploy.production.domain %>", :primary=> true),
+             %(role :app, "foo"\nrole :db, "foo", :primary=> true)
+        
+        @result.should == {'deploy.production.domain' => 'foo'}
+      end
+      
+      it "should pull a variable out of an internal if var?" do
+        pull %(<% if foo? %>a <%= foo %> c<% end %>), "a b c"
+          @result.should == {"foo" => "b"}
+      end
+      
+      it "should pull a variable out of an internal if var" do
+        pull %(<% if foo %>a <%= foo %> c<% end %>), "a b c"
+          @result.should == {"foo" => "b"}
+      end
+      
+      it "should pull a variable from a single line" do
+        pull %(hi <%= name %> hey), %(hi Dan hey)
+        @result.should == {"name" => "Dan"}
+      end
+      
+      it "should not be confused by less-than after a variable" do
+        pull %(class <%= name %> < Base), %(class Foo < Base)
+        @result.should == {"name" => "Foo"}
+      end
+      
+      it "should pull two variables from the same line" do
+        pull %(hi <%= name %> hey <%= version %>), %(hi Dan hey 1.0)
+        @result.should == {"name" => "Dan", "version" => "1.0"}
+      end
+      
+      it "should error when two ERB variables are close to one another" do
+        lambda { pull %(hi <%= name %><%= version %>), %(hi Dan1.0) }.should raise_error(Rapid::InvalidTemplateError)
+      end
+      
+      it "should error when there is no variable given" do
+        lambda { pull %(hi <%= %> hey), "hi hey" }.should raise_error(Rapid::InvalidTemplateError)
+      end
+      
+      it "should error when the content doesn't match the template" do
+        lambda { pull %(hi), %(hey) }.should raise_error(Rapid::NotMatchingTemplateError)
+        lambda { pull %(<%= name %> foo), %(Dan bar) }.should raise_error(Rapid::NotMatchingTemplateError)
+        lambda { pull %(foo <%= name %>), %(bar Dan) }.should raise_error(Rapid::NotMatchingTemplateError)
+        lambda { pull %(foo <%= name %> bar <%= version %> baz), %(X Dan bar 1.0 baz) }.should raise_error(Rapid::NotMatchingTemplateError)
+        lambda { pull %(foo <%= name %> bar <%= version %> baz), %(foo Dan X 1.0 baz) }.should raise_error(Rapid::NotMatchingTemplateError)
+        lambda { pull %(foo <%= name %> bar <%= version %> baz), %(foo Dan bar 1.0 X) }.should raise_error(Rapid::NotMatchingTemplateError)
+        lambda { pull %(foo <%= name %> bar <%= version %> baz), %(foo) }.should raise_error(Rapid::NotMatchingTemplateError)
+      end
+    
+    end
+    
+    describe "if statements" do
+      
+      it "should pull true" do
+        pull %(<% if foo %>bar<% end %> hi), "bar hi"
+        @result.should == {"foo" => true}
+        
+        pull %(<% if foo? %>bar<% end %> hi), "bar hi"
+        @result.should == {"foo" => true}
+        
+        pull %(<% if foo == true %>bar<% end %> hi), "bar hi"
+        @result.should == {"foo" => true}
+      end
+      
+      it "should pull false" do
+        pull %(<% if foo %>bar<% end %> hi), " hi"
+        @result.should == {"foo" => false}
+        
+        pull %(<% if foo == false %>bar<% end %> hi), "bar hi"
+        @result.should == {"foo" => false}
+      end
+      
+      it "should pull double quoted strings" do
+        pull %(<% if foo == "hi" %>bar<% end %> hi), "bar hi"
+        @result.should == {"foo" => "hi"}
+      end
+      
+      it "should pull single quoted strings" do
+        pull %(<% if foo == 'hi' %>bar<% end %> hi), "bar hi"
+        @result.should == {"foo" => "hi"}
+      end
+      
+      it "should pull integers" do
+        pull %(<% if foo == 1 %>bar<% end %> hi), "bar hi"
+        @result.should == {"foo" => 1}
+      end
+      
+      it "should pull floats" do
+        pull %(<% if foo.bar == 1.2 %>bar<% end %> hi), "bar hi"
+        @result.should == {"foo.bar" => 1.2}
+      end
+      
+      it "should not pull regex" do
+        lambda { pull %(<% if foo == /aa/ %>bar<% end %> hi), "bar hi" }.should raise_error(Rapid::InvalidTemplateError)
+      end
+      
+    end
+    
+    describe "if-else statements" do
+      
+      it "should pull if" do
+        pull %(<% if foo %>bar<% else %>baz<% end %> hi), "bar hi"
+        @result.should == {"foo" => true}
+      end
+      
+      it "should pull else" do
+        pull %(<% if foo %>bar<% else %>baz<% end %> hi), "baz hi"
+        @result.should == {"foo" => false}
+      end
+      
+    end
+    
+    describe "if-elsif-else statements" do
+      
+      it "should pull if" do
+        pull %(<% if foo == 1 %>foo<% elsif foo == 2 %>bar<% else %>baz<% end %> hi), "foo hi"
+        @result.should == {"foo" => 1}
+      end
+      
+      it "should pull elsif" do
+        pull %(<% if foo == 1 %>foo<% elsif foo == 2 %>bar<% else %>baz<% end %> hi), "bar hi"
+        @result.should == {"foo" => 2}
+      end
+      
+      it "should pull else" do
+        pull %(<% if foo == 1 %>foo<% elsif foo == 2 %>bar<% else %>baz<% end %> hi), "baz hi"
+        @result.should == {}
+      end
+      
+      # it "should ignore whitespace" do
+      #   pull %(<% if foo == 1 %>\n\nfoo\t\t<% elsif foo == 2 %>\t\tbar\n\n<% else %>\n\tbaz  <% end %> hi\n\n), "  baz\n  hi \t"
+      #   @result.should == {}
+      # end
+      
+    end
+    
+    describe "nested if statements" do
+      
+      it "should pull nested if statements" do
+        pull %(<% if foo %>foo <% if bar == 2 %>bar<% end %><% end %>), "foo bar"
+        @result.should == {"foo" => true, "bar" => 2}
+      end
+      
+      it "should handle content after the nested if statement" do
+        pull %(<% if development.domain? %>{:host => "<%= development.domain %>"<% if development.port? %>, :port => <%= development.port %><% end %>}<% end %>),
+             %({:host => "www.example.com", :port => 8080})
+        
+        @result.should == {'development.domain' => 'www.example.com', 'development.port' => '8080'}
+      end
+      
+    end
+    
+    describe "yield" do
+      
+      it "should pull around a yield" do
+        pull %(class <%= class_name %>\n  <%= yield %>\nend), "class Foo\n  def baz\n end\n\nend"
+        @result.should == {"yield" => "def baz\n end\n", "class_name" => "Foo" }
+      end
+      
+    end
+    
+    describe "comment_unless" do
+      
+      it "should pull when false" do
+        pull %(foo <%= comment_unless foo %>bar), "foo # bar"
+        @result.should == {"foo" => false}
+      end
+      
+      it "should pull when true" do
+        pull %(foo <%= comment_unless foo %>bar), "foo bar"
+        @result.should == {"foo" => true}
+      end
+      
+    end
+    
+    describe "comment_if" do
+      
+      it "should pull when false" do
+        pull %(foo <%= comment_if foo %>bar), "foo bar"
+        @result.should == {"foo" => false}
+      end
+      
+      it "should pull when true" do
+        pull %(foo <%= comment_if foo %>bar), "foo # bar"
+        @result.should == {"foo" => true}
+      end
+      
+    end
+    
+  end
+  
+  describe "push" do
+    
+    def push skeleton, content
+      @template = Rapid::Template::Base.new content
+      @template.push skeleton
+    end
+    
+    before do
+      @settings = mock('settings', :get_binding => nil)
+    end
+    
+    it "should push a template with no logic" do
+      @skeleton = Rapid::Skeleton::Base.new @settings
+      push(@skeleton, %(foobar)).should == "foobar"
+    end
+    
+    it "should catch NameError inside the template and re-raise under the Rapid namespace" do
+      @skeleton = Rapid::Skeleton::Base.new @settings
+      lambda { push(@skeleton, %(<%= foo %>)) }.should raise_error(Rapid::TemplateRenderError)
+    end
+    
+    it "should catch SyntaxEror inside the template and re-raise under the Rapid namespace" do
+      @skeleton = Rapid::Skeleton::Base.new @settings
+      lambda { push(@skeleton, %(<% if true %>foo)) }.should raise_error(Rapid::TemplateRenderError)
+    end
+    
+  end
+  
+end

data/spec/rapid/template/node/base_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe Rapid::Template::Node::Base do
+  
+  it "should not implement pull" do
+    lambda { Rapid::Template::Node::Base.new.pull(nil) }.should raise_error(NotImplementedError)
+  end
+  
+end

data/spec/rapid/template/node/comment_node_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe Rapid::Template::Node::CommentNode do
+  
+  it "should implement inspect" do
+    Rapid::Template::Node::CommentNode.new(true, "foo").inspect.class.should == String
+  end
+  
+  it "should automatically remove the ?" do
+    Rapid::Template::Node::CommentNode.new(true, "foo?").variable.should == "foo"
+  end
+  
+  it "should implement ==" do
+    Rapid::Template::Node::CommentNode.new(true, "foo").should == Rapid::Template::Node::CommentNode.new(true, "foo")
+    
+    Rapid::Template::Node::CommentNode.new(true, "foo").should_not == Rapid::Template::Node::CommentNode.new(false, "foo")
+    
+  end
+  
+  describe "pull" do
+    
+    before do
+      @node = Rapid::Template::Node::CommentNode.new(true, "foo")
+    end
+    
+    it "should move the result and set the variable when comment is present" do
+      @result = Rapid::Template::Pulling::Explicit.new("# something")
+      
+      @node.pull @result
+      
+      @result.content.should == "something"
+      @result["foo"].should == true
+    end
+    
+    it "should not move the result over and set the variable when comment is not present" do
+      @result = Rapid::Template::Pulling::Explicit.new("something")
+      
+      @node.pull @result
+      
+      @result.content.should == "something"
+      @result["foo"].should == false
+    end
+    
+  end
+  
+end

data/spec/rapid/template/node/if_node_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe Rapid::Template::Node::IfNode do
+  
+  it "should implement inspect" do
+    Rapid::Template::Node::IfNode.new("foo", nil).inspect.class.should == String
+  end
+  
+  it "should not accept random arguments as nodes" do
+    lambda { Rapid::Template::Node::IfNode.new("foo", 3) }.should raise_error(ArgumentError)
+  end
+  
+  it "should require content from the then node" do
+    lambda { Rapid::Template::Node::IfNode.new("foo", nil).pull(nil) }.should raise_error(Rapid::InvalidTemplateError)
+  end
+  
+  it "should delegate next_to to its parent" do
+    @parent = mock("parent")
+    
+    @if = Rapid::Template::Node::IfNode.new("foo", nil)
+    @if.send :parent=, @parent
+    
+    @parent.should_receive(:next_to).with(@if).and_return(3)
+    
+    @if.next_to(mock("child")).should == 3
+  end
+  
+end

data/spec/rapid/template/node/root_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe Rapid::Template::Node::Root do
+  
+  it "should implement inspect" do
+    Rapid::Template::Node::Root.new([]).inspect.class.should == String
+  end
+  
+end

data/spec/rapid/template/node/static_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe Rapid::Template::Node::Static do
+  
+  it "should implement inspect" do
+    Rapid::Template::Node::Static.new("foo").inspect.class.should == String
+  end
+  
+  it "should delegate pull to result.match!" do
+    @result = mock 'result'
+    @result.should_receive(:match!).with("foo")
+    
+    @node = Rapid::Template::Node::Static.new("foo")
+    @node.pull @result
+  end
+  
+end

data/spec/rapid/template/node/variable_spec.rb

@@ -0,0 +1,87 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe Rapid::Template::Node::Variable do
+  
+  it "should implement inspect" do
+    Rapid::Template::Node::Variable.new("foo").inspect.class.should == String
+  end
+  
+  describe "pull" do
+    
+    before do
+      @next_text = " abcdefghijklmnopqrstuvwxyz0123456789"
+      @node = Rapid::Template::Node::Variable.new("foo")
+      @next = Rapid::Template::Node::Static.new(@next_text)
+      
+      @node.stub!(:next_node).and_return(@next)
+    end
+    
+    it "should succeed" do
+      @result = Rapid::Template::Pulling::Explicit.new("3 abcdefghijklmnopqrstuvwxyz0123456789")
+      @node.pull @result
+      
+      @result["foo"].should == "3"
+      @result.previous_content.should == "3"
+      @result.content.should == " abcdefghijklmnopqrstuvwxyz0123456789"
+    end
+    
+    it "should work even when the last piece is nil" do
+      @node = Rapid::Template::Node::Variable.new("foo")
+      @node.should_receive(:next_node).and_return(nil)
+      
+      @result = Rapid::Template::Pulling::Explicit.new("3")
+      @node.pull @result
+      
+      @result["foo"].should == "3"
+      @result.previous_content.should == "3"
+      @result.content.should == ""
+    end
+    
+    it "should just fail if the content after the variable doesn't match at all" do
+      @result = Rapid::Template::Pulling::Explicit.new("foo baz")
+      
+      begin
+        @node.pull @result
+        raise "it should fail"
+        
+      rescue Rapid::NotMatchingTemplateError => e
+        e.result.should == {}
+        e.expected_content.should == ' abcdefghijklmnopqrstuvwxyz0123456789'
+        e.content.should == 'foo baz'
+        e.previous_content.should == ''
+      end
+    end
+    
+    it "should match a blank variable and some text even when it fails" do
+      @result = Rapid::Template::Pulling::Explicit.new(" abcdefghijklmnopqrstuvwxyz0123")
+      
+      begin
+        @node.pull @result
+        raise "it should fail"
+        
+      rescue Rapid::NotMatchingTemplateError => e
+        e.result.should == {"foo" => ""}
+        e.content.should == ''
+        e.previous_content.should == ' abcdefghijklmnopqrstuvwxyz0123'
+        e.expected_content.should == '456789'
+      end
+    end
+    
+    it "should some of the content after the variable" do
+      @result = Rapid::Template::Pulling::Explicit.new("foo abcdefghijklmnopqrstuvwxyz0123")
+      
+      begin
+        @node.pull @result
+        raise "it should fail"
+        
+      rescue Rapid::NotMatchingTemplateError => e
+        e.result.should == {"foo" => "foo"}
+        e.expected_content.should == '456789'
+        e.content.should == ''
+        e.previous_content.should == 'foo abcdefghijklmnopqrstuvwxyz0123'
+      end
+    end
+    
+  end
+  
+end

data/spec/rapid/template/parser_spec.rb

@@ -0,0 +1,187 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Rapid::Template::Parser do
+  
+  def compile str
+    Rapid::Template::Parser.new(str).parse
+  end
+  
+  def root_node *nodes
+    Rapid::Template::Node::Root.new(nodes)
+  end
+  
+  def static_node str
+    Rapid::Template::Node::Static.new(str)
+  end
+  
+  def variable_node variable_name
+    Rapid::Template::Node::Variable.new(variable_name)
+  end
+  
+  def if_node *args
+    Rapid::Template::Node::IfNode.new(*args)
+  end
+  
+  it "should compile a static string" do
+    compile("hey Dan hi").should == root_node(static_node("hey Dan hi"))
+  end
+  
+  it "should recognize comments" do
+    compile("<%# some comment %>").should == root_node
+    compile("hi<%# some comment %>").should == root_node(static_node("hi"))
+    compile("<%# some comment%>hey").should == root_node(static_node("hey"))
+    compile("hi<%# some comment %>hey").should == root_node(static_node("hihey"))
+  end
+  
+  it "should compile a variable assignment within a string" do
+    compile("<%= name %>").should == root_node(variable_node("name"))
+    compile("hey <%= name %> hi").should == root_node(static_node("hey "), variable_node("name"), static_node(" hi"))
+    compile("hey <%= name %>").should == root_node(static_node("hey "), variable_node("name"))
+  end
+  
+  it "should compile an if statement" do
+    compile("hey <% if true %>Dan<% end %>").should == root_node(static_node("hey "), if_node("true", static_node("Dan")))
+  end
+  
+  it "should raise an error for unhandled indicators" do
+    lambda { compile("<%== foo %>") }.should raise_error(Rapid::UnknownMethodTemplateError)
+  end
+  
+  it "should raise an error when an unknown method is called" do
+    lambda { compile("<% foo do %>hey<% end %>") }.should raise_error(Rapid::UnknownMethodTemplateError)
+  end
+  
+  it "should compile an if-else statement" do
+    compile("<% if true %>Dan<% else %>Rob<% end %>").should == 
+      root_node(if_node("true", static_node("Dan"), static_node("Rob")))
+    
+    compile("hey <% if true %>Dan<% else %>Rob<% end %>").should == 
+      root_node(static_node("hey "), if_node("true", static_node("Dan"), static_node("Rob")))
+    
+    compile("<% if true %>Dan<% else %>Rob<% end %> hi").should == 
+      root_node(if_node("true", static_node("Dan"), static_node("Rob")), static_node(" hi"))
+    
+    compile(%(<% if true %>a<% else %>b<% end %>c<%= foo %>)).should ==
+      root_node(if_node("true", static_node("a"), static_node("b")), static_node("c"), variable_node("foo"))
+  end
+  
+  it "should compile an if-elsif-else statement" do
+    compile("hey <% if true %>Dan<% elsif a %>Jim<% else %>Rob<% end %>").should == 
+      root_node(static_node("hey "), if_node("true", static_node("Dan"), if_node("a", static_node("Jim"), static_node("Rob"))))
+    
+    compile(%(<% if true %>a<% elsif false %>b<% else %>c<% end %>d<%= foo %>)).should ==
+      root_node(if_node("true", static_node("a"), if_node("false", static_node("b"), static_node("c"))), static_node("d"), variable_node("foo"))
+  end
+  
+  describe "not removing whitespace" do
+    
+    it "should not lose newlines after one-line if-statement" do
+      compile(%(a <% if true %> b <% end %> c )).should ==
+        root_node(static_node("a "), if_node("true", static_node(" b ")), static_node(" c "))
+    end
+    
+    it "should not lose newlines after one-line if-statement" do
+      compile(%(a\n<% if true %>b<% end %>c)).should ==
+        root_node(static_node("a\n"), if_node("true", static_node("b")), static_node("c"))
+    end
+    
+    it "should not lose newlines after one-line if-statement" do
+      compile(%(a<% if true %>\nb<% end %>c)).should ==
+        root_node(static_node("a"), if_node("true", static_node("\nb")), static_node("c"))
+    end
+    
+    it "should not lose newlines after one-line if-statement" do
+      compile(%(a<% if true %>b\n<% end %>c)).should ==
+        root_node(static_node("a"), if_node("true", static_node("b\n")), static_node("c"))
+    end
+    
+    it "should not lose newlines after one-line if-statement" do
+      compile(%(a<% if true %>b<% end %>\nc)).should ==
+        root_node(static_node("a"), if_node("true", static_node("b")), static_node("\nc"))
+    end
+    
+    it "should not lose newlines after one-line if-statement" do
+      compile(%(a<% if true %>b<% end %>c\n)).should ==
+        root_node(static_node("a"), if_node("true", static_node("b")), static_node("c\n"))
+    end
+    
+    it "should not lose newlines after one-line if-statement" do
+      compile(%(a<% if true %>\nb\n<% end %>c)).should ==
+        root_node(static_node("a"), if_node("true", static_node("\nb\n")), static_node("c"))
+    end
+    
+    it "should not remove whitespace inside the block" do
+      compile(%(a<% if true %>\n b \n<% end %>c)).should ==
+        root_node(static_node("a"), if_node("true", static_node("\n b \n")), static_node("c"))
+    end
+    
+    it "should not remove trailing spaces after the block" do
+      compile(%(a\n<% if true %>   \nb\n<% end %>   \nc)).should ==
+        root_node(static_node("a\n"), if_node("true", static_node("b\n")), static_node("c"))
+    end
+    
+    it "should not remove whitespace when there's content after the newline" do
+      compile(%(\n foo <% if true %>\nbar\n <% end %>\n)).should == 
+        root_node(static_node("\n foo "), if_node("true", static_node("\nbar\n")))
+    end
+    
+  end
+  
+  describe "removing whitespace" do
+    
+    it "should remove whitespace if statement is on its own line" do
+      compile(%(a\n<% if true %>\nb\n<% end %>\nc)).should ==
+        root_node(static_node("a\n"), if_node("true", static_node("b\n")), static_node("c"))
+    end
+    
+    it "should remove prepended spaces on the empty line too" do
+      compile(%(a\n   <% if true %>\nb\n   <% end %>\nc)).should ==
+        root_node(static_node("a\n"), if_node("true", static_node("b\n")), static_node("c"))
+    end
+    
+    it "should remove prepended tabs on the empty line too" do
+      compile(%(a\n\t\t<% if true %>\nb\n\t\t<% end %>\nc)).should ==
+        root_node(static_node("a\n"), if_node("true", static_node("b\n")), static_node("c"))
+    end
+    
+    it "should not remove trailing tabs on the empty line too" do
+      compile(%(a\n<% if true %>\t\t\nb\n<% end %>\t\t\nc)).should ==
+        root_node(static_node("a\n"), if_node("true", static_node("b\n")), static_node("c"))
+    end
+    
+    it "should know '-%>' but not do anything different" do
+      compile(%(a\n<%- if true -%>\nb\n<%- end -%>\nc)).should ==
+        root_node(static_node("a\n"), if_node("true", static_node("b\n")), static_node("c"))
+    end
+    
+    it "should remove newline when block is the first thing in the file" do
+      compile(%(  <% if true %>\nbar<% end %>c)).should ==
+        root_node(if_node("true", static_node("bar")), static_node("c"))
+    end
+    
+    it "should maintain correct whitespace with two if statements side-by-side" do
+      compile(%(a\n<% if true %>\n  b\n<% end %>\n<% if true %>\n  c\n<% end %>\nd\n)).should == 
+        root_node(static_node("a\n"), if_node("true", static_node("  b\n")), if_node("true", static_node("  c\n")), static_node("d\n"))
+    end
+    
+  end
+  
+  describe "<%%" do
+    
+    it "should work when it's alone" do
+      compile("<%% foo %>").should == root_node(static_node("<% foo %>"))
+    end
+    
+    it "should work surrounded by other static text" do
+      # this could be done better, but oh well
+      compile("a<%% foo %>b").should == root_node(static_node("a<% foo %>b"))
+    end
+    
+    it "should work with new lines inside it" do
+      compile(%(<%%\n code\n %>\n a)).should == 
+        root_node(static_node("<%\n code\n %>\n a"))
+    end
+    
+  end
+  
+end