class MouseHole
    def upwink( req, res )
        if res.status == 200 and req.request_uri.to_s !~ /^#{ home_url }/
            if req.request_uri.path =~ /\.user\.rb$/
                scrip = File.basename( req.request_uri.path )
                evaluator = Evaluator.new( scrip, res.body.dup )
                t = Tempfile.new( scrip )
                t.write evaluator.code
                evaluator.script_id = t.path
                @temp_scripts[t.path] = [t, req.request_uri.to_s, scrip]
                t.close
                Thread.start( evaluator ) do |e|
                    e.taint
                    $SAFE = 4
                    e.evaluate
                end
                res.body = installer_pane( evaluator, "#{ home_url }mouseHole/install" )
                res['content-type'] = 'text/html'
                res['content-length'] = res.body.length
                no_cache res
                res.setup_header
            elsif @conf[:rewrites_on]
                each_fresh_script do |path, script|
                    next unless script.match req.request_uri
                    next unless script.document_converter.handles_type?(res.content_type)
                    logger.info "Executing #{script.name}"
                    script.execute( req, res )
                end
                res['content-length'] = res.body.length
                no_cache res
            end
        end
    end
    
    class HtmlDocumentConverter
        def parse_string(body)
            parse_xhtml(HTree.parse(body))
        end
        def output_string(document, stream)
            fix_doc(document)
            document.write(stream)
        end
        def fix_doc(e)
            if(HTree::ElementContent[e.expanded_name] == :empty) 
                e.children.each { |x| x.delete}
            elsif e.children.empty?
                e << REXML::Text.new('')
            end
            e.each { |x| fix_doc(x) if REXML::Element === x}
        end
        def parse_xhtml( htree )
            htree.each_child do |child|
            if child.respond_to? :qualified_name
                if child.qualified_name == 'html'
                return HTree::Doc.new( child ).to_rexml
                break
                end
            end
            end
        end	  
        def handles_type?(type)
            [
                /^text\/html/, 
                /^application\/xhtml+xml/
            ].any? {|x| x === type }
        end        
    end
    
    class XmlDocumentConverter
        def parse_string(body)
            REXML::Document.new(body)
        end
        def output_string(document, stream)
            document.write(stream)
        end
        def handles_type?(type)
            /^text\/xml/ === type
        end
    end
    
    class UserScript

	def document_converter s = nil; s ? @document_converter = s : (@document_converter || HtmlDocumentConverter.new) end
        def execute( req, res )
            return unless rewrite_proc
            @document = document_converter.parse_string( res.body )
            return unless @document
            rewrite_proc[ req, res ]
            document_converter.output_string(document, res.body = "" )
        end

        def read_xhtml_from( uri )
            HtmlDocumentConverter.new.parse_xhtml( open( uri ) { |f| HTree.parse f } )
        end
    end    
end

#restore this so that it can go about it's business.
class REXML::Element
	def write(writer=$stdout, indent=-1, transitive=false, ie_hack=false)
		#print "ID:#{indent}"
                writer << "<#@expanded_name"
                @attributes.each_attribute do |attr|
                        writer << " "
                        attr.write( writer, indent )
                end unless @attributes.empty?

                if @children.empty?
			if transitive and indent>-1
			  writer << "\n"
			  indent( writer, indent )
			elsif ie_hack
			  writer << " " 
			end
			writer << "/" 
		else
			if transitive and indent>-1 and !@children[0].kind_of? Text
				writer << "\n"
				indent writer, indent+1
			end
			writer << ">"
			write_children( writer, indent, transitive, ie_hack )
			writer << "</#{expanded_name}"
		end
		if transitive and indent>-1 and !@children.empty?
			writer << "\n"
			indent -= 1 if next_sibling.nil?
			indent(writer, indent)
		end
		writer << ">"
	end
end