main/components.py

#!/usr/bin/python
# -*- coding: utf-8 -*-

import shutil
import sys
import re
import os

from optparse import OptionParser

def read_file(path):
    with open(path) as f:
        return f.read().strip()

def write_file(path, content):
    open(path, "w").write(content)
    open(path, "a").write("\n")

class Components():
    COMPONENT_XML = """<PISI>
    <Name>%s</Name>
</PISI>
"""
    EMPTY_COMPONENT = """        <Component>
            <Name>%s</Name>
            <LocalName xml:lang="en">FIXME</LocalName>
            <Summary xml:lang="en">FIXME</Summary>
            <Description xml:lang="en">FIXME</Description>
            <Group>FIXME</Group>
            <Maintainer>
                <Name>PisiLinux Community</Name>
                <Email>admins@pisilinux.org</Email>
            </Maintainer>
        </Component>"""
    CBGN = """<PISI>
    <Components>"""
    CEND = """
    </Components>
</PISI>"""
    LOCALNAME = '            <LocalName xml:lang="%s">%s</LocalName>\n'
    SUMMARY = '            <Summary xml:lang="%s">%s</Summary>\n'
    DESCRIPTION = '            <Description xml:lang="%s">%s</Description>\n'
    COMPONENT = """
        <Component>
            <Name>%s</Name>
%s%s%s            <Group>%s</Group>
            <Maintainer>
                <Name>%s</Name>
                <Email>%s</Email>
            </Maintainer>
        </Component>"""

    def __init__(self, path):
        self.path = path
        self.components = []
        self.components_xml = "%s/components.xml" % self.path
        self.name_ptrn = re.compile("\s*<Name>(.+?)<\/Name>\s*")
        self.lnamech_ptrn = re.compile("\s*<LocalName.*?>(.+?)<\/LocalName>\s*")
        self.lname_ptrn = re.compile("\s*<LocalName\s+xml:lang\s?=\s?[\'\"](\w\w.*?)[\'\"]\s?>(.+?)<\/LocalName>\s*")
        self.summarych_ptrn = re.compile("\s*<Summary.*?>(.+?)<\/Summary>\s*")
        self.summary_ptrn = re.compile("\s*<Summary\s+xml:lang\s?=\s?[\'\"](\w\w.*?)[\'\"]\s?>(.+?)<\/Summary>\s*")
        self.descch_ptrn = re.compile("\s*<Description.*?>(.+?)<\/Description>\s*")
        self.desc_ptrn = re.compile("\s*<Description\s+xml:lang\s?=\s?[\'\"](\w\w.*?)[\'\"]\s?>(.+?)<\/Description>\s*")
        self.group_ptrn = re.compile("\s*<Group>(.+?)<\/Group>\s*")
        self.email_ptrn = re.compile("\s*<Email>(.+?)<\/Email>\s*")
        self.cbgn_ptrn = re.compile("\s*<Component>\s*")
        self.cend_ptrn = re.compile("\s*<\/Component>\s*")
        self.mbgn_ptrn = re.compile("\s*<Maintainer>\s*")
        self.mend_ptrn = re.compile("\s*<\/Maintainer>\s*")
        self.csend_ptrn = re.compile("\s*<\/Components>\s*")

    def read_components(self):
        csfile = read_file(self.components_xml)
        cread = False
        mread = False
        component = {}
        for line in csfile.split("\n"):
            if re.search(self.cbgn_ptrn, line):
                cread = True
                component["err"] = []
                component["unknown"] = []
                component["clname"] = []
                component["csummary"] = []
                component["cdesc"] = []
                continue
            elif re.search(self.cend_ptrn, line):
                cread = False
                self.components.append(component)
                component = {}
                continue
            if cread:
                if re.search(self.mbgn_ptrn, line):
                    mread = True
                    continue
                elif re.search(self.mend_ptrn, line):
                    mread = False
                    continue
                elif re.search(self.name_ptrn, line):
                    if mread: component["mname"] = re.sub(self.name_ptrn, r"\1", line)
                    else: component["cname"] = re.sub(self.name_ptrn, r"\1", line)
                elif re.search(self.lnamech_ptrn, line):
                    if re.search(self.lname_ptrn, line):
                        component["clname"].append(re.sub(self.lname_ptrn, r"\1:\2", line))
                    else:
                        component["err"].append("LocalName") 
                elif re.search(self.summarych_ptrn, line):
                    if re.search(self.summary_ptrn, line):
                        component["csummary"].append(re.sub(self.summary_ptrn, r"\1:\2", line))
                    else:
                        component["err"].append("Summary") 
                elif re.search(self.descch_ptrn, line):
                    if re.search(self.desc_ptrn, line):
                        component["cdesc"].append(re.sub(self.desc_ptrn, r"\1:\2", line))
                    else:
                        component["err"].append("Description") 
                elif re.search(self.group_ptrn, line):        
                    component["cgroup"] = re.sub(self.group_ptrn, r"\1", line)
                elif re.search(self.email_ptrn, line):        
                    component["memail"] = re.sub(self.email_ptrn, r"\1", line)
                else: component["unknown"].append(line)

    def sort_components(self):
        self.components = sorted(self.components, key=lambda k: k['cname'])

    def backup_components(self):
        files = os.walk(self.path).next()[2]
        last = 0
        for f in files:
            if f.startswith("components.xml.") and int(f[-3:]) > last: last = int(f[-3:])
        last = str(last + 1)
        while len(last) < 3: last = "0" + last
        shutil.copyfile(self.components_xml, ".".join((self.components_xml, last))) 

    def write_components(self):
        self.sort_components()
        cs = ''
        for c in self.components:
            ln = ""
            for i in c["clname"]:
                ln += self.LOCALNAME % tuple(i.split(":"))
            s = ""
            for i in c["csummary"]:
                s += self.SUMMARY % tuple(i.split(":"))
            d = ""
            for i in c["cdesc"]:
                d += self.DESCRIPTION % tuple(i.split(":"))
            cs += self.COMPONENT % (c["cname"], ln, s, d, c["cgroup"], c["mname"], c["memail"])
        self.backup_components()
        open(self.components_xml, "w").write(self.CBGN)
        open(self.components_xml, "a").write(cs)
        open(self.components_xml, "a").write(self.CEND)
        open(self.components_xml, "a").write("\n")        

    def edit(self):
        l = []
        mcommands = {"q": "quit",
                    "l": "list components",
                    "c": "choose component",
                    "h": "help"}
        ecommands = {"mn": "set maintainer name",
                     "me": "set maintainer email",
                     "ln": "set local name (lang:name)",
                     "s": "set summary (lang:summary)",
                     "d": "set description (lang:description)",
                     "m": "main menu",
                     "w": "write",
                     "h": "help"}
        
        def read_command(m):
            opts = mcommands.keys() if m == "m" else ecommands.keys()
            return (opts, raw_input(":".join(sorted(opts)) + " > ").split())
        
        def list_components(param, regexp = True):
            res = []
            num = 0
            if not param: param = ".*"
            for c in self.components:
                if regexp and re.search(param, c["cname"]):
                    res.append(c["cname"])
                    print num, c["cname"]
                    num += 1
                elif not regexp and param == c["cname"]:
                    res.append(c["cname"])
                    break
            return res
        
        def get_component_data(name):
            #print self.components
            for c in self.components:
                if name == c["cname"]: return c
            print "Component %s not found!" % name
            return False
        
        def print_help(hdict):
            for i in iter(sorted(hdict.iteritems())):
                print i[0] + "\t" + i[1]
        
        def edit_loop(component):
            def update(key, val, data):
                d = val.split(":")
                if not len(d) == 2: print "Wrong param format! (ln lang:text)"
                else:
                    lexists = -1
                    for i in data[key]:
                        if i.split(":")[0] == d[0]:
                            lexists = data[key].index(i)
                            break  
                    if lexists > -1: data[key][lexists] = val
                    else: data[key].append(val)
                return data
                
            data = get_component_data(component)
            while True:
                print "-" * (len(component) + 8)
                print "Editing " + component
                print "-" * (len(component) + 8)
                print "LocalName:"
                for i in data["clname"]: print "  %s" %i
                print "Summary:"
                for i in data["csummary"]: print "  %s" %i
                print "Description:"
                for i in data["cdesc"]: print "  %s" %i
                print "Group:\n  %s" % data["cgroup"] 
                print "Maintainer name:\n  %s" % data["mname"]
                print "Email:\n  %s" % data["memail"]
                o, c = read_command("c")
                if not c[0] in o: continue
                if len(c) == 1: c.append("")
                if c[0] == "m": break
                elif c[0] == "h": print_help(ecommands)
                elif c[0] == "ln": data = update("clname", c[1], data)
                elif c[0] == "s": data = update("csummary", c[1], data)
                elif c[0] == "d": data = update("cdesc", c[1], data)
                elif c[0] == "mn": data["mname"] = c[1]
                elif c[0] == "me": data["memail"] = c[1]
                elif c[0] == "w":  self.write_components()
                else: print"%s is not implemented yet" % c[0]
        
        def edit_component(param, l):
            try:
                int(param)
                edit_loop(l[int(param)])
            except ValueError:
                l = list_components(param, regexp = False)
            if not len(l) == 1: print "Component %s not found" % param
            else: edit_loop(l[0])
        
        while True:
            o, c = read_command("m")
            if len(c) == 1: c.append("")
            if not c[0] in o: continue
            elif c[0] == "q": break
            elif c[0] == "l": l = list_components(c[1])
            elif c[0] == "c": edit_component(c[1], l)
            elif c[0] == "h": print_help(mcommands) 
            else: print"%s is not implemented yet" % c[0]

    def check(self):      
        cs = []
        for root, dirs, files in os.walk(self.path):
            c = root.split(self.path)[1][1:].split("/")
            if "files" in c or "comar" in c: continue
            c = ".".join(c)
            component_xml = "%s/component.xml" % root
            pspec_xml = "%s/pspec.xml" % root
            actions_py = "%s/actions.py" % root
            if not os.path.isfile(component_xml) and not os.path.isfile(pspec_xml):
                if os.path.isfile(actions_py): print "WARNING: %s not exists" % pspec_xml
                else:
                    is_src_repo = False
                    for r, d, f in os.walk(root):
                        if "pspec.xml" in f:
                            is_src_repo = True
                            break
                    if is_src_repo and c:
                        print "%s not exists. creating..." % component_xml
                        write_file(component_xml, self.COMPONENT_XML % c)
            if os.path.isfile(component_xml) and c: cs.append(c) 
        
        mcs = cs[:]
        csfile = read_file(self.components_xml)
        maintainer = False
        new_file = []
        for line in csfile.split("\n"):
            new_file.append(line)
            if re.search(self.mbgn_ptrn, line): maintainer = True
            elif re.search(self.mend_ptrn, line): maintainer = False
            elif re.search(self.csend_ptrn, line):
                for m in mcs:
                    new_file.insert(-1, self.EMPTY_COMPONENT % m)
            if not re.search(self.name_ptrn, line) or maintainer: continue
            cn = re.sub(self.name_ptrn, r"\1", line)
            if cn in mcs: mcs.pop(mcs.index(cn))
        
        new_file = "\n".join(new_file)
        write_file(self.components_xml, new_file)


if __name__ == "__main__":
    usage = "Usage: %prog [PATH]"
    parser = OptionParser(usage)
    parser.add_option("-c", "--check", action="store_true", dest="check", help="fix missing component.xml files and entries in components.xml")
    parser.add_option("-e", "--edit", action="store_true", dest="edit", help="edit components.xml")
    (options,args) = parser.parse_args()
    try:
        root = args[0]
    except IndexError:
        print "Using ./ as PATH"
        root = "./"

    if root.endswith("/"): root = root[:-1]

    cs = Components(root)        
    if not os.path.isfile(cs.components_xml):
        print "%s not exists!" % cs.components_xml
        sys.exit(1)
    if not os.access(cs.components_xml, os.W_OK): 
        print "Cannot write to %s" % cs.components_xml
        sys.exit(1)
    cs.read_components()

    if options.check: cs.check()
    if options.edit: 
        cs.edit()