zena 1.2.1 → 1.2.2

data/test/unit/zafu_markup_test.rb

@@ -0,0 +1,414 @@
+require 'test_helper'
+
+class MarkupTest < Test::Unit::TestCase
+  include RubyLess
+  safe_method :day => {:class => String, :method => %q{Time.now.strftime('%A')}}
+  Markup = Zafu::Markup
+
+  context 'Parsing parameters' do
+    should 'retrieve values escaped with single quotes' do
+      h = {:class => 'worker', :style => 'tired'}
+      assert_equal h, Markup.parse_params("class='worker' style='tired'")
+    end
+
+    should 'retrieve values escaped with double quotes' do
+      h = {:class => 'worker', :style => 'tired'}
+      assert_equal h, Markup.parse_params('class="worker" style="tired"')
+    end
+
+    should 'retrieve values escaped with mixed quotes' do
+      h = {:class => 'worker', :style => 'tired'}
+      assert_equal h, Markup.parse_params('class=\'worker\' style="tired"')
+    end
+
+    should 'properly handle escaped single quotes' do
+      h = {:class => "that's nice", :style => 'tired'}
+      assert_equal h, Markup.parse_params("class='that\\\'s nice' style='tired'")
+    end
+
+    should 'properly handle escaped double quotes' do
+      h = {:class => '30"', :style => 'tired'}
+      assert_equal h, Markup.parse_params('class="30\\"" style="tired"')
+    end
+  end
+
+  context 'Setting parameters' do
+    setup do
+      @markup = Markup.new('p')
+    end
+
+    should 'parse params if the parameters are provided as a string' do
+      @markup.params = "class='shiny' id='slogan'"
+      h = {:class => 'shiny', :id => 'slogan'}
+      assert_equal h, @markup.params
+    end
+
+    should 'set params if the parameters are provided as a hash' do
+      @markup.params = {:class => 'shiny', :style => 'good'}
+      h = {:class => 'shiny', :style => 'good'}
+      assert_equal h, @markup.params
+    end
+
+    should 'respond to has_param' do
+      @markup.params     = {:class => 'one', :x => 'y'}
+      @markup.dyn_params = {:y => 'z'}
+      assert @markup.has_param?(:x)
+      assert @markup.has_param?(:y)
+      assert !@markup.has_param?(:z)
+    end
+  end
+
+  context 'Stealing html params' do
+    subject do
+      Markup.new('p')
+    end
+
+    should 'transfer common html params' do
+      base = {:class => 'blue', :name => 'sprout', :id => 'front_cover', :style => 'padding:5px;', :attr => 'title'}
+      subject.steal_html_params_from(base)
+      new_base = {:name => 'sprout', :attr => 'title'}
+      markup_params = {:class => 'blue', :id => 'front_cover', :style => 'padding:5px;'}
+      assert_equal new_base, base
+      assert_equal markup_params, subject.params
+    end
+
+    context 'on a link' do
+      subject do
+        Markup.new('link')
+      end
+
+      should 'transfer common html params' do
+        base = {:rel => 'rel', :type => 'type', :class => 'blue', :name => 'sprout', :id => 'front_cover', :style => 'padding:5px;', :attr => 'title'}
+        subject.steal_html_params_from(base)
+        new_base = {:name => 'sprout', :attr => 'title'}
+        markup_params = {:type=>"type", :rel=>"rel", :id => 'front_cover', :class => 'blue', :style => 'padding:5px;'}
+        assert_equal new_base, base
+        assert_equal markup_params, subject.params
+      end
+    end
+  end
+
+  context 'Defining the dom id' do
+    setup do
+      @markup = Markup.new('p')
+      @markup.params[:id] = 'foobar'
+      @markup.dyn_params[:id] = 'foobar'
+      @markup.set_id('<%= @node.zip %>')
+    end
+
+    should 'remove any predifined id' do
+      assert_nil @markup.params[:id]
+    end
+
+    should 'write id in the dynamic params' do
+      assert_equal '<%= @node.zip %>', @markup.dyn_params[:id]
+    end
+  end
+
+  context 'Setting a dynamic param' do
+    setup do
+      @markup = Markup.new('p')
+      @markup.params[:foo] = 'one'
+      @markup.set_dyn_params(:foo => '<%= @node.two %>')
+    end
+
+    should 'clear a static param with same key' do
+      assert_nil @markup.params[:foo]
+      assert_equal '<%= @node.two %>', @markup.dyn_params[:foo]
+    end
+  end
+
+  context 'Setting a static param' do
+    setup do
+      @markup = Markup.new('p')
+      @markup.dyn_params[:foo] = '<%= @node.two %>'
+      @markup.set_params(:foo => 'one')
+    end
+
+    should 'clear a dynamic param with same key' do
+      assert_nil @markup.dyn_params[:foo]
+      assert_equal 'one', @markup.params[:foo]
+    end
+  end
+
+
+  context 'Appending a static param' do
+    context 'on a static param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_params(:class => 'simple')
+      end
+
+      should 'append param in the static params' do
+        @markup.append_param(:class, 'mind')
+        assert_equal 'simple mind', @markup.params[:class]
+      end
+    end
+
+    context 'on a dynamic param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_dyn_params(:class => '<%= @foo %>')
+      end
+
+      should 'append param in the dynamic params' do
+        @markup.append_param(:class, 'bar')
+        assert_equal '<%= @foo %> bar', @markup.dyn_params[:class]
+      end
+    end
+
+    context 'on an empty param' do
+      setup do
+        @markup = Markup.new('p')
+      end
+
+      should 'set param in the static params' do
+        @markup.append_param(:class, 'bar')
+        assert_equal 'bar', @markup.params[:class]
+      end
+    end
+  end
+
+  context 'Prepending a static param' do
+    context 'on a static param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_params(:class => 'simple')
+      end
+
+      should 'prepend param in the static params' do
+        @markup.prepend_param(:class, 'super')
+        assert_equal 'super simple', @markup.params[:class]
+      end
+    end
+
+    context 'on a dynamic param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_dyn_params(:class => '<%= @fu %>')
+      end
+
+      should 'prepend param in the dynamic params' do
+        @markup.prepend_param(:class, 'to')
+        assert_equal 'to <%= @fu %>', @markup.dyn_params[:class]
+      end
+    end
+
+    context 'on an empty param' do
+      setup do
+        @markup = Markup.new('p')
+      end
+
+      should 'set param in the static params' do
+        @markup.prepend_param(:class, 'bar')
+        assert_equal 'bar', @markup.params[:class]
+      end
+    end
+  end
+
+  context 'Appending a dynamic param' do
+    context 'on a static param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_params(:class => 'simple')
+      end
+
+      should 'copy the static param in the dynamic params' do
+        @markup.append_dyn_param(:class, '<%= @mind %>')
+        assert_equal 'simple <%= @mind %>', @markup.dyn_params[:class]
+      end
+    end
+
+    context 'on a dynamic param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_dyn_params(:class => '<%= @foo %>')
+      end
+
+      should 'append param in the dynamic params' do
+        @markup.append_dyn_param(:class, '<%= @bar %>')
+        assert_equal '<%= @foo %> <%= @bar %>', @markup.dyn_params[:class]
+      end
+
+      should 'append param without spacer if conditional' do
+        @markup.append_dyn_param(:class, '<%= @bar %>', true)
+        assert_equal '<%= @foo %><%= @bar %>', @markup.dyn_params[:class]
+      end
+    end
+
+    context 'on an empty param' do
+      setup do
+        @markup = Markup.new('p')
+      end
+
+      should 'set param in the dynamic params' do
+        @markup.append_dyn_param(:class, '<%= @bar %>')
+        assert_equal '<%= @bar %>', @markup.dyn_params[:class]
+      end
+    end
+  end
+
+  context 'Prepending a dynamic param' do
+    context 'on a static param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_params(:class => 'fu')
+      end
+
+      should 'copy the static param in the dynamic params' do
+        @markup.prepend_dyn_param(:class, '<%= @to %>')
+        assert_equal '<%= @to %> fu', @markup.dyn_params[:class]
+      end
+    end
+
+    context 'on a dynamic param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_dyn_params(:class => '<%= @fu %>')
+      end
+
+      should 'prepend param in the dynamic params' do
+        @markup.prepend_dyn_param(:class, '<%= @to %>')
+        assert_equal '<%= @to %> <%= @fu %>', @markup.dyn_params[:class]
+      end
+
+      should 'prepend param without spacer if conditional' do
+        @markup.prepend_dyn_param(:class, '<%= @to %>', true)
+        assert_equal '<%= @to %><%= @fu %>', @markup.dyn_params[:class]
+      end
+    end
+
+    context 'on an empty param' do
+      setup do
+        @markup = Markup.new('p')
+      end
+
+      should 'set param in the dynamic params' do
+        @markup.prepend_dyn_param(:class, '<%= @bar %>')
+        assert_equal '<%= @bar %>', @markup.dyn_params[:class]
+      end
+    end
+  end
+  
+  context 'To string' do
+    subject do
+      Markup.new('img', :src => '/foo/bar.png')
+    end
+    
+    should 'render' do
+      assert_equal "<img src='/foo/bar.png'/>", subject.to_s
+    end
+  end
+
+  context 'Wrapping some text' do
+    setup do
+      @text = 'Alice: It would be so nice if something made sense for a change.'
+      @markup = Markup.new('p')
+      @markup.params[:class] = 'quote'
+      @markup.params[:style] = 'padding:3px; border:1px solid red;'
+    end
+
+    should 'add the markup tag around the text' do
+      assert_equal "<p class='quote' style='padding:3px; border:1px solid red;'>#{@text}</p>", @markup.wrap(@text)
+    end
+
+    should 'add the appended params inside the tag' do
+      @markup.append_attribute("<%= anything %>")
+      assert_equal "<p class='quote' style='padding:3px; border:1px solid red;'<%= anything %>>#{@text}</p>", @markup.wrap(@text)
+    end
+
+    should 'not wrap twice if called twice' do
+      assert_equal "<p class='quote' style='padding:3px; border:1px solid red;'>#{@text}</p>", @markup.wrap(@markup.wrap(@text))
+    end
+
+    should 'display static params before dynamic and keep them ordered' do
+      @markup.set_dyn_params(:foo => '<%= @bar %>')
+      @markup.set_params(:baz => 'buzz')
+      assert_equal "<p class='quote' style='padding:3px; border:1px solid red;' baz='buzz' foo='<%= @bar %>'>foo</p>", @markup.wrap('foo')
+    end
+
+    should 'insert pre_wrap content' do
+      @markup.pre_wrap[:foo] = 'FOO'
+      assert_equal %q{<p class='quote' style='padding:3px; border:1px solid red;'>FOOcontent</p>}, @markup.wrap('content')
+    end
+  end
+
+  context 'Compiling params' do
+    setup do
+      @markup = Markup.new('p')
+      @markup.params = %q{class='one #{day}' id='foobar' name='#{day}'}
+    end
+
+    context 'with compile_params' do
+      setup do
+        @markup.compile_params(self)
+      end
+
+      should 'translate dynamic params into ERB by using RubyLess' do
+        assert_equal %q{<%= "one #{Time.now.strftime('%A')}" %>}, @markup.dyn_params[:class]
+      end
+
+      should 'translate without string on single dynamic content' do
+        assert_equal %q{<%= Time.now.strftime('%A') %>}, @markup.dyn_params[:name]
+      end
+    end
+  end
+
+  context 'Duplicating a markup' do
+    context 'and changing params' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.params[:class]  = 'one'
+        @duplicate = @markup.dup
+      end
+
+      should 'not propagate params changes to original' do
+        @duplicate.params[:class] = 'two'
+        assert_equal "<p class='one'>one</p>", @markup.wrap('one')
+      end
+
+      should 'not propagate params changes to duplicate' do
+        @markup.params[:class] = 'two'
+        assert_equal "<p class='one'>one</p>", @duplicate.wrap('one')
+      end
+
+      should 'not propagate appended params to duplicate' do
+        @markup.append_param(:class, 'drop')
+        assert_equal "<p class='one'>one</p>", @duplicate.wrap('one')
+      end
+
+      should 'not propagate dyn_params changes to original' do
+        @markup.append_dyn_param(:class, 'two')
+        assert_equal "<p class='one'>one</p>", @duplicate.wrap('one')
+      end
+
+      should 'not propagate dyn_params changes to duplicate' do
+        @duplicate.append_dyn_param(:class, 'two')
+        assert_equal "<p class='one'>one</p>", @markup.wrap('one')
+      end
+
+      should 'not propagate pre_wrap changes to duplicate' do
+        @markup.pre_wrap[:drop] = 'no bombs'
+        @duplicate = @markup.dup
+        @duplicate.pre_wrap[:drop] = 'ego'
+        assert_equal "<p class='one'>no bombs</p>", @markup.wrap('')
+      end
+    end
+
+    context 'and wrapping' do
+      setup do
+        @markup = Markup.new('p')
+        @duplicate = @markup.dup
+      end
+
+      should 'not propagate done to duplicate' do
+        @markup.wrap('')
+        assert_equal '<p>one</p>', @duplicate.wrap('one')
+      end
+    end
+  end # Duplicating a markup
+end
+
+
+
+

