xref: /trunk/main/filter/source/config/tools/merge/pyAltFCFGMerge (revision 07a3d7f1)

#!/usr/bin/env python
#_____________________________________________
# Caolan McNamara caolanm@redhat.com
# converted from original java written by Andreas Schluens so we can continue
# to build 680 OpenOffice.org series without java
# this is not really a replacement for the existing java tool, just the
# minimum required to make it work for now, the existing tool is still
# the canonical base, changes to it will have to be mirrored here until
# there is a java which is available for use by all
#_____________________________________________

import sys, string, os.path

CFGFILE             = os.environ["SOLARVER"] + "/" + os.environ["INPATH"] + "/inc/l10ntools/FCFGMerge.cfg"

PROP_XMLVERSION      = "xmlversion"               # // <= global cfg file
PROP_XMLENCODING     = "xmlencoding"              # // <= global cfg file
PROP_XMLPATH         = "xmlpath"                  # // <= global cfg file
PROP_XMLPACKAGE      = "xmlpackage"               # // <= global cfg file
PROP_SETNAME_TYPES    = "setname_types"           # // <= global cfg file
PROP_SETNAME_FILTERS  = "setname_filters"         # // <= global cfg file
PROP_SETNAME_LOADERS  = "setname_frameloaders"    # // <= global cfg file
PROP_SETNAME_HANDLERS = "setname_contenthandlers" # // <= global cfg file
PROP_SUBDIR_TYPES    = "subdir_types"             # // <= global cfg file
PROP_SUBDIR_FILTERS  = "subdir_filters"           # // <= global cfg file
PROP_SUBDIR_LOADERS  = "subdir_frameloaders"      # // <= global cfg file
PROP_SUBDIR_HANDLERS = "subdir_contenthandlers"   # // <= global cfg file
PROP_EXTENSION_XCU   = "extension_xcu"            # // <= global cfg file
PROP_EXTENSION_PKG   = "extension_pkg"            # // <= global cfg file
PROP_DELIMITER       = "delimiter"                # // <= global cfg file
PROP_TRIM            = "trim"                     # // <= global cfg file
PROP_DECODE          = "decode"                   # // <= global cfg file
PROP_FRAGMENTSDIR    = "fragmentsdir"             # // <= cmdline
PROP_TEMPDIR         = "tempdir"                  # // <= cmdline
PROP_OUTDIR          = "outdir"                   # // <= cmdline
PROP_PKG             = "pkg"                      # // <= cmdline
PROP_TCFG            = "tcfg"                     # // <= cmdline
PROP_FCFG            = "fcfg"                     # // <= cmdline
PROP_LCFG            = "lcfg"                     # // <= cmdline
PROP_CCFG            = "ccfg"                     # // <= cmdline
PROP_LANGUAGEPACK    = "languagepack"             # // <= cmdline
PROP_ITEMS           = "items"                    # // <= pkg cfg files!

#---begin java.util.Properties copy---#
"""

An incomplete clean room implementation of
java.util.Properties written in Python.

Copyright (C) 2002,2004 - Ollie Rutherfurd <oliver@rutherfurd.net>

Based on:

        http://java.sun.com/j2se/1.3/docs/api/java/util/Properties.html

Missing:

 - Currently, u\XXXX sequences are escaped when saving, but not unescaped
   when read..

License: Python License

Example Usage:

>>> from properties import Properties
>>> props = Properties()
>>> props['one'] = '1'
>>> props['your name'] = "I don't know"
>>> print '\n'.join(props.keys())
your name
one
>>> from StringIO import StringIO
>>> buff = StringIO()
>>> props.store(buff, "a little example...")
>>> buff.seek(0)
>>> print buff.read()
# a little example...
your\ name=I\ don\'t\ know
one=1
>>> print props['your name']
I don't know

$Id: pyAltFCFGMerge,v 1.3 2007-12-07 10:57:44 vg Exp $

"""

__all__ = ['Properties']


def dec2hex(n):

    h = hex(n)[2:].upper()
    return '\\u' + '0' * (4 - len(h)) + h


def escapestr(s):

    buff = []
    # QUESTION: escape leading or trailing spaces?
    for c in s:
        if c == '\\':
            buff.append('\\\\')
        elif c == '\t':
            buff.append('\\t')
        elif c == '\n':
            buff.append('\\n')
        elif c == '\r':
            buff.append('\\r')
        elif c == ' ':
            buff.append('\\ ')
        elif c == "'":
            buff.append("\\'")
        elif c == '"':
            buff.append('\\"')
        elif c == '#':
            buff.append('\\#')
        elif c == '!':
            buff.append('\\!')
        elif c == '=':
            buff.append('\\=')
        elif 32 <= ord(c) <= 126:
            buff.append(c)
        else:
            buff.append(dec2hex(c))

    return ''.join(buff)


