honkster-erector 0.8.1

data/spec/erector/convenience_spec.rb

@@ -0,0 +1,259 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+
+describe Erector::Convenience do
+  include Erector::Mixin
+
+  describe "#to_pretty" do
+    it "calls to_html with :prettyprint => true" do
+      widget = Erector.inline do
+        div "foo"
+      end
+      mock(widget).to_html({:prettyprint => true})
+      widget.to_pretty
+    end
+
+    it "passes extra options through to to_html" do
+      pending "RR problem with Ruby 1.9" if RUBY_VERSION >= "1.9.0"
+      widget = Erector.inline do
+        div "foo"
+      end
+      mock(widget).to_html({:prettyprint => true, :extra => "yay"})
+      widget.to_pretty(:extra => "yay")
+    end
+  end
+
+  describe "#to_s" do
+    it "returns html" do
+      capturing_stderr do
+        Erector.inline do
+          div "foo"
+        end.to_s.should == "<div>foo</div>"
+      end
+    end
+  end
+
+  describe "#to_html" do
+    it "returns html" do
+      Erector.inline do
+        div "foo"
+      end.to_html.should == "<div>foo</div>"
+    end
+  end
+
+  describe "#to_text" do
+    it "strips tags" do
+      Erector.inline do
+        div "foo"
+      end.to_text.should == "foo"
+    end
+
+    it "unescapes named entities" do
+      s = "my \"dog\" has fleas & <ticks>"
+      Erector.inline do
+        text s
+      end.to_text.should == s
+    end
+
+    it "ignores >s inside attribute strings" do
+      Erector.inline do
+        a "foo", :href => "http://example.com/x>y"
+      end.to_text.should == "foo"
+    end
+
+    def with_prettyprint_default(value = true)
+      old_default = Erector::Widget.new.prettyprint_default
+      begin
+        Erector::Widget.prettyprint_default = value
+        yield
+      ensure
+        Erector::Widget.prettyprint_default = old_default
+      end
+    end
+
+    it "doesn't inherit unwanted pretty-printed whitespace (i.e. it turns off prettyprinting)" do
+      with_prettyprint_default(true) do
+        Erector.inline do
+          div { div { div "foo" } }
+        end.to_text.should == "foo"
+      end
+    end
+
+    it "passes extra attributes through to to_s" do
+      class Funny < Erector::Widget
+        def content
+          div "foo"
+        end
+
+        def funny
+          div "haha"
+        end
+      end
+      Funny.new.to_text(:content_method_name => :funny).should == "haha"
+    end
+
+    it "doesn't turn a p into a newline if it's at the beginning of the string" do
+      Erector.inline do
+        p "hi"
+      end.to_text.should == "hi\n"
+    end
+
+    it "puts a blank line (two newlines) after a /p tag" do
+      Erector.inline do
+        p "first paragraph"
+        p "second paragraph"
+      end.to_text.should == "first paragraph\n\nsecond paragraph\n"
+    end
+
+    it "separates p tags with attributes" do
+      Erector.inline do
+        p "first paragraph", :class => "first"
+        p "second paragraph", :class => "second"
+      end.to_text.should == "first paragraph\n\nsecond paragraph\n"
+    end
+
+    it "puts a newline after a br tag" do
+      Erector.inline do
+        text "first line"
+        br
+        text "second line"
+      end.to_text.should == "first line\nsecond line"
+    end
+
+    it "formats a UL (unordered list) using asterisks for bullets" do
+      Erector.inline do
+        ul do
+          li "vanilla"
+          li "chocolate"
+          li "strawberry"
+        end
+      end.to_text.should == "\n* vanilla\n* chocolate\n* strawberry\n"
+    end
+
+    # it's too hard to keep track of numbers with a regexp munger, so just use asterisks for bullets
+    # todo: integrate text output into core rendering code
+    it "formats an OL (ordered list)" do
+      Erector.inline do
+        ol do
+          li "vanilla"
+          li "chocolate"
+          li "strawberry"
+        end
+      end.to_text.should == "\n* vanilla\n* chocolate\n* strawberry\n"
+    end
+  end
+
+  describe "#join" do
+    it "empty array means nothing to join" do
+      erector do
+        join [], Erector::Widget.new { text "x" }
+      end.should == ""
+    end
+
+    it "larger example with two tabs" do
+      erector do
+        tab1 =
+                Erector.inline do
+                  a "Upload document", :href => "/upload"
+                end
+        tab2 =
+                Erector.inline do
+                  a "Logout", :href => "/logout"
+                end
+        join [tab1, tab2],
+             Erector::Widget.new { text nbsp(" |"); text " " }
+      end.should ==
+              '<a href="/upload">Upload document</a>&#160;| <a href="/logout">Logout</a>'
+    end
+
+    it "plain string as join separator means pass it to text" do
+      erector do
+        join [
+                Erector::Widget.new { text "x" },
+                Erector::Widget.new { text "y" }
+        ], "<>"
+      end.should == "x&lt;&gt;y"
+    end
+
+    it "plain string as item to join means pass it to text" do
+      erector do
+        join [
+                "<",
+                "&"
+        ], Erector::Widget.new { text " + " }
+      end.should == "&lt; + &amp;"
+    end
+  end
+
+  describe "#css" do
+    it "makes a link when passed a string" do
+      erector do
+        css "erector.css"
+      end.should == "<link href=\"erector.css\" rel=\"stylesheet\" type=\"text/css\" />"
+    end
+
+    it "accepts a media attribute" do
+      erector do
+        css "print.css", :media => "print"
+      end.should == "<link href=\"print.css\" media=\"print\" rel=\"stylesheet\" type=\"text/css\" />"
+    end
+
+    it "passes extra attributes through" do
+      erector { css "foo.css", :title => 'Foo' }.should == "<link href=\"foo.css\" rel=\"stylesheet\" title=\"Foo\" type=\"text/css\" />"
+    end
+  end
+
+  describe "#url" do
+    it "renders an anchor tag with the same href and text" do
+      erector do
+        url "http://example.com"
+      end.should == "<a href=\"http://example.com\">http://example.com</a>"
+    end
+
+    it "accepts extra attributes" do
+      erector do
+        url "http://example.com", :onclick=>"alert('foo')"
+      end.should == "<a href=\"http://example.com\" onclick=\"alert('foo')\">http://example.com</a>"
+    end
+
+  end
+
+  describe "#dom_id" do
+    class DOMIDWidget < Erector::Widget
+      def content
+        div :id => dom_id
+      end
+    end
+
+    it "makes a unique id based on the widget's class name and object id" do
+      widget = DOMIDWidget.new
+      widget.dom_id.should include("#{widget.object_id}")
+      widget.dom_id.should include("DOMIDWidget")
+    end
+
+    it "can be used as an HTML id" do
+      widget = DOMIDWidget.new
+      widget.to_html.should == "<div id=\"#{widget.dom_id}\"></div>"
+    end
+
+    describe 'for a namespaced widget class' do
+
+      module ::ErectorConvenienceSpec
+        class NestedWidget < Erector::Widget
+        end
+      end
+
+      it 'is colon escaped' do
+        g = ErectorConvenienceSpec::NestedWidget.new
+        g.dom_id.should_not =~ /:/
+      end
+
+      it 'combines all parent namespaces' do
+        g = ErectorConvenienceSpec::NestedWidget.new
+        g.dom_id.should == "ErectorConvenienceSpec_NestedWidget_#{g.object_id}"
+      end
+
+    end
+
+  end
+end
+

