narf 0.6.2 → 0.6.3

data/lib/web/runner.rb~

@@ -1,26 +0,0 @@
-#!/usr/bin/ruby
-
-require 'web'
-
-docroot = ENV["DOCUMENT_ROOT"]
-Web.set_docroot docroot
-$:.replace(["#{docroot}/../src","#{docroot}/../config"].concat($:))
-
-def cgi # :nodoc:
-    Web::CGI.create()
-end
-
-begin
-    load ARGV[0]
-rescue Exception => err
-    cgi.puts "<h3>ruby error:</h3>"
-    cgi.puts Dir.pwd
-    cgi.puts err.to_s.gsub(/\n/,"<br><br>")
-    cgi.puts "<blockquote>"
-    cgi.puts (if (err.backtrace.size > 3)
-               err.backtrace[0...-2]
-	     else
-               err.backtrace
-             end).collect{ |string| string + "<br>" }
-    cgi.puts "</blockquote>"
-end

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

@@ -1,25 +0,0 @@
-# see cgi.rb and Web::process
-
-require 'web/cgi'
-
-module Web
-  class FastCGD < CGD
-    def FastCGD::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
-

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

@@ -1,46 +0,0 @@
-# see cgi.rb and Web::process
-
-require 'web/cgi'
-
-module Web
-  class CGD
-    class ModRubyCGD < CGD
-      def initialize( options = {} )
-        options[:env] = {}
-        ENV.each{|k,v|
-          options[:env][k] = v
-        }
-        Apache::request.headers_in.each{ |k,v|
-          options[:env][k] = v
-        }
-        super(options)
-      end
-
-      def send_header header
-        Apache::request.status_line  = header['Status'].first.split.shift
-        Apache::request.content_type = header['Content-Type'].first
-        Apache::request.content_encoding = (header['Content-Encoding'] || [ ]).first
-        
-        header.delete( "Status" )
-        header.delete( "Content-Type" )
-        header.delete( "Content-Encoding" )
-        
-        if (header["Set-Cookie"])
-          header["Set-Cookie"].each{ |cookie|
-            Apache::request.headers_out.add( "Set-Cookie", cookie )
-          }
-          header.delete( "Set-Cookie" )
-        end
-        
-        header.each{ |k,v|
-          Apache::request.headers_out[k] = v.last
-        }
-        
-        Apache::request.send_http_header
-        
-      end
-
-    end
-  end
-end
-

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

@@ -1,89 +0,0 @@
-# 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 WebrickCGD < Web::CGD
-    def send_header( header )
-      
-    end
-  end
-
-  class NarfHandler < WEBrick::HTTPServlet::AbstractServlet
-
-    def initialize(server, name)
-      super
-      @script_filename = name
-      @tempdir = server[:TempDir]
-    end
-    
-    def do_GET(req, res)
-      header, body = nil, nil
-      
-      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]
-        
-        Web::process( :cgd => Web::WebrickCGD.new(:out => cgi_out,
-                                                  :in  => StringIO.new( req.body || '' ),
-                                                  :env => meta ) ) {
-          load( @script_filename, true )
-        }
-        
-      ensure
-        Web::close
-        
-        cgi_out.rewind
-        body = cgi_out.read
-        cgi_out.close(true)
-        
-        if errmsg = cgi_err.read
-          if errmsg.size > 0
-            @logger.error("NarfHandler: #{@script_filename}:\n" + errmsg)
-          end
-        end 
-        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
-  
-end

data/lib/web/session.rb~

