fortitude 0.0.1

data/spec/system/start_end_comments_system_spec.rb

@@ -0,0 +1,363 @@
+describe "Fortitude start/end comments support", :type => :system do
+  def eb(widget_class, expected_depth = 0)
+    "BEGIN #{widget_class.name} depth #{expected_depth}"
+  end
+
+  def ee(widget_class, expected_depth = 0)
+    "END #{widget_class.name} depth #{expected_depth}"
+  end
+
+  it "should not add comments by default" do
+    wc = widget_class do
+      def content
+        p "hi!"
+      end
+    end
+
+    expect(render(wc)).to eq("<p>hi!</p>")
+  end
+
+  it "should add comments if asked to" do
+    wc = widget_class do
+      start_and_end_comments true
+
+      def content
+        p "hi!"
+      end
+    end
+
+    expect(render(wc)).to eq("<!-- #{eb(wc)} --><p>hi!</p><!-- #{ee(wc)} -->")
+  end
+
+  it "should add passed assigns, including defaults" do
+    wc = widget_class do
+      start_and_end_comments true
+
+      needs :foo, :bar => nil, :baz => 'def_baz', :quux => 'the_quux'
+
+      def content
+        p "hi"
+      end
+    end
+
+    result = render(wc.new(:foo => 'the_foo', :bar => /whatever/i, :quux => 'the_quux'))
+    expect(result).to match(%r{^<!-- #{eb(wc)}: })
+    expect(result).to match(%r{:foo => \"the_foo\"})
+    expect(result).to match(%r{:bar => /whatever/i})
+    expect(result).to match(%r{:baz => \(DEFAULT\) \"def_baz\"})
+    expect(result).to match(%r{:quux => \"the_quux\"})
+    expect(result).to match(%r{ --><p>hi</p><!-- #{ee(wc)} -->$})
+  end
+
+  it "should not display extra assigns if we're not using them" do
+    wc = widget_class do
+      needs :foo
+      start_and_end_comments true
+
+      def content
+        p "hi"
+      end
+    end
+
+    expect(render(wc.new(:foo => 'bar', :bar => 'baz'))).to eq("<!-- #{eb(wc)}: " +
+      ":foo => \"bar\" --><p>hi</p><!-- #{ee(wc)} -->")
+  end
+
+  it "should display extra assigns if we're using them" do
+    wc = widget_class do
+      needs :foo
+      start_and_end_comments true
+      extra_assigns :use
+
+      def content
+        p "hi"
+      end
+    end
+
+    result = render(wc.new(:foo => 'bar', :bar => 'baz'))
+    expect(result).to match(%r{^<!-- #{eb(wc)}: })
+    expect(result).to match(%r{:foo => \"bar\"})
+    expect(result).to match(%r{:bar => \"baz\"})
+    expect(result).to match(%r{--><p>hi</p><!-- #{ee(wc)} -->})
+  end
+
+  it "should not display all of the text of long assigns" do
+    wc = widget_class do
+      needs :foo
+      start_and_end_comments true
+
+      def content
+        p "hi"
+      end
+    end
+
+    assigns = { :foo => "a" * 1000 }
+    text = render(wc.new(assigns))
+
+    expect(text).to match(%r{^<!-- #{eb(wc)}: :foo => \"aaaaa})
+    expect(text).to match(%r{aaa... --><p>hi</p><!-- #{ee(wc)} -->$})
+    expect(text.length).to be < 500
+    expect(text).not_to match("a" * 500)
+  end
+
+  it "should, by default, use #inspect, not #to_s, for assigns" do
+    obj = Object.new
+    class << obj
+      def to_s
+        "THIS IS TO_S"
+      end
+
+      def inspect
+        "THIS IS INSPECT"
+      end
+    end
+
+    wc = widget_class do
+      needs :foo
+      start_and_end_comments true
+
+      def content
+        p "hi"
+      end
+    end
+
+    expect(render(wc.new(:foo => obj))).to eq("<!-- #{eb(wc)}: " +
+      ":foo => THIS IS INSPECT --><p>hi</p><!-- #{ee(wc)} -->")
+  end
+
+  it "should allow overriding the text returned for assigns" do
+    obj = Object.new
+    class << obj
+      def to_s
+        "THIS IS TO_S"
+      end
+
+      def inspect
+        "THIS IS INSPECT"
+      end
+
+      def to_fortitude_comment_string
+        "THIS IS TO_FORTITUDE_COMMENT_STRING"
+      end
+    end
+
+    wc = widget_class do
+      needs :foo
+      start_and_end_comments true
+
+      def content
+        p "hi"
+      end
+    end
+
+    expect(render(wc.new(:foo => obj))).to eq("<!-- #{eb(wc)}: " +
+      ":foo => THIS IS TO_FORTITUDE_COMMENT_STRING --><p>hi</p><!-- #{ee(wc)} -->")
+  end
+
+  it "should order the comment text in whatever order the needs are declared" do
+    needed = [ ]
+    5.times { needed << "need#{rand(1_000_000_000)}".to_sym }
+    needed = needed.shuffle
+
+    wc = widget_class do
+      start_and_end_comments true
+
+      def content
+        p "hi"
+      end
+    end
+
+    remaining_needed = needed.dup
+    while remaining_needed.length > 0
+      this_slice = remaining_needed.shift(rand(3))
+      wc.needs *this_slice
+    end
+
+    params = { }
+    needed.shuffle.each { |n| params[n] = "value-#{n}" }
+
+    text = render(wc.new(params))
+
+    expected_output = "<!-- #{eb(wc)}: "
+    expected_output << needed.map do |n|
+      ":#{n} => \"value-#{n}\""
+    end.join(", ")
+    expected_output << " --><p>hi</p><!-- #{ee(wc)} -->"
+  end
+
+  it "should display the depth at which a widget is being rendered" do
+    inner = widget_class do
+      start_and_end_comments true
+      def content
+        text "hi!"
+      end
+    end
+
+    middle = widget_class do
+      start_and_end_comments true
+      cattr_accessor :klass
+      def content
+        widget klass.new
+      end
+    end
+
+    outer = widget_class do
+      start_and_end_comments true
+      cattr_accessor :klass
+      def content
+        widget klass.new
+      end
+    end
+
+    outer.klass = middle
+    middle.klass = inner
+
+    expect(render(outer)).to eq(
+      "<!-- #{eb(outer, 0)} -->" +
+      "<!-- #{eb(middle, 1)} -->" +
+      "<!-- #{eb(inner, 2)} -->" +
+      "hi!" +
+      "<!-- #{ee(inner, 2)} -->" +
+      "<!-- #{ee(middle, 1)} -->" +
+      "<!-- #{ee(outer, 0)} -->")
+  end
+
+  it "should display the depth at which a widget is being rendered, even if outer widgets aren't rendering comments" do
+    inner = widget_class do
+      start_and_end_comments true
+      def content
+        text "hi!"
+      end
+    end
+
+    middle = widget_class do
+      cattr_accessor :klass
+      def content
+        widget klass.new
+      end
+    end
+
+    outer = widget_class do
+      cattr_accessor :klass
+      def content
+        widget klass.new
+      end
+    end
+
+    outer.klass = middle
+    middle.klass = inner
+
+    expect(render(outer)).to eq(
+      "<!-- #{eb(inner, 2)} -->" +
+      "hi!" +
+      "<!-- #{ee(inner, 2)} -->")
+  end
+
+  it "should put comments on their own lines if we're formatting output" do
+    wc = widget_class do
+      start_and_end_comments true
+      format_output true
+
+      def content
+        text "hi"
+      end
+    end
+
+    expect(render(wc)).to eq(%{<!-- #{eb(wc)} -->
+hi
+<!-- #{ee(wc)} -->})
+  end
+
+  it "should put comments on their own lines, nested inside another widget, if we're formatting output" do
+    outer = widget_class do
+      format_output true
+      cattr_accessor :klass
+
+      def content
+        div do
+          div do
+            widget klass.new
+          end
+        end
+      end
+    end
+
+    inner = widget_class do
+      start_and_end_comments true
+      format_output true
+
+      def content
+        text "hi"
+      end
+    end
+
+    outer.klass = inner
+    expect(render(outer)).to eq(%{<div>
+  <div>
+    <!-- #{eb(inner, 1)} -->
+    hi
+    <!-- #{ee(inner, 1)} -->
+  </div>
+</div>})
+  end
+
+  it "should put assignments on their own lines, with indentation, if they're long enough and we're formatting output" do
+    outer = widget_class do
+      format_output true
+      cattr_accessor :klass
+
+      def content
+        div do
+          div do
+            widget klass.new(:foo => "a" * 1000, :bar => "b" * 1000)
+          end
+        end
+      end
+    end
+
+    inner = widget_class do
+      needs :foo, :bar
+      start_and_end_comments true
+      format_output true
+
+      def content
+        text "hi"
+      end
+    end
+
+    outer.klass = inner
+
+    result = render(outer)
+    expect(result).to match(%r{^<div>\n  <div>\n    <!-- #{eb(inner, 1)}:\n         :}m)
+    expect(result).to match(%r{^         :foo => \"a{97}...\n})
+    expect(result).to match(%r{^         :bar => \"b{97}...\n})
+    expect(result).to match(%r{^     -->$})
+    expect(result).to match(%r{^    hi})
+    expect(result).to match(%r{^    <!-- #{ee(inner, 1)} -->\n  </div>\n</div>$}m)
+  end
+
+  BAD_VALUES = [ ">foo", "fo -- bar", "--", "->bar", "baz-" ]
+
+  BAD_VALUES.each do |bad_value|
+    it "should escape any potentially invalid-comment text in assign values, like #{bad_value.inspect}" do
+      wc = widget_class do
+        needs :foo
+        start_and_end_comments true
+
+        def content
+          p "hi"
+        end
+      end
+
+      instance = wc.new(:foo => bad_value)
+      text = render(instance)
+      # expect(text).to match(%r{^<!-- #{eb(wc)}: :foo => (.*) --><p>hi</p><!-- #{ee(wc)} -->$})
+      if text =~ %r{^<!-- #{eb(wc)}: :foo => (.*) --><p>hi</p><!-- #{ee(wc)} -->$}
+        data = $1
+        expect(data).not_to match(/\-\-/)
+      else
+        raise "Text does not match: #{text.inspect}"
+      end
+    end
+  end
+end

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