fortitude 0.0.1

data/spec/system/helpers_system_spec.rb

@@ -0,0 +1,235 @@
+describe "Fortitude helper support", :type => :system do
+  before :each do
+    @output_buffer = ""
+    @output_buffer_holder_class = Class.new do
+      attr_accessor :output_buffer
+    end
+    @output_buffer_holder = @output_buffer_holder_class.new
+    @output_buffer_holder.output_buffer = @output_buffer
+
+    @helpers_class = Class.new do
+      attr_accessor :output_buffer_holder
+
+      def helper1
+        "this is helper1"
+      end
+
+      def helper2(input)
+        "this is #{input} helper2"
+      end
+
+      def helper3(input)
+        output_buffer << "this is #{input} helper3"
+      end
+
+      def helper4(arg)
+        result = yield(arg)
+        "foo #{result} bar"
+      end
+
+      def p(input)
+        "pp#{input}pp"
+      end
+
+      def kaboom
+        raise "kaboom!"
+      end
+
+      def output_buffer
+        @output_buffer_holder.output_buffer
+      end
+    end
+
+    @helpers_object = @helpers_class.new
+    @helpers_object.output_buffer_holder = @output_buffer_holder
+  end
+
+  def render(widget_or_class, options = { })
+    @output_buffer.replace("")
+    super(widget_or_class, { :rendering_context => rc(
+      :helpers_object => @helpers_object, :output_buffer_holder => @output_buffer_holder) }.merge(options))
+  end
+
+  describe "manual invocation of helpers using #invoke_helper" do
+    it "should work for a very simple helper, without arguments" do
+      expect(render(widget_class_with_content { s = invoke_helper(:helper1); text s })).to eq("this is helper1")
+    end
+
+    it "should allow passing arguments" do
+      expect(render(widget_class_with_content { s = invoke_helper(:helper2, 'foo'); text s })).to eq("this is foo helper2")
+    end
+
+    it "should work even if automatic_helper_access is off" do
+      wc = widget_class do
+        automatic_helper_access false
+        def content
+          text invoke_helper(:helper1)
+        end
+      end
+
+      expect(render(wc)).to eq("this is helper1")
+    end
+
+    it "should allow passing a block" do
+      expect(render(widget_class_with_content { text invoke_helper(:helper4, "b") { |a| "x#{a}x" } })).to eq("foo xbx bar")
+    end
+
+    it "should return an exception properly" do
+      expect { render(widget_class_with_content { invoke_helper(:kaboom) }) }.to raise_error(/kaboom!/i)
+    end
+
+    it "should allow calling a helper that outputs" do
+      expect(render(widget_class_with_content { invoke_helper(:helper3, "aaa") })).to eq("this is aaa helper3")
+    end
+
+    it "should allow calling a method that's overridden on Widget" do
+      expect(render(widget_class_with_content { text invoke_helper(:p, "a") })).to eq("ppapp")
+    end
+  end
+
+  it "should, by default, allow automatic access to helpers" do
+    expect(render(widget_class_with_content { text "helper1: #{helper1}" })).to eq("helper1: this is helper1")
+    expect(render(widget_class_with_content { text "helper2: #{helper2("yo")}" })).to eq("helper2: this is yo helper2")
+    expect(render(widget_class_with_content { helper3("ho") })).to eq("this is ho helper3")
+  end
+
+  it "should not allow automatic access to helpers if we say not to" do
+    wc = widget_class do
+      automatic_helper_access false
+      def content
+        helper1_value = begin
+          helper1
+        rescue => e
+          e.class.name
+        end
+
+        helper2_value = begin
+          helper2("foo")
+        rescue => e
+          e.class.name
+        end
+
+        helper3_value = begin
+          helper3("bar")
+        rescue => e
+          e.class.name
+        end
+
+        text "helper1: #{helper1_value}, helper2: #{helper2_value}, helper3: #{helper3_value}"
+      end
+    end
+
+    expect(render(wc)).to eq("helper1: NameError, helper2: NoMethodError, helper3: NoMethodError")
+  end
+
+  it "should allow manually declaring helpers" do
+    wc = widget_class do
+      automatic_helper_access false
+      helper :helper1, :helper3
+      def content
+        helper2_value = begin
+          helper2("foo")
+        rescue => e
+          e.class.name
+        end
+
+        text "helper1: #{helper1}, helper2: #{helper2_value}, helper3: "
+        helper3("hi")
+      end
+    end
+
+    expect(render(wc)).to eq("helper1: this is helper1, helper2: NoMethodError, helper3: this is hi helper3")
+  end
+
+  it "should allow overriding a manually-declared helper, and allow use of #super" do
+    wc = widget_class do
+      automatic_helper_access false
+      helper :helper1
+
+      def helper1
+        "xx" + super + "yy"
+      end
+
+      def content
+        text "helper1: #{helper1}"
+      end
+    end
+
+    expect(render(wc)).to eq("helper1: xxthis is helper1yy")
+  end
+
+  it "should allow overriding a helper accessed using automatic_helper_access, and allow use of #super" do
+    wc = widget_class do
+      def helper1
+        "xx" + super + "yy"
+      end
+
+      def content
+        text "helper1: #{helper1}"
+      end
+    end
+
+    expect(render(wc)).to eq("helper1: xxthis is helper1yy")
+  end
+
+  it "should allow transforming helpers that return to helpers that output" do
+    wc = widget_class do
+      helper :helper1, :transform => :output_return_value
+
+      def content
+        text "helper1: "
+        helper1
+      end
+    end
+
+    expect(render(wc)).to eq("helper1: this is helper1")
+  end
+
+  it "should allow transforming helpers that output to helpers that return" do
+    wc = widget_class do
+      helper :helper3, :transform => :return_output
+
+      def content
+        helper3_value = helper3("boo")
+        text "helper3: #{helper3_value}, done"
+      end
+    end
+
+    expect(render(wc)).to eq("helper3: this is boo helper3, done")
+  end
+
+  it "should allow aliasing helper method names" do
+    wc = widget_class do
+      helper :h2a, :call => :helper2
+      helper :h2b, :call => :helper2, :transform => :output_return_value
+
+      def content
+        h2b("yo")
+        text ", h2a: #{h2a('xx')}, done"
+      end
+    end
+
+    expect(render(wc)).to eq("this is yo helper2, h2a: this is xx helper2, done")
+  end
+
+  it "should allow declaring helpers with :transform = nil, false, or none" do
+    wc = widget_class do
+      automatic_helper_access false
+      helper :helper1, :transform => nil
+      helper :helper2, :transform => false
+      helper :helper3, :transform => :none
+
+      def content
+        text "helper1: #{helper1}, helper2: #{helper2('yo')}, helper3: "
+        helper3("hi")
+      end
+    end
+
+    expect(render(wc)).to eq("helper1: this is helper1, helper2: this is yo helper2, helper3: this is hi helper3")
+  end
+
+  it "should validate the options passed to .helper" do
+    expect { widget_class { helper :foo, :transform => :boo } }.to raise_error(ArgumentError)
+    expect { widget_class { helper :foo, :foo => :bar } }.to raise_error(ArgumentError)
+  end
+end

