def test_build_pages_nav(self):

->     self.spb.build_pages(self.fs_root)

       self.linker.replace_dirpath(self.base, False)

       funcsource = self.base.join('source/pkg/func.py.html')

       assert funcsource.check(file=True)

       html = funcsource.read()

       print html

       run_string_sequence_test(html, [

           'href="../style.css"',

           '<a href="index.html">pkg</a>',

           '<a href="someclass.py.html">someclass.py</a>',

           '<a href="somesubclass.py.html">somesubclass.py</a>',

       ])

   def build_pages(self, base):

       for fspath in [base] + list(base.visit()):

           if fspath.ext in ['.pyc', '.pyo']:

               continue

           if self.capture:

               self.capture.err.writeorg('.')

           relfspath = fspath.relto(base)

           if relfspath.find('%s.' % (os.path.sep,)) > -1:

               # skip hidden dirs and files

               continue

           elif fspath.check(dir=True):

               if relfspath != '':

                   relfspath += os.path.sep

               reloutputpath = 'source%s%sindex.html' % (os.path.sep,

                                                         relfspath)

           else:

               reloutputpath = "source%s%s.html" % (os.path.sep, relfspath)

           reloutputpath = reloutputpath.replace(os.path.sep, '/')

           outputpath = self.base.join(reloutputpath)

           self.linker.set_link(str(fspath), reloutputpath)

->         self.build_page(fspath, outputpath, base)

   def build_page(self, fspath, outputpath, base):

       """ build syntax-colored source views """

       if fspath.check(ext='.py'):

           try:

               tag, nav = self.build_python_page(fspath)

           except (KeyboardInterrupt, SystemError):

               raise

           except: # XXX strange stuff going wrong at times... need to fix

               raise

               exc, e, tb = py.std.sys.exc_info()

               print '%s - %s' % (exc, e)

               print

               print ''.join(py.std.traceback.format_tb(tb))

               print '-' * 79

               del tb

               tag, nav = self.build_nonpython_page(fspath)

       elif fspath.check(dir=True):

->         tag, nav = self.build_dir_page(fspath)

       else:

           tag, nav = self.build_nonpython_page(fspath)

       title = 'sources for %s' % (fspath.basename,)

       rev = self.get_revision(fspath)

       if rev:

           title += ' [rev. %s]' % (rev,)

       reltargetpath = outputpath.relto(self.base).replace(os.path.sep,

                                                           '/')

       self.write_page(title, reltargetpath, tag, nav)

   def build_dir_page(self, fspath):

       dirs, files = source_dirs_files(fspath)

       dirs = [(p.basename, self.linker.get_lazyhref(str(p))) for p in dirs]

       files = [(p.basename, self.linker.get_lazyhref(str(p))) for p in files]

       tag = H.DirList(dirs, files)

->     nav = self.build_navigation(fspath)

       return tag, nav

   def build_navigation(self, fspath):

       nav = H.Navigation(class_='sidebar')

       relpath = fspath.relto(self.projroot)

       path = relpath.split(os.path.sep)

       indent = 0

       # build links to parents

       if relpath != '':

           for i in xrange(len(path)):

               dirpath = os.path.sep.join(path[:i])

               abspath = self.projroot.join(dirpath).strpath

               if i == 0:

                   text = self.projroot.basename

               else:

                   text = path[i-1]

               nav.append(H.NavigationItem(self.linker, abspath, text,

                                           indent, False))

               indent += 1

       # build siblings or children and self

       if fspath.check(dir=True):

           # we're a dir, build ourselves and our children

           dirpath = fspath

           nav.append(H.NavigationItem(self.linker, dirpath.strpath,

                                       dirpath.basename, indent, True))

           indent += 1

       elif fspath.strpath == self.projroot.strpath:

           dirpath = fspath

       else:

           # we're a file, build our parent's children only

           dirpath = fspath.dirpath()

->     diritems, fileitems = source_dirs_files(dirpath)

       for dir in diritems:

           nav.append(H.NavigationItem(self.linker, dir.strpath, dir.basename,

                                       indent, False))

       for file in fileitems:

           selected = (fspath.check(file=True) and

                       file.basename == fspath.basename)

           nav.append(H.NavigationItem(self.linker, file.strpath,

                                       file.basename, indent, selected))

       return nav

   def source_dirs_files(fspath):

       """ returns a tuple (dirs, files) for fspath

           dirs are all the subdirs, files are the files which are interesting

           in building source documentation for a Python code tree (basically all

           normal files excluding .pyc and .pyo ones)

           all files and dirs that have a name starting with . are considered

           hidden

       """

       dirs = []

       files = []

->     for child in fspath.listdir():

           if child.basename.startswith('.'):

               continue

           if child.check(dir=True):

               dirs.append(child)

           elif child.check(file=True):

               if child.ext in ['.pyc', '.pyo']:

                   continue

               files.append(child)

       return sorted(dirs), sorted(files)