@@ -1,75 +0,0 @@
-require 'digest/md5'
-module Web
-  # == Purpose
-  # Provides a file based implemetation of a session.
-  # This is hacked up from matz's CGI::Session
-  class Session
-	
-
-	class << self
-	    def create_id
-		md5 = Digest::MD5.new
-		md5.update( String(Time.now.to_f) )
-		md5.update( String(rand(0))  ) 
-		#md5.update( String($$)       )
-		#md5.update( 'thanks matz'    )
-		md5.hexdigest[0,16]
-	    end
-	end
-
-	def initialize( cgi, options={} )
-	    @session_id = load_id( cgi, options )
-
-	    send_cookie( cgi, options[:session_key] || "_session_id" )
-
-	    @session = get_session_from_disk
-	end
-
-	def get_session_from_disk
-	    if File.exists? file
-		File.open( file, "r" ) { |store|
-		    Marshal.load store
-		}
-	    else
-		{}
-	    end
-	end
-
-	def load_id( cgi, options )
-	    if (options.has_key? :session_id)
-		options[:session_id]
-	    elsif(cgi.cookies["_session_id"] && !cgi.cookies["_session_id"].empty?)
-		cgi.cookies["_session_id"][0]
-	    else
-		Session.create_id
-	    end
-	end
-	    
-
-	def send_cookie( cgi, session_key )
-	    cgi.set_cookie( session_key, @session_id )
-	end
-
-
-	# saves session to disk
-	def save
-	    File.open( file, "w+" ) { |store|
-		Marshal.dump( @session, store )
-	    }
-	end
-
-	def file
-	    File.expand_path(File.join((ENV['TMP'] || '/tmp' ), @session_id.to_s))
-	end
-	
-	# resets session to empty hash, for use in testing
-	def reset
-	    @session = {}
-	end
-	
-	def method_missing(method, *args, &block)
-	    # much faster than simple delegator
-	    @session.send(method,*args,&block)
-	end
-    end
-end

data/lib/web/tagparser.rb~

@@ -1,96 +0,0 @@
-Struct.new("Tag",:name,:attributes)
-Tag = Struct::Tag
-
-class StrScanParser < StrScanParserR #:nodoc:
-
-    TAG_START = /<narf:/
-    TAG_END = />/
-    TAG_CLOSE_START = /<\/narf:/
-    TAG_NAME = /(\w+)/
-    WHITESPACE = /\s*/
-    QUOTE = /"/
-    QUOTED_ATTRIBUTE_VALUE = /([^"?]+)/
-    UNQUOTED_ATTRIBUTE_VALUE = /([\w.\/\$?]+)/
-    EQUALS = /=/
-    ATTRIBUTE_NAME = /(\w+)/
-    
-    def match_value 
-	if @scanner.scan(QUOTE)
-	    if @scanner.scan(QUOTED_ATTRIBUTE_VALUE)
-		yield @scanner[1]
-		@scanner.scan(QUOTE) || raise(MissingQuoteException.new)
-	    end
-	elsif @scanner.scan(UNQUOTED_ATTRIBUTE_VALUE)
-	    yield @scanner[1]
-	end
-    end
-    
-    def match_attribute
-	if @scanner.scan(ATTRIBUTE_NAME)
-	    name = @scanner[1]
-	    if @scanner.scan(EQUALS)
-		match_value do |value|
-		    yield({ name => value })
-		end || raise(MissingAttributeException.new)
-	    else
-		yield({ name => nil })
-	    end
-	end 
-    end
-    
-    def match_tag
-	if @scanner.scan(TAG_START)
-	    name = ""
-	    nvs = {}
-	    if @scanner.scan(TAG_NAME)
-		name = @scanner[1]
-		while true
-		    @scanner.scan(WHITESPACE)
-		    match_attribute do |nv|
-			nvs.update(nv)
-		    end || if @scanner.scan(TAG_END)
-			       yield Tag.new(name,nvs)
-			       return true
-			   else 
-			       raise(TagNotClosedException.new)
-			   end
-		end
-	    else
-		raise(TagNotNamedException.new)
-	    end
-	end
-    end
-
-    def match_close_tag
-	if @scanner.scan (TAG_CLOSE_START)
-	    tag = nil
-	    if @scanner.scan(TAG_NAME) 
-		tag = @scanner[1]
-	    end # TODO raise missing name exception
-	    @scanner.scan(TAG_END) # TODO raise missing end tag exception
-	    yield tag if tag
-	end
-    end
-
-    def match_identifier
-	if @scanner.scan(/\{\$([\w.\?]*?)\}/)
-            yield @scanner[1]
-        end
-    end
-end
-
-class MissingAttributeException < Exception # :nodoc:
-
-end
-
-class TagNotClosedException < Exception # :nodoc:
-    
-end
-
-class TagNotNamedException < Exception # :nodoc:
-    
-end
-
-class MissingQuoteException < Exception # :nodoc:
-    
-end

data/lib/web/template.rb~

@@ -1,613 +0,0 @@
-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.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"}]
-  #
-  #     --- 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