zafu 0.5.0 → 0.6.0

data/test/mock/classes.rb

@@ -0,0 +1,24 @@
+module Foo
+end
+
+unless defined?(ActiveRecord)
+  module ActiveRecord
+    class Base
+    end
+  end
+end
+
+class Page < ActiveRecord::Base
+  include RubyLess
+  safe_context :root => Page
+end
+
+class SubPage < Page
+  include Foo
+end
+
+class SubSubPage < SubPage
+end
+
+class Comment
+end

data/test/mock/core_ext.rb

@@ -0,0 +1,9 @@
+class String
+  alias blank? empty?
+end
+
+class NilClass
+  def blank?
+    true
+  end
+end

data/test/mock/params.rb

@@ -1,19 +1,13 @@
 module Mock
   module Params
     def self.included(base)
-      base.before_process :filter_params
+      base.before_process :filter_post_string
     end
 
-    def filter_params
-      if klass = @params.delete(:class)
-        if klass =~ /#\{/
-          res = RubyLess.translate("\"#{klass}\"", self)
-          @markup.append_dyn_param(:class, "<%= #{res} %>")
-        else
-          @markup.append_param(:class, klass)
-        end
+    def filter_post_string
+      if str = @params.delete(:post_string)
+        out_post str
       end
-      true
     end
   end
 end

data/test/mock/process.rb

@@ -0,0 +1,7 @@
+module Mock
+  module Process
+    def r_link
+      out "<%= make_link(#{node}) %>"
+    end
+  end
+end

data/test/mock/test_compiler.rb

@@ -0,0 +1,9 @@
+require 'mock/params'
+require 'mock/process'
+require 'mock/classes'
+
+TestCompiler = Zafu.parser_with_rules(
+  Zafu::All,
+  Mock::Params,
+  Mock::Process
+)

data/test/node_context_test.rb

@@ -1,83 +1,145 @@
 require 'test_helper'
 
+class String
+  def underscore
+    gsub(/(^|.)([A-Z])/) {$1 == '' ? $2.downcase : "#{$1}_#{$2.downcase}"}
+  end
+end
+
 class NodeContextTest < Test::Unit::TestCase
-  class Page;end
-  class SubPage < Page; end
-  class Comment;end
   NodeContext = Zafu::NodeContext
 
   context 'In a blank context' do
-    setup do
-      @context = NodeContext.new('@node', Page)
+    subject do
+      NodeContext.new('@node', Page)
     end
 
     should 'return the current name' do
-      assert_equal '@node', @context.name
+      assert_equal '@node', subject.name
     end
 
     should 'return the current class' do
-      assert_equal Page, @context.klass
+      assert_equal Page, subject.klass
     end
-    
+
     should 'return true on will_be with the same class' do
-      assert @context.will_be?(Page)
+      assert subject.will_be?(Page)
     end
-    
+
     should 'return false on will_be with a sub class' do
-      assert !@context.will_be?(SubPage)
+      assert !subject.will_be?(SubPage)
     end
-    
+
     should 'return false on will_be with a different class' do
-      assert !@context.will_be?(String)
+      assert !subject.will_be?(String)
     end
 
     should 'return self on a get for the same class' do
-      assert_equal @context.object_id, @context.get(Page).object_id
+      assert_equal subject.object_id, subject.get(Page).object_id
     end
 
     should 'return nil on a get for another class' do
-      assert_nil @context.get(Comment)
+      assert_nil subject.get(Comment)
+    end
+
+    context 'calling as_main' do
+      should 'build the name from the class' do
+        assert_equal '@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 'page', subject.form_name
+      end
     end
-    
+
     context 'with a sub-class' do
-      setup do
-        @context = NodeContext.new('@node', SubPage)
+      subject do
+        NodeContext.new('@node', SubPage)
       end
-      
+
       should 'return true on will_be with the same class' do
