fortitude 0.0.1

data/spec/system/tag_rendering_system_spec.rb

@@ -0,0 +1,253 @@
+describe "Fortitude tag rendering", :type => :system do
+  def r(&block)
+    render(widget_class_with_content(&block))
+  end
+
+  def should_render_to(value, &block)
+    expect(r(&block)).to eq(value)
+  end
+
+  it "should render a void tag correctly" do
+    should_render_to("<hr/>") { hr }
+  end
+
+  it "should not allow passing text content in a block to a tag that doesn't take content" do
+    expect { r { br { text "hi" } } }.to raise_error(Fortitude::Errors::NoContentAllowed)
+  end
+
+  it "should quote HTML specs at you when you screw up" do
+    expect { r { br { text "hi" } } }.to raise_error(Fortitude::Errors::NoContentAllowed, /THE_SPEC_FOR_BR/)
+  end
+
+  it "should not allow passing element content in a block to a tag that doesn't take content" do
+    expect { r { br { p } } }.to raise_error(Fortitude::Errors::NoContentAllowed)
+  end
+
+  it "should not allow passing text content to a tag that doesn't take content" do
+    expect { r { br "hi" } }.to raise_error(Fortitude::Errors::NoContentAllowed)
+  end
+
+  it "should not allow passing text content to a tag that doesn't take content, even if it has attributes" do
+    expect { r { br "hi", :class => 'yo' } }.to raise_error(Fortitude::Errors::NoContentAllowed)
+  end
+
+  it "should render a tag with direct text content correctly" do
+    should_render_to("<p>hello, world</p>") { p "hello, world" }
+  end
+
+  it "should render a tag with numeric content correctly" do
+    should_render_to("<p>12345</p>") { p 12345 }
+  end
+
+  it "should render a tag using a specific tag_* method" do
+    should_render_to("<p>foo</p>") { tag_p "foo" }
+  end
+
+  it "should let you override a tag and use #super" do
+    wc = widget_class do
+      def p(data, options = { })
+        text "before_p"
+        super(data, { :bar => 'baz' }.merge(options))
+        text("after_p")
+      end
+
+      def content
+        text "yo"
+        p "hello"
+        text "bye"
+      end
+    end
+
+    expect(render(wc)).to eq("yobefore_p<p bar=\"baz\">hello</p>after_pbye")
+  end
+
+  it "should let you override a tag and use #super, even if it's defined directly on that widget class" do
+    wc = widget_class do
+      tag :mytag
+
+      def mytag(data, options = { })
+        text "before_mytag"
+        super(data, { :bar => 'baz' }.merge(options))
+        text("after_mytag")
+      end
+
+      def content
+        text "yo"
+        mytag "hello"
+        text "bye"
+      end
+    end
+
+    expect(render(wc)).to eq("yobefore_mytag<mytag bar=\"baz\">hello</mytag>after_mytagbye")
+  end
+
+  def arbitrary_object_with_to_s(value)
+    out = Object.new
+    class << out
+      attr_accessor :value
+
+      def to_s
+        @value
+      end
+    end
+    out.value = value
+    out
+  end
+
+  it "should render an arbitrary object as content, using #to_s, and escaping it" do
+    foo = arbitrary_object_with_to_s("this is <>&\" foo!")
+    should_render_to("<p>this is &lt;&gt;&amp;&quot; foo!</p>") { p foo }
+  end
+
+  it "should escape content directly passed to a tag" do
+    should_render_to("<p>&lt;hello&gt; &quot;world&amp;</p>") { p "<hello> \"world&" }
+  end
+
+  it "should render a tag with an attribute correctly" do
+    should_render_to("<hr class=\"foo\"/>") { hr 'class' => 'foo' }
+  end
+
+  it "should convert symbol attribute names to strings" do
+    should_render_to("<hr class=\"foo\"/>") { hr :class => 'foo' }
+  end
+
+  it "should convert symbol attribute values to strings" do
+    should_render_to("<hr class=\"foo\"/>") { hr 'class' => :foo }
+  end
+
+  it "should allow numbers for attribute names" do
+    should_render_to("<hr 12345=\"foo\"/>") { hr 12345 => 'foo' }
+  end
+
+  it "should allow numbers for attribute values, and still quote them" do
+    should_render_to("<hr class=\"12345\"/>") { hr 'class' => 12345 }
+  end
+
+  it "should escape attribute names" do
+    should_render_to("<hr &lt;&amp;&quot;&gt;=\"foo\"/>") { hr '<&">' => "foo" }
+  end
+
+  it "should escape attribute values" do
+    should_render_to("<hr class=\"&lt;&amp;&quot;&gt;\"/>") { hr :class => "<&\">" }
+  end
+
+  it "should separate multiple attributes with spaces" do
+    result = r { hr 'class' => "foo", 'other' => "bar" }
+    expect(result).to match(%r{^<hr .*\"/>$})
+    expect(result).to match(%r{ class=\"foo\"})
+    expect(result).to match(%r{ other=\"bar\"})
+  end
+
+  unless RUBY_VERSION =~ /^1\.8\./
+    it "should render attributes in the order they're present in the Hash" do
+      order = [ ]
+      attributes = { }
+      100.times do |index|
+        name = "attr#{rand(1_000_000_000)}"
+        attributes[name] = "order#{index}"
+        order << name
+      end
+
+      expected_string = "<hr"
+      order.each_with_index do |attrname, index|
+        expected_string << " #{attrname}=\"order#{index}\""
+      end
+      expected_string << "/>"
+
+      should_render_to(expected_string) { hr attributes }
+    end
+  end
+
+  it "should render a tag given a block" do
+    should_render_to("<p>hello, world</p>") { p { text "hello, world" } }
+  end
+
+  it "should render an empty tag given an empty block" do
+    should_render_to("<p></p>") { p { } }
+  end
+
+  it "should render with both attributes and a block" do
+    result = r { p(:class => 'foo', :bar => 'baz') { text "hello, world" } }
+    expect(result).to match(%r{^<p .*\">hello, world</p>$})
+    expect(result).to match(%r{ class=\"foo\"})
+    expect(result).to match(%r{ bar=\"baz\"})
+  end
+
+  it "should render with both attributes and direct content" do
+    result = r { p("hello, world", :class => 'foo', :bar => 'baz') }
+    expect(result).to match(%r{^<p .*\">hello, world</p>$})
+    expect(result).to match(%r{ class=\"foo\"})
+    expect(result).to match(%r{ bar=\"baz\"})
+  end
+
+  it "should render with both direct content and a block" do
+    should_render_to("<p>hello, worldbienvenue, le monde</p>") { p("hello, world") { text "bienvenue, le monde" } }
+  end
+
+  it "should render with both attributes and a block" do
+    result = r { p(:class => :foo, :bar => :baz) { text "hello, world" } }
+    expect(result).to match(%r{^<p .*\">hello, world</p>$})
+    expect(result).to match(%r{ class=\"foo\"})
+    expect(result).to match(%r{ bar=\"baz\"})
+  end
+
+  it "should render with attributes, direct content, and a block" do
+    result = r { p("hello, world", :class => :foo, :bar => :baz) { text "bienvenue, le monde" } }
+    expect(result).to match(%r{^<p .*\">hello, worldbienvenue, le monde</p>$})
+    expect(result).to match(%r{ class=\"foo\"})
+    expect(result).to match(%r{ bar=\"baz\"})
+  end
+
+  it "should render attribute values that are hashes as a sequence of prefixed attributes" do
+    result = r { p :data => { :foo => 'bar', :bar => 'baz' } }
+    expect(result).to match(%r{^<p .*\"/>$})
+    expect(result).to match(%r{ data-foo=\"bar\"})
+    expect(result).to match(%r{ data-bar=\"baz\"})
+  end
+
+  it "should render an arbitrary object as an attribute key, escaping it" do
+    foo = arbitrary_object_with_to_s("and&<>\"this")
+    should_render_to("<p and&amp;&lt;&gt;&quot;this=\"bar\"/>") { p foo => "bar" }
+  end
+
+  it "should render an arbitrary object as an attribute value, escaping it" do
+    foo = arbitrary_object_with_to_s("and&<>\"this")
+    should_render_to("<p foo=\"and&amp;&lt;&gt;&quot;this\"/>") { p :foo => foo }
+  end
+
+  it "should render an arbitrary object as an attribute key nested in a hash, escaping it" do
+    foo = arbitrary_object_with_to_s("and&<>\"this")
+    should_render_to("<p data-and&amp;&lt;&gt;&quot;this=\"bar\"/>") { p :data => { foo => "bar" } }
+  end
+
+  it "should render an arbitrary object as an attribute value nested in a hash, escaping it" do
+    foo = arbitrary_object_with_to_s("and&<>\"this")
+    should_render_to("<p data-and&amp;&lt;&gt;&quot;this=\"bar\"/>") { p :data => { foo => "bar" } }
+  end
+
+  it "should allow an arbitrary object as an attribute key, mapping to a hash" do
+    foo = arbitrary_object_with_to_s("and&<>\"this")
+    result = r { p foo => { :foo => 'bar', :bar => 'baz' } }
+    expect(result).to match(%r{^<p .*\"/>$})
+    expect(result).to match(%r{ and&amp;&lt;&gt;&quot;this-foo=\"bar\"})
+    expect(result).to match(%r{ and&amp;&lt;&gt;&quot;this-bar=\"baz\"})
+    # should_render_to("<p and&amp;&lt;&gt;&quot;this-foo=\"bar\" and&amp;&lt;&gt;&quot;this-bar=\"baz\"/>")
+  end
+
+  it "should allow multi-level hash nesting" do
+    result = r { p :foo => { :bar => 'bar', :baz => { :a => 'xxx', 'b' => :yyy } } }
+    expect(result).to match(%r{^<p .*\"/>})
+    expect(result).to match(%r{ foo-bar=\"bar\"})
+    expect(result).to match(%r{ foo-baz-a=\"xxx\"})
+    expect(result).to match(%r{ foo-baz-b=\"yyy\"})
+  end
+
+  it "should allow arrays as attribute values, separating elements with spaces" do
+    should_render_to("<p foo=\"bar baz quux\"/>") { p :foo => [ 'bar', 'baz', 'quux' ]}
+  end
+
+  it "should allow arrays as attribute values, calling #to_s on values in them" do
+    quux = arbitrary_object_with_to_s("quux")
+    should_render_to("<p foo=\"bar baz quux\"/>") { p :foo => [ 'bar', :baz, quux ]}
+  end
+end

data/spec/system/tag_return_value_system_spec.rb

@@ -0,0 +1,41 @@
+describe "Fortitude tag return values", :type => :system do
+  context "should blow up when calling a method on" do
+    def expect_nrv(name, &block)
+      e = capture_exception(Fortitude::Errors::NoReturnValueFromTag) { render(widget_class_with_content(&block)) }
+      expect(e).to be
+      expect(e.method_name).to eq(name)
+    end
+
+    it "a simple tag" do
+      expect_nrv(:foo) { p.foo }
+    end
+
+    it "a tag with attributes" do
+      expect_nrv(:foo) { p(:foo => :bar).foo }
+    end
+
+    it "a tag with direct content" do
+      expect_nrv(:foo) { p("whatever").foo }
+    end
+
+    it "a tag with a block" do
+      expect_nrv(:foo) { p { text "whatever" }.foo }
+    end
+
+    it "a tag with a block and direct content" do
+      expect_nrv(:foo) { p("foo") { text "whatever" }.foo }
+    end
+
+    it "a tag with direct content and attributes" do
+      expect_nrv(:foo) { p("foo", :foo => :bar).foo }
+    end
+
+    it "a tag with a block and attributes" do
+      expect_nrv(:foo) { p(:foo => :bar) { text "whatever" }.foo }
+    end
+
+    it "a tag with a block, direct content, and attributes" do
+      expect_nrv(:foo) { p("foo", :foo => :bar) { text "whatever" }.foo }
+    end
+  end
+end

data/spec/system/tag_rules_system_spec.rb

@@ -0,0 +1,196 @@
+describe "Fortitude tag rules enforcement", :type => :system do
+  def widget_class(options = { }, &block)
+    out = super(options, &block)
+    out.class_eval { enforce_element_nesting_rules true } unless options[:no_enforcement]
+    out
+  end
+
+  it "should not allow a <div> inside a <p>" do
+    expect { render(widget_class_with_content { p { div } })}.to raise_error(Fortitude::Errors::InvalidElementNesting)
+  end
+
+  it "should quote HTML specifications at you when you screw up" do
+    expect { render(widget_class_with_content { p { div } })}.to raise_error(Fortitude::Errors::InvalidElementNesting, /THE_SPEC_FOR_P/)
+  end
+
+  it "should allow a <b> inside a <p>" do
+    expect(render(widget_class_with_content { p { b } })).to eq('<p><b/></p>')
+  end
+
+  it "should not allow text where it's, well, not allowed, when specified directly" do
+    expect { render(widget_class_with_content { div "hi" }) }.to raise_error(Fortitude::Errors::InvalidElementNesting)
+  end
+
+  it "should not allow text where it's, well, not allowed, when specified directly and with a hash" do
+    expect { render(widget_class_with_content { div "hi", :class => "something" }) }.to raise_error(Fortitude::Errors::InvalidElementNesting)
+  end
+
+  it "should not allow text where it's, well, not allowed, when specified indirectly" do
+    expect { render(widget_class_with_content { div { text "hi" } }) }.to raise_error(Fortitude::Errors::InvalidElementNesting)
+  end
+
+  it "should always allow rawtext" do
+    expect(render(widget_class_with_content { div { rawtext "yo" }})).to eq("<div>yo</div>")
+  end
+
+  it "should always allow html_safe text, when specified indirectly" do
+    expect(render(widget_class_with_content { div { text "yo".html_safe } })).to eq("<div>yo</div>")
+  end
+
+  it "should always allow html_safe text, when specified directly" do
+    expect(render(widget_class_with_content { div "yo".html_safe })).to eq("<div>yo</div>")
+  end
+
+  it "should not enforce rules inside a widget with the setting off, even if surrounding widgets have it on" do
+    outer = widget_class do
+      attr_accessor :inner
+      def content
+        p do
+          widget inner
+        end
+      end
+    end
+
+    middle = widget_class(:no_enforcement => true) do
+      attr_accessor :inner
+      def content
+        div do
+          p do
+            widget inner
+          end
+        end
+      end
+    end
+
+    inner = widget_class_with_content do
+      text "yo"
+    end
+
+    outer_instance = outer.new
+    middle_instance = middle.new
+    inner_instance = inner.new
+
+    outer_instance.inner = middle_instance
+    middle_instance.inner = inner_instance
+
+    expect(render(outer_instance)).to eq("<p><div><p>yo</p></div></p>")
+  end
+
+  it "should still enforce rules from one widget to the next" do
+    outer = widget_class do
+      attr_accessor :inner
+      def content
+        p do
+          widget inner
+        end
+      end
+    end
+
+    middle = widget_class do
+      def content
+        div do
+          text "hi"
+        end
+      end
+    end
+
+    outer_instance = outer.new
+    middle_instance = middle.new
+
+    outer_instance.inner = middle_instance
+
+    expect { render(outer_instance) }.to raise_error(Fortitude::Errors::InvalidElementNesting)
+  end
+
+  it "should allow you to disable enforcement with a block" do
+    wc = widget_class_with_content do
+      p do
+        with_element_nesting_rules(false) do
+          div do
+            text "hi"
+          end
+        end
+      end
+    end
+
+    expect(render(wc)).to eq("<p><div>hi</div></p>")
+  end
+
+  it "should allow you to disable enforcement with a block, even across widget boundaries" do
+    outer = widget_class do
+      attr_accessor :inner
+      def content
+        p do
+          with_element_nesting_rules(false) do
+            widget inner
+          end
+        end
+      end
+    end
+
+    inner = widget_class_with_content { div { text "hi" } }
+
+    outer_instance = outer.new
+    inner_instance = inner.new
+    outer_instance.inner = inner_instance
+
+    expect(render(outer_instance)).to eq("<p><div>hi</div></p>")
+  end
+
+  it "should allow you to re-enable enforcement with a block" do
+    wc = widget_class_with_content do
+      with_element_nesting_rules(false) do
+        p do
+          with_element_nesting_rules(true) do
+            div do
+              text "hi"
+            end
+          end
+        end
+      end
+    end
+
+    expect { render(wc) }.to raise_error(Fortitude::Errors::InvalidElementNesting)
+  end
+
+  it "should let you re-enable enforcement with a block, even across widget boundaries" do
+    outer = widget_class do
+      attr_accessor :inner
+      def content
+        with_element_nesting_rules(false) do
+          p do
+            widget inner
+          end
+        end
+      end
+    end
+
+    inner = widget_class_with_content { with_element_nesting_rules(true) { div { text "hi" } } }
+
+    outer_instance = outer.new
+    inner_instance = inner.new
+    outer_instance.inner = inner_instance
+
+    expect { render(outer_instance) }.to raise_error(Fortitude::Errors::InvalidElementNesting)
+  end
+
+  it "should raise an error if you try to enable enforcement with a block in a widget that isn't enforcing in the first place" do
+    wc = widget_class_with_content(:no_enforcement => true) do
+      with_element_nesting_rules(true) do
+        text "hi"
+      end
+    end
+
+    expect { render(wc) }.to raise_error(ArgumentError)
+  end
+
+  it "should not raise an error if you try to DISable enforcement with a block in a widget that isn't enforcing in the first place" do
+    wc = widget_class_with_content(:no_enforcement => true) do
+      with_element_nesting_rules(false) do
+        text "hi"
+      end
+    end
+
+    expect(render(wc)).to eq("hi")
+  end
+end

data/spec/system/tag_updating_system_spec.rb

@@ -0,0 +1,171 @@
+describe "Fortitude tag updating", :type => :system do
+  before :each do
+    @base_class = widget_class do
+      enforce_attribute_rules true
+      enforce_element_nesting_rules true
+
+      tag :foo, :valid_attributes => %w{bar baz}
+    end
+
+    @derived_class = widget_class(:superclass => @base_class)
+  end
+
+  it "should be enforcing rules" do
+    @base_class.class_eval do
+      def content
+        foo :something => 'whatever'
+      end
+    end
+
+    expect { render(@base_class) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  it "should allow replacing a tag completely" do
+    @derived_class.tag :foo, :can_enclose => %w{p}
+    @derived_class.class_eval do
+      def content
+        foo :something => 'whatever' do
+          p "hi"
+        end
+      end
+    end
+
+    expect(render(@derived_class)).to eq("<foo something=\"whatever\"><p>hi</p></foo>")
+  end
+
+  it "should not change the parent class's tag when replacing a tag completely" do
+    @derived_class.tag :foo, :can_enclose => %w{p}
+    @derived_class.class_eval do
+      def content
+        foo :something => 'whatever' do
+          p "hi"
+        end
+      end
+    end
+
+    expect(render(@derived_class)).to eq("<foo something=\"whatever\"><p>hi</p></foo>")
+
+    @base_class.class_eval do
+      def content
+        foo :something => 'something_else'
+      end
+    end
+
+    expect { render(@base_class) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  it "should not change the parent class's tag when modifying a tag" do
+    @derived_class.modify_tag(:foo) { |t| t.valid_attributes += %w{quux} }
+    @derived_class.class_eval do
+      def content
+        foo :quux => 'baz'
+      end
+    end
+
+    expect(render(@derived_class)).to eq("<foo quux=\"baz\"/>")
+
+    @base_class.class_eval do
+      def content
+        foo :quux => 'baz'
+      end
+    end
+
+    expect { render(@base_class) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  it "should allow modifying a tag's :valid_attributes" do
+    @derived_class.modify_tag(:foo) { |t| t.valid_attributes += %w{quux} }
+    @derived_class.class_eval do
+      def content
+        foo :quux => 'baz'
+      end
+    end
+
+    expect(render(@derived_class)).to eq("<foo quux=\"baz\"/>")
+  end
+
+  it "should allow modifying a tag's :can_enclose" do
+    @derived_class.modify_tag(:div) { |t| t.can_enclose += %w{_text} }
+    @derived_class.modify_tag(:p) { |t| t.can_enclose += %w{div} }
+    @derived_class.class_eval do
+      def content
+        p do
+          div "whatever"
+        end
+      end
+    end
+
+    expect(render(@derived_class)).to eq("<p><div>whatever</div></p>")
+  end
+
+  it "should allow modifying a tag's :newline_before" do
+    @derived_class.modify_tag(:a) { |t| t.newline_before = true }
+    @derived_class.class_eval do
+      format_output true
+
+      def content
+        p do
+          text "hello"
+          a "there"
+          text "goodbye"
+        end
+      end
+    end
+
+    expect(render(@derived_class)).to eq("<p>\n  hello\n  <a>there</a>\n  goodbye\n</p>")
+  end
+
+  it "should allow modifying a tag's :content_allowed" do
+    @derived_class.modify_tag(:br) { |t| t.content_allowed = true }
+    @derived_class.class_eval do
+      def content
+        br "hello"
+      end
+    end
+
+    expect(render(@derived_class)).to eq("<br>hello</br>")
+  end
+
+  it "should allow modifying a tag's :allow_data_attributes" do
+    @derived_class.modify_tag(:p) { |t| t.allow_data_attributes = false }
+    @derived_class.class_eval do
+      def content
+        p :'data-foo' => 'bar'
+      end
+    end
+
+    expect { render(@derived_class) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  it "should allow modifying a tag's :allow_aria_attributes" do
+    @derived_class.modify_tag(:p) { |t| t.allow_aria_attributes = false }
+    @derived_class.class_eval do
+      def content
+        p :'aria-foo' => 'bar'
+      end
+    end
+
+    expect { render(@derived_class) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  it "should allow overriding a doctype's tags, but shouldn't modify the doctype itself" do
+    @base_class.modify_tag(:p) { |t| t.valid_attributes += %w{bonk} }
+    @base_class.class_eval do
+      def content
+        p :bonk => "whatever"
+      end
+    end
+
+    expect(render(@base_class)).to eq("<p bonk=\"whatever\"/>")
+
+    other_widget = widget_class do
+      enforce_attribute_rules true
+
+      def content
+        p :bonk => :whatever
+      end
+    end
+
+    expect { render(other_widget) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+end