erector 0.8.3 → 0.9.0.pre1

data/spec/erector/caching_spec.rb

@@ -1,5 +1,6 @@
 require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
 
+# todo: figure out why "include Caching" only works when it's on Widget
   describe Erector::Cache do
     before do
       @cache = Erector::Cache.new

data/spec/erector/externals_spec.rb

@@ -27,7 +27,6 @@ module ExternalsSpec
       Quesadilla.my_dependencies.should == []
     end
 
-
     describe '#interpret_args' do
 
       class Test

data/spec/erector/html_spec.rb

@@ -3,13 +3,6 @@ require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
 describe Erector::HTML do
   include Erector::Mixin
 
-  describe ".all_tags" do
-    it "returns set of full and empty tags" do
-      Erector::Widget.all_tags.class.should == Array
-      Erector::Widget.all_tags.should == Erector::Widget.full_tags + Erector::Widget.empty_tags
-    end
-  end
-
   describe "#instruct" do
     it "when passed no arguments; returns an XML declaration with version 1 and utf-8" do
       # version must precede encoding, per XML 1.0 4th edition (section 2.8)
@@ -148,7 +141,7 @@ describe Erector::HTML do
     end
 
     it "renders the proper full tags" do
-      Erector::Widget.full_tags.each do |tag_name|
+      Erector::HTMLWidget.full_tags.each do |tag_name|
         expected = "<#{tag_name}></#{tag_name}>"
         actual = erector { send(tag_name) }
         begin
@@ -252,7 +245,7 @@ describe Erector::HTML do
     end
 
     it "renders the proper empty-element tags" do
-      Erector::Widget.empty_tags.each do |tag_name|
+      Erector::HTMLWidget.self_closing_tags.each do |tag_name|
         expected = "<#{tag_name} />"
         actual = erector { send(tag_name) }
         begin
@@ -412,6 +405,7 @@ describe Erector::HTML do
         erector { text h(plain) }.should == escaped
       end
     end
+
     describe "#rawtext" do
       it "doesn't HTML escape its param" do
         erector { rawtext plain }.should == plain
@@ -427,11 +421,6 @@ describe Erector::HTML do
         erector { element "foo", plain }.should == "<foo>#{escaped}</foo>"
       end
     end
-    describe "#element!" do
-      it "doesn't HTML escape its param" do
-        erector { element! "foo", plain }.should == "<foo>#{plain}</foo>"
-      end
-    end
   end
 
   describe "#javascript" do
@@ -500,13 +489,6 @@ describe Erector::HTML do
     end
   end
 
-  describe "#close_tag" do
-    it "works when it's all alone, even though it messes with the indent level" do
-      erector { close_tag :foo }.should == "</foo>"
-      erector { close_tag :foo; close_tag :bar }.should == "</foo></bar>"
-    end
-  end
-
   describe "exception handling" do
     class RenderWithReturn < Erector::Widget
       def content
@@ -536,14 +518,16 @@ describe Erector::HTML do
     it "closes tags when throwing block versus text exception" do
       erector do
         begin
-          span "a value" do
-            text "a block"
+          div do
+            span "a value" do
+              text "a block"
+            end
           end
         rescue ArgumentError => e
           e.to_s.should include(
-            "You can't pass both a block and a value")
+            "You can't pass both a block and a value to span")
         end
-      end.should == "<span></span>"
+      end.should == "<div></div>"
     end
   end
 

data/spec/erector/output_spec.rb

@@ -1,5 +1,7 @@
 require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
 
+require 'active_support'
+
 module Erector
   describe Erector::Output do
     before do
@@ -38,11 +40,17 @@ module Erector
         @output << "foo" << "bar"
         @output.to_a.join.should == "foobar"
       end
+
+      it "works with a string buffer" do
+        o = Output.new(:buffer => "")
+        o << "foo" << "bar"
+        o.to_a.should == ["foobar"]
+      end
     end
 
     it "can be initialized with an existing string buffer" do
       s = "foo"
-      @output = Output.new { s }
+      @output = Output.new(:buffer => s)
       @output << "bar"
       s.should == "foobar"
       @output.to_s.should == "foobar"
@@ -184,16 +192,101 @@ module Erector
 
     end
 
-    class Puppy < Erector::Widget
-    end
-    class Kitten < Erector::Widget
+    describe "widget tracking" do
+
+      class Puppy < Erector::Widget
+      end
+      class Kitten < Erector::Widget
+      end
+
+      it "can keep track of widget classes emitted to it" do
+        @output.widgets << Puppy
+        @output.widgets << Kitten
+        @output.widgets << Puppy
+        @output.widgets.to_a.should include_only([Puppy, Kitten])
+      end
+
     end
 
