narf 0.6.3 → 0.7.1

data/lib/web/sapi/fastcgi.rb

@@ -16,7 +16,7 @@ module Web
       end
       
       def close
-        options[:fcgi].finish
+        options[:fcgi].finish if options[:fcgi]
         options[:fcgi] = nil
       end
     end

data/lib/web/sapi/fastcgi.rb~

@@ -0,0 +1,26 @@
+# see cgi.rb and Web::process
+
+require 'web/cgi'
+
+module Web
+  class CGD
+    class Fastcgi < CGD
+      def Fastcgi::new( options = {} )
+        fcgi = options[:fcgi]
+        
+        options[:out]  = fcgi.out
+        options[:in]   = fcgi.in
+        options[:env]  = fcgi.env
+        
+        super(options) 
+      end
+      
+      def close
+        options[:fcgi].finish
+        options[:fcgi] = nil
+      end
+    end
+  end
+  
+end
+

data/lib/web/sapi/webrick.rb

@@ -32,8 +32,6 @@ module Web
     end
     
     def do_GET(req, res)
-      header, body = nil, nil
-      
       cgi_out = Tempfile.new("webrick.cgiout.", @tempdir)
       cgi_err = Tempfile.new("webrick.cgierr.", @tempdir)
       
@@ -46,44 +44,38 @@ module Web
         meta["SCRIPT_FILENAME"] = @script_filename
         meta["PATH"] = @config[:CGIPathEnv]
         
-        Web::process( :cgd => Web::CGD::Webrick.new(:out => cgi_out,
-                                                  :in  => StringIO.new( req.body || '' ),
-                                                  :env => meta ) ) {
-          load( @script_filename, true )
-        }
+        cgd = Web::CGD::Webrick.new(:out => cgi_out,
+                                    :in  => StringIO.new( req.body || '' ),
+                                    :env => meta   )
+        Web::load( @script_filename, :cgd => cgd )
         
-      ensure
-        Web::close
+        res.status = Web::status.to_i
+ 
+        Web::header.each do |key, val|
+          unless key =~ /status/i
+            res[key] = val.join(", ")
+          end
+        end
         
         cgi_out.rewind
-        body = cgi_out.read
-        cgi_out.close(true)
+        res.body = cgi_out.read
         
+        cgi_err.rewind
         if errmsg = cgi_err.read
           if errmsg.size > 0
             @logger.error("NarfHandler: #{@script_filename}:\n" + errmsg)
           end
         end 
+
+      rescue Exception => ex
+        #Web::report_error( ex )
+        raise HTTPStatus::InternalServerError, ex.message
+
+      ensure
+        cgi_out.close(true)
         cgi_err.close(true)
-        
         $stderr = old_stderr
       end
-      
-      begin
-        header = Web::header
-        
-        if /^(\d+)/ =~ header['Status'].last
-          res.status = $1.to_i
-          header.delete('Status')
-        end
-        header.each{|key, val|
-          res[key] = val.join(", ") }
-      rescue => ex
-        raise HTTPStatus::InternalServerError, ex.message
-      end
-      
-      res.body = body
-      
     end
     alias do_POST do_GET
   end

data/lib/web/sapi/webrick.rb~

@@ -0,0 +1,82 @@
+# Based on: 
+# cgihandler.rb -- CGIHandler Class
+#       
+# Author: IPR -- Internet Programming with Ruby -- writers
+# Copyright (c) 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
+# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
+# reserved.
+#   
+# $IPR: cgihandler.rb,v 1.27 2003/03/21 19:56:01 gotoyuzo Exp $
+
+require 'tempfile'
+require 'webrick/httpservlet/abstract'
+
+require 'web'
+
+module Web
+  
+  class CGD
+    class Webrick < Web::CGD
+      def send_header( header )
+        
+      end
+    end
+  end
+
+  class NarfHandler < WEBrick::HTTPServlet::AbstractServlet
+
+    def initialize(server, name)
+      super
+      @script_filename = name
+      @tempdir = server[:TempDir]
+    end
+    
+    def do_GET(req, res)
+      #cgi_out = Tempfile.new("webrick.cgiout.", @tempdir)
+      cgi_err = Tempfile.new("webrick.cgierr.", @tempdir)
+      
+      old_stderr = $stderr
+      
+      begin
+        $stderr    = cgi_err
+        
+        meta = req.meta_vars
+        meta["SCRIPT_FILENAME"] = @script_filename
+        meta["PATH"] = @config[:CGIPathEnv]
+        
+        cgd = Web::CGD::Webrick.new(:out => StringIO.new(''),
+                                    :in  => StringIO.new( req.body || '' ),
+                                    :env => meta   )
+        Web::load( @script_filename, :cgd => cgd )
+        
+        res.status = Web::status.to_i
+ 
+        Web::header.each do |key, val|
+          unless key =~ /status/i
+            res[key] = val.join(", ")
+          end
+        end
+        
+        res.body = Web::get_content
+        
+        cgi_err.rewind
+        if errmsg = cgi_err.read
+          if errmsg.size > 0
+            @logger.error("NarfHandler: #{@script_filename}:\n" + errmsg)
+          end
+        end 
+
+      rescue Exception => ex
+        #Web::report_error( ex )
+        raise HTTPStatus::InternalServerError, ex.message
+
+      ensure
+        Web::close()
+        cgi_err.close(true)
+        $stderr = old_stderr
+      end
+    end
+    alias do_POST do_GET
+  end
+  
+end

