#!/usr/bin/env python

# -*- coding: utf-8 -*-

##############################################################################

# cmd_py2sis.py - Ensymble command line tool, py2sis command

# Copyright 2006, 2007, 2008, 2009 Jussi Ylänen

#

# Portions Copyright (c) 2008-2009 Nokia Corporation

#

# This file is part of Ensymble developer utilities for Symbian OS(TM).

#

# Ensymble is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# Ensymble is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with Ensymble; if not, write to the Free Software

# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

##############################################################################

import sys

import os

import re

import imp

import getopt

import getpass

import locale

import zlib

import shutil

import time

import zipfile

import sisfile

import sisfield

import symbianutil

import rscfile

import miffile

import module_repo

import py_compile

##############################################################################

#  Specify the magic number of the Python interpreter used in PyS60.

##############################################################################

pys60_magic_number = '\xb3\xf2\r\n'

##############################################################################

# Help texts

##############################################################################

shorthelp = 'Create a SIS package for a "Python for S60" application'

longhelp = '''py2sis

    [--uid=0x01234567] [--appname=AppName] [--version=1.0.0]

    [--lang=EN,...] [--icon=icon.svg] [--shortcaption="App. Name",...]

    [--caption="Application Name",...] [--drive=C] [--extrasdir=root]

    [--textfile=mytext_%C.txt] [--cert=mycert.cer] [--privkey=mykey.key]

    [--passphrase=12345] [--heapsize=min,max] [--caps=Cap1+Cap2+...]

    [--vendor="Vendor Name",...] [--autostart] [--runinstall]

    [--encoding=terminal,filesystem] [--verbose] [--profile=s60ui]

    [--mode=pys60] [--extra-modules=mod1,...] [--sourcecode]

    [--ignore-missing-deps] [--platform-uid=0x101f7961,...]

    <src> [sisfile]

Create a SIS package for a "Python for S60" application.

Options:

    src           - Source script or directory

    sisfile       - Path of the created SIS file

    uid           - Symbian OS UID for the application

    appname       - Name of the application

    version       - Application version: X.Y.Z or X,Y,Z (major, minor, build)

    lang          - Comma separated list of two-character language codes

    icon          - Icon file in SVG-Tiny format

    shortcaption  - Comma separated list of short captions in all languages

    caption       - Comma separated list of long captions in all languages

    drive         - Drive where the package will be installed (any by default)

    extrasdir     - Name of dir. tree placed under drive root (none by default)

    textfile      - Text file (or pattern, see below) to display during install

    cert          - Certificate to use for signing (PEM format)

    privkey       - Private key of the certificate (PEM format)

    passphrase    - Pass phrase of the private key (insecure, use stdin instead)

    caps          - Capability names, separated by "+" (LocalServices, NetworkServices,

                    ReadUserData, WriteUserData and UserEnvironment by default)

    vendor        - Vendor name or a comma separated list of names in all lang.

    autostart     - Application is registered to start on each device boot

    runinstall    - Application is automatically started after installation

    heapsize      - Application heap size, min. and/or max. ("100K,4M" by default)

    encoding      - Local character encodings for terminal and filesystem

    verbose       - Print extra statistics

    profile       - Script execution environment. Either console or s60ui

    mode          - Module to be packaged when names conflict. Either from pycore or pys60

    extra-modules - Additional dependency modules that should be packaged with the application

    sourcecode    - Package scripts as source code. By default the scripts are packaged as bytecode

    ignore-missing-deps - Ignore any missing dependencies during packaging

    platform-uid  - UID of the supported S60 platforms

If no certificate and its private key are given, a default self-signed

certificate is used to sign the SIS file. Software authors are encouraged

to create their own unique certificates for SIS packages that are to be

distributed.

If no icon is given, the Python logo is used as the icon. The Python

logo is a trademark of the Python Software Foundation.

Text to display uses UTF-8 encoding. The file name may contain formatting

characters that are substituted for each selected language. If no formatting

characters are present, the same text will be used for all languages.

    %%           - literal %

    %n           - language number (01 - 99)

    %c           - two-character language code in lowercase letters

    %C           - two-character language code in capital letters

    %l           - language name in English, using only lowercase letters

    %l           - language name in English, using mixed case letters

'''