data/spec/system/id_uniqueness_system_spec.rb

@@ -0,0 +1,205 @@
+describe "Fortitude ID uniqueness", :type => :system do
+  def widget_class(options = { }, &block)
+    needs_uniqueness = true unless options.delete(:no_enforcement)
+    out = super(options, &block)
+    out.class_eval { enforce_id_uniqueness true } if needs_uniqueness
+    out
+  end
+
+  it "should not enforce ID uniqueness by default" do
+    wc = widget_class_with_content(:no_enforcement => true) do
+      p :id => "foo"
+      p :id => "foo"
+    end
+
+    expect(render(wc)).to eq("<p id=\"foo\"/><p id=\"foo\"/>")
+  end
+
+  it "should enforce ID uniqueness if asked to" do
+    wc = widget_class_with_content do
+      p :id => "foo"
+      p :id => "foo"
+    end
+
+    instance = wc.new
+    e = capture_exception(Fortitude::Errors::DuplicateId) { render(instance) }
+    expect(e.widget).to be(instance)
+    expect(e.id).to eq("foo")
+    expect(e.already_used_widget).to be(instance)
+    expect(e.already_used_tag_name).to eq(:p)
+    expect(e.tag_name).to eq(:p)
+  end
+
+  it "should enforce ID uniqueness between Symbols and Strings properly" do
+    wc = widget_class_with_content do
+      p :id => :foo
+      p :id => "foo"
+    end
+
+    instance = wc.new
+    e = capture_exception(Fortitude::Errors::DuplicateId) { render(instance) }
+    expect(e.widget).to be(instance)
+    expect(e.id).to eq("foo")
+    expect(e.already_used_widget).to be(instance)
+    expect(e.already_used_tag_name).to eq(:p)
+    expect(e.tag_name).to eq(:p)
+  end
+
+  it "should enforce ID uniqueness across different kinds of tags" do
+    wc = widget_class_with_content do
+      p :id => "foo"
+      div :id => :foo
+    end
+
+    instance = wc.new
+    e = capture_exception(Fortitude::Errors::DuplicateId) { render(instance) }
+    expect(e.widget).to be(instance)
+    expect(e.id).to eq("foo")
+    expect(e.already_used_widget).to be(instance)
+    expect(e.already_used_tag_name).to eq(:p)
+    expect(e.tag_name).to eq(:div)
+  end
+
+  it "should enforce ID uniqueness across different widgets" do
+    outer = widget_class do
+      attr_accessor :inner
+      def content
+        p :id => 'foo'
+        widget inner
+      end
+    end
+
+    inner = widget_class_with_content do
+      p :id => :foo
+    end
+
+    outer_instance = outer.new
+    inner_instance = inner.new
+    outer_instance.inner = inner_instance
+
+    e = capture_exception(Fortitude::Errors::DuplicateId) { render(outer_instance) }
+    expect(e.widget).to be(inner_instance)
+    expect(e.id).to eq("foo")
+    expect(e.already_used_widget).to be(outer_instance)
+    expect(e.already_used_tag_name).to eq(:p)
+    expect(e.tag_name).to eq(:p)
+  end
+
+  it "should not enforce uniqueness 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 :id => 'foo'
+        widget inner
+        p :id => 'bar'
+      end
+    end
+
+    inner = widget_class_with_content(:no_enforcement => true) do
+      p :id => :foo
+    end
+
+    outer_instance = outer.new
+    inner_instance = inner.new
+    outer_instance.inner = inner_instance
+
+    expect(render(outer_instance)).to eq("<p id=\"foo\"/><p id=\"foo\"/><p id=\"bar\"/>")
+  end
+
+  it "should allow you to disable enforcement with a block" do
+    wc = widget_class_with_content do
+      p :id => :foo
+      with_id_uniqueness(false) do
+        p :id => :foo
+      end
+      begin
+        p :id => :foo
+      rescue => e
+        text e.class.name
+      end
+    end
+
+    expect(render(wc)).to eq('<p id="foo"/><p id="foo"/>Fortitude::Errors::DuplicateId')
+  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 :id => 'foo'
+        with_id_uniqueness(false) do
+          widget inner
+        end
+        p :id => 'bar'
+      end
+    end
+
+    inner = widget_class_with_content do
+      p :id => :foo
+    end
+
+    outer_instance = outer.new
+    inner_instance = inner.new
+    outer_instance.inner = inner_instance
+
+    expect(render(outer_instance)).to eq("<p id=\"foo\"/><p id=\"foo\"/><p id=\"bar\"/>")
+  end
+
+  it "should allow you to re-enable enforcement with a block" do
+    wc = widget_class_with_content do
+      p :id => :foo
+      with_id_uniqueness(false) do
+        with_id_uniqueness(true) do
+          p :id => :foo
+        end
+      end
+    end
+
+    expect { render(wc) }.to raise_error(Fortitude::Errors::DuplicateId)
+  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
+        p :id => 'foo'
+        with_id_uniqueness(false) do
+          widget inner
+        end
+      end
+    end
+
+    inner = widget_class_with_content do
+      with_id_uniqueness(true) do
+        p :id => :foo
+      end
+    end
+
+    outer_instance = outer.new
+    inner_instance = inner.new
+    outer_instance.inner = inner_instance
+
+    expect { render(outer_instance) }.to raise_error(Fortitude::Errors::DuplicateId)
+  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_id_uniqueness(true) do
+        p :id => "foo"
+      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_id_uniqueness(false) do
+        p :id => "foo"
+        p :id => "foo"
+      end
+    end
+
+    expect(render(wc)).to eq('<p id="foo"/><p id="foo"/>')
+  end
+end

