PageTemplate 2.0.0 → 2.1.0

data/test.rb

@@ -23,8 +23,8 @@
 
 require 'test/unit' unless defined? $ZENTEST and $ZENTEST
 
-require 'PageTemplate/commands.rb'
 require 'PageTemplate/parser.rb'
+require 'PageTemplate/commands.rb'
 require 'PageTemplate/case.rb'
 
 module TestPageTemplate
@@ -68,11 +68,11 @@ module TestPageTemplate
 
   class TestCaseCommand < Test::Unit::TestCase
     def setup
-      @@cc = PageTemplate::CaseCommand.new('case foo')
+      @@cc = PageTemplate::CaseCommand.new('foo')
     end
 
     def test_initialize
-      assert(PageTemplate::CaseCommand.new('case foo'))
+      assert(PageTemplate::CaseCommand.new('foo'))
     end
 
     def test_add
@@ -82,24 +82,24 @@ module TestPageTemplate
     def test_current_case
       # Shouldn't I be failing? I don't see an accessor for CaseCommand.current_case
       assert_equal(nil, @@cc.current_case)
-      @@cc.modifies?("when 1")
+      @@cc.when("1")
       assert_equal("1", @@cc.current_case)
     end
 
     def test_modifies_eh
-      assert(@@cc.modifies?("when 1"))
-      assert(@@cc.modifies?("else"))
-      assert_equal(false, @@cc.modifies?("unless"))
+      assert(@@cc.when("1"))
+      assert(@@cc.else)
     end
 
     def test_output
+      p = PageTemplate::Parser.new
       c_1 = PageTemplate::TextCommand.new("I am 1")
       c_2 = PageTemplate::TextCommand.new("I am 2")
       c_3 = PageTemplate::TextCommand.new("I don't know what I am")
       @@cc.add(c_3)
-      @@cc.modifies?("when 1")
+      @@cc.when("1")
       @@cc.add(c_1)
-      @@cc.modifies?("when 2")
+      @@cc.when("2")
       @@cc.add(c_2)
       ns = PageTemplate::Namespace.new()
       ns["foo"] = nil
@@ -161,14 +161,18 @@ module TestPageTemplate
 
   class TestFileSource < Test::Unit::TestCase
     def setup
-      @p   = PageTemplate::Parser.new()
-      @@fs = PageTemplate::FileSource.new(@p.args)
+      @@args = {}
+      @@fs = PageTemplate::FileSource.new(@@args)
+      @@filename = 'tdata/dummy.txt'
+      @@location = File.join(Dir.getwd, @@filename)
+      @@text = IO.read(@@location)
     end
 
     def test_get
-      filename = 'tdata/dummy.txt'
-      location = File.join(Dir.getwd, filename)
-      assert_equal(IO.read(location), @@fs.get(filename))
+      assert_equal(@@text, @@fs.get(@@filename),
+        "Dir.getwd is a path by default")
+      assert_equal(@@text, @@fs.get(@@location),
+        "Full path is allowed by default")
     end
 
     def test_get_filename
@@ -178,22 +182,48 @@ module TestPageTemplate
     end
 
     def test_paths
-      assert_equal([Dir.getwd], @@fs.paths)
+      assert_equal([Dir.getwd,'/'], @@fs.paths)
+    end
+
+    def test_include_path
+      fs = PageTemplate::FileSource.new(
+          'include_path'=>File.join(Dir.getwd,'tdata')
+        )
+      assert_equal([File.join(Dir.getwd,'tdata')],fs.paths,
+        "Explicit set include_path should only include the one element")
+      assert_equal(@@text,fs.get('dummy.txt'),
+        "Just a filename of something in an include path works")
+    end
+    def test_include_paths
+      location = File.dirname(@@location)
+      ptlocation = File.join(Dir.getwd,'lib')
+      pt = IO.read(File.join(ptlocation,'PageTemplate.rb'))
+      fs = PageTemplate::FileSource.new(
+          'include_paths'=>[location,ptlocation]
+        )
+      assert_equal([location,ptlocation],fs.paths,
+        "Explicit set include_paths should include all set elements")
+      assert_equal(@@text,fs.get('dummy.txt'),
+        "Just a filename of something in an include path works")
+      assert_equal(pt,fs.get('PageTemplate.rb'),
+        "Just a filename of something in an include path works")
     end
   end
 
   class TestIfCommand < Test::Unit::TestCase
     def setup
