← Back to branch summary

~laney/ubuntu-packaging-guide/new-package-no-debuild

« back to all changes in this revision

Viewing changes to debian/scripts/add-languages

  • Committer: Daniel Holbach
  • Date: 2012-06-13 07:28:34 UTC
  • mfrom: (100.1.6 961936)
  • Revision ID: daniel.holbach@canonical.com-20120613072834-qdzwn8qvtffamsuo
https://launchpad.net/bugs/961936
provide a means to ship per-language per-flavour packages, if a certain
level of completeness of the translations is reached. (LP: #961936)

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/scripts/add-languages
 
1
#!/usr/bin/python
 
2
 
 
3
#
 
4
# Some notes to get this script up and running.
 
5
#
 
6
# To play around with this some more, try to:
 
7
#
 
8
# - create an empty translation:
 
9
#    cp po/ubuntu-packaging-guide.pot po/xx.po
 
10
# - run the script and see if it works and just takes the translations
 
11
#   above the threshold (PERCENTAGE variable)
 
12
# - make sure you don't accidentally commit changes to the packaging
 
13
#
 
14
 
 
15
import copy
 
16
import glob
 
17
import sys
 
18
import os
 
19
import re
 
20
 
 
21
try:
 
22
    import polib
 
23
except:
 
24
    print >> sys.stderr, "You need to have  python-polib  installed."
 
25
    sys.exit(1)
 
26
 
 
27
try:
 
28
    from debian import deb822
 
29
except:
 
30
    print >> sys.stderr, "You need to have  python-debian  installed."
 
31
    sys.exit(1)
 
32
 
 
33
PERCENTAGE = 70
 
34
 
 
35
class Package(object):
 
36
    stanzas = None
 
37
 
 
38
    def __init__(self):
 
39
        # we assume, this file lives in "debian/scripts"
 
40
        self.script_path = os.path.dirname(__file__)
 
41
        self.base_path = os.path.join(self.script_path, "../..")
 
42
        self.po_path = os.path.join(self.base_path, "po/")
 
43
        self.control_file = os.path.join(self.base_path, "debian/control")
 
44
        self.all_pofiles = self.get_all_pofiles()
 
45
        self.all_languages = self.get_all_languages()
 
46
        self.semi_complete_pofiles = self.get_semi_complete_pofiles()
 
47
        self.semi_complete_languages = self.get_semi_complete_languages()
 
48
        self.available_binary_packages = self.get_available_binary_packages()
 
49
        self.available_binary_package_names = self.get_available_binary_package_names()
 
50
        self.base_package_names = self.get_base_package_names()
 
51
 
 
52
    def get_all_pofiles(self):
 
53
        return map(lambda a: os.path.abspath(a),
 
54
                   glob.glob("%s/*.po" % self.po_path))
 
55
    
 
56
    def get_all_languages(self):
 
57
        return map(lambda a: os.path.basename(a).split(".po")[0],
 
58
                   self.all_pofiles)
 
59
 
 
60
    def get_semi_complete_pofiles(self):
 
61
        languages = self.all_pofiles
 
62
        complete = []
 
63
        for language in languages:
 
64
            pofile = polib.pofile(language)
 
65
            if pofile.percent_translated() >= PERCENTAGE:
 
66
                complete += [ language ]
 
67
        return complete
 
68
 
 
69
    def get_semi_complete_languages(self):
 
70
        return map(lambda a: os.path.basename(a).split(".po")[0],
 
71
                   self.semi_complete_pofiles)
 
72
 
 
73
    def get_available_binary_packages(self):
 
74
        BLACKLIST = [u'ubuntu-packaging-guide']     # metapackages and stuff
 
75
        self.stanzas = deb822.Packages.iter_paragraphs(open(self.control_file))
 
76
        return filter(lambda a: a.has_key("Package") and \
 
77
                                a["Package"] not in BLACKLIST, self.stanzas)
 
78
 
 
79
    def get_available_binary_package_names(self):
 
80
        return map(lambda a: a["Package"], 
 
81
                   self.available_binary_packages)
 
82
 
 
83
    def get_base_package_names(self):
 
84
        base_packages = []
 
85
        for name in self.available_binary_package_names:
 
86
            is_translations_package = False
 
87
            for language in self.all_languages:
 
88
                if name.endswith("-%s" % language):
 
89
                    is_translations_package = True
 
90
            if not is_translations_package:
 
91
                base_packages += [ name ]
 
92
        return base_packages
 
93
 
 
94
    def get_package_name_permutations(self, languages):
 
95
        permutations = []
 
96
        for language in languages:
 
97
            permutations +=  map(lambda pkg: "%s-%s" % (pkg, language),
 
98
                                 self.base_package_names)
 
99
        return permutations
 
100
 
 
101
    def get_missing_binary_packages(self, languages):
 
102
        return filter(lambda a: a not in self.available_binary_package_names,
 
103
                      self.get_package_name_permutations(languages))
 
104
 
 
105
    def add_to_control_file(self, language, template_name):
 
106
        new_package_name = "%s-%s" % (template_name, language)
 
107
        template = filter(lambda a: a["Package"] == template_name,
 
108
                          self.available_binary_packages)[0]
 
109
        new_stanza = copy.copy(template)
 
110
        new_stanza["Package"] = new_package_name
 
111
        desc = new_stanza["Description"].split("\n")
 
112
        desc[0] += " - '%s' version" % language
 
113
        desc[-1] = desc[-1].rstrip()
 
114
        desc += [ " .", " This is the '%s' version." % language ]
 
115
        new_stanza["Description"] = "\n".join(desc)
 
116
        f = open(self.control_file, "a")
 
117
        f.write(u"\n")
 
118
        f.write(unicode(new_stanza))
 
119
        f.close()
 
120
 
 
121
    def add_installation_files(self, language, template_name):
 
122
        new_package_name = "%s-%s" % (template_name, language)
 
123
        template_file = os.path.join(self.base_path, "debian/" + template_name + ".docs")
 
124
        new_file = os.path.join(self.base_path, "debian/" + new_package_name + ".docs")
 
125
        doc_type = template_name.split("-")[-1]
 
126
        with open(template_file, "r") as template_file:
 
127
            lines = template_file.readlines()
 
128
        with open(new_file, "w") as new_file:
 
129
            for line in lines:
 
130
                new_file.write(re.sub("%s/" % doc_type,
 
131
                                      "%s/%s/" % (doc_type, language),
 
132
                                      line))
 
133
 
 
134
    def add_docbase_files(self, language, template_name):
 
135
        if template_name.endswith("html"):
 
136
            new_package_name = "%s-%s" % (template_name, language)
 
137
            docbase_template = os.path.join(self.base_path,
 
138
                                            "debian/" + template_name + ".doc-base")
 
139
            new_docbase_file = os.path.join(self.base_path,
 
140
                                            "debian/" + new_package_name + ".doc-base")
 
141
            single_template = os.path.join(self.base_path,
 
142
                                           "debian/" + template_name + ".doc-base.single")
 
143
            new_single_file = os.path.join(self.base_path,
 
144
                                           "debian/" + new_package_name + ".doc-base.single")
 
145
            self.write_docbase_file(language, template_name, new_package_name,
 
146
                                    docbase_template, new_docbase_file)
 
147
            self.write_docbase_file(language, template_name, new_package_name,
 
148
                                    single_template, new_single_file)
 
149
        else:
 
150
            pass
 
151
 
 
152
    def write_docbase_file(self, language, template_name, new_package_name,template_file, new_file):
 
153
        with open(template_file, "r") as template_file:
 
154
            lines = template_file.readlines()
 
155
        with open(new_file, "w") as new_file:
 
156
            for line in lines:
 
157
                if line.startswith("Document:"):
 
158
                    line = "Document: " + new_package_name + "\n"
 
159
                elif line.startswith("Index:") | line.startswith("Files:"):
 
160
                    line = re.sub("/html", "/html/%s" % language, line)
 
161
                    line = re.sub("-html", "-html-%s" % language, line)
 
162
                elif line.startswith("Title:"):
 
163
                    line = "Title: Ubuntu Packaging Guide - %s Version\n" % language
 
164
                else:
 
165
                    line = line
 
166
                new_file.write(line)
 
167
 
 
168
    def add_package(self, package_name):
 
169
        base_template = "-".join(package_name.split("-")[0:-1])
 
170
        language = package_name.split("-")[-1]
 
171
        self.add_to_control_file(language, base_template)
 
172
        self.add_installation_files(language, base_template)
 
173
        self.add_docbase_files(language, base_template)
 
174
 
 
175
def main():
 
176
    package = Package()
 
177
    for name in package.get_missing_binary_packages(package.semi_complete_languages):
 
178
        package.add_package(name)
 
179
 
 
180
if __name__ == '__main__':
 
181
    try:
 
182
        main()
 
183
    except KeyboardInterrupt:
 
184
        print >> sys.stderr, "Aborted."
 
185
        sys.exit(1)