RubyGems - fortitude - Versions diffs - 0.0.4-java - Mend

fortitude 0.0.4-java

Files changed (355) hide show

data/spec/system/basic_system_spec.rb ADDED

@@ -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 ADDED

@@ -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 ADDED

@@ -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 ADDED

@@ -0,0 +1,228 @@
+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,
+      :requires_close_void_tags_to_be => nil,
+      :doctype_line => '<!DOCTYPE html>',
+      :javascript => :none
+    },
+    :html4_strict => {
+      :allows_dir  => false, :allows_background => false, :allows_frame => false, :closes_void_tags => false,
+      :requires_close_void_tags_to_be => 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,
+      :requires_close_void_tags_to_be => 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,
+      :requires_close_void_tags_to_be => 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,
+      :requires_close_void_tags_to_be => 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,
+      :requires_close_void_tags_to_be => 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,
+      :requires_close_void_tags_to_be => 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,
+      :requires_close_void_tags_to_be => 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
+      unless expected_results[:requires_close_void_tags_to_be] == nil
+        it "should require close_void_tags to be #{expected_results[:requires_close_void_tags_to_be]}" do
+          expect { the_widget_class.close_void_tags expected_results[:requires_close_void_tags_to_be] }.not_to raise_error
+          expect { the_widget_class.close_void_tags (! expected_results[:requires_close_void_tags_to_be]) }.to raise_error(ArgumentError, /doctype/i)
+        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 ADDED

@@ -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 ADDED

@@ -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\"></p>")
+  end
+  it "should escape attribute values" do
+    expect(render(widget_class_with_content { p :foo => 'a<b' })).to eq("<p foo=\"a&lt;b\"></p>")
+  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 ADDED

@@ -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>}) { 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