-      @@if     = PageTemplate::IfCommand.new("if flag")
-      @@unless = PageTemplate::IfCommand.new("unless flag")
+      parser = PageTemplate::Parser.new()
+      @@if     = PageTemplate::IfCommand.new("if", "flag")
+      @@unless = PageTemplate::IfCommand.new("unless", "flag")
     end
 
     def test_initialize
+      parser = PageTemplate::Parser.new
       good_1 = "if flag"
       good_2 = "unless flag"
       bad_1  = "heck no"
-      assert(PageTemplate::IfCommand.new(good_1))
-      assert(PageTemplate::IfCommand.new(good_2))
+      assert(PageTemplate::IfCommand.new("if", "flag"))
+      assert(PageTemplate::IfCommand.new("unless", "flag"))
       assert_raises(ArgumentError,
         "IfCommand will not initialize without a command declaring 'if/unless'") {
           PageTemplate::IfCommand.new(bad_1)
@@ -208,32 +238,30 @@ module TestPageTemplate
         "IfCommand#add adds a command to the block to be executed when false")
     end
 
-    def test_closes_eh
-      closers = [
-        [ "endif",        0, nil ],
-        [ "/if",          0, nil ],
-        [ "end if",       0, nil ],
-        [ "/ if",         0, nil ],
-        [ "endunless",  nil,   0 ],
-        [ "/unless",    nil,   0 ],
-        [ "end unless", nil,   0 ],
-        [ "/ unless",   nil,   0 ]
-      ]
-
-      closers.each do |x|
-        assert_equal(x[1], @@if.closes?(x[0]))
-        assert_equal(x[2], @@unless.closes?(x[0]))
-      end
-
+    def test_else
+      assert(@@if.else)
+      assert(@@unless.else)
     end
 
-    def test_modifies_eh
-      assert_equal(false, @@if.modifies?("otherwise"))
-      assert(@@if.modifies?("else"))
-      assert_raises(ArgumentError) { @@if.modifies?("else") }
-      assert_equal(false, @@unless.modifies?("otherwise"))
-      assert(@@unless.modifies?("else"))
-      assert_raises(ArgumentError) { @@unless.modifies?("else") }
+    def test_elsif
+      ns = PageTemplate::Namespace.new
+      parser = PageTemplate::Parser.new
+      tester = PageTemplate::IfCommand.new('if','redflag')
+      tester.add(PageTemplate::TextCommand.new('Red Flag'))
+      tester.elsif('blueflag')
+      tester.add(PageTemplate::TextCommand.new('Blue Flag'))
+      tester.elsif('greenflag')
+      tester.add(PageTemplate::TextCommand.new('Green Flag'))
+      tester.else
+      tester.add(PageTemplate::TextCommand.new('No Flag'))
+
+      assert_equal('No Flag',tester.output(ns))
+      ns['greenflag'] = true
+      assert_equal('Green Flag',tester.output(ns))
+      ns['blueflag'] = true
+      assert_equal('Blue Flag',tester.output(ns))
+      ns['redflag'] = true
+      assert_equal('Red Flag',tester.output(ns))
     end
 
     def test_output
@@ -248,8 +276,8 @@ module TestPageTemplate
       ns["flag"] = false
       assert_equal("", @@if.output(ns))
       assert_equal("dude!", @@unless.output(ns))
-      @@if.modifies?("else")
-      @@unless.modifies?("else")
+      @@if.else
+      @@unless.else
       c2 = PageTemplate::TextCommand.new("sweet!")
       @@if.add(c2)
       @@unless.add(c2)
@@ -260,35 +288,36 @@ module TestPageTemplate
       assert_equal("sweet!", @@if.output(ns))
       assert_equal("dude!", @@unless.output(ns))
     end
+    def test_empty_false
+      parser = PageTemplate::Parser.new('empty_is_true' => false)
+      template = parser.parse('[%if foo%]Foo[%else%]Bar[%end%]')
+      template['foo'] = []
+      assert_equal(template.output,'Bar')
+      parser.args['empty_is_true'] = true
+      assert_equal(template.output,'Foo')
+    end
   end
 
   class TestIncludeCommand < Test::Unit::TestCase
     def test_output