##############################################################################

# Parameters

##############################################################################

MAXPASSPHRASELENGTH     = 256

MAXCERTIFICATELENGTH    = 65536

MAXPRIVATEKEYLENGTH     = 65536

MAXICONFILESIZE         = 65536

MAXOTHERFILESIZE        = 1024 * 1024 * 8   # Eight megabytes

MAXTEXTFILELENGTH       = 1024

##############################################################################

# Public module-level functions

##############################################################################

def run(pgmname, argv):

    # Determine system character encodings.

    try:

        # getdefaultlocale() may sometimes return None.

        # Fall back to ASCII encoding in that case.

        terminalenc = locale.getdefaultlocale()[1] + ""

    except TypeError:

        # Invalid locale, fall back to ASCII terminal encoding.

        terminalenc = "ascii"

    try:

        # sys.getfilesystemencoding() was introduced in Python v2.3 and

        # it can sometimes return None. Fall back to ASCII if something

        # goes wrong.

        filesystemenc = sys.getfilesystemencoding() + ""

    except (AttributeError, TypeError):

        filesystemenc = "ascii"

    try:

        gopt = getopt.gnu_getopt

    except:

        # Python <v2.3, GNU-style parameter ordering not supported.

        gopt = getopt.getopt

    # Parse command line arguments.

    short_opts = "u:n:r:l:i:s:c:f:x:t:a:k:p:b:d:gRH:e:vhP:m:o:Sy:Iq"

    long_opts = [

        "uid=", "appname=", "version=", "lang=", "icon=",

        "shortcaption=", "caption=", "drive=", "extrasdir=", "textfile=",

        "cert=", "privkey=", "passphrase=", "caps=", "vendor=",

        "autostart", "runinstall", "heapsize=",

        "encoding=", "verbose", "debug", "help", "profile=", "mode=",

        "extra-modules=", "sourcecode", "ignore-missing-deps", "platform-uid="]

    args = gopt(argv, short_opts, long_opts)

    opts = dict(args[0])

    pargs = args[1]

    if len(pargs) == 0:

        raise ValueError("no source file name given")

    # Override character encoding of command line and filesystem.

    encs = opts.get("--encoding", opts.get("-e", "%s,%s" % (terminalenc,

                                                            filesystemenc)))

    try:

        terminalenc, filesystemenc = encs.split(",")

    except (ValueError, TypeError):

        raise ValueError("invalid encoding string '%s'" % encs)

    # Determine if debug output is requested.

    if "--debug" in opts.keys():

        # Enable debug output for OpenSSL-related functions.

        import cryptutil

        cryptutil.setdebug(True)

        module_repo.debug = True

    module_repo.debug_log = open("debug.txt", "w")

    # Check if ignore-missing-deps flag is set. If not then abort sis

    # generation printing the missing dependencies as errors.

    if "--ignore-missing-deps" in opts.keys() or "-I" in opts.keys():

        module_repo.ignore_missing_deps = True

    # If sourcecode option is set then the application is packaged as source

    # code. By default it is packaged as bytecode.

    bytecode = True

    if "--sourcecode" in opts.keys() or "-S" in opts.keys():

        bytecode = False

    # Get source name, either a Python program or a directory.

    src = pargs[0].decode(terminalenc).encode(filesystemenc)

    extrasdir = opts.get("--extrasdir", opts.get("-x", None))

    if extrasdir != None:

        extrasdir = extrasdir.decode(terminalenc).encode(filesystemenc)

        if extrasdir[-1] == os.sep:

            # Strip trailing slash (or backslash).

            extrasdir = extrasdir[:-1]

        if os.sep in extrasdir:

            raise ValueError("%s: too many path components" % extrasdir)

        if not os.path.isdir(src):

            raise RuntimeError("extrasdir option can only be used when the" +

                               " source is a directory")

        if not os.path.isdir(os.path.join(os.path.abspath(src), extrasdir)):

            raise RuntimeError("Directory specified using --extrasdir" +\

                               " option does not exist")

    # Get the profile in which the  python script should be executed - OpenC

    # console mode or s60ui mode

    profile = opts.get("--profile", opts.get("-P", "s60ui"))

    if profile not in ['console', 's60ui']:

        raise ValueError("Invalid profile. Set either console or s60ui")

    # Check if Python core modules take priority over PyS60 modules

    mode = opts.get("--mode", opts.get("-m", "pycore"))

    if mode not in ['pycore', 'pys60']:

        raise ValueError("Invalid mode. Set either pys60 or pycore")

    # Get the S60 platform uid of the devices on which the Python

    # application is supported

    platform_uid = opts.get("--platform-uid", "0x101f7961,0x1028315F")

    # Extra module(s) to be packaged with application sis

    extra_modules = opts.get("--extra-modules", opts.get("-o", None))

    # module_repo.get_dependency_list returns a map with the following format:

    # {'repo': [<dependency list of standard repo modules>],

    #  'dev': [<dependency list of dev modules>]}

    extra_modules_map = module_repo.get_dependency_list(src, extra_modules)

    if mode == 'pys60':

        # Add calendar.py and socket.py wrappers to app's private directory

        conflicting_modules = {'calendar': 'e32calendar', 'socket': 'btsocket'}

        for module in conflicting_modules:

            if module in extra_modules_map[module_repo.std_repo_module]:

                extra_modules_map[module_repo.std_repo_module].remove(module)

                extra_modules_map[module_repo.dev_repo_module].append(

                                                   conflicting_modules[module])

    tmpdir_suffix = '_' + time.strftime("%H%M%S")

    if not os.path.isdir(src):

        # app is a file. Create app directory, rename app file to

        # default.py, and add dependency

        srcdir, srcfile = os.path.split(src)

        appdir = os.path.join(srcdir, srcfile[:-3] + tmpdir_suffix)

        os.mkdir(appdir)

        shutil.copy(src, appdir)

        os.rename(os.path.join(appdir, srcfile),

                  os.path.join(appdir, "default.py"))

        src = appdir

    else:

        module_repo.debug_print("Copying '%s' to '%s' " %

              (os.path.abspath(src), os.path.abspath(src) + tmpdir_suffix))

        shutil.copytree(os.path.abspath(src),

                        os.path.abspath(src) + tmpdir_suffix)

        src += tmpdir_suffix

        appdir = src

    # appdir should be deleted if there is any exception during packaging

    try:

        if extra_modules_map:

            module_repo.debug_print("Extra modules list:" + str(extra_modules_map))

            module_repo.appdir = appdir

            module_repo.extrasdir = extrasdir

            dep_module_paths = module_repo.search_module(extra_modules_map)

            if module_repo.error_count != 0:

                raise RuntimeError(str(module_repo.error_count) +\

                                   " dependency files not found")

            module_repo.process_dependent_modules(dep_module_paths)

            extrasdir = module_repo.extrasdir

        if os.path.isdir(src):

            # Add calendar.py and socket.py wrappers to app's lib.zip

            conflicting_modules = {'calendar_py': 'calendar.py',

                                   'socket_py': 'socket.py'}

            if mode == 'pys60':

                for module in conflicting_modules:

                    module_repo.debug_print("Adding socket & calendar " +

                                            "wrappers")

                    shutil.copy(

                        os.path.join("templates", conflicting_modules[module]),

                                os.path.join(src, conflicting_modules[module]))

            # All the py[c|o] files in the app directory except for default.py

            # are zipped into lib.zip. This file is added to sys.path by

            # launcher.py

            py_ignore_list = []

            lib_zip = zipfile.ZipFile(os.path.join(src,

                                      "lib.zip"), "w", zipfile.ZIP_DEFLATED)

            def process_bytecode(dirpath, name, file_ext):

                # Process the files to be written to the lib_zip based on the

                # `bytecode` option

                if not bytecode or file_ext in ['.pyc', '.pyo']:

                    final_filename = name + file_ext

                elif bytecode and file_ext == '.py':

                    if imp.get_magic() != pys60_magic_number:

                        raise RuntimeError("Python Version on \

                        the host system not bytecode compatible with \

                        the Python version used in PyS60")

                    py_compile.compile(os.path.join(dirpath, name + file_ext))

                    # Compilation can result in either a pyc or a pyo.

                    for ext in ['.pyc', '.pyo']:

                        if os.path.exists(os.path.join(dirpath, name + ext)):

                            final_filename = name + ext

                return final_filename

            for dirpath, dirs, files in os.walk(src):

                if extrasdir in dirs:

                    dirs.remove(extrasdir)

                for filename in files:

                    name, file_ext = os.path.splitext(os.path.basename(

                                                      filename))

                    file_ext = file_ext.lower()

                    if file_ext == '.py':

                        for ext in ['.pyc', '.pyo']:

                            if os.path.exists(os.path.join(dirpath,

                                                           name + ext)):

                                os.remove(os.path.join(dirpath, name + ext))

                                files.remove(name + ext)

                    if file_ext in ['.py', '.pyc', '.pyo'] and \

                       filename != 'default.py':

                        final_filename = process_bytecode(dirpath, name,

                                                          file_ext)

                        relative_path = \

                            os.path.join(dirpath, final_filename).split(

                                         os.path.basename(src) + os.sep)[-1]

                        module_repo.debug_print("Adding %s to lib.zip as %s" %\

                            (os.path.join(src, relative_path), relative_path))

                        lib_zip.write(os.path.join(src, relative_path),

                                      relative_path)

                        if extra_modules_map:

                            # After copying the files to the lib_zip delete

                            # them otherwise they too will find their way into

                            # the zip.

                            os.remove(os.path.join(src, relative_path))

                            if bytecode and file_ext == '.py':

                                # The `py` files which will be compiled will

                                # also have to be deleted.

                                os.remove(os.path.join(dirpath, filename))

                        else:

                            py_ignore_list.append(relative_path)

            lib_zip.close()

            if not len(lib_zip.infolist()):

                # Delete the lib_zip if it is empty

                os.remove(os.path.join(src, "lib.zip"))

            # Remove trailing slashes (or whatever the separator is).

            src = os.path.split(src + os.sep)[0]

            # Use last directory component as the name.

            basename = os.path.basename(src)

            # Source is a directory, recursively collect files it contains.

            srcdir = src

            srcfiles = []

            prefixlen = len(srcdir) + len(os.sep)

            def getfiles(arg, dirname, names):

                for name in names:

                    path = os.path.join(dirname, name)

                    if not os.path.isdir(path) and \

                                        path[prefixlen:] not in py_ignore_list:

                        arg.append(path[prefixlen:])

            os.path.walk(srcdir, getfiles, srcfiles)

            # Read application version and UID3 from default.py.

            version, uid3 = scandefaults(os.path.join(srcdir, "default.py"))

        else:

            if src.lower().endswith(".py"):

                # Use program name without the .py extension.

                basename = os.path.basename(src)[:-3]

            else:

                # Unknown extension, use program name as-is.

                basename = os.path.basename(src)

            # Source is a file, use it.

            srcdir, srcfiles = os.path.split(src)

            srcfiles = [srcfiles]

            # Read application version and UID3 from file.

            version, uid3 = scandefaults(os.path.join(srcdir, srcfiles[0]))

        # The sis file name should not have the tmpdir_suffix appended to src

        basename = basename.rsplit(tmpdir_suffix, 1)[0]

        # Parse version string, use 1.0.0 by default.

        version = opts.get("--version", opts.get("-r", version))

        if version == None:

            version = "1.0.0"

            print ("%s: warning: no application version given, "

                   "using %s" % (pgmname, version))

        try:

            version = parseversion(version)

        except (ValueError, IndexError, TypeError):

            raise ValueError("invalid version string '%s'" % version)

        # Determine output SIS file name.

        if len(pargs) == 1:

            # Derive output file name from input file name.

            outfile = "%s_v%d_%d_%d.sis" % (basename, version[0],

                                            version[1], version[2])

        elif len(pargs) == 2:

            outfile = pargs[1].decode(terminalenc).encode(filesystemenc)

            if os.path.isdir(outfile):

                # Output to directory, derive output name from input file name.

                outfile = os.path.join(outfile, "%s_v%d_%d_%d.sis" % (

                    basename, version[0], version[1], version[2]))

            if not outfile.lower().endswith(".sis"):

                outfile += ".sis"

        else:

            raise ValueError("wrong number of arguments")

        # Determine application name (install dir.), use basename by default.

        appname = opts.get("--appname", opts.get("-n", basename))

        appname = appname.decode(terminalenc)

        # Auto-generate a test-range UID from application name.

        autouid = symbianutil.uidfromname(appname)

        # Get UID3.

        uid3 = opts.get("--uid", opts.get("-u", uid3))

        if uid3 == None:

            # No UID given, use auto-generated UID.

            uid3 = autouid

            print ("%s: warning: no UID given, using auto-generated "

                   "test-range UID 0x%08x" % (pgmname, uid3))

        elif uid3.lower().startswith("0x"):

            # Prefer hex UIDs with leading "0x".

            uid3 = long(uid3, 16)

        else:

            try:

                if len(uid3) == 8:

                    # Assuming hex UID even without leading "0x".

                    print ('%s: warning: assuming hex UID even '

                           'without leading "0x"' % pgmname)

                    uid3 = long(uid3, 16)

                else:

                    # Decimal UID.

                    uid3 = long(uid3)

                    print ('%s: warning: decimal UID converted to 0x%08x' %

                           (pgmname, uid3))

            except ValueError:

                raise ValueError("invalid UID string '%s'" % uid3)

        # Warn against specifying a test-range UID manually.

        if uid3 & 0xf0000000L == 0xe0000000L and uid3 != autouid:

            print ("%s: warning: manually specifying a test-range UID is "

                   "not recommended" % pgmname)

        # Determine application language(s), use "EN" by default.

        lang = opts.get("--lang", opts.get("-l", "EN")).split(",")

        numlang = len(lang)

        # Verify that the language codes are correct.

        for l in lang:

            try:

                symbianutil.langidtonum[l]

            except KeyError:

                raise ValueError("%s: no such language code" % l)

        # Get icon file name.

        icon = opts.get("--icon", opts.get("-i", None))

        if icon != None:

            icon = icon.decode(terminalenc).encode(filesystemenc)

            # Read icon file.

            f = file(icon, "rb")

            icondata = f.read(MAXICONFILESIZE + 1)

            f.close()

            if len(icondata) > MAXICONFILESIZE:

                raise ValueError("icon file too large")

        else:

            # No icon given, use a default icon.

            icondata = zlib.decompress(defaulticondata.decode("base-64"))

        # Determine application short caption(s).

        shortcaption = opts.get("--shortcaption", opts.get("-s", ""))

        shortcaption = shortcaption.decode(terminalenc)

        if len(shortcaption) == 0:

            # Short caption not given, use application name.

            shortcaption = [appname] * numlang

        else:

            shortcaption = shortcaption.split(",")

        # Determine application long caption(s), use short caption by default.

        caption = opts.get("--caption", opts.get("-c", ""))

        caption = caption.decode(terminalenc)

        if len(caption) == 0:

            # Caption not given, use short caption.

            caption = shortcaption

        else:

            caption = caption.split(",")

        # Compare the number of languages and captions.

        if len(shortcaption) != numlang or len(caption) != numlang:

            raise ValueError("invalid number of captions")

        # Determine installation drive, any by default.

        drive = opts.get("--drive", opts.get("-f", "any")).upper()

        if drive == "ANY" or drive == "!":

            drive = "!"

        elif drive != "C" and drive != "E":