data/spec/system/localization_system_spec.rb

@@ -0,0 +1,94 @@
+describe "Fortitude native (non-Rails) localization support", :type => :system do
+  before :each do
+    @klass = widget_class do
+      def localized_content_en
+        text "english!"
+      end
+
+      def localized_content_en_GB
+        text "hullo!"
+      end
+
+      def localized_content_fr
+        text "french!"
+      end
+
+      def content
+        text "saluton"
+      end
+
+      def widget_locale
+        nil
+      end
+    end
+  end
+
+  it "should not run a localized method unless #widget_locale returns something" do
+    expect(render(@klass)).to eq("saluton")
+  end
+
+  it "should run the correct content method" do
+    @klass.send(:define_method, :widget_locale) { :en }
+    expect(render(@klass)).to eq("english!")
+    @klass.send(:define_method, :widget_locale) { 'en' }
+    expect(render(@klass)).to eq("english!")
+    @klass.send(:define_method, :widget_locale) { :fr }
+    expect(render(@klass)).to eq("french!")
+    @klass.send(:define_method, :widget_locale) { :en_GB }
+    expect(render(@klass)).to eq("hullo!")
+  end
+
+  it "should run the default method for unknown locales" do
+    @klass.send(:define_method, :widget_locale) { :es }
+    expect(render(@klass)).to eq("saluton")
+  end
+
+  context "with simple locale setting" do
+    before :each do
+      @klass = widget_class do
+        attr_accessor :widget_locale
+
+        def initialize(attributes = { })
+          self.widget_locale = attributes.delete(:widget_locale)
+          super(attributes)
+        end
+
+        def content
+          text "saluton"
+        end
+      end
+    end
+
+    it "should work even if localized methods come from a superclass" do
+      subclass = Class.new(@klass)
+      @klass.class_eval do
+        def localized_content_en
+          text "english!"
+        end
+      end
+
+      expect(render(subclass.new)).to eq("saluton")
+      expect(render(subclass.new(:widget_locale => 'en'))).to eq("english!")
+    end
+
+    it "should work even if localized methods come from a module" do
+      mod = Module.new do
+        def localized_content_en
+          text "english!"
+        end
+      end
+
+      expect(render(@klass.new(:widget_locale => 'en'))).to eq("saluton")
+      @klass.send(:include, mod)
+      expect(render(@klass.new(:widget_locale => 'en'))).to eq("english!")
+    end
+
+    it "should work even if localized methods are added late" do
+      expect(render(@klass.new(:widget_locale => 'en'))).to eq("saluton")
+      @klass.send(:define_method, :localized_content_en) do
+        text "english!"
+      end
+      expect(render(@klass.new(:widget_locale => 'en'))).to eq("english!")
+    end
+  end
+end

data/spec/system/method_precedence_system_spec.rb

@@ -0,0 +1,48 @@
+describe "Fortitude method precedence", :type => :system do
+  it "should have widget methods > need methods > helper methods > tag methods" do
+    helpers_class = Class.new do
+      def foo
+        "helper_foo"
+      end
+
+      def bar
+        "helper_bar"
+      end
+
+      def baz
+        "helper_baz"
+      end
+
+      def quux
+        "helper_quux"
+      end
+    end
+
+    helpers_object = helpers_class.new
+
+    wc = widget_class do
+      tag :foo
+      tag :bar
+      tag :baz
+      tag :quux
+
+      helper :foo, :bar, :baz
+
+      needs :foo => 'need_foo', :bar => 'need_bar'
+
+      def foo
+        "method foo"
+      end
+
+      def content
+        text "foo: #{foo}, "
+        text "bar: #{bar}, "
+        text "baz: #{baz}, "
+        quux
+      end
+    end
+
+    expect(render(wc, :rendering_context => rc(
+      :helpers_object => helpers_object))).to eq("foo: method foo, bar: need_bar, baz: helper_baz, <quux/>")
+  end
+end