data/spec/erector/dependency_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+require 'benchmark'
+require 'active_support' # for Symbol#to_proc
+
+module DependencySpec
+  describe Erector::Dependency do
+    it "can be constructed with type and text" do
+      x = Erector::Dependency.new(:foo, "abc")
+      x.type.should == :foo
+      x.text.should == "abc"
+      x.options.should == {}
+    end
+
+    it "can be constructed with type, text, and options" do
+      x = Erector::Dependency.new(:foo, "abc", {:bar => 7})
+      x.options.should == {:bar => 7}
+    end
+
+    it "can be constructed with a file" do
+      file = File.new("#{File.dirname(__FILE__)}/sample-file.txt")
+      x = Erector::Dependency.new(:foo, file)
+      x.text.should == "sample file contents, 2 + 2 = \#{2 + 2}\n"
+    end
+
+    it "can be constructed with a file and interpolate the text" do
+      file = File.new("#{File.dirname(__FILE__)}/sample-file.txt")
+      x = Erector::Dependency.new(:foo, file, :interpolate => true)
+      x.text.should == "sample file contents, 2 + 2 = 4\n"
+    end
+
+    describe "comparison methods" do
+      before do
+        @castor = Erector::Dependency.new(:foo, "abc", {:bar => 7})
+        @pollux = Erector::Dependency.new(:foo, "abc", {:bar => 7})
+        @leo = Erector::Dependency.new(:foo, "abc")
+        @pisces = Erector::Dependency.new(:foo, "xyz", {:bar => 7})
+      end
+
+      it "is equal to an identical external" do
+        @castor.should == @pollux
+        [@castor].should include(@pollux)
+        @castor.eql?(@pollux).should be_true
+        @castor.hash.should == @pollux.hash
+      end
+
+      it "is not equal to an otherwise identical external with different options" do
+        @castor.should_not == @leo
+        [@castor].should_not include(@leo)
+        @castor.eql?(@leo).should_not be_true
+        @castor.hash.should_not == @leo.hash
+      end
+
+      it "is not equal to a different external with the same options" do
+        @castor.should_not == @pisces
+        [@castor].should_not include(@pisces)
+        @castor.eql?(@pisces).should_not be_true
+        @castor.hash.should_not == @pisces.hash
+      end
+
+      # see http://blog.nathanielbibler.com/post/73525836/using-the-ruby-array-uniq-with-custom-classes
+      it "works with uniq" do
+        [@castor, @pollux, @leo].uniq.should == [@castor, @leo]
+      end
+
+    end
+  end
+end

