# Build and install an Apple Help Viewer compatible version of the Python

# documentation into the framework.

# Code by Bill Fancher, with some modifications by Jack Jansen.

#

# You must run this as a two-step process

# 1. python setupDocs.py build

# 2. Wait for Apple Help Indexing Tool to finish

# 3. python setupDocs.py install

#

# To do:

# - test whether the docs are available locally before downloading

# - fix buildDocsFromSource

# - Get documentation version from sys.version, fallback to 2.2.1

# - See if we can somehow detect that Apple Help Indexing Tool is finished

# - data_files to setup() doesn't seem the right way to pass the arguments

#

import sys, os, re

from distutils.cmd import Command

from distutils.command.build import build

from distutils.core import setup

from distutils.file_util import copy_file

from distutils.dir_util import copy_tree

from distutils.log import log

from distutils.spawn import spawn

from distutils import sysconfig, dep_util

from distutils.util import change_root

import HelpIndexingTool

import Carbon.File

import time

MAJOR_VERSION='2.4'

MINOR_VERSION='2.4.1'

DESTDIR='/Applications/MacPython-%s/PythonIDE.app/Contents/Resources/English.lproj/PythonDocumentation' % MAJOR_VERSION

class DocBuild(build):

    def initialize_options(self):

        build.initialize_options(self)

        self.build_html = None

        self.build_dest = None

        self.download = 1

        self.doc_version = MINOR_VERSION # Only needed if download is true

    def finalize_options(self):

        build.finalize_options(self)

        if self.build_html is None:

            self.build_html = os.path.join(self.build_base, 'html')

        if self.build_dest is None:

            self.build_dest = os.path.join(self.build_base, 'PythonDocumentation')

    def spawn(self, *args):

        spawn(args, 1,  self.verbose, self.dry_run)

    def downloadDocs(self):

        workdir = os.getcwd()

        # XXX Note: the next strings may change from version to version

        url = 'http://www.python.org/ftp/python/doc/%s/html-%s.tar.bz2' % \

                (self.doc_version,self.doc_version)

        tarfile = 'html-%s.tar.bz2' % self.doc_version

        dirname = 'Python-Docs-%s' % self.doc_version

        if os.path.exists(self.build_html):

            raise RuntimeError, '%s: already exists, please remove and try again' % self.build_html

        os.chdir(self.build_base)

        self.spawn('curl','-O', url)

        self.spawn('tar', '-xjf', tarfile)

        os.rename(dirname, 'html')

        os.chdir(workdir)

##        print "** Please unpack %s" % os.path.join(self.build_base, tarfile)

##        print "** Unpack the files into %s" % self.build_html