-        assert @context.will_be?(SubPage)
+        assert subject.will_be?(SubPage)
       end
 
       should 'return true on will_be with a super class' do
-        assert @context.will_be?(Page)
+        assert subject.will_be?(Page)
       end
 
       should 'return false on will_be with a different class' do
-        assert !@context.will_be?(String)
+        assert !subject.will_be?(String)
       end
-    end
+
+      context 'calling form_name' do
+        should 'return underscore name of base class' do
+          assert_equal '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 an ancestor when using after_class argument' do
+          subject = NodeContext.new('@node', SubSubPage)
+          assert_equal SubPage, subject.as_main(Page).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(Page).name
+        end
+      end
+
+      should 'return subclass on class_name' do
+        assert_equal 'SubPage', subject.class_name
+      end
+    end # with a sub-class
+
+    context 'with an anonymoys sub-class' do
+      subject do
+        NodeContext.new('@node', Class.new(Page))
+      end
+
+      should 'return class on class_name' do
+        assert_equal 'Page', subject.class_name
+      end
+    end # with an anonymoys sub-class
   end
 
   context 'In a sub-context' do
     setup do
       @parent  = NodeContext.new('@node', Page)
-      @context = @parent.move_to('comment1', Comment)
+    end
+
+    subject do
+      @parent.move_to('comment1', Comment)
     end
 
     should 'return the current name' do
-      assert_equal 'comment1', @context.name
+      assert_equal 'comment1', subject.name
     end
 
     should 'return the current class' do
-      assert_equal Comment, @context.klass
+      assert_equal Comment, subject.klass
     end
 
     should 'return self on a get for the same class' do
-      assert_equal @context.object_id, @context.get(Comment).object_id
+      assert_equal subject.object_id, subject.get(Comment).object_id
     end
 
     should 'return the parent on a get for the class of the parent' do
-      assert_equal @parent.object_id, @context.get(Page).object_id
+      assert_equal @parent.object_id, subject.get(Page).object_id
     end
   end
 
@@ -86,56 +148,80 @@ class NodeContextTest < Test::Unit::TestCase
       @grandgrandma = NodeContext.new('@comment', Comment)
       @grandma = @grandgrandma.move_to('page', Page)
       @mother  = @grandma.move_to('comment1', Comment)
-      @context = @mother.move_to('var1', String)
+    end
+
+    subject do
+      @mother.move_to('var1', String)
     end
 
     should 'return the current name' do
-      assert_equal 'var1', @context.name
+      assert_equal 'var1', subject.name
     end
 
     should 'return the current class' do
-      assert_equal String, @context.klass
+      assert_equal String, subject.klass
     end
 
     should 'return the first ancestor matching class on get' do
-      assert_equal @mother.object_id, @context.get(Comment).object_id
+      assert_equal @mother.object_id, subject.get(Comment).object_id
     end
 
     should 'return nil if no ancestor matches class on get' do
-      assert_nil @context.get(Fixnum)
+      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
-    setup do
-      @context = NodeContext.new('super', SubPage)
+    subject do
+      NodeContext.new('super', SubPage)
     end
 
     should 'find the current context required class is an ancestor' do
-      assert_equal @context.object_id, @context.get(Page).object_id
+      assert_equal subject.object_id, subject.get(Page).object_id
     end
   end
 
   context 'In a list context' do
     setup do
-      @context = NodeContext.new('list', [Page])
+      @grandma = NodeContext.new('@page', Page)
+      @mother = @grandma.move_to('@comment', Comment)
+    end
+
+    subject do
+      @mother.move_to('list', [Page])
     end
 
     should 'find the context and resolve with first' do
-      assert context = @context.get(Page)
+      assert context = subject.get(Page)
       assert_equal 'list.first', context.name
       assert_equal Page, context.klass
     end
