PageTemplate 1.1.1

data/README.txt

@@ -0,0 +1,85 @@
+= PageTemplate.rb README
+
+Use PageTemplate.rb to create output based on template pages and 
+the code of your program.  This package is inspired by, but not 
+quite like, Perl's HTML::Template package.  Its main intent is to 
+separate design and code for CGI programs, but it could be useful 
+in other contexts as well (Ex: site generation packages).
+
+PageTemplate.rb is distributed under the MIT License, which is included
+within this document in the License section.  
+
+As a side note: if you are using PageTemplate in your projects, or 
+add features to your copy, I'd love to hear about it.  If you feel like
+it.
+
+Brian Wisti (brian@coolnamehere.com)
+http://www.coolnamehere.com/products/pagetemplate/
+
+== Features
+
+* Variable substitution
+* If and If/Else structures
+* Loops and Loop/Else structures
+* Customizable Syntax
+* Include content from external files (new in 1.1)
+
+== Requirements
+
+  * ruby 1.8
+
+== Install
+
+=== Generic Install
+
+De-Compress archive and enter its top directory.
+Then type:
+
+    $ ruby install.rb config
+    $ ruby install.rb setup
+   ($ su)
+    # ruby install.rb install
+
+You can also install files into your favorite directory
+by supplying install.rb some options. Try "ruby install.rb --help".
+
+=== Install With Rake
+
+    $ rake
+    $ sudo rake install
+
+=== Install With RubyGems
+
+Download the gem file from the 
+[PageTemplate RubyForge page]:http://rubyforge.org/projects/pagetemplate/
+
+Then, use the gem command to install it:
+
+    $ sudo gem install -l PageTemplate-1.1.1.gem
+
+I think that's all there is to it. I'm new to gems, though, so let me
+know if I missed something.
+
+== Usage
+
+PageTemplate.rb is a class library, and has no command line or 
+interactive capabilities.  See PageTemplate for a
+reference to the classes and methods contained in this package.
+There is a tutorial and user guide available online, at 
+http://coolnamehere.com/products/pagetemplate/
+
+== License
+
+The MIT License
+
+Copyright (c) 2002-2005 Brian Wisti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+Brian Wisti (brian@coolnamehere.com)

data/TC_PageTemplate.rb