data/test/unit/zafu_node_context_test.rb

@@ -0,0 +1,375 @@
+require 'test_helper'
+
+module NCFoo
+end
+
+class NCPage < ActiveRecord::Base
+  include RubyLess
+  safe_context :root => Page
+end
+
+class SubPage < NCPage
+  include NCFoo
+end
+
+class SubSubPage < SubPage
+end
+
+class NCComment
+end
+
+class NodeContextTest < Test::Unit::TestCase
+
+  NodeContext = Zafu::NodeContext
+
+  context 'In a blank context' do
+    subject do
+      NodeContext.new('@node', NCPage)
+    end
+
+    should 'return the current name' do
+      assert_equal '@node', subject.name
+    end
+
+    should 'return the current class' do
+      assert_equal NCPage, subject.klass
+    end
+
+    should 'return true on will_be with the same class' do
+      assert subject.will_be?(NCPage)
+    end
+
+    should 'return false on will_be with a sub class' do
+      assert !subject.will_be?(SubPage)
+    end
+
+    should 'return false on will_be with a different class' do
+      assert !subject.will_be?(String)
+    end
+
+    should 'return self on a get for the same class' do
+      assert_equal subject.object_id, subject.get(NCPage).object_id
+    end
+
+    should 'return nil on a get for another class' do
+      assert_nil subject.get(NCComment)
+    end
+
+    context 'calling as_main' do
+      should 'build the name from the class' do
+        assert_equal '@nc_page', subject.as_main.name
+      end
+
+      should 'return same class' do
+        assert_equal subject.klass, subject.as_main.klass
+      end
+    end
+
+    context 'calling form_name' do
+      should 'return underscore name of base class' do
+        assert_equal 'nc_page', subject.form_name
+      end
+    end
+
+    context 'with a sub-class' do
+      subject do
+        NodeContext.new('@node', SubPage)
+      end
+
+      should 'return true on will_be with the same class' do
+        assert subject.will_be?(SubPage)
+      end
+
+      should 'return true on will_be with a super class' do
+        assert subject.will_be?(NCPage)
+      end
+
+      should 'return false on will_be with a different class' do
+        assert !subject.will_be?(String)
+      end
+
+      context 'calling form_name' do
+        should 'return underscore name of base class' do
+          assert_equal 'nc_page', subject.form_name
+        end
+      end
+
+      context 'calling as_main' do
+        should 'build the name from the class' do
+          assert_equal '@sub_page', subject.as_main.name
+        end
+
+        should 'return same class' do
+          assert_equal subject.klass, subject.as_main.klass
+        end
+
+        should 'return current class when using after_class argument' do
+          subject = NodeContext.new('@node', SubSubPage)
+          assert_equal SubSubPage, subject.as_main(NCPage).klass
+        end
+
+        should 'rebuild name from ancestor when using after_class argument' do
+          subject = NodeContext.new('@node', SubSubPage)
+          assert_equal '@sub_page', subject.as_main(NCPage).name
+        end
+
+        context 'in a list context' do
+          subject do
+            NodeContext.new('list', [SubSubPage])
+          end
+
+          should 'return current class when using after_class argument' do
+            assert_equal SubSubPage, subject.as_main(NCPage).klass
+          end
+
+          should 'rebuild name from ancestor when using after_class argument' do
+            assert_equal '@sub_page', subject.as_main(NCPage).name
+          end
+        end # in a list context
+
+      end
+
+      should 'return subclass on class_name' do
+        assert_equal 'SubPage', subject.class_name
+      end
+    end # with a sub-class
+
+    context 'with an anonymous sub-class' do
+      subject do
+        NodeContext.new('@node', Class.new(NCPage))
+      end
+
+      should 'return class on class_name' do
+        assert_equal 'NCPage', subject.class_name
+      end
+    end # with an anonymous sub-class
+  end
+
+  context 'In a sub-context' do
+    setup do
+      @parent  = NodeContext.new('@node', NCPage)
+    end
+
+    subject do
+      @parent.move_to('comment1', NCComment)
+    end
+
+    should 'return the current name' do
+      assert_equal 'comment1', subject.name
+    end
+
+    should 'return the current class' do
+      assert_equal NCComment, subject.klass
+    end
+
+    should 'return self on a get for the same class' do
+      assert_equal subject.object_id, subject.get(NCComment).object_id
+    end
+
+    should 'return the parent on a get for the class of the parent' do
+      assert_equal @parent.object_id, subject.get(NCPage).object_id
+    end
+  end
+
+  context 'In a deeply nested context' do
+    setup do
+      @grandgrandma = NodeContext.new('@comment', NCComment)
+      @grandma = @grandgrandma.move_to('page', NCPage)
+      @mother  = @grandma.move_to('comment1', NCComment)
+    end
+
+    subject do
+      @mother.move_to('var1', String)
+    end
+
+    should 'return the current name' do
+      assert_equal 'var1', subject.name
+    end
+
+    should 'return the current class' do
+      assert_equal String, subject.klass
+    end
+
+    should 'return the first ancestor matching class on get' do
+      assert_equal @mother.object_id, subject.get(NCComment).object_id
+    end
+
+    should 'return nil if no ancestor matches class on get' do
+      assert_nil subject.get(Fixnum)
+    end
+
+    should 'return the parent on up' do
+      assert_equal @mother, subject.up
+    end
+  end
+
+  context 'In a sub-classes context' do
+    subject do
+      NodeContext.new('super', SubPage)
+    end
+
+    should 'find the required class in ancestors' do
+      assert_equal subject.object_id, subject.get(NCPage).object_id
+    end
+  end
+
+  context 'In a list context' do
+    setup do
+      @grandma = NodeContext.new('@nc_page', SubPage)
+      @mother = @grandma.move_to('@comment', NCComment)
+    end
+
+    subject do
+      @mother.move_to('list', [NCPage])
+    end
+
+    should 'find the context and resolve without using first' do
+      assert context = subject.get(NCPage)
+      assert_equal '@nc_page', context.name
+      assert_equal SubPage, context.klass
+    end
+
+    should 'return parent on up with class' do
+      assert_equal @grandma, subject.up(NCPage)
+    end
+
+    should 'return true on will_be with the same class' do
+      assert subject.will_be?(NCPage)
+    end
+
+    should 'return class on master_class' do
+      assert_equal NCPage, subject.master_class(ActiveRecord::Base)
+    end
+  end
+
+  context 'In a deeply nested list context' do
+    setup do
+      @grandma = NodeContext.new('@nc_page', SubPage)
+      @mother = @grandma.move_to('@comment', NCComment)
+    end
+
+    subject do
+      @mother.move_to('list', [[[NCPage]]])
+    end
+
+    should 'find the context without using first' do
+      assert context = subject.get(NCPage)
+      assert_equal '@nc_page', context.name
+      assert_equal SubPage, context.klass
+    end
+
+    should 'return parent on up with class' do
+      assert_equal @grandma, subject.up(NCPage)
+    end
+
+    should 'return true on will_be with the same class' do
+      assert subject.will_be?(NCPage)
+    end
+
+    should 'return class on master_class' do
+      assert_equal NCPage, subject.master_class(ActiveRecord::Base)
+    end
+  end
+
+  context 'Generating a dom id' do
+    context 'in a blank context' do
+      subject do
+        n = NodeContext.new('@foo', NCPage)
+        n.dom_prefix = 'list1'
+        n
+      end
+
+      should 'return the node name in DOM id' do
+        assert_equal '<%= %Q{list1_#{@foo.zip}} %>', subject.dom_id
+      end
+
+      should 'not use zip on list false' do
+        assert_equal 'list1', subject.dom_id(:list => false)
+      end
+
+      should 'scope without erb on erb false' do
+        assert_equal 'list1_#{@foo.zip}', subject.dom_id(:erb => false)
+      end
+    end
+
+    context 'in a hierarchy of contexts' do
+      setup do
+        @a       = NodeContext.new('@node', NCPage)
+        @a.dom_prefix = 'a'
+        @b       = NodeContext.new('var1', [NCPage], @a)
+        @b.dom_prefix = 'b'
+        @c       = NodeContext.new('var2', NCPage, @b)
+      end
+
+      subject do
+        NodeContext.new('var3', NCPage, @c)
+      end
+
+      context 'with parents as dom_scopes' do
+        setup do
+          @b.propagate_dom_scope!
+          @c.propagate_dom_scope!
+        end
+
+        should 'use dom_scopes' do
+          assert_equal '<%= %Q{b_#{var1.zip}_#{var2.zip}_#{var3.zip}} %>', subject.dom_id
+        end
+
+        should 'use dom_scopes and dom_prefix not in list' do
+          subject.dom_prefix = 'd'
+          assert_equal '<%= %Q{b_#{var1.zip}_#{var2.zip}_d} %>', subject.dom_id(:list => false)
+        end
+        
+        context 'with a saved dom_id' do
+          setup do
+            @c.saved_dom_id = '#{ndom_id(@foo)}'
+          end
+          
+          should 'use saved id in scope' do
+            assert_equal '<%= %Q{#{ndom_id(@foo)}_#{var3.zip}} %>', subject.dom_id
+          end
+        end
+      end
+      
+      context 'with a saved dom_id' do
+        setup do
+          @c.saved_dom_id = '#{ndom_id(@foo)}'
+        end
+        
+        should 'not use saved id in scope' do
+          # We did not ask for dom_scope to propagate.
+          assert_equal '<%= %Q{b_#{var3.zip}} %>', subject.dom_id
+        end
+      end
+
+      context 'with ancestors and self as dom_scopes' do
+        setup do
+          @a.propagate_dom_scope!
+          subject.propagate_dom_scope!
+        end
+
+        should 'not use self twice' do
+          assert_equal '<%= %Q{a_#{@node.zip}_#{var3.zip}} %>', subject.dom_id
+        end
+      end
+
+      context 'with a parent defining a dom_prefix' do
+        setup do
+          @b.dom_prefix = 'cart'
+        end
+
+        should 'use dom_prefix' do
+          subject.dom_prefix = nil
+          assert_equal '<%= %Q{cart_#{var3.zip}} %>', subject.dom_id
+        end
+      end
+
+    end
+  end
+end
+
+
+
+
+
+