data/spec/erector/externals_spec.rb

@@ -0,0 +1,236 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+require 'benchmark'
+require 'active_support' # for Symbol#to_proc
+
+module ExternalsSpec
+
+  describe "adding dependencies" do
+    before do
+      @args = [:what, :ever, :is, :passed]
+      @result = Erector::Dependency.new :js, '/foo.js'
+      @result2 = Erector::Dependency.new :css, '/foo.css'
+    end
+
+    after do
+      Erector::Widget.my_dependencies.clear
+    end
+
+    it "calls #interpret_args with given arguments and passes result to #push_dependency" do
+      pending "RR problem with Ruby 1.9" if RUBY_VERSION >= "1.9.0"
+      mock(Erector::Widget).interpret_args(*@args).returns(@result)
+      Erector::Widget.depends_on *@args
+    end
+
+    it "starts out with no items in @_dependencies" do
+      class Quesadilla < Erector::Widget
+      end
+      Quesadilla.my_dependencies.should == []
+    end
+
+
+    describe '#interpret_args' do
+
+      class Test
+        include Erector::Externals
+      end
+
+      it "will infer that a .js extension is javascript" do
+        x = Test.send :interpret_args, ('/path/to/a.js')
+        x.text.should == '/path/to/a.js'
+        x.type.should == :js
+      end
+
+      it "will infer that a .css extension is a stylesheet" do
+        x = Test.send :interpret_args, ('/path/to/a.css')
+        x.text.should == '/path/to/a.css'
+        x.type.should == :css
+      end
+
+      it "will capture render options when just a file is mentioned" do
+        x = Test.send(:interpret_args, '/path/to/a.css', :render=>:link)
+        x.text.should == '/path/to/a.css'
+        x.type.should == :css
+        x.options.should == {:render=>:link} # could also be "embed"
+      end
+
+      it "embeds javascript" do
+        x = Test.send :interpret_args, :js, "alert('foo')"
+        x.text.should == "alert('foo')"
+        x.type.should == :js
+      end
+
+      it "guesses Javascript type from .js" do
+        x = Test.send :interpret_args, "/script/foo.js"
+        x.text.should == "/script/foo.js"
+        x.type.should == :js
+      end
+
+      it "guesses CSS type from .css" do
+        x = Test.send :interpret_args, "/script/foo.css"
+        x.text.should == "/script/foo.css"
+        x.type.should == :css
+      end
+
+      it "add multiple files without an options hash" do
+        x = Test.send :interpret_args, :js, "/script/foo.js", "/script/bar.js"
+        x.size.should == 2
+        x[0].text.should == "/script/foo.js"
+        x[0].type.should == :js
+        x[1].text.should == "/script/bar.js"
+        x[1].type.should == :js
+      end
+
+      it "add multiple files with an options hash" do
+        x = Test.send :interpret_args, :js, "/script/foo.js", "/script/bar.js", :embed=>true
+        x.size.should == 2
+        x[0].text.should == "/script/foo.js"
+        x[0].type.should == :js
+        x[0].options[:embed].should == true
+        x[1].text.should == "/script/bar.js"
+        x[1].type.should == :js
+        x[1].options[:embed].should == true
+      end
+
+      it "adds multiple files from hash" do
+        x = Test.send :interpret_args, :js => ["foo.js", "bar.js"]
+        x.size.should == 2
+        x[0].text.should == "foo.js"
+        x[0].type.should == :js
+        x[1].text.should == "bar.js"
+        x[1].type.should == :js
+      end
+
+      it "adds multiple files from hash of different types" do
+        x = Test.send :interpret_args, :js => ["foo.js", "bar.js"], :css=>'file.css'
+        x.size.should == 3
+        x.map(&:text).include?('foo.js')
+        x.map(&:text).include?('bar.js')
+        x.map(&:text).include?('file.css')
+      end
+
+      it "adds multiple files from hash and preserves the options" do
+        x = Test.send :interpret_args, :js => ["foo.js", "bar.js"], :foo=>false
+        x.size.should == 2
+        x[0].text.should == "foo.js"
+        x[0].type.should == :js
+        x[0].options.should == {:foo=>false}
+        x[1].text.should == "bar.js"
+        x[1].type.should == :js
+        x[1].options.should == {:foo=>false}
+      end
+    end
+
+  end
+
+  describe 'extracting the dependencies (integration tests)' do
+    attr_reader :HotSauce, :SourCream, :Tabasco
+    
+    before do
+      @HotSauce = Class.new(Erector::Widget) do
+        depends_on :css, "/css/tapatio.css", :media => "print"
+        depends_on :css, "/css/salsa_picante.css"
+        depends_on :js, "/lib/jquery.js"
+        depends_on :js, "/lib/picante.js"
+      end
+      @SourCream = Class.new(Erector::Widget) do
+        depends_on :css, "/css/sourcream.css"
+        depends_on :js, "/lib/jquery.js"
+        depends_on :js, "/lib/dairy.js"
+      end
+      @Tabasco = Class.new(self.HotSauce) do
+        depends_on :js, "tabasco.js"
+        depends_on :css, "/css/salsa_picante.css"
+      end
+    end
+
+    it "can be fetched via the type" do
+      self.HotSauce.dependencies(:css).map(&:text).should == [
+        "/css/tapatio.css",
+        "/css/salsa_picante.css",
+      ]
+    end
+
+    it "can be filtered via the class" do
+      self.SourCream.dependencies(:css).map(&:text).should == [
+        "/css/sourcream.css",
+      ]
+    end
+
+    it "grabs dependencies from superclasses too" do
+      self.Tabasco.dependencies(:js).map(&:text).should == ["/lib/jquery.js", "/lib/picante.js", "tabasco.js"]
+    end
+
+    it "retains the options" do
+      self.HotSauce.dependencies(:css).map(&:options).should == [
+        {:media => "print"},
+        {}
+      ]
+    end
+
+    it "removes duplicates" do
+      self.Tabasco.dependencies(:css).map(&:text).should == [
+        "/css/tapatio.css",
+        "/css/salsa_picante.css",
+      ]
+    end
+
+    it "works with strings or symbols" do
+      self.HotSauce.dependencies("css").map(&:text).should == [
+        "/css/tapatio.css",
+        "/css/salsa_picante.css",
+      ]
+    end
+
+    class Taco < Erector::Widget
+      depends_on :filling, "beef"
+      depends_on :filling, "beef", :media => "print"
+    end
+
+    it "considers options when removing duplicates" do
+      Taco.dependencies(:filling).map(&:text).should == ["beef", "beef"]
+    end
+
+
+  end
+
+  describe "rendering with externals" do
+    class Dinner < Erector::Widget
+      external :js, "/dinner.js"
+
+      def content
+        span "dinner"
+        widget Dessert
+      end
+    end
+
+    class Dessert < Erector::Widget
+      external :js, "/dessert.js"
+      external :css, "/dessert.css"
+
+      def content
+        span "dessert"
+      end
+    end
+
+    it "#render_with_externals sticks the externals for all its rendered sub-widgets at the end of the output buffer" do
+      s = Dinner.new.render_with_externals
+      s.join.should ==
+        "<span>dinner</span>" +
+          "<span>dessert</span>" +
+          "<link href=\"/dessert.css\" media=\"all\" rel=\"stylesheet\" type=\"text/css\" />" +
+          "<script src=\"/dinner.js\" type=\"text/javascript\"></script>" +
+          "<script src=\"/dessert.js\" type=\"text/javascript\"></script>"
+    end
+
+    it "#render_externals returns externals for all rendered sub-widgets to an output buffer" do
+      widget = Dinner.new
+      widget.to_html
+      widget.render_externals.join.should ==
+        "<link href=\"/dessert.css\" media=\"all\" rel=\"stylesheet\" type=\"text/css\" />" +
+          "<script src=\"/dinner.js\" type=\"text/javascript\"></script>" +
+          "<script src=\"/dessert.js\" type=\"text/javascript\"></script>"
+    end
+  end
+
+
+end