@@ -0,0 +1,856 @@
+#!/usr/local/bin/ruby -w
+
+require 'test/unit'
+require './lib/PageTemplate.rb'
+
+require "date"
+
+class TC_Namespace < Test::Unit::TestCase
+  @@namespace = Namespace.new()
+  
+  def testNamespaceSet
+    assert(@@namespace.set("name", "Frank"))
+  end
+  
+  def testNamespaceGet
+    @@namespace.set("name", "Frank")
+    assert_equal("Frank", @@namespace.get("name"))
+  end
+  
+  def testTrue
+    assert_not_nil(@@namespace.true?("name"))
+    assert_nil(@@namespace.true?("null"))
+    @@namespace.set("falseFlag", false)
+    assert_nil(@@namespace.true?("falseFlag"))
+  end
+  
+  def testNamespacePush
+    assert_equal("Frank", @@namespace.get("name"))
+    names = { 'name' => "Eddie Baby" }
+    
+    # Pushing a hash (and nested namespace)
+    assert(@@namespace.push(names))
+    assert_equal("Eddie Baby", @@namespace.get("name"))
+    
+    # Pushing an object
+    date = Date.today()
+    date2 = Date.today()
+    
+    @@namespace.push(date)
+    assert_equal(date2.year, @@namespace.get("year"))
+  end
+  
+  def testNamespacePop
+    names = { 'name' => "Eddie Baby" }
+    @@namespace.push(names)
+    assert_equal("Eddie Baby", @@namespace.get("name"))
+    assert(@@namespace.pop())
+    assert_equal("Frank", @@namespace.get("name"))
+    assert_nil(@@namespace.pop())
+  end
+  
+end
+
+class TC_Command < Test::Unit::TestCase
+  @@command = Command.new()
+  
+  def testCommandOutput
+    assert_raises(NotImplementedError) { @@command.output() }
+  end
+  
+end
+
+class TC_BlockCommand < Test::Unit::TestCase
+  @@command = BlockCommand.new()
+  
+  def testAddCommand
+    aCommand = TextCommand.new("Hello")
+    assert(@@command.add(aCommand))
+    
+    assert_raises(TypeError) { @@command.add("Hello") }
+  end
+  
+  def testOutput
+    bCommand = TextCommand.new(", ")
+    cCommand = TextCommand.new("World")
+    
+    @@command.add(bCommand)
+    @@command.add(cCommand)
+    
+    assert_equal("Hello, World", @@command.output)
+  end
+end
+
+class TC_TextCommand < Test::Unit::TestCase
+  @@command = TextCommand.new("Just testing")
+  
+  def testCommandOutput
+    assert_equal("Just testing", @@command.output)
+  end
+  
+end
+
+class TC_ValueCommand < Test::Unit::TestCase
+  @@valueCommand = ValueCommand.new("name")
+  
+  def testOutput
+    ns = Namespace.new()
+    ns.set("name", "Frank")
+    assert_equal(ns.get("name"), @@valueCommand.output(ns))
+  end
+end
+
+class TC_IfCommand < Test::Unit::TestCase
+  
+  def testOutput
+    aCommand = TextCommand.new("Programming ")
+    bCommand = TextCommand.new("Ruby")
+    commandBlock = BlockCommand.new()
+    commandBlock.add(aCommand)
+    commandBlock.add(bCommand)
+    
+    ns = Namespace.new()
+    ns.set("testing", 1)
+    
+    # First test for output with true condition
+    ifCommand = IfCommand.new("testing", commandBlock)
+    assert_equal("Programming Ruby", ifCommand.output(ns))
+    
+    # Test for nil output with false condition
+    ifCommand = IfCommand.new("production", commandBlock)
+    assert_nil(ifCommand.output(ns))
+    
+    ns.set("production", false)
+    assert_nil(ifCommand.output(ns))
+  end
+end
+
+class TC_IfElseCommand < Test::Unit::TestCase
+  
+  def testOutput
+    aCommand = TextCommand.new("This is ")
+    bCommand = TextCommand.new("True")
+    cCommand = TextCommand.new("False")
+    ifBlock = BlockCommand.new()
+    ifBlock.add(aCommand)
+    ifBlock.add(bCommand)
+    elseBlock = BlockCommand.new()
+    elseBlock.add(aCommand)
+    elseBlock.add(cCommand)
+    
+    ns = Namespace.new()
+    ns.set("testing", 1)
+    
+    # First test for output with true condition
+    ifElseCommand = IfElseCommand.new("testing", ifBlock, elseBlock)
+    assert_equal("This is True", ifElseCommand.output(ns))
+    
+    # Test for output with false condition
+    ifElseCommand = IfElseCommand.new("live", ifBlock, elseBlock)
+    assert_equal("This is False", ifElseCommand.output(ns))
+  end
+  
+end
+
+class TC_LoopCommand < Test::Unit::TestCase
+  
+  def testOutput
+    # Build a list of hashes for the namespace
+    loopItems = [
+      { 'x'=> '1 ', 'y'=> '2 ', 'z'=> '3' },
+      { 'x'=> 'a ', 'y'=> 'b ', 'z'=> 'c' },
+    ]
+    ns = Namespace.new()
+    ns.set('list', loopItems)
+    
+    # Build a command list
+    xCommand = ValueCommand.new('x')
+    yCommand = ValueCommand.new('y')
+    zCommand = ValueCommand.new('z')
+    commandBlock = BlockCommand.new()
+    commandBlock.add(xCommand)
+    commandBlock.add(yCommand)
+    commandBlock.add(zCommand)
+    
+    loopCommand = LoopCommand.new('list', commandBlock)
+    assert_equal("1 2 3a b c", loopCommand.output(ns))
+    loopCommand = LoopCommand.new('noshow', commandBlock)
+    assert_nil(loopCommand.output(ns))
+    ns.set("string", "hello")
+    loopCommand = LoopCommand.new("string", commandBlock)
+    assert_raises(TypeError) { loopCommand.output(ns) }
+  end
+end
+
+class TC_LoopElseCommand < Test::Unit::TestCase
+  
+  def testOutput
+    # Build a list of hashes for the namespace
+    loopItems = [
+      { 'x'=> '1 ', 'y'=> '2 ', 'z'=> '3' },
+      { 'x'=> 'a ', 'y'=> 'b ', 'z'=> 'c' },
+    ]
+    ns = Namespace.new()
+    ns.set('list', loopItems)
+    
+    # Build a command list
+    xCommand = ValueCommand.new('x')
+    yCommand = ValueCommand.new('y')
+    zCommand = ValueCommand.new('z')
+    commandBlock = BlockCommand.new()
+    commandBlock.add(xCommand)
+    commandBlock.add(yCommand)
+    commandBlock.add(zCommand)
+    
+    # Build a command list for the else block
+    aCommand = TextCommand.new("In the else block")
+    elseCommands = BlockCommand.new()
+    elseCommands.add(aCommand)
+    
+    # Build the LoopCommand
+    loopCommand = 
+                 LoopElseCommand.new('list', commandBlock, elseCommands)
+    
+    # Test for output when loop variable is true
+    assert_equal("1 2 3a b c", loopCommand.output(ns))
+    
+    # Test for nil when loop variable is false
+    loopCommand = 
+                 LoopElseCommand.new('noshow', commandBlock, elseCommands)
+    assert_equal("In the else block", loopCommand.output(ns))
+  end
+  
+end
+
+
+class TC_NestedCommands < Test::Unit::TestCase
+  
+  def testNestedIfs
+    ns = Namespace.new()
+    
+    innerBlock = BlockCommand.new()
+    innerBlock.add(TextCommand.new("Inner"))
+    innerIf = IfCommand.new("inner", innerBlock)
+    
+    outerBlock = BlockCommand.new()
+    outerBlock.add(TextCommand.new("Outer"))
+    outerBlock.add(innerIf)
+    outerIf = IfCommand.new("outer", outerBlock)
+    
+    mainBlock = BlockCommand.new()
+    mainBlock.add(outerIf)
+    
+    # True in a true should yield result of both command lists
+    ns.set("outer", 1)
+    ns.set("inner", 1)
+    assert_equal("OuterInner", mainBlock.output(ns))
+    
+    # False in a true should yield result of outside list
+    ns.set("inner", false)
+    assert_equal("Outer", mainBlock.output(ns))
+    
+    # False in a false should yield nil
+    ns.set("outer", false)
+    assert_nil(mainBlock.output(ns))
+    
+    # True in a false should yield nil
+    ns.set("inner", 1)
+    ns.set("outer", false)
+    assert_nil(mainBlock.output(ns))
+  end
+  
+  def testNestedLoops
+    loop1 = [
+      { 'a' => 'o1 ', 'b' => 'o2 ', 'c' => [
+          { 'x' => 'i1 ', 'y' => 'i2 ', 'z' => 'i3 ' },
+          { 'x' => 'i4 ', 'y' => 'i5 ', 'z' => 'i6 ' } ]
+      },
+      { 'a' => 'o3 ', 'b' => 'o4 ', 'c' => [
+          { 'x' => 'j1 ', 'y' => 'j2 ', 'z' => 'j3 ' },
+          { 'x' => 'j4 ', 'y' => 'j5 ', 'z' => 'j6 ' } ]
+      }
+    ]
+    ns = Namespace.new()
+    ns.set("loop", loop1)
+    
+    aCommand = ValueCommand.new('a')
+    bCommand = ValueCommand.new('b')
+    xCommand = ValueCommand.new('x')
+    yCommand = ValueCommand.new('y')
+    zCommand = ValueCommand.new('z')
+    innerBlock = BlockCommand.new()
+    innerBlock.add(xCommand)
+    innerBlock.add(yCommand)
+    innerBlock.add(zCommand)
+    cCommand = LoopCommand.new('c', innerBlock)
+    outerBlock = BlockCommand.new()
+    outerBlock.add(aCommand)
+    outerBlock.add(bCommand)
+    outerBlock.add(cCommand)
+    loopCommand = LoopCommand.new('loop', outerBlock)
+    
+    # Loop in a loop should yield lots of text ;-)
+    # 'o1 o2 i1 i2 i3 i4 i5 i6 o3 o4 j1 j2 j3 j4 j5 j6 '
+    assert_equal('o1 o2 i1 i2 i3 i4 i5 i6 o3 o4 j1 j2 j3 j4 j5 j6 ',
+                 loopCommand.output(ns))
+    
+    # False in a loop should yield outside loop
+    # 'o1 o2 o3 o4 '
+    loop1.each { |item| item['c'] = [] }
+    assert_equal('o1 o2 o3 o4 ', loopCommand.output(ns))
+  end
+  
+  def testMixedNesting
+    # Loop in If
+    loop1 = [
+      { 'a' => '1 ', 'b' => '2 ', 'c' => '3 ' },
+      { 'a' => 'x ', 'b' => 'y ', 'c' => 'z ' }
+    ]
+    
+    aCommand = ValueCommand.new('a')
+    bCommand = ValueCommand.new('b')
+    cCommand = ValueCommand.new('c')
+    loopBlock = BlockCommand.new()
+    loopBlock.add(aCommand)
+    loopBlock.add(bCommand)
+    loopBlock.add(cCommand)
+    loopCommand = LoopCommand.new("loop", loopBlock)
+    ifBlock = BlockCommand.new()
+    ifBlock.add(loopCommand)
+    ifCommand = IfCommand.new("flag", ifBlock)
+    
+    ns = Namespace.new()
+    ns.set("loop", loop1)
+    ns.set("flag", 1)
+    assert_equal("1 2 3 x y z ", ifCommand.output(ns))
+    ns.set("flag", false)
+    assert_nil(ifCommand.output(ns))
+    
+    # If in Loop
+    
+    dCommand = TextCommand.new("(true)")
+    ifBlock = BlockCommand.new()
+    ifBlock.add(dCommand)
+    ifCommand = IfCommand.new("flag", ifBlock)
+    loopBlock = BlockCommand.new()
+    loopBlock.add(aCommand)
+    loopBlock.add(bCommand)
+    loopBlock.add(cCommand)
+    loopBlock.add(ifCommand)
+    loopCommand = LoopCommand.new("loop", loopBlock)
+    
+    loop1[-1]['flag'] = 1
+    assert_equal("1 2 3 x y z (true)", loopCommand.output(ns))
+    loop1[-1]['flag'] = false
+    assert_equal("1 2 3 x y z ", loopCommand.output(ns))
+  end
+  
+end
+
+class TC_SyntaxGlossary < Test::Unit::TestCase
+  @@syntax = Syntax::Glossary.new( /\[%(.+?)%\]/,
+                                   'value'      => /var (\w+)/,
+                                   'ifopen'     => /if (\w+)/,
+                                   'ifclose'    => /endif/,
+                                   'ifbranch'   => /else/,
+                                   'loopopen'   => /in (\w+)/,
+                                   'loopclose'  => /endin/,
+                                   'loopbranch' => /no/,
+                                   'include'    => /include (\w+)/
+                                   )
+  
+  def testGlossary
+    assert_equal(/\[%(.+?)%\]/, @@syntax.directive)
+    assert_equal(/in (\w+)/, @@syntax.glossary['loopopen'])
+    
+    badSyntax = {
+      'flargle' => /flargle/
+    }
+    assert_raises(ArgumentError) { 
+      Syntax::Glossary.new(/%(.+?)%/, badSyntax)
+    }
+  end
+  
+  def testLookup
+    assert_equal(["value", "name"], @@syntax.lookup("var name"))
+    assert_equal(["ifopen", "name"], @@syntax.lookup("if name"))
+    assert_equal(["ifclose", nil], @@syntax.lookup("endif"))
+    assert_equal(["ifbranch", nil], @@syntax.lookup("else"))
+    assert_equal(["loopopen", "x"], @@syntax.lookup("in x"))
+    assert_equal(["loopclose", nil], @@syntax.lookup("endin"))
+    assert_equal(["loopbranch", nil], @@syntax.lookup("no"))
+    assert_equal(["include", "foo"], @@syntax.lookup("include foo"))
+    assert_nil(@@syntax.lookup("foo"))
+    assert_nil(@@syntax.lookup("foo bar"))
+  end
+  
+end
+
+class TC_SyntaxParser < Test::Unit::TestCase
+  @@parser = Syntax::Parser.new(Syntax::DEFAULT)
+  
+  def testParse
+    assert_equal([[1, ""]], @@parser.parse([""]))
+    assert_equal([
+                   [1, "Hello "], 
+                   [1, ["value", "world"]],
+                   [1, ""]
+                 ], @@parser.parse(["Hello [%var world%]"])
+                 )
+    
+    assert_equal([
+                   [1, ""],
+                   [1, ["value", "articleno"]],
+                   [1, ""]
+                 ], @@parser.parse(["[%var articleno%]"]))
+    assert_equal([
+                   [1, ""],
+                   [1, ["value", "articleno"]],
+                   [1, ""]
+                 ], @@parser.parse(["[%  var articleno  %\]"]))
+    
+    multiline = [
+      "Hello [%var world%\]",
+      "[%if return%]",
+      "Welcome Back!",
+      "[%endif%]"
+    ]
+    
+    mResult = [
+      [1, "Hello "],
+      [1, ["value", "world"]],
+      [1, ""],
+      [2, ""],
+      [2, ["ifopen", "return"]],
+      [2, ""],
+      [3, "Welcome Back!"],
+      [4, ""],
+      [4, ["ifclose", nil]],
+      [4, ""]
+    ]
+    
+    assert_equal(mResult, @@parser.parse(multiline))
+  end
+  
+  def testCompile
+    directives = [
+      "Hello [%var world%]",
+      "[%if return%]",
+      "Welcome Back!",
+      "[%endif%]"
+    ]
+    assert(@@parser.compile(@@parser.parse(directives)))
+  end
+  
+  def testBuild
+    assert(@@parser.build("tdata/p/b1.txt"))
+    # Make sure nothing panics if we ask for the commands again.
+    assert(@@parser.build("tdata/p/b1.txt"))
+  end
+end
+
+class TC_SyntaxCachedParser < Test::Unit::TestCase
+  @@parser = Syntax::CachedParser.new(Syntax::DEFAULT)
+  
+  def testBuild
+    assert(@@parser.build("tdata/p/b1.txt"))
+    assert(File.exists?("tdata/p/_b1.txt"))
+    
+    ns = Namespace.new()
+    ns["world"] = "World"
+    assert(@@parser.output(ns))
+  end
+  
+  def testCachedBuild
+    assert(@@parser.build("tdata/p/cb1.txt"))
+    assert(File.exists?("tdata/p/_cb1.txt"))
+    assert(@@parser.reset)
+    assert(@@parser.build("tdata/p/cb1.txt"))
+  end
+  
+  def testCachedRebuild
+    # Create a new parser and build with the cached information.
+    p2 = Syntax::CachedParser.new(Syntax::DEFAULT)
+    assert(p2.build("tdata/p/cb1.txt"))
+    
+    # Clean up after ourselves.
+    system("rm -f tdata/p/_cb1.txt")
+  end
+end
+
+class TC_PageTemplate < Test::Unit::TestCase
+  @@template = PageTemplate.new( 'syntax' => Syntax::DEFAULT )
+  
+  def testLoadFile
+    assert(@@template.load("tdata/t.txt"))
+    assert_equal("tdata/t.txt", @@template.file)
+    assert_raises(ArgumentError) { @@template.load("tdata/null") }
+  end
+  
+  def testInitializeTemplate
+    assert(PageTemplate.new())
+    assert(PageTemplate.new("filename" => "tdata/t.txt"))
+    assert_raises(ArgumentError) { PageTemplate.new("filename" => "tdata/null") }
+  end
+  
+  def testSetParameter
+    assert(@@template.setParameter("name", "PageTemplate"))
+  end
+  
+  def testGetParameter
+    @@template.setParameter("name", "PageTemplate")
+    assert_equal("PageTemplate", @@template.getParameter("name"))
+    assert_nil(@@template.getParameter("null"))
+  end
+  
+  def testHashAccess
+    @@template['hash'] = 'test'
+    assert_equal('test', @@template['hash'])
+  end
+  
+  def testOutputNoMarkup
+    @@template.load("tdata/nm.txt")
+    cmpFile = File.open("tdata/nm.txt").read()
+    assert_equal(cmpFile, @@template.output())
+  end
+  
+  def testOutputValueMarkup
+    
+    # Valid markup, value exists.
+    @@template['title'] = "ValueMarkup"
+    @@template.load("tdata/v1.txt")
+    assert(@@template.output =~ /<h1>ValueMarkup<\/h1>/)
+    
+    # Valid markup, value does not exist.
+    @@template['title'] = ""
+    assert(@@template.output =~ /<h1><\/h1>/)
+    
+    # Invalid markup.
+    @@template.load("tdata/v2.txt")
+    assert(@@template.output =~ /<h1>title%\]<\/h1>/)
+  end
+  
+  def testOutputIfMarkup
+    @@template['flag'] = true
+    @@template.load("tdata/i1.txt")
+    assert(@@template.output =~ /It's all true!/)
+    
+    @@template['flag'] = false
+    assert(@@template.output !~ /It's all true!/)
+    
+    # Nested if expressions
+    @@template.load("tdata/i2.txt")
+    
+    # 1. Both true.
+    @@template['outer'] = true
+    @@template['inner'] = true
+    assert(@@template.output =~ /This is outer text/)
+    assert(@@template.output =~ /This is inner text/)
+    
+    # 2. Outer true, inner false.
+    @@template['outer'] = true
+    @@template['inner'] = false
+    assert(@@template.output =~ /This is outer text/)
+    assert(@@template.output !~ /This is inner text/)
+    
+    # 3. Inner true, outer false.
+    @@template['outer'] = false
+    @@template['inner'] = true
+    assert(@@template.output !~ /This is outer text/)
+    assert(@@template.output !~ /This is inner text/)
+  end
+  
+  def testOutputIfBranchMarkup
+    @@template.load("tdata/ie1.txt")
+    
+    # True: if block executes, not else block
+    @@template["flag"] = true
+    assert(@@template.output =~ /It's all true!/)
+    assert(@@template.output !~ /Nothing is true/)
+    
+    # False: else block executes, not if block
+    @@template["flag"] = false
+    assert(@@template.output =~ /Nothing is true/)
+    assert(@@template.output !~ /It's all true!/)
+  end
+  
+  def testOutputNestedIfBranchMarkup
+    @@template.load("tdata/ie2.txt")
+    
+    # Outer true, inner true
+    @@template['outer'] = true
+    @@template['inner'] = true
+    assert(@@template.output =~ /Outer is true/)
+    assert(@@template.output =~ /Inner is true/)
+    
+    # Outer true, inner false
+    @@template['outer'] = true
+    @@template['inner'] = false
+    assert(@@template.output =~ /Outer is true/)
+    assert(@@template.output =~ /Inner is false/)
+    
+    # Outer false, inner true
+    @@template['outer'] = false
+    @@template['inner'] = true
+    assert(@@template.output =~ /Outer is false/)
+    assert(@@template.output =~ /Inner is true/)
+    
+    # Outer false, inner false
+    @@template['outer'] = false
+    @@template['inner'] = false
+    assert(@@template.output =~ /Outer is false/)
+    assert(@@template.output =~ /Inner is false/)
+  end
+  
+  def testOutputLoopMarkup
+    @@template.load("tdata/l1.txt")
+    
+    # Loop Exists
+    myLoop = []
+    1.upto(5) { |v| myLoop << {'value' => v} }
+    
+    @@template['loop'] = myLoop
+    assert(@@template.output =~ /<li>3<\/li>/)
+    
+    # Loop Doesn't Exist
+    @@template['loop'] = false
+    assert(@@template.output !~ /<li>3<\/li>/)
+    
+    # Loop Is Empty List
+    @@template['loop'] = []
+    assert(@@template.output !~ /<li>.*?<\/li>/)
+  end
+  
+  def testOutputNestedLoopMarkup
+    @@template.load("tdata/l2.txt")
+    
+    # Outer Loop Exists, Inner Loop Exists
+    innerLoop = []
+    'a'.upto('f') { |v| innerLoop << { 'value' => v } }
+    outerLoop = []
+    1.upto(5) do |v| 
+      outerLoop << {'value' => v, 'inner' => innerLoop}
+    end
+    @@template['loop'] = outerLoop
+    assert(@@template.output =~ /<li>\d/)
+    assert(@@template.output =~ /<li>[a-f]<\/li>/)
+    
+    # Outer Loop Exists, Inner Loop Empty
+    outerLoop.each { |x| x['inner'] = [] }
+    assert(@@template.output !~ /<li>[a-f]<\/li>/)
+    
+    # Outer Loop Exists, Alternate Inner Loops Empty
+    outerLoop.each_with_index do |x, i|
+      x['inner'] = innerLoop if i % 2 == 0
+    end
+    assert(@@template.output =~ /<li>4\s+?<ul><\/ul>/m)
+    assert(@@template.output =~ /<li>3\s+?<ul><li>a/m)
+    
+    # Outer Loop Empty
+    @@template['loop'] = false
+    assert(@@template.output !~ /<li>/)
+  end
+  
+  def testOutputLoopBranchMarkup
+    @@template.load("tdata/ib1.txt")
+    
+    # Loop exists
+    myLoop = []
+    1.upto(5) { |v| myLoop << {'value' => v} }
+    @@template['loop'] = myLoop
+    assert(@@template.output =~ /<li>\d<\/li>/)
+    assert(@@template.output !~ /No values/)
+    
+    # No loop
+    @@template['loop'] = []
+    assert(@@template.output !~ /<li>\d<\/li>/)
+    assert(@@template.output =~ /No values/)
+  end
+  
+  def testOutputNestedLoopBranchMarkup
+    @@template.load("tdata/ib2.txt")
+    # Outer Loop Exists, Inner Loop Exists
+    innerLoop = []
+    'a'.upto('f') { |v| innerLoop << { 'value' => v } }
+    outerLoop = []
+    1.upto(5) do |v| 
+      outerLoop << {'value' => v, 'inner' => innerLoop}
+    end
+    @@template['loop'] = outerLoop
+    assert(@@template.output =~ /<li>\d/)
+    assert(@@template.output =~ /<li>[a-f]<\/li>/)
+    
+    # Outer Loop Exists, Inner Loop Empty
+    outerLoop.each { |x| x['inner'] = [] }
+    assert(@@template.output =~ /No inner values/)
+    
+    # Outer Loop Exists, Alternate Inner Loops Empty
+    outerLoop.each_with_index do |x, i|
+      x['inner'] = innerLoop if i % 2 == 0
+    end
+    assert(@@template.output =~ /<li>4\s+?<ul>.+?No inner values/m)
+    assert(@@template.output =~ /<li>3\s+?<ul>.+?<li>a/m)
+    
+    # Outer Loop Empty
+    @@template['loop'] = false
+    assert(@@template.output =~ /No values/)
+  end
+  
+  def testOutputComplexMarkup
+    title = "Testing"
+    reverse = true
+    
+    languages = [
+      { 'name'=> 'C', 'author'=> 'Dennis Ritchie' },
+      { 'name'=> 'C++', 'author'=> 'Bjarne Stroustrup' },
+      { 'name'=> 'Perl', 'author'=> 'Larry Wall',
+       'guideline'=> 'TMTOWTDI - There\'s More Than One Way To Do It'},
+      { 'name'=> 'Python', 'author'=> 'Guido van Rossum',
+       'guideline'=> 'There Should Be One Obvious Way To Do It' },
+      { 'name'=> 'Ruby', 'author'=> 'Yukihiro Matsumoto',
+       'guideline'=> 'TPOL - The Principle Of Least Surprise'}
+    ]
+    
+    favorites = [
+      { 'topic'=> 'Interesting Comic Books',
+       'items'=> [
+          {'title'=> 'Dropsie Avenue', 
+           'creator'=> 'Will Eisner'},
+          {'title'=> 'Cerebus', 
+           'creator'=> 'Dave Sim'},
+          {'title'=> 'Jar Of Fools', 
+           'creator'=> 'Jason Lutes'}]},
+      { 'topic'=> 'Favorite Albums',
+       'items'=> [
+          {'title'=> 'Amnesiac', 
+           'creator'=> 'Radiohead'},
+          {'title'=> 'The Moon and Antarctica', 
+           'creator'=> 'Modest Mouse'},
+          {'title'=> 'Dirt Track Date', 
+           'creator'=> 'Southern Culture On The Skids'},
+          {'title'=> 'My Motor', 
+           'creator'=> 'Dorkweed'},
+          {'title'=> 'Swordfishtrombones', 
+           'creator'=> 'Tom Waits'}]}
+    ]
+    
+    page = PageTemplate.new(
+                            'filename' => "tdata/complex.txt"
+                            )
+    page.setParameter("title", title)
+    page.setParameter("ifTest", 1)
+    page.setParameter("languages", languages)
+    page.setParameter("favorites", favorites)
+    if reverse == 1
+      page.setParameter("reverse", 1)
+	end
+    
+    assert(page.output)
+  end
+  
+  def testCachedTemplate
+    assert(ct = PageTemplate.new(
+                                 'filename' => "tdata/complex.txt",
+                                 'use_cache' => true
+                                 ))
+    
+    languages = [
+      { 'name'=> 'C', 'author'=> 'Dennis Ritchie' },
+      { 'name'=> 'C++', 'author'=> 'Bjarne Stroustrup' },
+      { 'name'=> 'Perl', 'author'=> 'Larry Wall',
+       'guideline'=> 'TMTOWTDI - There\'s More Than One Way To Do It'},
+      { 'name'=> 'Python', 'author'=> 'Guido van Rossum',
+       'guideline'=> 'There Should Be One Obvious Way To Do It' },
+      { 'name'=> 'Ruby', 'author'=> 'Yukihiro Matsumoto',
+       'guideline'=> 'TPOL - The Principle Of Least Surprise'}
+    ]
+    
+    favorites = [
+      { 'topic'=> 'Interesting Comic Books',
+       'items'=> [
+          {'title'=> 'Dropsie Avenue', 
+           'creator'=> 'Will Eisner'},
+          {'title'=> 'Cerebus', 
+           'creator'=> 'Dave Sim'},
+          {'title'=> 'Jar Of Fools', 
+           'creator'=> 'Jason Lutes'}]},
+      { 'topic'=> 'Favorite Albums',
+       'items'=> [
+          {'title'=> 'Amnesiac', 
+           'creator'=> 'Radiohead'},
+          {'title'=> 'The Moon and Antarctica', 
+           'creator'=> 'Modest Mouse'},
+          {'title'=> 'Dirt Track Date', 
+           'creator'=> 'Southern Culture On The Skids'},
+          {'title'=> 'My Motor', 
+           'creator'=> 'Dorkweed'},
+          {'title'=> 'Swordfishtrombones', 
+           'creator'=> 'Tom Waits'}]}
+    ]
+    ct["languages"] = languages
+    ct["favorites"] = favorites
+    assert(ct.output)
+    assert(File.exists?("tdata/_complex.txt"))
+    system("rm -f tdata/_complex.txt")
+    
+  end
+  
+  def testClearFile
+    assert(@@template.clearFile)
+  end
+end
+
+class TC_Include < Test::Unit::TestCase
+  def testIncludeCommand()
+    ns = Namespace.new()
+
+
+    incCommand = IncludeCommand.new("tdata/include.1.txt")
+    text = File.open("tdata/include.1.txt").read()
+    assert_equal(text, incCommand.output(ns),
+                 "IncludeCommands can be initialized with relative filenames")
+
+    text = File.open("tdata/include.2.txt").read()
+    incCommand = IncludeCommand.new("tdata/include.2.txt")
+    assert_equal(text, incCommand.output(ns))
+
+    # Including text with template markup.
+    ns["x"] = "Dude!"
+    pt = PageTemplate.new()
+    pt.load("tdata/include.3.txt")
+    pt["x"] = "Dude!"
+    incCommand = IncludeCommand.new("tdata/include.3.txt")
+    assert_equal(pt.output(), incCommand.output(ns),
+                 "Include Commands can parse standard Template markup")
+
+  end
+
+  def testIncludePath
+    incCommand = IncludeCommand.new("include.4.txt", "tdata")
+    text = File.open("tdata/include.4.out.txt").read()
+    assert_equal(text, incCommand.output,
+                 "IncludeCommand accepts an include path as a second arg")
+
+    pt = PageTemplate.new('include_path' => "tdata")
+    pt.load("tdata/include.4.txt")
+    pt["file"] = "include.4b.txt"
+    text = File.open("tdata/include.4.out.txt").read()
+    assert_equal(text, pt.output,
+                 "Include Commands can be given a variable name as an argument")
+
+  end
+
+  def testIncludeSyntax
+    text = File.open("tdata/include.4.out.txt").read()
+    pt = PageTemplate.new("include_path" => "tdata")
+    pt.load("include.4.txt")
+    assert_equal(text, pt.output(),
+                 "PageTemplate supports 'include' syntax")
+    pt = PageTemplate.new('include_path' => "tdata")
+    pt.load("include.5.txt")
+    assert_equal(text, pt.output(),
+                 "PageTemplate supports 'include' syntax")
+
+  end
+
+end

metadata

@@ -0,0 +1,39 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.4
+specification_version: 1
+name: PageTemplate
+version: !ruby/object:Gem::Version 
+  version: 1.1.1
+date: 2005-02-16
+summary: A simple templating system for Web sites.
+require_paths: 
+  - lib
+email: brian@coolnamehere.com
+homepage: http://coolnamehere.com/products/pagetemplate
+rubyforge_project: 
+description: 
+autorequire: PageTemplate
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Brian Wisti
+files: 
+  - README.txt
+test_files: 
+  - TC_PageTemplate.rb
+rdoc_options: []
+extra_rdoc_files: 
+  - README.txt
+executables: []
+extensions: []
+requirements: []
+dependencies: []