fortitude 0.0.4-java

data/spec/system/static_method_system_spec.rb

@@ -0,0 +1,348 @@
+describe "Fortitude staticization behavior", :type => :system do
+  it "should allow making a method static, and it should not change behavior ever" do
+    $global_value = 12345
+    wc = widget_class do
+      def content
+        p :class => 'foo' do
+          text "bar: #{$global_value}"
+        end
+        p "baz"
+      end
+
+      static :content
+    end
+
+    expect(render(wc)).to eq('<p class="foo">bar: 12345</p><p>baz</p>')
+
+    $global_value = 23456
+    expect(render(wc)).to eq('<p class="foo">bar: 12345</p><p>baz</p>')
+  end
+
+  it "should allow making a method static twice, and it should not cause problems" do
+    $global_value = 12345
+    wc = widget_class do
+      def content
+        p :class => 'foo' do
+          text "bar: #{$global_value}"
+        end
+        p "baz"
+      end
+
+      static :content
+      static :content
+    end
+
+    expect(render(wc)).to eq('<p class="foo">bar: 12345</p><p>baz</p>')
+
+    $global_value = 23456
+    expect(render(wc)).to eq('<p class="foo">bar: 12345</p><p>baz</p>')
+  end
+
+  it "should update the static definition of a method if static is called again" do
+    $global_value = 12345
+    wc = widget_class do
+      def content
+        p :class => 'foo' do
+          text "bar: #{$global_value}"
+        end
+        p "baz"
+      end
+
+      static :content
+    end
+
+    expect(render(wc)).to eq('<p class="foo">bar: 12345</p><p>baz</p>')
+
+    $global_value = 23456
+    expect(render(wc)).to eq('<p class="foo">bar: 12345</p><p>baz</p>')
+    wc.class_eval { static :content }
+    expect(render(wc)).to eq('<p class="foo">bar: 23456</p><p>baz</p>')
+    $global_value = 34567
+    expect(render(wc)).to eq('<p class="foo">bar: 23456</p><p>baz</p>')
+  end
+
+  it "should allow you to yield from a method that's made static" do
+    $global_value = 12345
+    wc = widget_class do
+      def content
+        text "content before:#{$global_value}"
+        foo do
+          text "yield inside:#{$global_value}"
+        end
+        text "content after:#{$global_value}"
+      end
+
+      def foo
+        text "foo before:#{$global_value}"
+        yield
+        text "foo after:#{$global_value}"
+      end
+
+      static :foo
+    end
+
+    expect(render(wc)).to eq('content before:12345foo before:12345yield inside:12345foo after:12345content after:12345')
+
+    $global_value = 23456
+    expect(render(wc)).to eq('content before:23456foo before:12345yield inside:23456foo after:12345content after:23456')
+    $global_value = 34567
+    expect(render(wc)).to eq('content before:34567foo before:12345yield inside:34567foo after:12345content after:34567')
+  end
+
+  it "should not allow you to yield more than once from a method that's made static" do
+    wc = widget_class do
+      def content
+        foo do
+          text "yo"
+        end
+      end
+
+      def foo
+        text "one"
+        yield
+        text "two"
+        yield
+        text "three"
+      end
+    end
+
+    expect { wc.class_eval { static :foo }; render(wc) }.to raise_error(/yields more than once/i)
+  end
+
+  it "should raise an error if you try to access a variable from within a method that's being made static" do
+    wc = widget_class do
+      needs :foo => 12345
+
+      def content
+        bar
+      end
+
+      def bar
+        text "foo is: #{foo}"
+      end
+    end
+
+    e = capture_exception(Fortitude::Errors::DynamicAccessFromStaticMethod) { wc.class_eval { static :bar }; render(wc) }
+    expect(e.widget.class).to be(wc)
+    expect(e.static_method_name).to eq(:bar)
+    expect(e.method_called).to eq(:foo)
+  end
+
+  def check_dynamic_raises(base_class, method_called, &block)
+    subclass = Class.new(base_class)
+    subclass.send(:define_method, :bar, &block)
+
+    e = capture_exception(Fortitude::Errors::DynamicAccessFromStaticMethod) { subclass.static :bar; render(subclass) }
+    expect(e.widget.class).to be(subclass)
+    expect(e.static_method_name).to eq(:bar)
+    expect(e.method_called).to eq(method_called)
+  end
+
+  it "should raise an error if you try to access dynamic data in other ways from within a method that's being made static" do
+    base_class = widget_class do
+      needs :foo => 12345
+
+      def content
+        bar
+      end
+    end
+
+    check_dynamic_raises(base_class, :foo) { foo }
+    check_dynamic_raises(base_class, :assigns) { assigns }
+    check_dynamic_raises(base_class, :shared_variables) { shared_variables }
+  end
+
+  it "should allow static-izing a widget that has required needs" do
+    wc = widget_class do
+      needs :foo
+
+      def content
+        text "foo: #{foo}"
+        bar
+      end
+
+      def bar
+        text "bar!"
+      end
+
+      static :bar
+    end
+
+    expect(render(wc.new(:foo => 12345))).to eq("foo: 12345bar!")
+    expect(render(wc.new(:foo => 23456))).to eq("foo: 23456bar!")
+  end
+
+  it "should allow disabling locale support" do
+    $global_value = 12345
+    wc = widget_class do
+      def initialize(locale)
+        @locale = locale
+      end
+
+      def widget_locale
+        @locale
+      end
+
+      def content
+        foo
+      end
+
+      def foo
+        text "locale: #{widget_locale}, #{$global_value}"
+      end
+
+      static :foo, :locale_support => false
+    end
+
+    expect(render(wc.new(:en))).to eq("locale: en, 12345")
+    $global_value = 23456
+    expect(render(wc.new(:fr))).to eq("locale: en, 12345")
+    expect(render(wc.new(:en))).to eq("locale: en, 12345")
+  end
+
+  describe "helper support" do
+    before :each do
+      @helpers_class = Class.new do
+        def foo(x)
+          "foo #{x} foo!"
+        end
+      end
+      @helpers_object = @helpers_class.new
+
+      @wc = widget_class do
+        def content
+          text "it is: #{foo('bar')}"
+        end
+      end
+    end
+
+    def do_render(widget_or_class, options = { })
+      render(widget_or_class, { :rendering_context => rc(:helpers_object => @helpers_object) }.merge(options))
+    end
+
+    it "should allow static methods to access helpers by default" do
+      expect(do_render(@wc)).to eq("it is: foo bar foo!")
+      @wc.static :content
+      expect(do_render(@wc)).to eq("it is: foo bar foo!")
+      expect(do_render(@wc)).to eq("it is: foo bar foo!")
+    end
+  end
+
+  describe "around_content support" do
+    before :each do
+      $global_value = 12345
+      @wc = widget_class do
+        around_content :ac
+
+        def ac
+          text "before #{$global_value}"
+          yield
+          text "after #{$global_value}"
+        end
+
+        def content
+          text "this is content"
+          sub
+        end
+
+        def sub
+          text "this is sub #{$global_value}"
+        end
+      end
+    end
+
+    it "should not run around_content filters around a static method, if that method is not #content" do
+      @wc.static :sub
+      expect(render(@wc)).to eq("before 12345this is contentthis is sub 12345after 12345")
+      $global_value = 23456
+      expect(render(@wc)).to eq("before 23456this is contentthis is sub 12345after 23456")
+    end
+
+    it "should run around_content filters around a static method, if that method is #content" do
+      @wc.static :content
+      expect(render(@wc)).to eq("before 12345this is contentthis is sub 12345after 12345")
+      $global_value = 23456
+      expect(render(@wc)).to eq("before 23456this is contentthis is sub 12345after 23456")
+    end
+  end
+
+  it "should still run the proper localized content methods even if #content, or one of them, is static" do
+    $global_value = 12345
+    wc = widget_class do
+      def initialize(locale)
+        self.widget_locale = locale
+        super({ })
+      end
+
+      def localized_content_en
+        text "hullo! #{$global_value}"
+      end
+
+      def localized_content_fr
+        text "bonjour! #{$global_value}"
+      end
+
+      def content
+        text "saluton! #{$global_value}"
+      end
+
+      attr_accessor :widget_locale
+    end
+
+    expect(render(wc.new(nil))).to eq("saluton! 12345")
+    expect(render(wc.new(:en))).to eq("hullo! 12345")
+    expect(render(wc.new(:fr))).to eq("bonjour! 12345")
+
+    wc.static :localized_content_fr
+    expect(render(wc.new(:fr))).to eq("bonjour! 12345")
+    $global_value = 23456
+
+    expect(render(wc.new(nil))).to eq("saluton! 23456")
+    expect(render(wc.new(:en))).to eq("hullo! 23456")
+    expect(render(wc.new(:fr))).to eq("bonjour! 12345")
+
+    wc.static :content
+    expect(render(wc.new(nil))).to eq("saluton! 23456")
+    $global_value = 34567
+
+    expect(render(wc.new(nil))).to eq("saluton! 23456")
+    expect(render(wc.new(:en))).to eq("hullo! 34567")
+    expect(render(wc.new(:fr))).to eq("bonjour! 12345")
+  end
+
+  describe "localization support" do
+    it "should allow staticized methods to have different output per-locale" do
+      $global_value = 12345
+      wc = widget_class do
+        def initialize(locale)
+          @locale = locale
+        end
+
+        def widget_locale
+          @locale
+        end
+
+        def content
+          text "this is content in #{widget_locale} language #{$global_value}!"
+        end
+      end
+
+      expect(render(wc.new(nil))).to eq("this is content in  language 12345!")
+      expect(render(wc.new("en"))).to eq("this is content in en language 12345!")
+      expect(render(wc.new("fr"))).to eq("this is content in fr language 12345!")
+
+      $global_value = 23456
+      wc.static :content
+
+      expect(render(wc.new(nil))).to eq("this is content in  language 23456!")
+      expect(render(wc.new("en"))).to eq("this is content in en language 23456!")
+      expect(render(wc.new("fr"))).to eq("this is content in fr language 23456!")
+
+      $global_value = 34567
+
+      expect(render(wc.new(nil))).to eq("this is content in  language 23456!")
+      expect(render(wc.new("en"))).to eq("this is content in en language 23456!")
+      expect(render(wc.new("fr"))).to eq("this is content in fr language 23456!")
+    end
+  end
+end

data/spec/system/tag_rendering_system_spec.rb

@@ -0,0 +1,260 @@
+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 render a non-self-closing tag correctly" do
+    should_render_to("<script></script>") { script }
+    should_render_to("<script></script>") { script { } }
+    should_render_to("<script></script>") { script('') }
+    should_render_to("<script></script>") { script('') { } }
+    should_render_to("<script src=\"foo\"></script>") { script(:src => "foo") }
+  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 .*\"></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>") { 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>") { 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>") { 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>") { 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 .*\"></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\"})
+  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 .*\"></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>") { 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>") { p :foo => [ 'bar', :baz, quux ]}
+  end
+end