##        raise RuntimeError, "You need to unpack the docs manually"

    def buildDocsFromSource(self):

        srcdir = '../../..'

        docdir = os.path.join(srcdir, 'Doc')

        htmldir = os.path.join(docdir, 'html')

        spawn(('make','--directory', docdir, 'html'), 1, self.verbose, self.dry_run)

        self.mkpath(self.build_html)

        copy_tree(htmldir, self.build_html)

    def ensureHtml(self):

        if not os.path.exists(self.build_html):

            if self.download:

                self.downloadDocs()

            else:

                self.buildDocsFromSource()

    def hackIndex(self):

        ind_html = 'index.html'

        #print 'self.build_dest =', self.build_dest

        hackedIndex = file(os.path.join(self.build_dest, ind_html),'w')

        origIndex = file(os.path.join(self.build_html,ind_html))

        r = re.compile('<style type="text/css">.*</style>', re.DOTALL)

        hackedIndex.write(r.sub('<META NAME="AppleTitle" CONTENT="Python Documentation">',origIndex.read()))

    def hackFile(self,d,f):

        origPath = os.path.join(d,f)

        assert(origPath[:len(self.build_html)] == self.build_html)

        outPath = os.path.join(self.build_dest, d[len(self.build_html)+1:], f)

        (name, ext) = os.path.splitext(f)

        if os.path.isdir(origPath):

            self.mkpath(outPath)

        elif ext == '.html':

            if self.verbose: print 'hacking %s to %s' % (origPath,outPath)

            hackedFile = file(outPath, 'w')

            origFile = file(origPath,'r')

            hackedFile.write(self.r.sub('<dl><dt><dd>', origFile.read()))

        else:

            copy_file(origPath, outPath)

    def hackHtml(self):

        self.r = re.compile('<dl><dd>')

        os.path.walk(self.build_html, self.visit, None)

    def visit(self, dummy, dirname, filenames):

        for f in filenames:

            self.hackFile(dirname, f)

    def makeHelpIndex(self):

        app = '/Developer/Applications/Apple Help Indexing Tool.app'

        self.spawn('open', '-a', app , self.build_dest)

        print "Please wait until Apple Help Indexing Tool finishes before installing"

    def makeHelpIndex(self):

        app = HelpIndexingTool.HelpIndexingTool(start=1)

        app.open(Carbon.File.FSSpec(self.build_dest))

        sys.stderr.write("Waiting for Help Indexing Tool to start...")

        while 1:

            # This is bad design in the suite generation code!

            idle = app._get(HelpIndexingTool.Help_Indexing_Tool_Suite._Prop_idleStatus())

            time.sleep(10)

            if not idle: break

            sys.stderr.write(".")

        sys.stderr.write("\n")

        sys.stderr.write("Waiting for Help Indexing Tool to finish...")

        while 1:

            # This is bad design in the suite generation code!

            idle = app._get(HelpIndexingTool.Help_Indexing_Tool_Suite._Prop_idleStatus())

            time.sleep(10)

            if idle: break

            sys.stderr.write(".")

        sys.stderr.write("\n")

    def run(self):

        self.ensure_finalized()

        self.mkpath(self.build_base)

        self.ensureHtml()

        if not os.path.isdir(self.build_html):

            raise RuntimeError, \

            "Can't find source folder for documentation."

        self.mkpath(self.build_dest)

        if dep_util.newer(os.path.join(self.build_html,'index.html'), os.path.join(self.build_dest,'index.html')):

            self.mkpath(self.build_dest)

            self.hackHtml()

            self.hackIndex()

            self.makeHelpIndex()

class AHVDocInstall(Command):

    description = "install Apple Help Viewer html files"

    user_options = [('install-doc=', 'd',

            'directory to install HTML tree'),

             ('root=', None,

             "install everything relative to this alternate root directory"),

            ]

    def initialize_options(self):

        self.build_dest = None

        self.install_doc = None

        self.prefix = None

        self.root = None

    def finalize_options(self):

        self.set_undefined_options('install',

                ('prefix', 'prefix'),

                ('root', 'root'))

#               import pdb ; pdb.set_trace()

        build_cmd = self.get_finalized_command('build')

        if self.build_dest is None:

            build_cmd = self.get_finalized_command('build')

            self.build_dest = build_cmd.build_dest

        if self.install_doc is None:

            self.install_doc = os.path.join(self.prefix, DESTDIR)

        print 'INSTALL', self.build_dest, '->', self.install_doc

    def run(self):

        self.finalize_options()

        self.ensure_finalized()

        print "Running Installer"

        instloc = self.install_doc

        if self.root:

            instloc = change_root(self.root, instloc)

        self.mkpath(instloc)

        copy_tree(self.build_dest, instloc)

        print "Installation complete"

def mungeVersion(infile, outfile):

    i = file(infile,'r')

    o = file(outfile,'w')

    o.write(re.sub('\$\(VERSION\)',sysconfig.get_config_var('VERSION'),i.read()))

    i.close()

    o.close()

def main():

    # turn off warnings when deprecated modules are imported

##      import warnings

##      warnings.filterwarnings("ignore",category=DeprecationWarning)

    setup(name = 'Documentation',

            version = '%d.%d' % sys.version_info[:2],

            cmdclass = {'install_data':AHVDocInstall, 'build':DocBuild},

            data_files = ['dummy'],

            )

if __name__ == '__main__':

    main()