# TODO: add support for \uXXXX?
def unescapestr(line):

    buff = []
    escape = 0
    for i in range(len(line)):
        c = line[i]
        if c == '\\':
            if escape:
                escape = 0
                buff.append('\\')
                continue
            else:
                # this is to deal with '\'
                # acting as a line continuation
                # character
                if i == len(line) - 1:
                    buff.append('\\')
                    break
                else:
                    escape = 1
                    continue
        elif c == 'n':
            if escape:
                escape = 0
                buff.append('\n')
                continue
        elif c == 'r':
            if escape:
                escape = 0
                buff.append('\r')
                continue
        elif c == 't':
            if escape:
                escape = 0
                buff.append('\t')
                continue

        buff.append(c)

        # make sure escape doesn't stay one
        # all expected escape sequences either break
        # or continue, so this should be safe
        if escape:
            escape = 0

    return ''.join(buff)



class Properties(dict):

    def __init__(self, defaults={}):
        dict.__init__(self)
        for n,v in defaults.items():
            self[n] = v

    def __getittem__(self,key):
        try:
            return dict.__getittem__(self,key)
        except KeyError:
            return None

    def read(self,filename):
        """
        Reads properties from a file (java Property class
        reads from an input stream -- see load()).
        """
        f = None
        try:
            f = open(filename)
            self.load(f)
        finally:
            if f:
                f.close()

    def load(self, buff):
        """
        Reads properties from a stream (StringIO, file, etc...)
        """
        props = readprops(buff)
        #for n,v in props.iteritems():
        for n in props.keys():
            self[n] = props[n]

def readprops(buff):

    name,value = None,''
    props = {}
    continued = 0

    while 1:
        line = buff.readline()
        if not line:
            break
        line = line.strip()

        # empty line
        if not line:
            continue

        # comment
        if line[0] in ('#','!'):
            continue

        # find name
        i,escaped = 0,0
        while i < len(line):
            c = line[i]

            if c == '\\':
                if escaped:
                    escaped = 0
                else:
                    escaped = 1
                i += 1
                continue

            elif c in (' ', '\t', ':', '=') and not escaped:
                name = unescapestr(line[:i])
                break

            # make sure escaped doesn't stay on
            if escaped:
                escaped = 0

            i += 1

        # no dlimiter was found, name is entire line, there is no value
        if name == None:
            name = unescapestr(line.lstrip())

        # skip delimiter
        while line[i:i+1] in ('\t', ' ', ':', '='):
            i += 1

        value = unescapestr(line[i:].strip())
        while value[-1:] == '\\':
            value = value[:-1]      # remove \
            line = buff.readline()
            if not line:
                break
            value += unescapestr(line.strip())

        #print 'value:',value   ##
        props[name] = value

    return props
#---end java.util.Properties copy---#

#   Its a simple command line tool, which can merge different XML fragments
#   together. Such fragments must exist as files on disk, will be moved into
#   one file together on disk.
#
#  @author  Andreas Schluens
#
def run(sCmdLine):
    printCopyright()

    aCfg = ConfigHelper(CFGFILE, sCmdLine)

    # help requested?
    if aCfg.isHelp():
        printHelp()
        sys.exit(-1)

    #create new merge object and start operation
    aMerger = Merger(aCfg)
    aMerger.merge()

    sys.exit(0)

#prints out a copyright message on stdout.
def printCopyright():
    print("FCFGMerge")
    print("Copyright: 2003 by Red Hat, Inc., based on FCFGMerge.java` by Sun")
    print("All Rights Reserved.")

#prints out a help message on stdout.
def printHelp():
    print("____________________________________________________________")
    print("usage: FCFGMerge cfg=<file name>")
    print("parameters:")
    print("\tcfg=<file name>")
    print("\t\tmust point to a system file, which contains")
    print("\t\tall necessary configuration data for the merge process.")
    print("\tFurther cou can specify every parameter allowed in the")
    print("\tconfig file as command line parameter too, to overwrite")
    print("\tthe value from the file.")

def StringTokenizer(mstring, separators, isSepIncluded=0):
#Return a list of tokens given a base string and a string of
#separators, optionally including the separators if asked for"""
    token=''
    tokenList=[]
    for c in mstring:
        if c in separators:
            if token != '':
                tokenList.append(token)
                token=''
                if isSepIncluded:
                    tokenList.append(c)
        else:
            token+=c
    if token:
        tokenList.append(token)
    return tokenList