-    it "can keep track of widget classes emitted to it" do
-      @output.widgets << Puppy
-      @output.widgets << Kitten
-      @output.widgets << Puppy
-      @output.widgets.to_a.should include_only([Puppy, Kitten])
+    describe "mark and rewind" do
+      it "with an array buffer" do
+        a = []
+        @output = Output.new(:buffer => a)
+        @output << "foo"
+        @output.mark
+
+        @output << "bar"
+        a.should == ["foo", "bar"]
+        @output.to_s.should == "foobar"
+
+        @output.rewind
+        @output.to_s.should == "foo"
+        a.should == ["foo"]
+
+        @output << "goo"
+        a.should == ["foo", "goo"]
+        @output.to_s.should == "foogoo"
+
+        @output.rewind
+        @output << "fa"
+        @output << "la"
+        a.should == ["foo", "fa", "la"]
+        @output.to_s.should == "foofala"
+      end
+
+      it "with a string buffer" do
+        s = ""
+        @output = Output.new(:buffer => s)
+        @output << "foo"
+        @output.mark
+
+        @output << "bar"
+        s.should == "foobar"
+
+        @output.rewind
+        s.should == "foo"
+
+        @output << "goo"
+        s.should == "foogoo"
+
+        @output.rewind
+        @output << "fa"
+        @output << "la"
+        s.should == "foofala"
+      end
+
+      it "with a SafeBuffer buffer" do
+        s = ActiveSupport::SafeBuffer.new
+        @output = Output.new(:buffer => s)
+        @output << "foo"
+        @output.mark
+
+        @output << "bar"
+        s.should == "foobar"
+
+        @output.rewind
+        s.should == "foo"
+
+        @output << "goo"
+        s.should == "foogoo"
+
+        @output.rewind
+        @output << "fa"
+        @output << "la"
+        s.should == "foofala"
+      end
+
+      it "returns and accepts a value" do
+        s = ""
+        @output = Output.new(:buffer => s)
+        @output << "a"
+        mark1 = @output.mark
+        @output << "b"
+        mark2 = @output.mark
+
+        @output.rewind(mark1)
+        s.should == "a"
+      end
     end
   end
 end

data/spec/erector/promise_spec.rb

@@ -0,0 +1,173 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+
+require "erector/promise"
+# a "promise" is my working name for a pointer back into the output stream, so we can rewrite the current tag (or a different one)
+module Erector
+  describe Promise do
+    before do
+      @buffer = []
+      @output = Output.new(:buffer => @buffer)
+    end
+
+    it "has a tag name" do
+      promise = Promise.new(@output, "foo")
+      promise._tag_name.should == "foo"
+    end
+
+    it "can have attributes" do
+      promise = Promise.new(@output, "foo", :att => "val")
+      promise._tag_name.should == "foo"
+      promise._attributes.should == {"att" => "val"}
+    end
+
+    it "turns a dot call into a 'class' attribute" do
+      promise = Promise.new(@output, "foo")
+      promise.logo
+      promise._tag_name.should == "foo"
+      promise._attributes.should == {"class" => "logo"}
+    end
+
+    it "appends dot calls to an existing class attribute" do
+      promise = Promise.new(@output, "foo", :class => "logo")
+      promise.header
+      promise._attributes.should == {"class" => "logo header"}
+    end
+
+    it "chains dot calls" do
+      promise = Promise.new(@output, "foo")
+      promise.logo
+      promise.header
+      promise._attributes.should == {"class" => "logo header"}
+    end
+
+    it "turns a dot-bang call into an 'id' attribute" do
+      promise = Promise.new(@output, "foo")
+      promise.logo!
+      promise._tag_name.should == "foo"
+      promise._attributes.should == {"id" => "logo"}
+    end
+
+    it "fails if an id is already present" do
+      promise = Promise.new(@output, "foo", :id => 'logo')
+      lambda {
+        promise.logo!
+      }.should raise_error(ArgumentError)
+    end
+
+    describe '#_render' do
+      it "renders an empty tag" do
+        promise = Promise.new(@output, "foo")
+        promise._render
+        @output.to_s.should == "<foo></foo>"
+      end
+
+      it "renders an empty tag" do
+        promise = Promise.new(@output, "foo")
+        promise._render
+        @output.to_s.should == "<foo></foo>"
+      end
+
+      it "renders a self-closing tag" do
+        promise = Promise.new(@output, "foo", {}, true)
+        promise._render
+        @output.to_s.should == "<foo />"
+      end
+
+      it "renders RawStrings for open and close" do
+        promise = Promise.new(@output, "foo")
+        promise._render
+        @buffer.each{|s| s.should be_a(RawString)}
+      end
+
+      it "fills its target with attributes" do
+        promise = Promise.new(@output, "foo", :bar => "baz")
+        promise._render
+        @output.to_s.should == "<foo bar=\"baz\"></foo>"
+      end
+
+      it "replaces its target after a dot call" do
+        promise = Promise.new(@output, "foo")
+        promise._render
+        promise.logo
+        promise._render
+        @output.to_s.should == "<foo class=\"logo\"></foo>"
+      end
+
+      it "replaces its target after two dot calls" do
+        promise = Promise.new(@output, "foo")
+        promise.logo.header
+        @output.to_s.should == "<foo class=\"logo header\"></foo>"
+      end
+    end
+  end
+end
+
+describe Erector::HTML do
+  include Erector::Mixin
+
+  describe "#element" do
+    it "returns a promise" do
+      erector {
+        div.should be_a(Erector::Promise)
+      }.should == "<div></div>"
+    end
+
+    it "re-renders the open tag when the promise changes" do
+      erector {
+        div.header
+      }.should == "<div class=\"header\"></div>"
+    end
+
+    it "re-renders the open tag when passed a hash" do
+      erector {
+        div.header :style => 'font-size: 10px'
+      }.should == "<div class=\"header\" style=\"font-size: 10px\"></div>"
+    end
+
+    it "re-renders the inside tag when passed a string" do
+      erector {
+        div.header "welcome"
+      }.should == "<div class=\"header\">welcome</div>"
+    end
+
+    it "re-renders the open and inside when passed a string and a hash" do
+      erector {
+        div.header "welcome", :style => 'font-size: 10px'
+      }.should == "<div class=\"header\" style=\"font-size: 10px\">welcome</div>"
+    end
+
+    it "re-renders the inside tag when passed a block" do
+      erector {
+        div.header do
+          p "welcome"
+        end
+      }.should == "<div class=\"header\"><p>welcome</p></div>"
+    end
+
+    it "totally works" do
+      erector {
+        div.header.zomg!.zoom "hi"
+        div.main :style => 'font-size: 12pt' do
+          p "hello"
+        end
+        div.footer! do
+          img.logo! :src=>"logo.gif"
+          text "OmniCorp"
+        end
+      }.should == "<div class=\"header zoom\" id=\"zomg\">hi</div>" +
+      "<div class=\"main\" style=\"font-size: 12pt\"><p>hello</p></div>" +
+      "<div id=\"footer\">" +
+      "<img id=\"logo\" src=\"logo.gif\" />" +
+      "OmniCorp" +
+      "</div>"
+    end
+
+  end
+
+end
+
+
+
+      # newlines and indentation
+
+      # self-closing tags

