fortitude 0.0.4-java

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></quux>")
+  end
+end

data/spec/system/needs_system_spec.rb

@@ -0,0 +1,381 @@
+describe "Fortitude needs", :type => :system do
+  def required
+    Fortitude::Widget::REQUIRED_NEED
+  end
+
+  it "should return the current needs from .needs, with or without arguments" do
+    parent = widget_class
+    child = widget_class(:superclass => parent)
+
+    expect(parent.needs).to eq({ })
+    expect(parent.needs(:foo)).to eq(:foo => required)
+    expect(parent.needs(:bar => 'def_bar')).to eq(:foo => required, :bar => 'def_bar')
+
+    expect(child.needs).to eq(:foo => required, :bar => 'def_bar')
+    expect(child.needs(:bar)).to eq(:foo => required, :bar => required)
+    expect(child.needs(:baz => 'def_baz')).to eq(:foo => required, :bar => required, :baz => 'def_baz')
+  end
+
+  it "should raise an exception if you try to modify a 'needs' default value" do
+    wc = widget_class do
+      needs :foo, :bar => [ 'a', 'b' ]
+
+      def content
+        bar << foo
+        text "bar: #{bar.join(",")}"
+      end
+    end
+
+    expect { render(wc.new(:foo => 'c')) }.to raise_error
+  end
+
+  it "should allow you to override a 'needs' method, and use #super" do
+    klass = widget_class do
+      needs :foo
+
+      def foo
+        "xx" + super + "yy"
+      end
+
+      def content
+        p "foo is: #{foo}"
+      end
+    end
+
+    expect(render(klass.new(:foo => 'aaa'))).to eq("<p>foo is: xxaaayy</p>")
+  end
+
+  describe "shadowing" do
+    it "should shadow tags with needs, not the other way around" do
+      klass = widget_class do
+        needs :p, :div => 'whatever'
+
+        def content
+          text "p is: #{p}, div is: #{div}"
+        end
+      end
+
+      expect(render(klass.new(:p => 'aaa'))).to eq("p is: aaa, div is: whatever")
+    end
+
+    it "should still allow access to tags using tag_*" do
+      klass = widget_class do
+        needs :p, :div => 'whatever'
+
+        def content
+          tag_p "this is a p"
+          tag_div "this is a div"
+          text "p is: #{p}, div is: #{div}"
+        end
+      end
+
+      expect(render(klass.new(:p => 'bbb'))).to eq("<p>this is a p</p><div>this is a div</div>p is: bbb, div is: whatever")
+    end
+
+    it "should still allow access to text, comment, rawtext, and javascript using tag_*" do
+      klass = widget_class do
+        needs :text => 'foo', :comment => 'bar', :rawtext => 'baz', :javascript => 'quux'
+
+        def content
+          tag_text "text is: #{text}"
+          tag_comment "comment is: #{comment}"
+          tag_rawtext "rawtext is: #{rawtext}"
+          tag_javascript "javascript is: #{javascript}"
+        end
+      end
+
+      expect(render(klass)).to eq(%{text is: foo<!-- comment is: bar -->rawtext is: baz<script>javascript is: quux</script>})
+    end
+
+    it "should raise an error if you pass a block to a 'needs' method and debugging is on" do
+      klass = widget_class do
+        debug true
+        needs :p
+
+        def content
+          p { text "this is not run" }
+          text "p is: #{p}"
+        end
+      end
+
+      expect { render(klass.new(:p => 'aaa')) }.to raise_error(Fortitude::Errors::BlockPassedToNeedMethod)
+    end
+
+    it "should not raise an error if you pass a block to a 'needs' method and debugging is off" do
+      klass = widget_class do
+        needs :p
+
+        def content
+          p { text "this is not run" }
+          text "p is: #{p}"
+        end
+      end
+
+      expect(render(klass.new(:p => 'aaa'))).to eq("p is: aaa")
+    end
+  end
+
+  describe "names" do
+    BAD_METHOD_NAMES = [ " ", "0123", "0foo", "?baz", "!yo", "!", "?", "abc??" ]
+
+    BAD_METHOD_NAMES.each do |bad_method_name|
+      it "should fail if you try to use a name for a need that's not a valid method name, like #{bad_method_name.inspect}" do
+        expect { widget_class { needs bad_method_name } }.to raise_error(ArgumentError)
+        expect { widget_class { needs bad_method_name.to_sym } }.to raise_error(ArgumentError)
+      end
+
+      it "should ignore any extra assigns that aren't valid method names, like #{bad_method_name.inspect}" do
+        wc = widget_class do
+          extra_assigns :use
+
+          def content
+            rawtext assigns.to_hash.inspect
+          end
+        end
+
+        expect(render(wc.new(bad_method_name => "foobar", :foo => 'bar'))).to eq("{:foo=>\"bar\"}")
+      end
+    end
+
+    VALID_METHOD_NAMES = [ "o01239014", "______", "_", "foo?", "bar!", "_0123" ]
+
+    VALID_METHOD_NAMES.each do |valid_method_name|
+      it "should allow you to use corner-case names for a need, like #{valid_method_name.inspect}" do
+        wc = widget_class do
+          needs valid_method_name.to_sym
+
+          attr_accessor :method_name
+
+          def content
+            eval("p \"value: \#{#{method_name}}\"")
+          end
+        end
+
+        i = wc.new(valid_method_name => "foo")
+        i.method_name = valid_method_name
+
+        expect(render(i)).to eq("<p>value: foo</p>")
+      end
+
+      it "should allow you to pass corner-case names for an extra assign, like #{valid_method_name.inspect}" do
+        wc = widget_class do
+          extra_assigns :use
+
+          attr_accessor :method_name
+
+          def content
+            eval("p \"value: \#{#{method_name}}\"")
+          end
+        end
+
+        i = wc.new(valid_method_name => "foo")
+        i.method_name = valid_method_name
+
+        expect(render(i)).to eq("<p>value: foo</p>")
+      end
+    end
+  end
+
+  describe "inheritance" do
+    it "should require needs from all superclasses" do
+      grandparent = widget_class { needs :foo }
+      parent = widget_class(:superclass => grandparent) { needs :bar }
+      child = widget_class(:superclass => parent) do
+        needs :baz
+        def content
+          text "foo: #{foo}, bar: #{bar}, baz: #{baz}"
+        end
+      end
+
+      expect { child.new }.to raise_error(Fortitude::Errors::MissingNeed)
+      expect { child.new(:foo => 'f') }.to raise_error(Fortitude::Errors::MissingNeed)
+      expect { child.new(:foo => 'f', :bar => 'b') }.to raise_error(Fortitude::Errors::MissingNeed)
+      expect(render(child.new(:foo => 'f', :bar => 'b', :baz => 'z'))).to eq("foo: f, bar: b, baz: z")
+
+      expect(grandparent.needs).to eq({ :foo => required })
+      expect(parent.needs).to eq({ :foo => required, :bar => required })
+      expect(child.needs).to eq({ :foo => required, :bar => required, :baz => required })
+    end
+
+    it "should let you add needs later, and it should apply to both that class and any subclasses" do
+      parent = widget_class_with_content { text "parent" }
+      child = widget_class(:superclass => parent) do
+        needs :bar
+        def content
+          super
+          text "; child: bar: #{bar}"
+        end
+      end
+
+      expect(render(parent)).to eq("parent")
+      expect(render(child.new(:bar => "the_bar"))).to eq("parent; child: bar: the_bar")
+      expect(parent.needs).to eq({ })
+      expect(child.needs).to eq({ :bar => required })
+
+      parent.class_eval { needs :foo }
+      child.class_eval do
+        def content
+          super
+          text "; child: bar: #{bar}; foo: #{foo}"
+        end
+      end
+
+      expect { parent.new }.to raise_error(Fortitude::Errors::MissingNeed)
+      expect { child.new(:bar => 'the_bar') }.to raise_error(Fortitude::Errors::MissingNeed)
+
+      expect(render(parent.new(:foo => "the_foo"))).to eq("parent")
+      expect(render(child.new(:foo => "the_foo", :bar => "the_bar"))).to eq("parent; child: bar: the_bar; foo: the_foo")
+
+      expect(parent.needs).to eq(:foo => required)
+      expect(child.needs).to eq(:foo => required, :bar => required)
+    end
+  end
+
+  describe "defaults" do
+    it "should allow supplying defaults, and allow overriding them" do
+      c = widget_class do
+        needs :foo, :bar => 'def_bar', :baz => 'def_baz'
+        def content
+          text "foo: #{foo}, bar: #{bar}, baz: #{baz}"
+        end
+      end
+
+      expect { c.new }.to raise_error(Fortitude::Errors::MissingNeed)
+      expect(render(c.new(:foo => 'the_foo'))).to eq("foo: the_foo, bar: def_bar, baz: def_baz")
+      expect(render(c.new(:foo => 'the_foo', :baz => 'the_baz'))).to eq("foo: the_foo, bar: def_bar, baz: the_baz")
+
+      expect(c.needs).to eq(:foo => required, :bar => 'def_bar', :baz => 'def_baz')
+    end
+
+    it "should inherit defaults properly" do
+      parent = widget_class do
+        needs :foo, :bar => 'def_bar', :baz => 'def_baz'
+        def content
+          text "foo: #{foo}, bar: #{bar}, baz: #{baz}"
+        end
+      end
+
+      child = widget_class(:superclass => parent) do
+        needs :baz => 'child_def_baz', :quux => 'child_quux'
+        def content
+          super
+          text "; baz: #{baz}, quux: #{quux}"
+        end
+      end
+
+      expect(render(parent.new(:foo => 'the_foo'))).to eq('foo: the_foo, bar: def_bar, baz: def_baz')
+      expect { child.new }.to raise_error(Fortitude::Errors::MissingNeed)
+      expect(render(child.new(:foo => 'the_foo'))).to eq('foo: the_foo, bar: def_bar, baz: child_def_baz; baz: child_def_baz, quux: child_quux')
+
+      expect(parent.needs).to eq(:foo => required, :bar => 'def_bar', :baz => 'def_baz')
+      expect(child.needs).to eq(:foo => required, :bar => 'def_bar', :baz => 'child_def_baz', :quux => 'child_quux')
+    end
+
+    it "should allow overriding a default with a requirement" do
+      parent = widget_class do
+        needs :foo, :bar => 'def_bar'
+      end
+
+      child = widget_class(:superclass => parent) do
+        needs :bar
+        def content
+          text "foo: #{foo}, bar: #{bar}"
+        end
+      end
+
+      expect { child.new(:foo => 'the_foo') }.to raise_error(Fortitude::Errors::MissingNeed)
+      expect(render(child.new(:foo => 'the_foo', :bar => 'the_bar'))).to eq('foo: the_foo, bar: the_bar')
+
+      expect(parent.needs).to eq(:foo => required, :bar => 'def_bar')
+      expect(child.needs).to eq(:foo => required, :bar => required)
+    end
+
+    it "should allow overriding a requirement with a default" do
+      parent = widget_class do
+        needs :foo, :bar
+      end
+
+      child = widget_class(:superclass => parent) do
+        needs :foo => 'def_foo', :bar => 'def_bar'
+        def content
+          text "foo: #{foo}, bar: #{bar}"
+        end
+      end
+
+      expect(render(child.new)).to eq('foo: def_foo, bar: def_bar')
+      expect(render(child.new(:bar => 'the_bar'))).to eq('foo: def_foo, bar: the_bar')
+
+      expect(parent.needs).to eq(:foo => required, :bar => required)
+      expect(child.needs).to eq(:foo => 'def_foo', :bar => 'def_bar')
+    end
+  end
+
+  describe "extra assigns" do
+    it "should, by default, ignore assigns it doesn't need" do
+      c = widget_class do
+        needs :foo
+        def content
+          bar_value = begin
+            bar
+          rescue => e
+            e.class.name
+          end
+
+          text "foo: #{foo}, bar: #{bar_value}"
+        end
+      end
+
+      expect(render(c.new(:foo => 'the_foo', :bar => 'the_bar'))).to eq('foo: the_foo, bar: NameError')
+    end
+
+    it "should ignore assigns it doesn't need, if told to" do
+      c = widget_class do
+        extra_assigns :ignore
+        needs :foo
+        def content
+          bar_value = begin
+            bar
+          rescue => e
+            e.class.name
+          end
+
+          text "foo: #{foo}, bar: #{bar_value}"
+        end
+      end
+
+      expect(render(c.new(:foo => 'the_foo', :bar => 'the_bar'))).to eq('foo: the_foo, bar: NameError')
+    end
+
+    it "should fail if passed assigns it doesn't need, if asked to" do
+      c = widget_class do
+        extra_assigns :error
+        needs :foo
+        def content
+          text "foo: #{foo}"
+        end
+      end
+
+      expect { c.new(:foo => 'the_foo', :bar => 'the_bar') }.to raise_error(Fortitude::Errors::ExtraAssigns, /bar/i)
+      expect(render(c.new(:foo => 'the_foo'))).to eq("foo: the_foo")
+    end
+
+    it "should use extra assigns it doesn't need, if asked to" do
+      c = widget_class do
+        extra_assigns :use
+        needs :foo
+        def content
+          bar_value = begin
+            bar
+          rescue => e
+            e.class.name
+          end
+
+          text "foo: #{foo}; bar: #{bar_value}"
+        end
+      end
+
+      expect(render(c.new(:foo => 'the_foo'))).to eq('foo: the_foo; bar: NameError')
+      expect(render(c.new(:foo => 'the_foo', :bar => 'the_bar'))).to eq('foo: the_foo; bar: the_bar')
+    end
+  end
+end