}
 
 type File struct {
-       FileName, OutFile, Extension, Dir string
+       FileName, Extension, Dir string
 }
 
 type PageMeta struct {
                page.Summary = template.HTML(getRstContent(summary))
        }
 }
+
+func (p *Page) TargetPath() (outfile string) {
+
+       // Always use Url if it's specified
+       if len(strings.TrimSpace(p.Url)) > 2 {
+               outfile = strings.TrimSpace(p.Url)
+
+               if strings.HasSuffix(outfile, "/") {
+                       outfile = outfile + "index.html"
+               }
+               return
+       }
+
+       if len(strings.TrimSpace(p.Slug)) > 0 {
+               outfile = strings.TrimSpace(p.Slug) + "." + p.Extension
+       } else {
+               // Fall back to filename
+               _, t := path.Split(p.FileName)
+               outfile = replaceExtension(strings.TrimSpace(t), p.Extension)
+       }
+
+       return path.Join(p.Dir, strings.TrimSpace(outfile))
+}
+
 
                        continue
                }
 
-               trns, err := s.Target.Translate(p.OutFile)
+               trns, err := s.Target.Translate(p.TargetPath())
                if err != nil {
                        return err
                }
 
        "html/template"
        "io"
        "os"
-       "path"
        "strings"
        "time"
 )
                page.Tmpl = s.Tmpl
                page.Section = file.Section
                page.Dir = file.Dir
-               if err = s.setUrlPath(page); err != nil {
-                       return err
-               }
                if s.Config.BuildDrafts || !page.Draft {
                        s.Pages = append(s.Pages, page)
                }
        return
 }
 
-// Set p.Section and p.OutFile relying on p.FileName as the source.
-// Filename is broken apart for a "Section" which basically equates to
-// the folder the file exists in.
-func (s *Site) setUrlPath(p *Page) (err error) {
-
-       // Always use Url if it's specified
-       if len(strings.TrimSpace(p.Url)) > 2 {
-               p.OutFile = strings.TrimSpace(p.Url)
-
-               if strings.HasSuffix(p.OutFile, "/") {
-                       p.OutFile = p.OutFile + "index.html"
-               }
-               return
-       }
-
-       var outfile string
-       if len(strings.TrimSpace(p.Slug)) > 0 {
-               outfile = strings.TrimSpace(p.Slug) + "." + p.Extension
-       } else {
-               // Fall back to filename
-               _, t := path.Split(p.FileName)
-               outfile = replaceExtension(strings.TrimSpace(t), p.Extension)
-       }
-
-       p.OutFile = p.Dir + "/" + strings.TrimSpace(outfile)
-       return
-}
-
 func (s *Site) BuildSiteMeta() (err error) {
        s.Indexes = make(IndexList)
        s.Sections = make(Index)
                var layout string
 
                if !p.IsRenderable() {
-                       layout = "__" + p.FileName
+                       layout = "__" + p.TargetPath()
                        _, err := s.Tmpl.New(layout).Parse(string(p.Content))
                        if err != nil {
                                return err
                if err != nil {
                        return err
                }
-               err = s.WritePublic(p.OutFile, content)
+               err = s.WritePublic(p.TargetPath(), content)
                if err != nil {
                        return err
                }
 }
 
 func (s *Site) RenderHomePage() error {
+       return nil
+
        n := s.NewNode()
        n.Title = n.Site.Title
        n.Url = helpers.Urlize(string(n.Site.BaseUrl))
 
        }
 }
 
-func TestSetOutFile(t *testing.T) {
+func TestTargetPath(t *testing.T) {
        tests := []struct {
                doc             string
                content         string
                return
        }
        for _, test := range tests {
-               var err error
                s := &Site{
                        Config: Config{ContentDir: "content"},
                }
                p := pageMust(ReadFrom(strings.NewReader(test.content), s.Config.GetAbsPath(test.doc)))
-               if err = s.setUrlPath(p); err != nil {
-                       t.Fatalf("Unable to set urlpath: %s", err)
-               }
 
                expected := test.expectedOutFile
 
-               if p.OutFile != expected {
-                       t.Errorf("%s => p.OutFile  expected: '%s', got: '%s'", test.doc, expected, p.OutFile)
+               if p.TargetPath() != expected {
+                       t.Errorf("%s => OutFile  expected: '%s', got: '%s'", test.doc, expected, p.TargetPath())
                }
 
                if p.Section != test.expectedSection {
                {"sect/doc3.html", "<html><head></head><body><h1>doc3</h1>\n\n<p><em>some</em> content</p>\n</body></html>"},
                {"sect/doc4.html", "<html><head></head><body><h1>doc4</h1>\n\n<p><em>some content</em></p>\n</body></html>"},
                {"sect/doc5.html", "<!DOCTYPE html><html><head><script src=\"http://auth/bub/script.js\"></script></head><body>body5</body></html>"},
-               {"./doc7.html", "<html><head></head><body>doc7 content</body></html>"},
+               {"doc7.html", "<html><head></head><body>doc7 content</body></html>"},
        }
 
        for _, test := range tests {