+
+    should 'return parent on up with class' do
+      assert_equal @grandma, subject.up(Page)
+    end
+
+    should 'return true on will_be with the same class' do
+      assert subject.will_be?(Page)
+    end
+
+    should 'return class on master_class' do
+      assert_equal Page, subject.master_class(ActiveRecord::Base)
+    end
   end
 
   context 'Generating a dom id' do
     context 'in a blank context' do
-      setup do
-        @context = NodeContext.new('@foo', Page)
+      subject do
+        NodeContext.new('@foo', Page)
       end
 
       should 'return the node name in DOM id' do
-        assert_equal '<%= @foo.zip %>', @context.dom_id
+        assert_equal '<%= @foo.zip %>', subject.dom_id
       end
     end
 
@@ -144,7 +230,10 @@ class NodeContextTest < Test::Unit::TestCase
         @a       = NodeContext.new('@node', Page)
         @b       = NodeContext.new('var1', [Page], @a)
         @c       = NodeContext.new('var2', Page, @b)
-        @context = NodeContext.new('var3', Page, @c)
+      end
+
+      subject do
+        NodeContext.new('var3', Page, @c)
       end
 
       context 'with parents as dom_scopes' do
@@ -154,18 +243,18 @@ class NodeContextTest < Test::Unit::TestCase
         end
 
         should 'use dom_scopes' do
-          assert_equal '<%= var1.zip %>_<%= var2.zip %>_<%= var3.zip %>', @context.dom_id
+          assert_equal '<%= var1.zip %>_<%= var2.zip %>_<%= var3.zip %>', subject.dom_id
         end
       end
 
       context 'with ancestors and self as dom_scopes' do
         setup do
           @a.dom_scope!
-          @context.dom_scope!
+          subject.dom_scope!
         end
 
         should 'not use self twice' do
-          assert_equal '<%= @node.zip %>_<%= var3.zip %>', @context.dom_id
+          assert_equal '<%= @node.zip %>_<%= var3.zip %>', subject.dom_id
         end
       end
 
@@ -175,7 +264,7 @@ class NodeContextTest < Test::Unit::TestCase
         end
 
         should 'use dom_prefix' do
-          assert_equal 'cart_<%= var3.zip %>', @context.dom_id
+          assert_equal 'cart_<%= var3.zip %>', subject.dom_id
         end
       end
 

data/test/ordered_hash_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class OrderedHashTest < Test::Unit::TestCase
+
+  context 'An OrderedHash' do
+    setup do
+      @hash = Zafu::OrderedHash.new
+      @hash[:a] = 1
+      @hash[:c] = 2
+      @hash[:b] = 3
+    end
+
+    should 'keep keys in insertion order' do
+      assert_equal [:a, :c, :b], @hash.keys
+    end
+
+    should 'list each in insertion order' do
+      res = []
+      @hash.each do |k, v|
+        res << v
+      end
+      assert_equal [1, 2, 3], res
+    end
+
+    should 'remove entry on delete' do
+      @hash.delete(:c)
+      assert_equal [:a, :b], @hash.keys
+    end
+    
+    context 'running through keys' do
+      should 'allow key alteration' do
+        @hash.keys.each do |k|
+          assert k != :d
+          @hash[:d] = 'x'
+        end
+      end
+    end
+    
+    context 'running each' do
+      should 'allow key alteration' do
+        @hash.each do |k, v|
+          assert k != :d
+          @hash[:d] = 'x'
+        end
+      end
+    end
+
+    context 'with a duplicate' do
+      setup do
+        @dup = @hash.dup
+      end
+
+      should 'not alter duplicate on set' do
+        @hash[:d] = 4
+        assert_equal [:a, :c, :b], @dup.keys
+      end
+
+      should 'not alter duplicate on change' do
+        @hash[:a] = 10
+        assert_equal 1, @dup[:a]
+      end
+
+      should 'not alter duplicate on delete' do
+        @hash.delete(:a)
+        assert_equal [:a, :c, :b], @dup.keys
+      end
+    end
+  end
+end