# can be used to analyze command line parameters
# and merge it together with might existing config
# files. That provides the possibility to overwrite
# config values via command line parameter.
#
# @author Andreas Schluens
class ConfigHelper:
    def __init__(self, sPropFile, lCommandLineArgs):
        self.m_bEmpty = 1
        # first load prop file, so its values can be overwritten
        # by command line args later
        # Do it only, if a valid file name was given.
        # But in case this file name is wrong, throw an exception.
        # So the outside code can react!
        if sPropFile != None and len(sPropFile) > 0:
            self.props = Properties()
            self.props.read(sPropFile)

        count = 0
        if lCommandLineArgs != None:
            count = len(lCommandLineArgs)
            print("Count is {c}".format(c=count))
        self.m_bEmpty = (count < 1)

        #print( lCommandLineArgs, "and len is", count )
        for arg in range(count):
            # is it a named-value argument?
            # Note: We ignores double "=" signs! => search from left to right
            pos = lCommandLineArgs[arg].find('=')
            if pos != -1:
                sArg   = lCommandLineArgs[arg][0:pos]
                sValue = lCommandLineArgs[arg][pos+1:]
                self.props[sArg] = sValue
                continue

            # is it a boolean argument?
            # Note: Because "--" and "-" will be interpreted as the same
            # we search from right to left!
            pos = lCommandLineArgs[arg].rfind('-')
            if pos == -1:
                pos = lCommandLineArgs[arg].rfind('/')
            if pos != -1:
                sArg = lCommandLineArgs[arg][pos+1:]
                self.props[sArg] = 1
                continue

            raise Exception("Invalid command line detected. The argument \""+lCommandLineArgs[arg]+"\" use an unsupported format.")

#        for item in self.props:
#            print item, '->', self.props[item]

    def isHelp(self):
        return (
                ("help" in self.props) or
                ("?" in self.props   ) or
                ("h" in self.props   )
               )

    def getValue(self, sProp):
        if not sProp in self.props:
            raise Exception("The requested config value \""+sProp+"\" "\
                "does not exists!");
        return self.props[sProp];

    def getValueWithDefault(self, sProp, default):
        if not sProp in self.props:
            return default;
        return self.props[sProp];

    def getStringList(self, sProp, sDelimiter, bTrim, bDecode):
        if not sProp in self.props:
            raise Exception("The requested config value \""+sProp+"\" does "\
                "not exists!");
        sValue = self.props[sProp]

        lValue = []
        lTokens = StringTokenizer(sValue, sDelimiter)
        for sToken in lTokens:
            if bTrim:
                sToken = sToken.strip()

            # remove ""
            if ((bDecode) and (sToken.find("\"") == 0) and \
                (sToken.rfind("\"") == len(sToken)-1)):
                sToken = sToken[1, len(sToken)-1]
            lValue.append(sToken)

        return lValue

def generateHeader(sVersion, sEncoding, sPath, sPackage, bLanguagePack):
    sHeader = "<?xml version=\""
    sHeader += sVersion
    sHeader += "\" encoding=\""
    sHeader += sEncoding
    sHeader += "\"?>\n"

    if bLanguagePack:
        sHeader += "<oor:component-data oor:package=\""
        sHeader += sPath
        sHeader += "\" oor:name=\""
        sHeader += sPackage
        sHeader += "\" xmlns:install=\"http://openoffice.org/2004/installation\""
        sHeader += " xmlns:oor=\"http://openoffice.org/2001/registry\""
        sHeader += " xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
        sHeader += " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\n"
    else:
        sHeader += "<oor:component-data xmlns:oor=\"http://openoffice.org/2001/registry\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" oor:package=\""
        sHeader += sPath
        sHeader += "\" oor:name=\""
        sHeader += sPackage
        sHeader += "\">\n"
    return sHeader

def generateFooter():
    return "</oor:component-data>\n"

