PageTemplate 1.2.0 → 2.0.0

data/tdata/dummy.txt

@@ -0,0 +1,2 @@
+I am a simple text file for testing FileSource#get_filename.
+

data/test.rb

@@ -0,0 +1,616 @@
+# Code Generated by ZenTest v. 2.3.0
+# Couldn't find class for name User
+#                 classname: asrt / meth =  ratio%
+# PageTemplate::DefaultPreprocessor:    0 /    5 =   0.00%
+#   PageTemplate::Namespace:    0 /    5 =   0.00%
+# PageTemplate::CaseCommand:    0 /    6 =   0.00%
+# PageTemplate::LoopCommand:    0 /    6 =   0.00%
+#              PageTemplate:    0 /    1 =   0.00%
+# PageTemplate::TextCommand:    0 /    3 =   0.00%
+# PageTemplate::UnknownCommand:    0 /    3 =   0.00%
+# PageTemplate::CommentCommand:    0 /    3 =   0.00%
+#  PageTemplate::FileSource:    0 /    5 =   0.00%
+# PageTemplate::MiniValueCommand:    0 /    1 =   0.00%
+#                      User:    0 /    1 =   0.00%
+# PageTemplate::IncludeCommand:    0 /    3 =   0.00%
+#   PageTemplate::IfCommand:    0 /    6 =   0.00%
+#     PageTemplate::Command:    0 /    2 =   0.00%
+# PageTemplate::ValueCommand:    0 /    3 =   0.00%
+# PageTemplate::BlockCommand:    0 /    7 =   0.00%
+# PageTemplate::StackableCommand:    0 /    3 =   0.00%
+#      PageTemplate::Parser:    0 /    9 =   0.00%
+# PageTemplate::SyntaxGlossary:    0 /    4 =   0.00%
+
+require 'test/unit' unless defined? $ZENTEST and $ZENTEST
+
+require 'PageTemplate/commands.rb'
+require 'PageTemplate/parser.rb'
+require 'PageTemplate/case.rb'
+
+module TestPageTemplate
+  class TestBlockCommand < Test::Unit::TestCase
+    def setup
+      @@bc = PageTemplate::BlockCommand.new()
+    end
+
+    def test_add
+      c = PageTemplate::CommentCommand.new('foo')
+      assert(@@bc.add(c),
+        "Use BlockCommand#add to add a new Command to the Block")
+      assert_raises(TypeError,
+        "BlockCommand#add only accepts Commands") {
+          @@bc.add(23)
+      }
+    end
+
+    def test_length
+      assert_equal(0, @@bc.length,
+        "Use BlockCommand#length to find out how many commands are "\
+        "in the Block")
+      c = PageTemplate::CommentCommand.new('foo')
+      @@bc.add(c)
+      assert_equal(1, @@bc.length,
+        "BlockCommand#length reflects new Commands that have been " \
+        "added")
+    end
+
+    def test_output
+      c_1 = PageTemplate::TextCommand.new("Dude! What's mine say?\n")
+      c_2 = PageTemplate::TextCommand.new("Sweet! What's mine say?\n")
+      c_3 = PageTemplate::TextCommand.new("That never gets old.\n")
+      @@bc.add(c_1)
+      @@bc.add(c_2)
+      @@bc.add(c_3)
+      expected = c_1.output + c_2.output + c_3.output
+      assert_equal(expected, @@bc.output)
+    end
+  end
+
+  class TestCaseCommand < Test::Unit::TestCase
+    def setup
+      @@cc = PageTemplate::CaseCommand.new('case foo')
+    end
+
+    def test_initialize
+      assert(PageTemplate::CaseCommand.new('case foo'))
+    end
+
+    def test_add
+      assert(@@cc.add(PageTemplate::TextCommand.new("More foo?")))
+    end
+
+    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")
+      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"))
+    end
+
+    def test_output
+      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.add(c_1)
+      @@cc.modifies?("when 2")
+      @@cc.add(c_2)
+      ns = PageTemplate::Namespace.new()
+      ns["foo"] = nil
+      assert_equal(c_3.output, @@cc.output(ns))
+      ns["foo"] = "1"
+      assert_equal(c_1.output, @@cc.output(ns))
+      ns["foo"] = "2"
+      assert_equal(c_2.output, @@cc.output(ns))
+    end
+  end
+
+  class TestCommand < Test::Unit::TestCase
+    def test_output
+      assert_raises(NotImplementedError,
+        "Command is not to be directly used.") { 
+          c = PageTemplate::Command.new
+          c.output
+        }
+    end
+  end
+
+  class TestCommentCommand < Test::Unit::TestCase
+    def test_output
+      c = PageTemplate::CommentCommand.new("foo")
+      assert_equal('[ Comment: foo ]', c.to_s,
+        "CommentCommand stores the input string as a comment.")
+      assert_equal('', c.output(),
+        "CommentCommands output the empty string regardless of content.")
+      c = PageTemplate::CommentCommand.new
+      assert_equal('[ Comment:  ]', c.to_s,
+        "Comment defaults to the string '' if you don't provide a comment.")
+      c = PageTemplate::CommentCommand.new(23)
+      assert_equal('[ Comment: 23 ]', c.to_s,
+        "CommentCommand#to_s automatically converts comments to Strings.")
+    end
+  end
+
+  class TestDefaultPreprocessor < Test::Unit::TestCase
+    def test_process
+      assert_equal("str", PageTemplate::DefaultPreprocessor.process("str"),
+        "DefaultPreprocessor.process returns a copy of the string handed to it.")
+    end
+
+    def test_reverse
+      assert_equal("rts", PageTemplate::DefaultPreprocessor.reverse("str"),
+        "DefaultPreprocessor.reverse returns a reversed copy of the string handed to it.")
+    end
+
+    def test_escapeHTML
+      assert_equal("&lt;str&gt;", PageTemplate::DefaultPreprocessor.escapeHTML("<str>"),
+        "DefaultPreprocessor.escapeHTML returns a copy of the string input with HTML converted to entities.")
+    end
+
+    def test_escapeURI
+      assert_equal("+", PageTemplate::DefaultPreprocessor.escapeURI(" "),
+        "DefaultPreprocessor.escapeURI returns a URI-encoded copy of the string handed to it.")
+    end
+  end
+
+  class TestFileSource < Test::Unit::TestCase
+    def setup
+      @p   = PageTemplate::Parser.new()
+      @@fs = PageTemplate::FileSource.new(@p.args)
+    end
+
+    def test_get
+      filename = 'tdata/dummy.txt'
+      location = File.join(Dir.getwd, filename)
+      assert_equal(IO.read(location), @@fs.get(filename))
+    end
+
+    def test_get_filename
+      filename = 'tdata/dummy.txt'
+      location = File.join(Dir.getwd, filename)
+      assert_equal(location, @@fs.get_filename(filename))
+    end
+
+    def test_paths
+      assert_equal([Dir.getwd], @@fs.paths)
+    end
+  end
+
+  class TestIfCommand < Test::Unit::TestCase
+    def setup
+      @@if     = PageTemplate::IfCommand.new("if flag")
+      @@unless = PageTemplate::IfCommand.new("unless flag")
+    end
+
+    def test_initialize
+      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_raises(ArgumentError,
+        "IfCommand will not initialize without a command declaring 'if/unless'") {
+          PageTemplate::IfCommand.new(bad_1)
+      }
+    end
+
+    def test_add
+      c = PageTemplate::TextCommand.new("bleargh")
+      assert(@@if.add(c),
+        "IfCommand#add adds a command to the block to be executed when true")
+      assert(@@unless.add(c),
+        "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
+
+    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") }
+    end
+
+    def test_output
+      ns = PageTemplate::Namespace.new()
+      c = PageTemplate::TextCommand.new("dude!")
+      assert_equal("dude!", c.output())
+      @@if.add(c)
+      @@unless.add(c)
+      ns["flag"] = true
+      assert_equal("dude!", @@if.output(ns))
+      assert_equal("", @@unless.output(ns))
+      ns["flag"] = false
+      assert_equal("", @@if.output(ns))
+      assert_equal("dude!", @@unless.output(ns))
+      @@if.modifies?("else")
+      @@unless.modifies?("else")
+      c2 = PageTemplate::TextCommand.new("sweet!")
+      @@if.add(c2)
+      @@unless.add(c2)
+      ns["flag"] = true
+      assert_equal("dude!", @@if.output(ns))
+      assert_equal("sweet!", @@unless.output(ns))
+      ns["flag"] = false
+      assert_equal("sweet!", @@if.output(ns))
+      assert_equal("dude!", @@unless.output(ns))
+    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))
+    end
+  end
+
+  class TestLoopCommand < Test::Unit::TestCase
+    def setup
+      @@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) }
+    end
+
+    def test_add
+      c = PageTemplate::TextCommand.new("bleargh")
+      assert(@@loop.add(c),
+        "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") }
+    end
+
+    def test_output
+      ns = PageTemplate::Namespace.new()
+      ns["list"] = [1, 2, 3]
+
+      # Simple TextCommands in a Loop
+      c = PageTemplate::TextCommand.new("Dude!")
+      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!")
+      loop_1.add(c_1)
+      assert_equal("Dude!Sweet!Dude!Sweet!Dude!Sweet!", loop_1.output(ns))
+      ns["list"] = nil
+      assert_equal("", loop_1.output(ns))
+
+      # 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.add(c_1)
+      loop_2.modifies?("else")
+      loop_2.add(c_2)
+      ns["list"] = nil
+      assert_equal("Dude?", loop_2.output(ns))
+      ns["list"] = [1, 2]
+      assert_equal("Sweet!Sweet!", loop_2.output(ns))
+
+      # A Loop that uses its metavariables
+      c_1 = PageTemplate::TextCommand.new("First Post!")
+      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.add(c_1)
+      if_2 = PageTemplate::IfCommand.new("if __ODD__")
+      if_2.add(c_2)
+      if_2.modifies?("else")
+      if_2.add(c_3)
+      if_3 = PageTemplate::IfCommand.new("if __LAST__")
+      if_3.add(c_4)
+      loop_1 = PageTemplate::LoopCommand.new("in cliches")
+      loop_1.add(if_1)
+      loop_1.add(if_2)
+      loop_1.add(if_3)
+      ns["cliches"] = [1, 2]
+      expected = c_1.output + c_2.output + c_3.output + c_4.output
+      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())
+      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))
+    end
+  end
+
+  class TestNamespace < Test::Unit::TestCase
+    def setup
+      @@ns = PageTemplate::Namespace.new
+    end
+
+    def test_clear_cache
+      assert(@@ns.clear_cache,
+        "Use Namespace#clear_cache to reset a Namespace's values.")
+    end
+
+    def test_get
+      assert_nil(@@ns.get("Santa Claus"),
+        "If a key is not set, Namespace#get returns nil")
+      @@ns.set("Santa Claus", "Kris Kringle")
+      assert_equal("Kris Kringle", @@ns.get("Santa Claus"),
+        "Use Namespace#get to access to Namespace value")
+
+      assert_equal(nil, @@ns.get("occupation"))
+      p = PageTemplate::Namespace.new()
+      p["occupation"] = "Foole"
+      @@ns.parent = p
+      assert_equal("Foole", @@ns.get("occupation"),
+        "Namespace#get will search parent Namespaces if they are available")
+
+      assert_equal(nil, @@ns.get("abs"))
+      @@ns.object = -5
+      assert_equal(5, @@ns.get("abs"),
+        "Namespace#get will send get requests to a contained object if it is available")
+    end
+
+    def test_index
+      @@ns.set("Santa Claus", "Kris Kringle")
+      assert_equal("Kris Kringle", @@ns["Santa Claus"],
+        "Use Namespace#get to access to Namespace value")
+    end
+
+    def test_index_equals
+      assert(@@ns["Dude"] = "Sweet!",
+        "Namespace#[]= is an alias for Namespace#set.")
+      assert_equal("Sweet!", @@ns["Dude"])
+    end
+
+    def test_object
+      assert_equal(nil, @@ns.object)
+      @@ns.object = -5
+      assert_equal(-5, @@ns.object,
+        "Namespace#object is a getter for a Namespace's object")
+    end
+
+    def test_object_equals
+      obj = -5
+      assert(@@ns.object = obj,
+        "Namespace#object= is a setter for a Namespace's object")
+      assert_equal(-4, @@ns.get('succ'),
+        "Namespace#object= defines an object to search for synonyms")
+    end
+
+    def test_parent
+      assert_equal(nil, @@ns.parent)
+      p = PageTemplate::Namespace.new()
+      p["occupation"] = "Foole"
+      @@ns.parent = p
+      assert_equal(p, @@ns.parent,
+        "'parent' is a getter for a parent Namespace")
+    end
+
+    def test_parent_equals
+      p = PageTemplate::Namespace.new()
+      p["occupation"] = "Foole"
+      assert(@@ns.parent = p,
+        "'parent' is a setter for a parent Namespace")
+    end
+
+    def test_set
+      assert(@@ns.set("dude", "sweet!"),
+        "Use Namespace#set to set names to a value in your Namespace.")
+      assert(@@ns["sweet"] = "dude",
+        "Namespace#[]= is an alias for Namespace#set.")
+    end
+
+    def test_true_eh
+      assert_equal(false, @@ns.true?("enlightenment"),
+        "If a flag doesn't exist, then Namespace#true? returns false.")
+      @@ns["dude"] = false
+      assert_equal(false, @@ns.true?("dude"),
+        "If a flag is set to false, then Namespace#true? returns false.")
+      @@ns["dude"] = true
+      assert_equal(true, @@ns.true?("dude"),
+        "If a flag is set to true, then Namespace#true? returns true.")
+      @@ns["dude"] = "sweet!"
+      assert_equal(true, @@ns.true?("dude"),
+        "If a flag is set to pretty much anything but false, then Namespace#true? returns true.")
+    end
+  end
+
+  class TestParser < Test::Unit::TestCase
+    def setup
+      @@tc = PageTemplate::TextCommand.new("[ Template 'foo' not found ]")
+      @@p = PageTemplate::Parser.new()
+    end
+
+    def test_args
+      assert_equal({}, @@p.args)
+    end
+
+    def test_clearCommands
+      @@p.clearCommands
+      assert_equal(nil, @@p.commands)
+    end
+
+    def test_commands
+      assert_equal(nil, @@p.commands)
+      @@p.load('foo')
+      assert(@@p.commands)
+    end
+
+    def test_compile
+      assert_equal(@@tc.output, @@p.compile('foo').output)
+    end
+
+    def test_default_processor
+      assert_equal(:process, @@p.default_processor)
+    end
+
+    def test_load
+      assert(@@p.load('foo'))
+    end
+
+    def test_output
+      assert_equal('', @@p.output)
+      @@p.load('foo')
+      assert_equal(@@tc.output, @@p.output)
+    end
+
+    def test_parse
+      assert_equal('', @@p.parse('').output)
+      assert_equal('foo', @@p.parse('foo').output)
+      @@p['x'] = 'y'
+      assert_equal('y', @@p.parse('[%var x%]').output)
+    end
+
+    def test_preprocessor
+      assert_equal(PageTemplate::DefaultPreprocessor, @@p.preprocessor)
+    end
+
+    def test_index
+      assert_equal(nil, @@p['foo'])
+      @@p['foo'] = "Are you sick of foo yet?"
+      assert_equal("Are you sick of foo yet?", @@p['foo'])
+    end
+
+    def test_index_equals
+      assert(@@p['foo'] = "I'm sick of foo!")
+    end
+  end
+
+  class TestSyntaxGlossary < Test::Unit::TestCase
+    def setup
+      @@g = PageTemplate::SyntaxGlossary.new(
+        /<(.+?)>/,
+
+        /^--/i => PageTemplate::CommentCommand
+      )
+    end
+
+    def test_define
+      assert_equal(PageTemplate::UnknownCommand, @@g.lookup("foo"))
+      assert_raises(ArgumentError,
+        "SyntaxGlossary#define requires a Regexp for its first arg") {
+          @@g.define("foo", PageTemplate::CommentCommand)
+      }
+      assert(@@g.define(/^foo/, PageTemplate::CommentCommand),
+        "Use SyntaxGlossary#define to add or change SyntaxGlossary entries")
+    end
+
+    def test_define_global_var
+      assert_equal(PageTemplate::UnknownCommand, @@g.lookup("d"))
+      assert(@@g.define_global_var(/d/),
+        "Use SyntaxGlossary#define_global_var to create explicit ValueCommands")
+      assert_equal(PageTemplate::ValueCommand, @@g.lookup("d"))
+    end
+
+    def test_directive
+      assert_equal(/<(.+?)>/, @@g.directive)
+    end
+
+    def test_directive_equals
+      assert_equal(/<(.+?)>/, @@g.directive)
+      directive = /\[.+?\]/
+      assert(@@g.directive = directive)
+      assert_equal(directive, @@g.directive)
+    end
+
+    def test_lookup
+      assert_equal(PageTemplate::CommentCommand, @@g.lookup("--"))
+      assert_equal(PageTemplate::UnknownCommand, @@g.lookup("++"))
+    end
+  end
+
+  class TestTextCommand < Test::Unit::TestCase
+    def test_output
+      c = PageTemplate::TextCommand.new("Dude!")
+      assert_equal("Dude!", c.output(),
+        "A TextCommand outputs a simple text string.")
+    end
+  end
+
+  class TestUnknownCommand < Test::Unit::TestCase
+    def test_output
+      parser = PageTemplate::Parser.new()
+      uc = PageTemplate::UnknownCommand.new("waffle olive mango", parser)
+      assert_equal("[ Unknown Command: waffle olive mango ]", uc.output(parser.namespace))
+    end
+  end
+
+  class TestValueCommand < Test::Unit::TestCase
+    def test_output
+      p = PageTemplate::Parser.new()
+      p['x'] = 'y'
+      v = PageTemplate::ValueCommand.new('var x', p)
+      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)
+      assert_equal('4',w.output(p.namespace))
+      assert_equal('',v.output(p.namespace))
+    end
+  end
+end
+