honkster-erector 0.8.1

data/spec/erector/output_spec.rb

@@ -0,0 +1,199 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+
+module Erector
+  describe Erector::Output do
+    before do
+      @output = Output.new
+    end
+
+    it "accepts a string via the << operator" do
+      @output.to_s.should == ""
+      @output << "foo"
+      @output.to_s.should == "foo"
+      @output << "bar"
+      @output.to_s.should == "foobar"
+    end
+
+    it "#<< accepts a number" do
+      @output << 1
+      @output.to_s.should == "1"
+    end
+
+    it "accepts chained <<s" do
+      @output << "foo" << "bar"
+      @output.to_s.should == "foobar"
+    end
+
+    it "provides a placeholder string to be filled in later" do
+      @output << "foo"
+      placeholder = @output.placeholder
+      @output << "bar"
+      @output.to_s.should == "foobar"
+      placeholder << "baz"
+      @output.to_s.should == "foobazbar"
+    end
+
+    describe '#to_a' do
+      it "emits an array" do
+        @output << "foo" << "bar"
+        @output.to_a.join.should == "foobar"
+      end
+    end
+
+    it "can be initialized with an existing string buffer" do
+      s = "foo"
+      @output = Output.new { s }
+      @output << "bar"
+      s.should == "foobar"
+      @output.to_s.should == "foobar"
+    end
+
+    it "accepts a prettyprint option" do
+      Erector::Output.new(:prettyprint => true).prettyprint.should be_true
+      Erector::Output.new(:prettyprint => false).prettyprint.should be_false
+    end
+
+    it "accepts the global prettyprint_default setting" do
+      old_default = Erector::Widget.new.prettyprint_default
+      begin
+        Erector::Widget.prettyprint_default = true
+        Erector::Output.new.prettyprint.should be_true
+        Erector::Widget.prettyprint_default = false
+        Erector::Output.new.prettyprint.should be_false
+      ensure
+        Erector::Widget.prettyprint_default = old_default
+      end
+    end
+
+    describe '#newline' do
+      it "inserts a newline if we're in prettyprint mode" do
+        @output = Output.new(:prettyprint => true)
+        @output << "foo"
+        @output.newline
+        @output.should be_at_line_start
+        @output.to_s.should == "foo\n"
+      end
+
+      it "tracks whether we're at the beginning of a line or not" do
+        @output = Output.new(:prettyprint => true)
+        @output.should be_at_line_start
+        @output << "foo"
+        @output.should_not be_at_line_start
+        @output.newline
+        @output.should be_at_line_start
+        @output << "bar"
+        @output.should_not be_at_line_start
+        @output.newline
+        @output.should be_at_line_start
+      end
+
+      it "doesn't insert a newline (or track line starts) if we're not in prettyprint mode" do
+        @output = Output.new(:prettyprint => false)
+        @output << "foo"
+        @output.newline
+        @output.should_not be_at_line_start
+        @output.to_s.should == "foo"
+      end
+    end
+
+    describe "pretty printing" do
+      before do
+        @output = Output.new(:prettyprint => true)
+      end
+
+      it "indents the next line when we're at line start and indented" do
+        @output << "foo"
+        @output.newline
+        @output.indent
+        @output << "bar"
+        @output.newline
+        @output.undent
+        @output << "baz"
+        @output.newline
+
+        @output.to_s.should == "foo\n  bar\nbaz\n"
+      end
+
+      it "doesn't indent if there's a linebreak in the middle of a string" do
+        @output.indent
+        @output << "foo\nbar\nbaz\n"
+        @output.to_s.should == "  foo\nbar\nbaz\n"
+      end
+
+      it "turns off if prettyprint is false" do
+        @output = Output.new(:prettyprint => false)
+        @output.indent
+        @output << "bar"
+        @output.to_s.should == "bar"
+      end
+
+      it "doesn't crash if indentation level is less than 0" do
+        @output.undent
+        @output << "bar"
+        @output.to_s.should == "bar"
+        # [@indentation, 0].max
+      end
+
+      it "accepts an initial indentation level" do
+        @output = Output.new(:prettyprint => true, :indentation => 2)
+        @output << "foo"
+        @output.to_s.should == "    foo"
+      end
+
+      it "accepts a max line length" do
+        @output = Output.new(:prettyprint => true, :max_length => 10)
+        @output << "Now is the winter of our discontent made "
+        @output << "glorious summer by this sun of York."
+        @output.to_s.should ==
+                        "Now is the\n" +
+                        "winter of\n" +
+                        "our\n" +
+                        "discontent\n" +
+                        "made \n" +
+                        "glorious\n" +
+                        "summer by\n" +
+                        "this sun\n" +
+                        "of York."
+      end
+
+      it "preserves leading and trailing spaces" do
+        @output = Output.new(:max_length => 10)
+        @output << "123456789"
+        @output << " foo "
+        @output << "bar"
+        @output.to_s.should == "123456789 \nfoo bar"
+      end
+
+      it "accepts a max line length wth indentation" do
+        # note that 1 indent = 2 spaces
+        @output = Output.new(:prettyprint => true, :indentation => 1, :max_length => 10)
+        @output << "Now is the winter of our discontent made glorious summer by this sun of York."
+        @output.to_s.should ==
+                        "  Now is\n" +
+                        "  the\n" +
+                        "  winter\n" +
+                        "  of our\n" +
+                        "  discontent\n" +
+                        "  made\n" +
+                        "  glorious\n" +
+                        "  summer\n" +
+                        "  by this\n" +
+                        "  sun of\n" +
+                        "  York."
+      end
+
+    end
+
+    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
+end

