fortitude 0.0.1

data/spec/system/attribute_rules_system_spec.rb

@@ -0,0 +1,227 @@
+describe "Fortitude attribute rules enforcement", :type => :system do
+  def widget_class(options = { }, &block)
+    out = super(options, &block)
+    out.class_eval { enforce_attribute_rules true } unless options.delete(:no_enforcement)
+    out
+  end
+
+  it "should not allow an attribute 'foo' on <p>" do
+    expect { render(widget_class_with_content { p :foo => 'bar' })}.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  it "should quote HTML specs at you when you screw up" do
+    expect { render(widget_class_with_content { p :foo => 'bar' })}.to raise_error(Fortitude::Errors::InvalidElementAttributes, /THE_SPEC_FOR_P/)
+  end
+
+  it "should allow an attribute 'class' on <p>" do
+    expect(render(widget_class_with_content { p :class => 'bar' })).to eq("<p class=\"bar\"/>")
+  end
+
+  it "should allow arbitrary individual data-* attributes" do
+    result = render(widget_class_with_content { p :'data-foo' => 'bar', 'DATA-BAZ' => 'quux' })
+    expect([ '<p data-foo="bar" DATA-BAZ="quux"/>', '<p DATA-BAZ="quux" data-foo="bar"/>' ].include?(result)).to be
+  end
+
+  it "should allow a data attribute, specified as a Hash" do
+    result = render(widget_class_with_content { p :data => { :foo => 'bar', 'baz' => 'quux' }})
+    expect([ '<p data-foo="bar" data-baz="quux"/>', '<p data-baz="quux" data-foo="bar"/>' ].include?(result)).to be
+  end
+
+  it "should not allow a plain 'data' attribute" do
+    expect { render(widget_class_with_content { p :data => 'foo' }) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  it "should not allow a plain 'data-' attribute" do
+    expect { render(widget_class_with_content { p :'data-' => 'foo' }) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  def class_with_custom_tag(additional_attributes, &block)
+    out = widget_class
+    out.class_eval do
+      tag :mytag, { :valid_attributes => %w{foo bar} }.merge(additional_attributes)
+    end
+    out.class_eval(&block) if block
+    out
+  end
+
+  it "should allow data and ARIA attributes by default" do
+    klass = class_with_custom_tag({ }) do
+      def content
+        mytag :foo => 'bar', :data => { 'aaa' => 'bbb' }, :aria => { 'ccc' => 'ddd' }
+      end
+    end
+
+    result = render(klass)
+    expect(result).to match(%r{^<mytag .*\"/>$})
+    expect(result).to match(/foo=\"bar\"/)
+    expect(result).to match(/data-aaa=\"bbb\"/)
+    expect(result).to match(/aria-ccc=\"ddd\"/)
+    # expect(render(klass)).to eq("<mytag foo=\"bar\" data-aaa=\"bbb\" aria-ccc=\"ddd\"/>")
+  end
+
+  it "should not allow data attributes if told not to" do
+    klass = class_with_custom_tag(:allow_data_attributes => false) do
+      def content
+        mytag :foo => 'bar', :data => { :aaa => 'bbb' }
+      end
+    end
+    expect { render(klass) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  it "should not allow ARIA attributes if told not to" do
+    klass = class_with_custom_tag(:allow_aria_attributes => false) do
+      def content
+        mytag :foo => 'bar', :aria => { :ccc => 'ddd' }
+      end
+    end
+    expect { render(klass) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  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
+        widget inner
+      end
+    end
+
+    middle = widget_class(:no_enforcement => true) do
+      attr_accessor :inner
+      def content
+        p :foo => 'bar'
+        widget inner
+      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 foo=\"bar\"/>yo")
+  end
+
+  it "should allow you to disable attribute rules with a block" do
+    wc = widget_class_with_content do
+      begin
+        p :foo => 'bar'
+      rescue => e
+        text e.class.name
+      end
+
+      with_attribute_rules(false) do
+        begin
+          p :foo => 'bar'
+        rescue => e
+          text e.class.name
+        end
+      end
+
+      begin
+        p :foo => 'bar'
+      rescue => e
+        text e.class.name
+      end
+    end
+
+    expect(render(wc)).to eq("Fortitude::Errors::InvalidElementAttributes<p foo=\"bar\"/>Fortitude::Errors::InvalidElementAttributes")
+  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
+        with_attribute_rules(false) do
+          widget inner
+        end
+      end
+    end
+
+    inner = widget_class_with_content do
+      p :foo => 'bar'
+    end
+
+    inner_instance = inner.new
+    outer_instance = outer.new
+    outer_instance.inner = inner_instance
+
+    expect { render(inner_instance) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+    expect(render(outer_instance)).to eq("<p foo=\"bar\"/>")
+  end
+
+  it "should allow you to re-enable enforcement with a block" do
+    wc = widget_class_with_content do
+      with_attribute_rules(false) do
+        with_attribute_rules(true) do
+          p :foo => 'bar'
+        end
+      end
+    end
+
+    expect { render(wc) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  it "should allow you to re-enable enforcement with a block, even across widget boundaries" do
+    outer = widget_class do
+      attr_accessor :inner
+      def content
+        with_attribute_rules(false) do
+          widget inner
+        end
+      end
+    end
+
+    middle = widget_class do
+      attr_accessor :inner
+      def content
+        with_attribute_rules(true) do
+          widget inner
+        end
+      end
+    end
+
+    inner = widget_class_with_content do
+      p :foo => 'bar'
+    end
+
+    inner_instance = inner.new
+    middle_instance = middle.new
+    middle_instance.inner = inner_instance
+    outer_instance = outer.new
+    outer_instance.inner = middle_instance
+
+    expect { render(inner_instance) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+    expect { render(outer_instance) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  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_attribute_rules(true) do
+        p :foo => 'bar'
+      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
+      p :bar => 'baz'
+      with_attribute_rules(false) do
+        p :foo => 'bar'
+      end
+    end
+
+    expect(render(wc)).to eq("<p bar=\"baz\"/><p foo=\"bar\"/>")
+  end
+
+  it "should allow disabling attribute rules on a single element with an option" do
+    expect(render(widget_class_with_content { p :foo => 'bar', :_fortitude_skip_attribute_rule_enforcement => true })).to eq("<p foo=\"bar\"/>")
+  end
+end

data/spec/system/basic_system_spec.rb

@@ -0,0 +1,9 @@
+describe "Fortitude basic operations", :type => :system do
+  it "should render a widget with text" do
+    expect(render(widget_class_with_content { text "hello, world" })).to eq("hello, world")
+  end
+
+  it "should render a widget with a tag" do
+    expect(render(widget_class_with_content { p { text "hello, world" } })).to eq("<p>hello, world</p>")
+  end
+end

data/spec/system/content_inheritance_system_spec.rb

@@ -0,0 +1,13 @@
+describe "Fortitude content inheritance", :type => :system do
+  it "should allow calling super from #content" do
+    parent = widget_class_with_content { text 'parent!' }
+    child = widget_class_with_content(:superclass => parent) do
+      super()
+      text "child!"
+      super()
+    end
+
+    expect(render(parent.new)).to eq("parent!")
+    expect(render(child.new)).to eq("parent!child!parent!")
+  end
+end

data/spec/system/convenience_methods_system_spec.rb

@@ -0,0 +1,30 @@
+describe "Fortitude convenience methods", :type => :system do
+  describe "#javascript" do
+    it "should output JavaScript inside the proper tag, by default" do
+      expect(render(widget_class_with_content { javascript "hi, there" })).to eq(
+        %{<script>hi, there</script>})
+    end
+
+    it "should include newlines if we're formatting output, but not indent it" do
+      wc = widget_class do
+        format_output true
+
+        def content
+          div do
+            text "hi"
+            javascript "hi, there"
+            text "bye"
+          end
+        end
+      end
+
+      expect(render(wc)).to eq(%{<div>
+  hi
+<script>
+hi, there
+</script>
+  bye
+</div>})
+    end
+  end
+end

data/spec/system/doctypes_system_spec.rb

@@ -0,0 +1,213 @@
+describe "Fortitude doctype support", :type => :system do
+  def wc(*args, &block)
+    widget_class({ :superclass => Fortitude::Widget }.merge(args[-1] || { }), &block)
+  end
+
+  def wc_with_doctype(dt, *args, &block)
+    out = wc(*args, &block)
+    out.doctype(dt)
+    out
+  end
+
+  def allows_dir?(doctype)
+    widget_class = wc_with_doctype(doctype)
+    widget_class.class_eval do
+      def content
+        dir do
+          li "hi"
+        end
+      end
+    end
+
+    begin
+      render(widget_class)
+      true
+    rescue NoMethodError => nme
+      false
+    end
+  end
+
+  it "should autoload specific widgets" do
+    expect(Fortitude::Widgets::Html5).to be
+    expect(Fortitude::Widgets::Html4Strict).to be
+    expect(Fortitude::Widgets::Html4Transitional).to be
+    expect(Fortitude::Widgets::Html4Frameset).to be
+    expect(Fortitude::Widgets::Xhtml10Strict).to be
+    expect(Fortitude::Widgets::Xhtml10Transitional).to be
+    expect(Fortitude::Widgets::Xhtml10Frameset).to be
+    expect(Fortitude::Widgets::Xhtml11).to be
+  end
+
+  before :all do
+    @classes_by_doctype = { }
+  end
+
+  EXPECTED_RESULTS = {
+    :html5 => {
+      :allows_dir  => false, :allows_background => false, :allows_frame => false, :closes_void_tags => false,
+      :doctype_line => '<!DOCTYPE html>',
+      :javascript => :none
+    },
+
+    :html4_strict => {
+      :allows_dir  => false, :allows_background => false, :allows_frame => false, :closes_void_tags => false,
+      :doctype_line => '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">',
+      :javascript => :type
+    },
+
+    :html4_transitional => {
+      :allows_dir  => true, :allows_background => true, :allows_frame => false, :closes_void_tags => false,
+      :doctype_line => '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">',
+      :javascript => :type
+    },
+
+    :html4_frameset => {
+      :allows_dir  => true, :allows_background => true, :allows_frame => true, :closes_void_tags => false,
+      :doctype_line => '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">',
+      :javascript => :type
+    },
+
+    :xhtml10_strict => {
+      :allows_dir  => false, :allows_background => false, :allows_frame => false, :closes_void_tags => true,
+      :doctype_line => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
+      :javascript => :type_and_cdata
+    },
+
+    :xhtml10_transitional => {
+      :allows_dir  => true, :allows_background => true, :allows_frame => false, :closes_void_tags => true,
+      :doctype_line => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
+      :javascript => :type_and_cdata
+    },
+
+    :xhtml10_frameset => {
+      :allows_dir  => true, :allows_background => true, :allows_frame => true, :closes_void_tags => true,
+      :doctype_line => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">',
+      :javascript => :type_and_cdata
+    },
+
+    :xhtml11 => {
+      :allows_dir  => false, :allows_background => false, :allows_frame => false, :closes_void_tags => true,
+      :doctype_line => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">',
+      :javascript => :type_and_cdata
+    }
+  }.each do |doctype, expected_results|
+    describe doctype do
+      let(:the_widget_class) {
+        @classes_by_doctype[doctype] ||= wc_with_doctype(doctype)
+      }
+
+      it "should #{expected_results[:allows_dir] ? "" : "not "}allow <dir>" do
+        the_widget_class.class_eval do
+          def content
+            dir do
+              li "hi"
+            end
+          end
+        end
+
+        if expected_results[:allows_dir]
+          expect(render(the_widget_class)).to eq("<dir><li>hi</li></dir>")
+        else
+          expect { render(the_widget_class) }.to raise_error(NoMethodError, /dir/i)
+        end
+      end
+
+      it "should #{expected_results[:allows_background ? "" : "not "]}allow <body background=\"...\">" do
+        the_widget_class.class_eval do
+          enforce_attribute_rules true
+
+          def content
+            body :background => 'red' do
+              p "hi"
+            end
+          end
+        end
+
+        if expected_results[:allows_background]
+          expect(render(the_widget_class)).to eq("<body background=\"red\"><p>hi</p></body>")
+        else
+          expect { render(the_widget_class) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+        end
+      end
+
+      it "should #{expected_results[:allows_frame] ? "" : "not "} allow <frame>" do
+        the_widget_class.class_eval do
+          def content
+            frame :src => 'http://www.google.com/'
+          end
+        end
+
+        if expected_results[:allows_frame]
+          expect(render(the_widget_class)).to match(%r{<frame src="http://www.google.com/"/?>})
+        else
+          expect { render(the_widget_class) }.to raise_error(NoMethodError, /frame/i)
+        end
+      end
+
+      it "should #{expected_results[:closes_void_tags] ? "": "not "}close void tags" do
+        the_widget_class.class_eval do
+          def content
+            br
+          end
+        end
+
+        if expected_results[:closes_void_tags]
+          expect(render(the_widget_class)).to eq("<br/>")
+        else
+          expect(render(the_widget_class)).to eq("<br>")
+        end
+      end
+
+      it "should output the correct DOCTYPE line" do
+        the_widget_class.class_eval do
+          def content
+            doctype!
+          end
+        end
+
+        expect(render(the_widget_class)).to eq(expected_results[:doctype_line])
+      end
+
+      it "should not escape content inside <script>" do
+        the_widget_class.class_eval do
+          def content
+            script "foo < bar > baz & quux"
+          end
+        end
+
+        expect(render(the_widget_class)).to eq("<script>foo < bar > baz & quux</script>")
+      end
+
+      it "should not escape content inside <style>" do
+        the_widget_class.class_eval do
+          def content
+            style "foo < bar > baz & quux"
+          end
+        end
+
+        expect(render(the_widget_class)).to eq("<style>foo < bar > baz & quux</style>")
+      end
+
+      it "should output the correct tags for the #javascript method" do
+        the_widget_class.class_eval do
+          def content
+            javascript "hi"
+          end
+        end
+
+        expected_output = case expected_results[:javascript]
+        when :type_and_cdata then %{<script type="text/javascript">
+//<![CDATA[
+hi
+//]]>
+</script>}
+        when :type then %{<script type="text/javascript">hi</script>}
+        when :none then %{<script>hi</script>}
+        else raise "Unknown expected result for :javascript: #{expected_results[:javascript].inspect}"
+        end
+
+        expect(render(the_widget_class)).to eq(expected_output)
+      end
+    end
+  end
+end

data/spec/system/erector_compatibility_system_spec.rb

@@ -0,0 +1,84 @@
+describe "Fortitude Erector compatibility", :type => :system do
+  it "should allow implicit long-distance access to controller variables, if asked to" do
+    ivars[:foo] = "the_foo"
+    ivars[:bar] = "the_bar"
+
+    superclass = widget_class
+    subclass = widget_class(:superclass => superclass) do
+      implicit_shared_variable_access true
+
+      def content
+        text "foo: #{@foo}, "
+        text "bar: #{@bar}"
+        @baz = "widget_baz"
+      end
+    end
+
+    expect(render(subclass)).to eq("foo: the_foo, bar: the_bar")
+    expect(ivars[:baz]).to eq("widget_baz")
+  end
+
+  describe "@foo variable access" do
+    it "should not allow local access to needs via @foo, by default" do
+      wc = widget_class do
+        needs :foo
+        def content
+          text "foo: #{@foo.inspect}"
+        end
+      end
+
+      expect(render(wc.new(:foo => 'the_foo'))).to eq('foo: nil')
+    end
+
+    it "should not allow local access to needs via @foo, if turned off" do
+      wc = widget_class do
+        use_instance_variables_for_assigns false
+        needs :foo
+        def content
+          text "foo: #{@foo.inspect}"
+        end
+      end
+
+      expect(render(wc.new(:foo => 'the_foo'))).to eq('foo: nil')
+    end
+
+    it "should allow local access to needs via @foo, if asked to" do
+      wc = widget_class do
+        use_instance_variables_for_assigns true
+        needs :foo
+        def content
+          text "foo: #{@foo}"
+        end
+      end
+
+      expect(render(wc.new(:foo => 'the_foo'))).to eq('foo: the_foo')
+    end
+  end
+
+  describe "non-needed variables" do
+    it "should allow local access to non-needed passed variables via @foo, if asked to" do
+      wc = widget_class do
+        extra_assigns :use
+        use_instance_variables_for_assigns true
+        needs :foo
+        def content
+          text "foo: #{@foo}, "
+          text "bar: #{@bar}"
+        end
+      end
+      expect(render(wc.new(:foo => "the_foo", :bar => "the_bar"))).to eq("foo: the_foo, bar: the_bar")
+    end
+
+    it "should allow local access to non-needed passed variables via method, if asked to" do
+      wc = widget_class do
+        extra_assigns :use
+        needs :foo
+        def content
+          text "foo: #{foo}, "
+          text "bar: #{bar}"
+        end
+      end
+      expect(render(wc.new(:foo => "the_foo", :bar => "the_bar"))).to eq("foo: the_foo, bar: the_bar")
+    end
+  end
+end

data/spec/system/escaping_system_spec.rb

@@ -0,0 +1,43 @@
+describe "Fortitude escaping behavior", :type => :system do
+  it "should escape text by default" do
+    expect(render(widget_class_with_content { text "hi<>&\"' there" })).to match(/^hi&lt;&gt;&amp;&quot;&#(39|x27); there$/)
+  end
+
+  it "should not escape text tagged as .html_safe" do
+    expect(render(widget_class_with_content { text "hi<>&\" there".html_safe })).to eq("hi<>&\" there")
+  end
+
+  it "should not escape text output with rawtext" do
+    expect(render(widget_class_with_content { rawtext "hi<>&\" there" })).to eq("hi<>\&\" there")
+  end
+
+  it "should mark its output as html_safe" do
+    expect(render(widget_class_with_content { text "hi < there"} )).to be_html_safe
+  end
+
+  it "should mark its output as html_safe, even if output as raw" do
+    expect(render(widget_class_with_content { rawtext "hi < there"} )).to be_html_safe
+  end
+
+  it "should escape attribute names" do
+    expect(render(widget_class_with_content { p 'a<b' => 123 })).to eq("<p a&lt;b=\"123\"/>")
+  end
+
+  it "should escape attribute values" do
+    expect(render(widget_class_with_content { p :foo => 'a<b' })).to eq("<p foo=\"a&lt;b\"/>")
+  end
+
+  it "should escape direct arguments to tags" do
+    expect(render(widget_class_with_content { p "a<b" })).to eq("<p>a&lt;b</p>")
+  end
+
+  it "should escape direct arguments to tags and attributes, even if all together" do
+    expect(render(widget_class_with_content { p "a<b", 'b>a' => 'a&b' })).to eq("<p b&gt;a=\"a&amp;b\">a&lt;b</p>")
+  end
+
+  it "should still correctly escape very long strings" do
+    very_long_string = "&" + ("a" * 300) + "<" + ("b" * 300) + ">" + ("c" * 300) + "&" + ("d" * 300) + "&" + ("e" * 300) + "\"";
+    very_long_string_escaped = "&amp;" + ("a" * 300) + "&lt;" + ("b" * 300) + "&gt;" + ("c" * 300) + "&amp;" + ("d" * 300) + "&amp;" + ("e" * 300) + "&quot;"
+    expect(render(widget_class_with_content { text very_long_string })).to eq(very_long_string_escaped)
+  end
+end

data/spec/system/formatting_system_spec.rb

@@ -0,0 +1,63 @@
+describe "Fortitude formatting support", :type => :system do
+  def should_format_to(text, &block)
+    wc = widget_class do
+      format_output true
+    end
+
+    wc.send(:define_method, :content, &block)
+    expect(render(wc)).to eq(text)
+  end
+
+  it "should add newlines around <div> and <p>" do
+    should_format_to(%{<div>
+  <p>
+    yo!
+  </p>
+</div>}) { div { p { text "yo!" } } }
+  end
+
+  it "should not add newlines for <a>" do
+    should_format_to(%{<a href="foo">yo!</a>}) { a "yo!", :href => "foo" }
+  end
+
+  it "should still close tags directly if it can" do
+    should_format_to(%{<div/>}) { div }
+  end
+
+  it "should put a non-newlined element inside a newlined element properly" do
+    should_format_to(%{<div>
+  <a class="bar">foo</a>
+</div>}) { div { a "foo", :class => "bar" } }
+  end
+
+  it "should put a newlined element inside a non-newlined element properly" do
+    should_format_to(%{<a class="foo">
+<div class="bar">
+  baz
+</div>
+</a>}) { a(:class => 'foo') { div(:class => 'bar') { text "baz" } } }
+  end
+
+  it "should format a nested combination properly" do
+    should_format_to(%{<nav id="main-menu">
+  <h1 id="brand">
+    <a href="somewhere"><img src="an_img"/></a>
+  </h1>
+</nav>}) do
+      nav(:id => 'main-menu') do
+        h1(:id => 'brand') do
+          a :href => 'somewhere' do
+            img :src => 'an_img'
+          end
+        end
+      end
+    end
+  end
+
+  it "should put the start and end tag of a block element nested properly even if there's nothing inside it" do
+    should_format_to(%{<div class="foo">
+  <div class="bar">
+  </div>
+</div>}) { div(:class => 'foo') { div(:class => 'bar') { } } }
+  end
+end