data/spec/erector/sass_spec.rb

@@ -1,7 +1,7 @@
 require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
 
 if !Object.const_defined?(:Sass)
-  puts "Skipping Sass spec... run 'gem install haml' to enable these tests."
+  puts "Skipping Sass spec... run 'gem install sass' to enable these tests."
 else
   module CacheSpec
     describe Erector::Sass do

data/spec/erector/tag_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+require "erector/tag"
+
+module Erector
+  describe Tag do
+    it "takes a name" do
+      t = Tag.new("foo")
+      t.name.should == "foo"
+    end
+
+    it "has default values for its options" do
+      t = Tag.new("foo")
+      t.self_closing?.should == false
+      t.inline?.should == false
+    end
+
+    it "can take any combination of options" do
+      t = Tag.new("foo", :self_closing)
+      t.self_closing?.should == true
+      t.inline?.should == false
+
+      t = Tag.new("foo", :inline)
+      t.self_closing?.should == false
+      t.inline?.should == true
+
+      t = Tag.new("foo", :self_closing, :inline)
+      t.self_closing?.should == true
+      t.inline?.should == true
+
+      t = Tag.new("foo", :inline, :self_closing)
+      t.self_closing?.should == true
+      t.inline?.should == true
+    end
+
+    it "can take a method name" do
+      t = Tag.new("foo", "bar")
+      t.name.should == "foo"
+      t.method_name.should == "bar"
+      t.self_closing?.should == false
+      t.inline?.should == false
+    end
+
+    it "can take a method name and options" do
+      t = Tag.new("foo", "bar", :self_closing, :inline)
+      t.name.should == "foo"
+      t.method_name.should == "bar"
+      t.self_closing?.should == true
+      t.inline?.should == true
+    end
+
+    it "can underscorize its method name" do
+      t = Tag.new("InclusiveLowerBound", :snake_case)
+      t.name.should == "InclusiveLowerBound"
+      t.method_name.should == "inclusive_lower_bound"
+    end
+
+    it "is smart about acronyms" do
+      t = Tag.new("WatchCNNToday", :snake_case)
+      t.name.should == "WatchCNNToday"
+      t.method_name.should == "watch_cnn_today"
+    end
+
+
+  end
+end
+
+