data/spec/erector/sample-file.txt

@@ -0,0 +1 @@
+sample file contents, 2 + 2 = #{2 + 2}

data/spec/erector/sass_spec.rb

@@ -0,0 +1,33 @@
+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."
+else
+  module CacheSpec
+    describe Erector::Sass do
+      include Erector::Mixin
+      it "works" do
+        erector {sass SAMPLE_SASS}.should == SAMPLE_CSS
+      end
+    end
+  end
+end
+
+SAMPLE_SASS =<<-SASS
+h1
+  height: 118px
+  margin-top: 1em
+
+.tagline
+  font-size: 26px
+  text-align: right
+  SASS
+
+SAMPLE_CSS ="""<style>h1 {
+  height: 118px;
+  margin-top: 1em; }
+
+.tagline {
+  font-size: 26px;
+  text-align: right; }
+</style>"""

data/spec/erector/unicode_builder_spec.rb

@@ -0,0 +1,75 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+require File.expand_path("#{File.dirname(__FILE__)}/../../lib/erector/unicode_builder")
+
+describe "build unicode" do
+
+  def make_builder(input_string)
+    @output = ""
+    Erector::UnicodeBuilder.new(
+      StringIO.new(input_string), 
+      StringIO.new(@output))
+  end
+
+  it "#generate generates header and footer" do
+    make_builder("").generate()
+    @output.should == "Erector::CHARACTERS = {\n}\n"
+  end
+
+  it "generates nothing from empty file" do
+    make_builder("").process_file()
+    @output.should == ""
+  end
+  
+  it "generates nothing from blank line" do
+    make_builder("\n").process_file()
+    @output.should == ""
+  end
+  
+  it "generates entry from a simple line" do
+    make_builder(%q{
+0025;PERCENT SIGN;Po;0;ET;;;;;N;;;;;
+    }).process_file()
+    @output.should == "  :percent_sign => 0x0025\n"
+  end
+  
+  it "can process two lines" do
+    make_builder(%q{
+0906;DEVANAGARI LETTER AA;Lo;0;L;;;;;N;;;;;
+237E;BELL SYMBOL;So;0;ON;;;;;N;;;;;
+    }).process_file()
+    @output.should == "  :devanagari_letter_aa => 0x0906,\n" +
+      "  :bell_symbol => 0x237e\n"
+  end
+  
+  it "also adds an entry for an alias" do
+    make_builder(%q{
+2192;RIGHTWARDS ARROW;Sm;0;ON;;;;;N;RIGHT ARROW;;;;
+    }).process_file()
+    @output.should == "  :rightwards_arrow => 0x2192,\n" +
+      "  :right_arrow => 0x2192\n"
+  end
+  
+  it "can handle hyphen in name" do
+    make_builder(%q{
+2673;RECYCLING SYMBOL FOR TYPE-1 PLASTICS;So;0;ON;;;;;N;;pete;;;
+    }).process_file()
+    @output.should == "  :recycling_symbol_for_type_1_plastics => 0x2673\n"
+  end
+  
+  it "can handle characters above 0xffff" do
+    make_builder(%q{
+10400;DESERET CAPITAL LETTER LONG I;Lu;0;L;;;;;N;;;;10428;
+    }).process_file()
+    @output.should == "  :deseret_capital_letter_long_i => 0x10400\n"
+  end
+  
+  it "ignores entries whose names start with less than" do
+    make_builder(%q{
+F0000;<Plane 15 Private Use, First>;Co;0;L;;;;;N;;;;;
+FFFFD;<Plane 15 Private Use, Last>;Co;0;L;;;;;N;;;;;
+    }).process_file()
+    @output.should == ""
+  end
+  
+end
+