-      p = PageTemplate::Parser.new()
-      p['dummy'] = '/tdata/dummy.txt'
-      i = PageTemplate::IncludeCommand.new('include dummy', p)
-      p.load('tdata/dummy.txt')
-      assert_equal(p.output, i.output(p.namespace))
+      parser = PageTemplate::Parser.new()
+      parser['dummy'] = '/tdata/dummy.txt'
+      i = PageTemplate::IncludeCommand.new('dummy')
+      parser.load('tdata/dummy.txt')
+      assert_equal(parser.output, i.output(parser))
     end
   end
 
   class TestLoopCommand < Test::Unit::TestCase
     def setup
-      @@in = PageTemplate::LoopCommand.new("in list")
-      @@loop = PageTemplate::LoopCommand.new("loop list")
+      @@in = PageTemplate::LoopCommand.new("in", "list", "")
+      @@loop = PageTemplate::LoopCommand.new("loop", "list", "")
     end
 
     def test_initialize
-      good_1 = "in list"
-      assert(PageTemplate::LoopCommand.new(good_1))
-      good_2 = "in loop"
-      assert(PageTemplate::LoopCommand.new(good_2))
-      good_3 = "in list: item"
-      assert(PageTemplate::LoopCommand.new(good_3))
-      bad_1 = "bad list"
-      assert_raises(ArgumentError) { PageTemplate::LoopCommand.new(bad_1) }
-      bad_2 = "loop"
-      assert_raises(ArgumentError) { PageTemplate::LoopCommand.new(bad_2) }
+      assert(PageTemplate::LoopCommand.new("in", "list", ""))
+      assert(PageTemplate::LoopCommand.new("in", "loop", ""))
+      assert(PageTemplate::LoopCommand.new("in", "list", "item"))
     end
 
     def test_add
@@ -297,39 +326,19 @@ module TestPageTemplate
         "LoopCommand#add adds a command to the block to be executed in the loop")
     end
 
-    def test_closes_eh
-      closers = [
-        [ "endin",      0, nil],
-        [ "/in",        0, nil],
-        [ "end in",     0, nil],
-        [ "/ in",       0, nil],
-        [ "endloop",  nil,   0],
-        [ "/loop",    nil,   0],
-        [ "end loop", nil,   0],
-        [ "/ loop",   nil,   0]
-      ]
-
-      closers.each do |x|
-        assert_equal(x[1], @@in.closes?(x[0]),
-          "#{x[0]} on 'in' is expected to be #{x[1]}")
-        assert_equal(x[2], @@loop.closes?(x[0]),
-          "#{x[0]} on 'loop' is expected to be #{x[2]}")
-      end
-    end
-
-    def test_modifies_eh
-      assert_equal(false, @@loop.modifies?("otherwise"))
-      assert(@@loop.modifies?("else"))
-      assert_raises(ArgumentError) { @@loop.modifies?("else") }
+    def test_else
+      assert(@@loop.else)
     end
 
     def test_output
+      parser = PageTemplate::Parser.new()
       ns = PageTemplate::Namespace.new()
+      ns.parent = parser
       ns["list"] = [1, 2, 3]
 
       # Simple TextCommands in a Loop
       c = PageTemplate::TextCommand.new("Dude!")
-      loop_1 = PageTemplate::LoopCommand.new("loop list")
+      loop_1 = PageTemplate::LoopCommand.new("loop", "list", "")
       loop_1.add(c)
       assert_equal("Dude!Dude!Dude!", loop_1.output(ns))
       c_1 = PageTemplate::TextCommand.new("Sweet!")
@@ -341,9 +350,9 @@ module TestPageTemplate
       # Simple TextCommands in a Loop with an Else block
       c_1 = PageTemplate::TextCommand.new("Sweet!")
       c_2 = PageTemplate::TextCommand.new("Dude?")
-      loop_2 = PageTemplate::LoopCommand.new("loop list")
+      loop_2 = PageTemplate::LoopCommand.new("loop", "list", "")
       loop_2.add(c_1)