data/lib/web/session.rb

@@ -58,8 +58,16 @@ module Web
 	    }
 	end
 
+	def temp_dir
+	  temp = ENV['TMP'] || ENV['TEMP'] || '/tmp'
+	  unless( File.exists? temp )
+	    temp = "c:/windows/temp"
+	  end
+	  temp
+	end
+
 	def file
-	    File.expand_path(File.join((ENV['TMP'] || '/tmp' ), File.basename(@session_id.to_s).untaint))
+	    File.expand_path(File.join(self.temp_dir, File.basename(@session_id.to_s).untaint))
 	end
 	
 	# resets session to empty hash, for use in testing

data/lib/web/stringio.rb

@@ -0,0 +1,78 @@
+module Web 
+    # WritableIO uses << operator to add io style write, print, and puts methods
+    module WritableIO # :nodoc:
+	# writes object to output stream
+	def write object
+	    self << object
+	end
+
+	# writes objects to the output stream
+	def print( *objects )
+	    if (objects.empty?)
+		self << $_
+	    else
+		self << objects.collect{ |s| s.to_s }.join("")
+	    end
+	    if $\ then self << $\ end
+        end
+	
+	# writes multiple lines to the output stream
+	def puts( *objects )
+	    objects.flatten!
+	    self  << objects.collect{ |s|
+		s.to_s 
+	    }.collect{ |s|
+		unless ( /(\r|\n)\z/ =~ s )
+		    s + $/
+		else
+		    s
+		end
+	    }.join("")
+	end
+    end
+end
+
+begin
+    require('stringio') 
+rescue LoadError    
+  module Web
+    class StringIO  # :nodoc:
+      def initialize
+        @___content___ = ""
+      end
+      
+      def read
+        @___content___
+      end
+      
+      def clear
+        @___content___ = ""
+      end
+      
+      def string
+        @___content___
+      end
+      
+      def puts(*args)
+        @___content___ << args.join("\n") << "\n"
+      end
+      
+      def << var
+        @___content___ << var.to_s
+      end
+      
+      def write var
+        @___content___ << var.to_s
+      end
+      
+      def print var
+        @___content___ << var.to_s
+      end
+    end
+  end
+  
+  unless Kernel.const_defined? "StringIO"
+    StringIO = Web::StringIO.clone
+  end
+end
+

data/lib/web/template.rb~