# can merge different xml fragments together.
#
#   @author Caolan McNamara converted from the original java by Andreas Schluens
#
class Merger:
    def __init__(self, aCfg):
        self.m_aCfg = aCfg

        self.m_aFragmentsDir = self.m_aCfg.getValue(PROP_FRAGMENTSDIR)

        sDelimiter = self.m_aCfg.getValue(PROP_DELIMITER)
        bTrim = self.m_aCfg.getValue(PROP_TRIM)
        bDecode = self.m_aCfg.getValue(PROP_DECODE)

        try:
            aFcfg = ConfigHelper(self.m_aCfg.getValue(PROP_TCFG), None)
            self.m_lTypes = aFcfg.getStringList(PROP_ITEMS, sDelimiter, bTrim, bDecode)
        except:
            self.m_lTypes = []

        try:
            aFcfg = ConfigHelper(self.m_aCfg.getValue(PROP_FCFG), None)
            self.m_lFilters = aFcfg.getStringList(PROP_ITEMS, sDelimiter, bTrim, bDecode)
        except:
            print( "Filters are empty" )
            self.m_lFilters = []

        try:
            aFcfg = ConfigHelper(self.m_aCfg.getValue(PROP_LCFG), None)
            self.m_lLoaders = aFcfg.getStringList(PROP_ITEMS, sDelimiter, bTrim, bDecode)
        except:
            self.m_lLoaders = []

        try:
            aFcfg = ConfigHelper(self.m_aCfg.getValue(PROP_CCFG), None)
            self.m_lHandlers = aFcfg.getStringList(PROP_ITEMS, sDelimiter, bTrim, bDecode)
        except:
            self.m_lHandlers = []

    def merge(self):
        sPackage = self.m_aCfg.getValue(PROP_PKG)

        print("create package \""+sPackage+"\" ...")
        print("generate package header ... ")

        sBuffer = generateHeader(\
                self.m_aCfg.getValue(PROP_XMLVERSION ),\
                self.m_aCfg.getValue(PROP_XMLENCODING),\
                self.m_aCfg.getValue(PROP_XMLPATH    ),\
                self.m_aCfg.getValue(PROP_XMLPACKAGE ),\
                self.m_aCfg.getValueWithDefault(PROP_LANGUAGEPACK, False))

        # counts all transferred fragments
        # Can be used later to decide, if a generated package file
        # contains "nothing"!
        nItemCount = 0

        for i in range(4):
            sSetName = None
            sSubDir = None
            lFragments = None

            try:
                if i == 0: #types
                    print("generate set for types ... ")
                    sSetName = self.m_aCfg.getValue(PROP_SETNAME_TYPES)
                    sSubDir = self.m_aCfg.getValue(PROP_SUBDIR_TYPES )
                    lFragments = self.m_lTypes
                elif i == 1: # filters
                    print("generate set for filter ... ")
                    sSetName = self.m_aCfg.getValue(PROP_SETNAME_FILTERS)
                    sSubDir = self.m_aCfg.getValue(PROP_SUBDIR_FILTERS )
                    lFragments = self.m_lFilters
                elif i == 2: # loaders
                    print("generate set for frame loader ... ")
                    sSetName = self.m_aCfg.getValue(PROP_SETNAME_LOADERS)
                    sSubDir = self.m_aCfg.getValue(PROP_SUBDIR_LOADERS )
                    lFragments = self.m_lLoaders
                elif i == 3: # handlers
                    print("generate set for content handler ... ")
                    sSetName = self.m_aCfg.getValue(PROP_SETNAME_HANDLERS)
                    sSubDir = self.m_aCfg.getValue(PROP_SUBDIR_HANDLERS )
                    lFragments = self.m_lHandlers
            except:
                continue

            print("Length of Fragments: {f} Set Name {setname} Subdir {subdir}".
             format(f=len(lFragments),setname=sSetName,subdir=sSubDir))
            #sys.stdin.readline()
            nItemCount = nItemCount + len(lFragments)

            sBuffer = sBuffer + self.getFragments(\
                os.path.join(self.m_aFragmentsDir, sSubDir), \
                sSetName, lFragments, 1)

        print("generate package footer ... ")
        sBuffer = sBuffer + generateFooter()

        # Attention!
        # If the package seems to be empty, it make no sense to generate a
        # corresponding xml file. We should suppress writing of this file on
        # disk completely ...
        if nItemCount < 1:
            print("Package is empty and will not result into an xml file on disk!? Please check configuration file.")
            return
        print("package contains "+str(nItemCount)+" items")

        aPackage = open(sPackage, mode="w")
        print("write temp package {pkg}".format(pkg=sPackage))
        aPackage.write(sBuffer)

    def getFragments(self, aDir, sSetName, lFragments, nPrettyTabs):
        sBuffer = ''
        sExtXcu = self.m_aCfg.getValue(PROP_EXTENSION_XCU);

        if len(lFragments) < 1:
            return sBuffer

        for tabs in range(nPrettyTabs):
            sBuffer = sBuffer + "\t"
        sBuffer = sBuffer + "<node oor:name=\""+sSetName+"\">\n"
        nPrettyTabs = nPrettyTabs + 1

        for sFragment in lFragments:
            sFragPath = os.path.join(aDir, sFragment+"."+sExtXcu)
            try:
                aFragmentFile = open(sFragPath)
            except:
                # handle simple files only and check for existence!
                raise Exception("fragment \""+sFragPath+"\" does not exists.")

            print("merge fragment \""+sFragPath+"\" ...")
            sBuffer = sBuffer + aFragmentFile.read()

            sBuffer = sBuffer + "\n"

        nPrettyTabs = nPrettyTabs - 1
        for tabs in range(nPrettyTabs):
            sBuffer = sBuffer + "\t"
        sBuffer = sBuffer + "</node>\n"
        return sBuffer

run(sys.argv)