-      loop_2.modifies?("else")
+      loop_2.else
       loop_2.add(c_2)
       ns["list"] = nil
       assert_equal("Dude?", loop_2.output(ns))
@@ -355,15 +364,15 @@ module TestPageTemplate
       c_2 = PageTemplate::TextCommand.new("I know kung fu.")
       c_3 = PageTemplate::TextCommand.new("Prove it.")
       c_4 = PageTemplate::TextCommand.new("Last Post!")
-      if_1 = PageTemplate::IfCommand.new("if __FIRST__")
+      if_1 = PageTemplate::IfCommand.new("if", "__FIRST__")
       if_1.add(c_1)
-      if_2 = PageTemplate::IfCommand.new("if __ODD__")
+      if_2 = PageTemplate::IfCommand.new("if", "__ODD__")
       if_2.add(c_2)
-      if_2.modifies?("else")
+      if_2.else
       if_2.add(c_3)
-      if_3 = PageTemplate::IfCommand.new("if __LAST__")
+      if_3 = PageTemplate::IfCommand.new("if", "__LAST__")
       if_3.add(c_4)
-      loop_1 = PageTemplate::LoopCommand.new("in cliches")
+      loop_1 = PageTemplate::LoopCommand.new("in", "cliches", "")
       loop_1.add(if_1)
       loop_1.add(if_2)
       loop_1.add(if_3)
@@ -372,14 +381,26 @@ module TestPageTemplate
       assert_equal(expected, loop_1.output(ns))
 
       # A Loop with a named iterator over the items in its list
-      loop_1 = PageTemplate::LoopCommand.new("in list: item")
-      c_1 = PageTemplate::ValueCommand.new("item", PageTemplate::Parser.new())
+      loop_1 = PageTemplate::LoopCommand.new("in", "list", "item")
+      c_1 = PageTemplate::ValueCommand.new("item", nil)
       c_2 = PageTemplate::TextCommand.new(" ")
       loop_1.add(c_1)
       loop_1.add(c_2)
       ns["list"] = [0, -1, 2, -3, 4]
       expected = ns["list"].join(" ") + " "
       assert_equal(expected, loop_1.output(ns))
+
+      # A loop with multiple iterators
+      loop_1 = PageTemplate::LoopCommand.new("in", "names", "key val")
+      c1 = PageTemplate::ValueCommand.new("key",nil)
+      c2 = PageTemplate::ValueCommand.new("val",nil)
+      tc = PageTemplate::TextCommand.new(": ")
+      loop_1.add c1
+      loop_1.add tc
+      loop_1.add c2
+      ns["names"] = { 'Brian' => 'Wisti', 'Greg' => 'Millam' }
+      out = ns["names"].map { |fn,ln| "#{fn}: #{ln}" }.join('')
+      assert_equal(out,loop_1.output(ns))
     end
   end
 
@@ -411,6 +432,17 @@ module TestPageTemplate
       @@ns.object = -5
       assert_equal(5, @@ns.get("abs"),
         "Namespace#get will send get requests to a contained object if it is available")
+
+      assert_equal(3,@@ns.get("succ.succ.abs"),
+        "Namespace#get will send get requests subsequently to accessors if available")
+
+      @@ns.set("list", ['one','two','three'])
+      assert_equal('two',@@ns.get('list.1'),
+        "If an accessor looks like an integer, it's an array index")
+
+      @@ns.set('fruits',{'a'=>'apple','b'=>'banana'})
+      assert_equal('banana',@@ns.get('fruits.b'),
+        "If an object has_key?(b), it checks get object['b'] rather than send(:b)")
     end
 
     def test_index
@@ -540,29 +572,38 @@ module TestPageTemplate
   end
 
   class TestSyntaxGlossary < Test::Unit::TestCase
+    # Test modifications by gmillam
     def setup
-      @@g = PageTemplate::SyntaxGlossary.new(
-        /<(.+?)>/,
-
-        /^--/i => PageTemplate::CommentCommand
-      )
+      @@g = Class.new(PageTemplate::SyntaxGlossary)
+      @@g.directive = /<(.+?)>/
+      @@g.define(/^--(.*)/) { |match|
+        PageTemplate::CommentCommand.new(match[1])
+      }
+      @@g.default { |command|
+        PageTemplate::UnknownCommand.new(command)
+      }
     end
 
     def test_define