@@ -0,0 +1,615 @@
+require 'strscan'
+
+NOT_TOKEN = /(.*?)(?=[<{]\/?[n$])/m
+MAXFILESIZE = 1000000
+
+module Web
+  class TemplateException < Exception     # :nodoc:
+
+  end
+  
+  class Node  # :nodoc:
+    attr_reader :canonical_name, :value, :parent, :name
+    attr_accessor :anAlias, :scope
+
+    def initialize canonical_name, value, parent, name
+      @canonical_name = canonical_name
+      @value = value
+      @parent = parent
+      @name = name
+    end
+
+    def each 
+      @value.each_with_index { |value,i|
+	yield Scope.new(value,"#{@canonical_name}[#{i}]",@scope,@anAlias)
+      }
+    end
+  end
+
+  NODE = /^([\w?_]+)/
+  SEPARATOR = /^\./
+  ARRAY_VAR = /^\[(\d+)\]$/
+  ARRAY = /^\[(\d+)\]/
+  VAR = /^([\w?_]+)$/
+
+  class Scope  # :nodoc: all
+    def concat_name rootname, name
+      if rootname != ""
+	"#{rootname}.#{name}" 
+      else
+	"#{name}"
+      end
+    end
+
+    attr_reader :rootname, :anAlias
+
+    def initialize hash, rootname ="", parent = nil, anAlias = ""
+      @hash = hash
+      @rootname = rootname
+      @parent = parent
+      @anAlias = anAlias
+    end
+    
+    class VarNotFoundException < Exception # :nodoc:
+    end
+
+    def pull_value( name, collection )
+      value = if collection.kind_of? Hash
+		raise(VarNotFoundException.new("'#{name}' not found in #{collection.inspect}")) unless collection.has_key? name
+		collection[name]
+	      elsif collection.kind_of? Array
+		raise(VarNotFoundException.new("'#{name}' not found in #{collection.inspect}")) unless collection.has_key? name.to_i
+		collection[name.to_i]
+	      elsif collection.respond_to? name.intern
+		collection.send name.intern
+	      else
+		raise(VarNotFoundException.new("'#{name}' not found in #{collection.inspect}"))
+		#			collection.instance_eval { eval "@" + name }
+	      end
+      
+      #	    raise(VarNotFoundException.new("'#{name}' not found in #{collection.inspect}")) if value == nil
+
+      value
+    end
+    
+    def resolve_recurse scanner, hash, rootname
+      scanner.scan(SEPARATOR)
+      if scanner.scan(VAR)
+	nodename = scanner[1]
+	return Node.new(concat_name(rootname,nodename),pull_value( nodename, hash ),hash,nodename)
+      elsif scanner.scan(NODE)
+	nodename = scanner[1]
+	return resolve_recurse(scanner, pull_value( nodename, hash ), concat_name(rootname, nodename))
+      elsif scanner.scan(ARRAY_VAR)
+	nodename = scanner[1]
+	return Node.new(concat_name(rootname,"[" + nodename + "]"),pull_value( nodename, hash ),hash,nodename)
+      elsif scanner.scan(ARRAY)
+	#TODO check is hash->array
+	index = scanner[1]
+	return resolve_recurse(scanner, hash[index.to_i], "#{rootname}[#{index}]")
+      else
+	raise(scanner.rest)
+      end
+    end
+
+    def resolve varname, anAlias = ""
+      # strip alias off front of varname
+      varname = varname.sub(/\A#{@anAlias}\./, "")
+      raise "Varname is empty" if varname.empty? 
+      node = begin
+	       scanner = StringScanner.new(varname)
+	       resolve_recurse scanner, @hash, @rootname
+	     rescue VarNotFoundException => error
+	       if @parent
+		 @parent.resolve varname
+	       else
+		 raise error
+	       end
+	     end
+      node.anAlias = anAlias
+      node.scope = self
+      node
+    end
+
+    def update submitted
+      submitted.keys.each { |param|
+	begin
+	  var = resolve param
+	  if var.parent.kind_of? Hash
+	    var.parent[var.name] = submitted[param]
+	  elsif var.parent.kind_of? Array
+	    var.parent[var.name.to_i] = submitted[param]
+	  else
+	    var.parent.send( (var.name + "=").intern, submitted[param] )
+	  end
+	rescue VarNotFoundException
+	end
+      }
+      @hash
+    end
+  end
+
+  # == Purpose
+  # Templates allow you to seperate the design, which is a constant,
+  # from the things that change.  Testing is much easier if you can
+  # focus on just the things that change.
+  # 
+  # <i>Note: Narf intends to support multiple templating libraries.
+  # After supporting multiple backends, I will work on the supporting
+  # multiple templating libraries.  I will probably start with rdoc
+  # and amrita.</i>
+  #
+  # Back to business!  Here's an example Narflate:
+  #
+  #     <html>
+  #       <body>
+  #         {$myvar}
+  #         <narf:foreach from=alist item=i>
+  #           {$i.x}, {$i.x}<br>
+  #         </narf:foreach>
+  #       </body>
+  #     </html>
+  #
+  # You use the Web::print_template( template, value_hash ) to print
+  # the template merged with values:
+  #
+  #     --- script.rb:
+  #     Web::process do
+  #       Web.print_template "mytemplate.html",
+  #       		   "field1" => "val1",
+  #       		   "field2" => "val2",
+  #     	  	   "field3" => "val3",
+  #     		   "field4" => "3",
+  #     		   "values" => [{ "name" => "one", "value" => "1"},
+  #     		                { "name" => "two", "value" => "2"},
+  #     				{ "name' => "three", "value" => "3"}]
+  #     end
+  #
+  #     --- mytemplate.html:
+  #     <narf:input type="text" name="field1">
+  #     <narf:input type="hidden" name="field2">
+  #     <narf:textarea name="field3">
+  #     <narf:select name="field4" values="values">
+  #     
+  # This will produce the output:
+  # 
+  #     <input type="text" name="field1" value="val1">
+  #     <input type="hidden" name="field2" value="val2">
+  #     <textarea name="field3">
+  #     val3
+  #     </textarea>
+  #     <select name="field3">
+  #     	<option value="1">one</option>
+  #     	<option value="2">two</option>
+  #     	<option value="3" selected>three</option>
+  #     </select>
+  # 
+  class Narflates  
+    attr_reader :templates #:nodoc
+
+    # This is the default template_include_path
+    def Narflates.template_include_path #:nodoc:
+      [Dir.pwd,
+       File.join(Web.document_root.to_s,
+                 Web.script_path.to_s,
+                 "templates" ).gsub( /\/\//, "/" ),
+      ]
+    end
+    
+    def Narflates.template_file( template ) #:nodoc:
+      template_file = template
+      Web.template_include_path.reverse.each{ |dir|
+	full_template_path = File.join( dir, template )
+	if (File.exists? full_template_path)
+	  template_file = full_template_path
+	end
+      }
+      template_file
+    end
+    
+    def initialize template, query = {} 	# :nodoc:
+      @templates = [template]
+      @template = if (File.exists? Narflates.template_file(template))
+                    File.open(Narflates.template_file(template), "r") do |file|
+                      file.read || "" # this is because of a fixed bug in ruby.
+                    end                # eventually the || "" should disappear
+                  else
+                    template
+                  end
+      @parser = StrScanParser.new(StringScanner.new( @template ))
+      @query = query
+    end
+    
+    def parse io, vars 	# :nodoc:
+      vars = if vars.kind_of? Scope
+	       vars
+	     else
+	       Scope.new(vars)
+	     end
+      
+      parse_recurse.each do |item|
+	item.print(vars,io)
+      end
+     
+    end
+
+    class Foreach 	  # :nodoc:
+      attr_reader :array, :itemname, :contents
+      def initialize (array,itemname,contents)
+	@array = array
+	@itemname = itemname
+	@contents = contents
+      end
+
+      def print (globals,io) 
+	globals.resolve(array,@itemname).each { |item|
+	  contents.each { |i|
+	    i.print(item,io)
+	  }
+	}
+      end
+    end
+
+    class Form  	# :nodoc:
+      attr_reader :formname, :method
+      def initialize (formname,method,contents,query)
+	@formname = formname
+	@method = method
+	@contents = contents
+	@query = query
+      end
+
+      def print (globals,io) 
+	io << "<form name=\"#{@formname}\" method=\"#{@method}\">"
+	io << "<input type=\"hidden\" name=\"__submitted\" value=\"#{@formname}\">"
+	@query.each do | k,v|
+	  io << "<input type=\"hidden\" name=\"__q.#{k}\" value=\"" + v.gsub(/"/,"&quot;") +"\">"
+	end
+
+	@contents.each do |i|
+	  i.print(globals,io)
+	end
+	io << "</form>"
+      end
+    end
+
+    class If 	# :nodoc:
+      attr_reader :condvar, :contents
+      def initialize (condvar,contents)
+	@condvar = condvar
+	@contents = contents
+      end
+
+      def print (globals,io) 
+	var = globals.resolve(@condvar)
+	if var.value && var.value != []
+	  contents.each { |i|
+	    i.print(globals,io)
+	  }
+	end
+      end
+    end
+
+    class Unless	# :nodoc:
+      attr_reader :condvar, :contents
+      def initialize (condvar,contents)
+	@condvar = condvar
+	@contents = contents
+      end
+
+      def print (globals,io) 
+	var = globals.resolve(@condvar)
+	unless var.value || var.value == []
+	  contents.each { |i|
+	    i.print(globals,io)
+	  }
+	end
+      end
+    end
+
+    class Var 	# :nodoc:
+      attr_reader :varname
+      def initialize (varname)
+	@varname = varname
+      end
+
+      def print (globals,io) 
+	io << globals.resolve(@varname).value
+      end
+    end
+
+    class Link  	# :nodoc:
+      def initialize (link,contents)
+	@link = link
+	@contents = contents
+      end
+
+      def print (globals,io) 
+	io << "<a href=\"#{globals.resolve(@link).value.get_link}\">"
+	@contents.each { |i| 
+	  i.print(globals,io)
+	} 
+	io << "</a>"
+      end
+    end 
+
+    class Include  	# :nodoc:
+      def initialize (filename, vars, template_list)
+	@vars = vars
+	@filename = filename
+	@template_list = template_list
+      end
+
+      def print (globals,io) 
+	# resolve filename if it is var
+	filename = if @filename =~ /^\$(.*)/
+		     globals.resolve( $1 ).value
+		   else
+		     @filename
+		   end
+
+	# load file
+	
+	unless File.exists? Web::Narflates.template_file(filename)
+	  raise(TemplateException.new("Could not locate template file: " + filename))
+	end
+
+	templater = Narflates.new(filename,@query)
+	
+	if @vars == nil
+	  templater.parse(io, globals )
+	else
+	  templater.parse(io, Scope.new(globals.resolve(@vars).value))
+	end
+        
+	@template_list.concat( templater.templates )
+      end
+    end
+
+    class Data 	# :nodoc:
+      attr_reader :data
+      def initialize (data)
+	@data = data
+      end
+
+      def print (globals,io) 
+	io << @data if @data != nil
+      end
+    end
+
+    class Text  	# :nodoc:
+      attr_reader :name
+      def initialize (name)
+	@name = name
+      end        
+
+      def print (globals,io) 
+	var = globals.resolve(@name)
+	io << "<input type=\"text\" name=\"#{var.canonical_name}\" value=\"#{var.value}\">"
+      end
+    end
+
+    class Hidden  	# :nodoc:
+      attr_reader :name
+      def initialize (name)
+	@name = name
+      end        
+
+      def print (globals,io) 
+	var = globals.resolve(@name)
+	io << "<input type=\"hidden\" name=\"#{var.canonical_name}\" value=\"#{var.value}\">"
+      end
+    end
+
+    class Password  	# :nodoc:
+      attr_reader :name
+      def initialize (name)
+	@name = name
+      end        
+
+      def print (globals,io) 
+	var = globals.resolve(@name)
+	io << "<input type=\"password\" name=\"#{var.canonical_name}\" value=\"#{var.value}\">"
+      end
+    end
+
+    class CheckBox  	# :nodoc:
+      attr_reader :name
+      def initialize (name)
+	@name = name
+      end        
+
+      def print (globals,io) 
+	var = globals.resolve(@name)
+	io << "<input type=\"checkbox\" name=\"#{var.canonical_name}\""
+	if var.value == true
+	  io << " checked>"
+	end
+	io << "><input type=\"hidden\" name=\"__#{var.canonical_name}\" value=\"e\">"
+      end
+    end
+
+    class TextArea 	# :nodoc:
+      attr_reader :name
+      def initialize (name,rows,cols,virtual,style,id)
+	@name = name
+	@rows = rows
+	@cols = cols
+	@virtual = virtual
+	@style = style
+        @id = id
+      end        
+
+      def print (globals,io) 
+	value = globals.resolve(@name).value
+	io << "<textarea id=\"#{@id}\" name=\"#{@name}\" rows=\"#{@rows}\" cols=\"#{@cols}\" virtual=\"#{@virtual}\" style=\"#{@style}\">#{value}</textarea>"
+      end
+    end
+
+    class Select  	# :nodoc:
+      attr_reader :name, :values
+      def initialize (name,values)
+	@name = name
+	@values = values
+      end        
+      
+      def print (globals,io) 
+	value = globals.resolve(@name).value
+	values = globals.resolve(@values).value
+	io << "<select name=\"#{@name}\">"
+	
+	values = values.collect { |i|
+	  unless i.kind_of? Hash
+	    { "name" => i, "value" => i }
+	  else
+	    { "name" => i["name"], "value" => i["value"] }
+	  end
+	}
+
+	values.each { |item|
+	  item = item
+	  selected = if item["value"].to_s == value.to_s
+		       " selected"
+		     else
+		       ""
+		     end
+	  io << "<option value=\"#{item['value']}\"#{selected}>#{item['name']}</option>"
+	}
+	io << "</select>"
+      end
+    end
+
+
+    def match_identifiers tree=[]  	# :nodoc:
+      @parser.match_identifier do |identifier|
+	tree.push Var.new(identifier)
+      end
+    end
+
+
+    def match_tags tree=[] 	# :nodoc:
+      @parser.match_tag() do |tag|
+	case tag.name
+	when "input"
+	  case tag.attributes["type"]
+	  when "text"
+	    tree.push Text.new(tag.attributes["name"])			
+	  when "hidden"
+	    tree.push Hidden.new(tag.attributes["name"])
+	  when "password"
+	    tree.push Password.new(tag.attributes["name"])
+	  when "checkbox"
+	    tree.push CheckBox.new(tag.attributes["name"])
+	  end
+	when "textarea"
+	  tree.push TextArea.new(tag.attributes["name"],tag.attributes["rows"],tag.attributes["cols"],tag.attributes["virtual"],tag.attributes["style"],tag.attributes["id"])
+	when "foreach"
+	  parse_recurse("foreach") { |contents| 
+	    tree.push Foreach.new(tag.attributes["from"],tag.attributes["item"],contents)
+	  }
+	when "form"
+	  parse_recurse("form") { |contents| 
+	    tree.push Form.new(tag.attributes["name"],tag.attributes["method"],contents,@query)
+	  }
+	when "link"
+	  parse_recurse("link") { |contents| 
+	    tree.push Link.new(tag.attributes["value"],contents)
+	  }
+	when "select"
+	  tree.push Select.new(tag.attributes["name"], tag.attributes["values"])
+	when "if"
+	  parse_recurse("if") do |contents|
+	    tree.push If.new(tag.attributes["condition"],contents)		
+	  end
+	when "unless"
+	  parse_recurse("unless")do |contents|
+	    tree.push Unless.new(tag.attributes["condition"],contents)
+	  end
+	when "include"
+	  tree.push Include.new(tag.attributes["file"],tag.attributes["vars"],@templates)
+	else
+	  #TODO: raise unknown token exception
+	end
+      end
+    end
+    
+    def parse_recurse closeTag = nil, tree = [], &block  	# :nodoc:
+      catch(:done) do
+	while @parser.rest? do
+	  @parser.match( NOT_TOKEN ) do |m|
+	    tree.push Data.new(m[1])
+	  end 
+	  
+	  @parser.match_close_tag do |tag|
+	    if closeTag # TODO: make sure the correct close tag is given
+	      yield(tree) if block
+	      throw :done
+	    end
+	  end ||
+	    match_identifiers(tree) || 
+	    match_tags(tree) ||
+	    (tree.push(Data.new(@parser.rest)) &&
+	     throw(:done))
+	end     
+      end
+      tree
+    end
+  end
+
+
+  module TemplatePrinter #:nodoc:
+    attr_reader :template_name, :template_vars
+    # writes template to self.  Added by require 'narf/template'
+    # template can be a filename or a template string
+    def print_template (template, template_object ={}, query={})
+      flush
+      @template_vars = template_object
+      templater = Narflates.new(template,query)
+      templater.parse(self ,template_object)
+      @templates = templater.templates
+    end
+
+    # this must be an instance variable so that one can append
+    # to the include path without
+    # carrying over to the next test
+    def template_include_path
+      @template_include_path ||= Web::Narflates.template_include_path
+      #Web::Narflates.template_include_path
+    end
+    
+    # Check that a particluar template was used 
+    def assert_template_used expected, message =""
+      _wrap_assertion {
+        raise TemplateException.new("No template used") if @templates == nil
+        unless @templates.include? expected
+          msg = "expected template:<#{expected}> but not one of:<#{@templates.inspect}>"
+          flunk(msg)
+        end
+      }
+    end
+    
+    # Check that a particluar template was not used 
+    def assert_template_not_used expected, message =""
+      _wrap_assertion {
+        raise TemplateException.new("No template used") if @templates == nil
+        if @templates.include? expected
+          msg = "template:<#{expected}> not supposed to be used in:<#{@templates.inspect}>"
+          flunk(msg)
+        end
+      }
+    end
+    
+    # Check that these values were included in the output
+    def assert_vars_includes expected
+      assert_includes expected, @template_vars
+    end
+
+    def assert_vars_equals
+      raise Exception.new("Not yet implemented")
+    end
+  end
+  
+  class CGI
+    include TemplatePrinter
+  end
+end