data/spec/erector/widget_spec.rb

@@ -0,0 +1,250 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+require 'benchmark'
+
+module WidgetSpec
+  describe Erector::Widget do
+    include Erector::Mixin
+
+    describe "#to_html" do
+      it "invokes #content and returns the string representation of the rendered widget" do
+        Class.new(Erector::Widget) do
+          def content
+            text "Hello"
+          end
+        end.new.to_html.should == "Hello"
+      end
+
+      it "supports other content methods via :content_method_name" do
+        Class.new(Erector::Widget) do
+          def alternate
+            text "Alternate"
+          end
+        end.new.to_html(:content_method_name => :alternate).should == "Alternate"
+      end
+
+      it "returns an HTML-safe string" do
+        Erector::Widget.new.to_html.should be_html_safe
+      end
+
+      it "accepts an existing string as an output buffer" do
+        s = "foo"
+        Erector.inline { text "bar" }.to_html(:output => s)
+        s.should == "foobar"
+      end
+
+      it "accepts an existing Output as an output buffer" do
+        output = Erector::Output.new
+        output << "foo"
+        Erector.inline { text "bar" }.to_html(:output => output)
+        output.to_s.should == "foobar"
+      end
+    end
+
+    describe "#to_a" do
+      it "returns an array" do
+        a = Erector.inline { div "Hello" }.to_a
+        a.should be_an(Array)
+        a.join.should == "<div>Hello</div>"
+      end
+    end
+
+    describe '#widget' do
+      class Orphan < Erector::Widget
+        def content
+          p @name
+        end
+      end
+
+      it "renders a widget class" do
+        erector do
+          div do
+            widget Orphan, :name => "Annie"
+          end
+        end.should == "<div><p>Annie</p></div>"
+      end
+
+      it "renders a widget instance" do
+        erector do
+          div do
+            widget Orphan.new(:name => "Oliver")
+          end
+        end.should == "<div><p>Oliver</p></div>"
+      end
+
+      it "adds the widget to the parent's output widgets" do
+        inner = Class.new(Erector::Widget)
+        outer = Erector.inline { widget inner }
+        outer.to_html
+        outer.output.widgets.should include(inner)
+      end
+
+      it "supports specifying content_method_name" do
+        inner = Class.new(Erector::Widget) do
+          def foo; text "foo"; end
+        end
+        erector do
+          widget inner, {}, :content_method_name => :foo
+        end.should == "foo"
+      end
+
+      it "renders nested widgets in the correct order" do
+        class Parent < Erector::Widget
+          def content
+            text 1
+            widget Erector::Widget do
+              text 2
+              third
+            end
+          end
+
+          def third
+            text 3
+          end
+        end
+
+        Parent.new.to_html.should == '123'
+      end
+
+      context "when nested" do
+        module WhenNested
+          class Parent < Erector::Widget
+            def content
+              div :id => "parent_widget" do
+                super
+              end
+            end
+          end
+
+          class Child < Erector::Widget
+            def content
+              div :id => "child_widget" do
+                super
+              end
+            end
+          end
+
+          class Grandchild < Erector::Widget
+            needs :parent_widget, :child_widget
+            def content
+              widget(@parent_widget) do
+                widget(@child_widget) do
+                  div :id => "grandchild"
+                end
+              end
+            end
+          end
+        end
+
+        it "renders the tag around the rest of the block" do
+          WhenNested::Grandchild.new(
+                  :parent_widget => WhenNested::Parent,
+                  :child_widget => WhenNested::Child
+          ).to_html.should == '<div id="parent_widget"><div id="child_widget"><div id="grandchild"></div></div></div>'
+        end
+
+        it "renders the tag around the rest of the block with proper indentation" do
+          WhenNested::Grandchild.new(
+                  :parent_widget => WhenNested::Parent,
+                  :child_widget => WhenNested::Child
+          ).to_pretty.should ==
+                  "<div id=\"parent_widget\">\n" +
+                          "  <div id=\"child_widget\">\n" +
+                          "    <div id=\"grandchild\"></div>\n" +
+                          "  </div>\n" +
+                          "</div>\n"
+        end
+
+        it "passes a pointer to the child object back into the parent object's block" do
+          child_widget = Erector::Widget.new
+
+          class Parent2 < Erector::Widget
+            needs :child_widget
+            def content
+              div do
+                widget @child_widget do |child|
+                  b child.dom_id
+                end
+              end
+            end
+          end
+
+          Parent2.new(:child_widget => child_widget).to_html.should == "<div><b>#{child_widget.dom_id}</b></div>"
+        end
+      end
+    end
+
+    describe "#call_block" do
+      it "calls the block with a pointer to self" do
+        inside_arg = nil
+        inside_self = nil
+        x = Erector::Widget.new do |y|
+          inside_arg = y.object_id
+          inside_self = self.object_id
+        end
+        x.call_block
+        # inside the block...
+        inside_arg.should == x.object_id # the argument is the child
+        inside_self.should == self.object_id # and self is the parent
+      end
+    end
+
+    describe '#capture' do
+      it "should return content rather than write it to the buffer" do
+        erector do
+          captured = capture do
+            p 'Captured Content'
+          end
+          div do
+            text captured
+          end
+        end.should == '<div><p>Captured Content</p></div>'
+      end
+
+      it "returns a RawString" do
+        captured = nil
+        erector do
+          captured = capture {}
+        end.should == ""
+        captured.should be_a_kind_of(Erector::RawString)
+      end
+
+      it "works with nested captures" do
+        erector do
+          captured = capture do
+            captured = capture do
+              p 'Nested Capture'
+            end
+            p 'Captured Content'
+            text captured
+          end
+          div do
+            text captured
+          end
+        end.should == '<div><p>Captured Content</p><p>Nested Capture</p></div>'
+      end
+    end
+
+    describe '#text' do
+      it "renders a widget" do
+        erector do
+          text "B"
+          text Erector.inline { p "A" }
+          text "B"
+        end.should == "B<p>A</p>B"
+      end
+    end
+
+    describe "assigning instance variables" do
+      it "handles instance variable names with and without '@' in the beginning" do
+        html = Erector.inline(:foo => "bar", '@baz' => 'quux') do
+          div do
+            p @foo
+            p @baz
+          end
+        end.to_html
+        doc = Nokogiri::HTML(html)
+        doc.css("p").map {|p| p.inner_html}.should == ["bar", "quux"]
+      end
+    end
+  end
+end