-      assert_equal(PageTemplate::UnknownCommand, @@g.lookup("foo"))
+      # lookup() now returns instances, not classes
+      # assert_equal(PageTemplate::UnknownCommand, @@g.lookup("foo"))
+      assert_raises(ArgumentError,
+        "SyntaxGlossary#define requires a Regexp for its argument") {
+          @@g.define("foo") {}
+      }
       assert_raises(ArgumentError,
-        "SyntaxGlossary#define requires a Regexp for its first arg") {
-          @@g.define("foo", PageTemplate::CommentCommand)
+        "SyntaxGlossary#define requires a block to be passed") {
+        @@g.define("foo")
       }
-      assert(@@g.define(/^foo/, PageTemplate::CommentCommand),
+      assert(@@g.define(/^foo/) {|m,p|},
         "Use SyntaxGlossary#define to add or change SyntaxGlossary entries")
     end
 
     def test_define_global_var
-      assert_equal(PageTemplate::UnknownCommand, @@g.lookup("d"))
+      assert_equal(true, @@g.lookup("d").is_a?(PageTemplate::UnknownCommand))
       assert(@@g.define_global_var(/d/),
         "Use SyntaxGlossary#define_global_var to create explicit ValueCommands")
-      assert_equal(PageTemplate::ValueCommand, @@g.lookup("d"))
+      assert_equal(true, @@g.lookup("d").is_a?(PageTemplate::ValueCommand))
     end
 
     def test_directive
@@ -574,11 +615,12 @@ module TestPageTemplate
       directive = /\[.+?\]/
       assert(@@g.directive = directive)
       assert_equal(directive, @@g.directive)
+      @@g.directive = /<(.+?)>/
     end
 
     def test_lookup
-      assert_equal(PageTemplate::CommentCommand, @@g.lookup("--"))
-      assert_equal(PageTemplate::UnknownCommand, @@g.lookup("++"))
+      assert_equal(true, @@g.lookup("--").is_a?(PageTemplate::CommentCommand))
+      assert_equal(true, @@g.lookup("++").is_a?(PageTemplate::UnknownCommand))
     end
   end
 
@@ -593,7 +635,7 @@ module TestPageTemplate
   class TestUnknownCommand < Test::Unit::TestCase
     def test_output
       parser = PageTemplate::Parser.new()
-      uc = PageTemplate::UnknownCommand.new("waffle olive mango", parser)
+      uc = PageTemplate::UnknownCommand.new("waffle olive mango")
       assert_equal("[ Unknown Command: waffle olive mango ]", uc.output(parser.namespace))
     end
   end
@@ -602,15 +644,35 @@ module TestPageTemplate
     def test_output
       p = PageTemplate::Parser.new()
       p['x'] = 'y'
-      v = PageTemplate::ValueCommand.new('var x', p)
+      v = PageTemplate::ValueCommand.new('x',nil)
       assert_equal('y', v.output())
       assert_equal('y', v.output(p.namespace))
       p['x'] = 1
-      v = PageTemplate::ValueCommand.new('var x.succ.foo', p)
-      w = PageTemplate::ValueCommand.new('var x.succ.succ.succ', p)
+      v = PageTemplate::ValueCommand.new('x.succ.foo', nil)
+      w = PageTemplate::ValueCommand.new('x.succ.succ.succ', nil)
       assert_equal('4',w.output(p.namespace))
       assert_equal('',v.output(p.namespace))
     end
+    def test_raise_on_error
+      p = PageTemplate::Parser.new
+      template = p.parse("[% var foo.bar %]")
+      foo = "hello"
+      def foo.bar
+        asdf # method unknown error
+      end
+      template["foo"] = foo
+      assert_equal(
+        template.output,
+        "[ Error: undefined local variable or method `asdf' for \"hello\":String ]",
+        "With raise_on_error not set, we get error strings")
+      p.args['raise_on_error'] = true
+      assert_raises(NameError,
+        "With raise on error set, user has to catch errors") {
+        template.output
+      }
+    rescue Exception => er
+      puts "error: #{er.class}"
+    end
   end
 end