← Back to branch summary

~ubuntu-branches/ubuntu/karmic/eric/karmic

« back to all changes in this revision

Viewing changes to eric/XML/ProjectHandler.py

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2008-01-28 18:02:25 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20080128180225-6nrox6yrworh2c4v
Tags: 4.0.4-1ubuntu1
* Add python-qt3 to build-depends becuase that's where Ubuntu puts 
  pyqtconfig
* Change maintainer to MOTU

Show diffs side-by-side

added added

removed removed

Lines of Context:
eric/XML/ProjectHandler.py
8
8
"""
9
9
 
10
10
import os
11
 
import pickle
 
11
try:
 
12
    import cPickle as pickle
 
13
except:
 
14
    import pickle
12
15
 
13
16
from Config import projectFileFormatVersion
14
17
from XMLHandlerBase import XMLHandlerBase
36
39
            'Version' : (self.defaultStartElement, self.endVersion),
37
40
            'Author' : (self.defaultStartElement, self.endAuthor),
38
41
            'Email' : (self.defaultStartElement, self.endEmail),
39
 
            'TranslationPrefix' : (self.startTranslationPrefix, self.endTranslationPrefix),
 
42
            'TranslationPrefix' : (self.startTranslationPrefix, 
 
43
                                   self.endTranslationPrefix),
 
44
            'TranslationsBinPath' : (self.startTranslationsBinPath, 
 
45
                                     self.endTranslationsBinPath),
40
46
            'VcsType' : (self.defaultStartElement, self.endVcsType),
41
 
            'VcsOptions' : (self.defaultStartElement, self.endVcsOptions),
42
 
            'VcsOtherData' : (self.defaultStartElement, self.endVcsOtherData),
 
47
            'VcsOptions' : (self.startVcsOptions, self.endVcsOptions),
 
48
            'VcsOtherData' : (self.startVcsOtherData, self.endVcsOtherData),
43
49
            'Eric3DocParams' : (self.defaultStartElement, self.endEric3DocParams),
44
50
            'Eric3ApiParams' : (self.defaultStartElement, self.endEric3ApiParams),
 
51
            'Eric4DocParams' : (self.startEric4DocParams, self.endEric4DocParams),
 
52
            'Eric4ApiParams' : (self.startEric4ApiParams, self.endEric4ApiParams),
 
53
            # for really old project files
45
54
            'HappyDocParams' : (self.defaultStartElement, self.defaultEndElement),
46
55
            'Dir' : (self.defaultStartElement, self.endDir),
47
56
            'Name' : (self.defaultStartElement, self.endName),
48
57
            'Source' : (self.startSource, self.endSource),
49
58
            'Form' : (self.startForm, self.endForm),
50
59
            'Translation' : (self.startTranslation, self.endTranslation),
 
60
            'TranslationException' : (self.startTranslationException, 
 
61
                                      self.endTranslationException),
 
62
            'Resource' : (self.startResource, self.endResource),
51
63
            'Interface' : (self.startInterface, self.endInterface),
52
64
            'Other' : (self.startOther, self.endOther),
53
65
            'MainScript' : (self.startMainScript, self.endMainScript),
54
 
            'FiletypeAssociation' : (self.startFiletypeAssociation, self.defaultEndElement),
55
 
            'CxfreezeParams' : (self.defaultStartElement, self.endCxfreezeParams),
56
 
            'PyLintParams' : (self.defaultStartElement, self.endPyLintParams),
 
66
            'FiletypeAssociation' : (self.startFiletypeAssociation, 
 
67
                                     self.defaultEndElement),
 
68
            'CxfreezeParams' : (self.startCxfreezeParams, self.endCxfreezeParams),
 
69
            'PyLintParams' : (self.startPyLintParams, self.endPyLintParams),
57
70
        })
58
71
    
59
72
        self.project = project
62
75
        """
63
76
        Handler called, when the document parsing is started.
64
77
        """
 
78
        self.version = ''
65
79
        self.pathStack = []
66
80
        
67
81
    ###################################################
96
110
        """
97
111
        Handler method for the "Description" end tag.
98
112
        """
99
 
        self.buffer = self.utf8_to_code(self.buffer)
 
113
        self.buffer = self.unescape(self.utf8_to_code(self.buffer))
100
114
        self.project.pdata["DESCRIPTION"] = self.buffer.split(os.linesep)
101
115
        
102
116
    def endVersion(self):
103
117
        """
104
118
        Handler method for the "Version" end tag.
105
119
        """
106
 
        self.buffer = self.utf8_to_code(self.buffer)
 
120
        self.buffer = self.unescape(self.utf8_to_code(self.buffer))
107
121
        self.project.pdata["VERSION"] = [self.buffer]
108
122
        
109
123
    def endAuthor(self):
110
124
        """
111
125
        Handler method for the "Author" end tag.
112
126
        """
113
 
        self.buffer = self.utf8_to_code(self.buffer)
 
127
        self.buffer = self.unescape(self.utf8_to_code(self.buffer))
114
128
        self.project.pdata["AUTHOR"] = [self.buffer]
115
129
        
116
130
    def endEmail(self):
117
131
        """
118
132
        Handler method for the "Email" end tag.
119
133
        """
120
 
        self.buffer = self.utf8_to_code(self.buffer)
 
134
        self.buffer = self.unescape(self.utf8_to_code(self.buffer))
121
135
        self.project.pdata["EMAIL"] = [self.buffer]
122
136
        
123
137
    def endVcsType(self):
127
141
        self.buffer = self.utf8_to_code(self.buffer)
128
142
        self.project.pdata["VCS"] = [self.buffer]
129
143
        
 
144
    def startVcsOptions(self, attrs):
 
145
        """
 
146
        Handler method for the "VcsOptions" start tag.
 
147
        
 
148
        @param attrs list of tag attributes
 
149
        """
 
150
        self.defaultStartElement(attrs)
 
151
        if self.version >= '4.0':
 
152
            self._prepareBasics()
 
153
        
130
154
    def endVcsOptions(self):
131
155
        """
132
156
        Handler method for the "VcsOptions" end tag.
133
157
        """
134
 
        self.buffer = self.utf8_to_code(self.buffer)
135
 
        if self.buffer:
136
 
            if self.version > '3.8':
137
 
                self.project.pdata["VCSOPTIONS"] = [pickle.loads(self.buffer)]
 
158
        if self.version >= '4.0':
 
159
            try:
 
160
                self.project.pdata["VCSOPTIONS"] = [self.stack[-1]]
 
161
            except IndexError:
 
162
                self.project.pdata["VCSOPTIONS"] = []
 
163
        else:
 
164
            self.buffer = self.utf8_to_code(self.buffer)
 
165
            if self.buffer:
 
166
                if self.version > '3.8':
 
167
                    self.project.pdata["VCSOPTIONS"] = [pickle.loads(self.buffer)]
 
168
                else:
 
169
                    if self.project.checkSecurityString(self.buffer, 'VcsOptions'):
 
170
                        self.project.pdata["VCSOPTIONS"] = []
 
171
                    else:
 
172
                        self.project.pdata["VCSOPTIONS"] = [eval(self.buffer)]
138
173
            else:
139
 
                if self.project.checkSecurityString(self.buffer, 'VcsOptions'):
140
 
                    self.project.pdata["VCSOPTIONS"] = []
141
 
                else:
142
 
                    self.project.pdata["VCSOPTIONS"] = [eval(self.buffer)]
143
 
        else:
144
 
            self.project.pdata["VCSOPTIONS"] = []
 
174
                self.project.pdata["VCSOPTIONS"] = []
 
175
        
 
176
    def startVcsOtherData(self, attrs):
 
177
        """
 
178
        Handler method for the "VcsOtherData" start tag.
 
179
        
 
180
        @param attrs list of tag attributes
 
181
        """
 
182
        self.defaultStartElement(attrs)
 
183
        if self.version >= '4.0':
 
184
            self._prepareBasics()
145
185
        
146
186
    def endVcsOtherData(self):
147
187
        """
148
188
        Handler method for the "VcsOtherData" end tag.
149
189
        """
150
 
        self.buffer = self.utf8_to_code(self.buffer)
151
 
        if self.buffer:
152
 
            if self.version > '3.8':
153
 
                self.project.pdata["VCSOTHERDATA"] = [pickle.loads(self.buffer)]
 
190
        if self.version >= '4.0':
 
191
            try:
 
192
                self.project.pdata["VCSOTHERDATA"] = [self.stack[-1]]
 
193
            except IndexError:
 
194
                self.project.pdata["VCSOTHERDATA"] = []
 
195
        else:
 
196
            self.buffer = self.utf8_to_code(self.buffer)
 
197
            if self.buffer:
 
198
                if self.version > '3.8':
 
199
                    self.project.pdata["VCSOTHERDATA"] = [pickle.loads(self.buffer)]
 
200
                else:
 
201
                    if self.project.checkSecurityString(self.buffer, 'VcsOtherData'):
 
202
                        self.project.pdata["VCSOTHERDATA"] = []
 
203
                    else:
 
204
                        self.project.pdata["VCSOTHERDATA"] = [eval(self.buffer)]
154
205
            else:
155
 
                if self.project.checkSecurityString(self.buffer, 'VcsOtherData'):
156
 
                    self.project.pdata["VCSOTHERDATA"] = []
157
 
                else:
158
 
                    self.project.pdata["VCSOTHERDATA"] = [eval(self.buffer)]
159
 
        else:
160
 
            self.project.pdata["VCSOTHERDATA"] = []
 
206
                self.project.pdata["VCSOTHERDATA"] = []
161
207
        
162
208
    def endEric3DocParams(self):
163
209
        """
166
212
        self.buffer = self.utf8_to_code(self.buffer)
167
213
        if self.buffer:
168
214
            if self.version > '3.8':
169
 
                self.project.pdata["ERIC3DOCPARMS"] = [pickle.loads(self.buffer)]
 
215
                self.project.pdata["ERIC4DOCPARMS"] = [pickle.loads(self.buffer)]
170
216
            else:
171
 
                if self.project.checkSecurityString(self.buffer, 'Eric3DocParams'):
172
 
                    self.project.pdata["ERIC3DOCPARMS"] = []
 
217
                if self.project.checkSecurityString(self.buffer, 'Eric4DocParams'):
 
218
                    self.project.pdata["ERIC4DOCPARMS"] = []
173
219
                else:
174
 
                    self.project.pdata["ERIC3DOCPARMS"] = [eval(self.buffer)]
 
220
                    self.project.pdata["ERIC4DOCPARMS"] = [eval(self.buffer)]
175
221
        else:
176
 
            self.project.pdata["ERIC3DOCPARMS"] = []
 
222
            self.project.pdata["ERIC4DOCPARMS"] = []
177
223
        
178
224
    def endEric3ApiParams(self):
179
225
        """
182
228
        self.buffer = self.utf8_to_code(self.buffer)
183
229
        if self.buffer:
184
230
            if self.version > '3.8':
185
 
                self.project.pdata["ERIC3APIPARMS"] = [pickle.loads(self.buffer)]
 
231
                self.project.pdata["ERIC4APIPARMS"] = [pickle.loads(self.buffer)]
186
232
            else:
187
 
                if self.project.checkSecurityString(self.buffer, 'Eric3ApiParams'):
188
 
                    self.project.pdata["ERIC3APIPARMS"] = []
 
233
                if self.project.checkSecurityString(self.buffer, 'Eric4ApiParams'):
 
234
                    self.project.pdata["ERIC4APIPARMS"] = []
189
235
                else:
190
 
                    self.project.pdata["ERIC3APIPARMS"] = [eval(self.buffer)]
 
236
                    self.project.pdata["ERIC4APIPARMS"] = [eval(self.buffer)]
191
237
        else:
192
 
            self.project.pdata["ERIC3APIPARMS"] = []
 
238
            self.project.pdata["ERIC4APIPARMS"] = []
 
239
        
 
240
    def startEric4DocParams(self, attrs):
 
241
        """
 
242
        Handler method for the "Eric4DocParams" start tag.
 
243
        
 
244
        @param attrs list of tag attributes
 
245
        """
 
246
        self.defaultStartElement(attrs)
 
247
        self._prepareBasics()
 
248
        
 
249
    def endEric4DocParams(self):
 
250
        """
 
251
        Handler method for the "Eric4DocParams" end tag.
 
252
        """
 
253
        try:
 
254
            self.project.pdata["ERIC4DOCPARMS"] = [self.stack[-1]]
 
255
        except IndexError:
 
256
            self.project.pdata["ERIC4DOCPARMS"] = []
 
257
        
 
258
    def startEric4ApiParams(self, attrs):
 
259
        """
 
260
        Handler method for the "Eric4ApiParams" start tag.
 
261
        
 
262
        @param attrs list of tag attributes
 
263
        """
 
264
        self.defaultStartElement(attrs)
 
265
        self._prepareBasics()
 
266
        
 
267
    def endEric4ApiParams(self):
 
268
        """
 
269
        Handler method for the "Eric4ApiParams" end tag.
 
270
        """
 
271
        try:
 
272
            self.project.pdata["ERIC4APIPARMS"] = [self.stack[-1]]
 
273
        except IndexError:
 
274
            self.project.pdata["ERIC4APIPARMS"] = []
 
275
        
 
276
    def startCxfreezeParams(self, attrs):
 
277
        """
 
278
        Handler method for the "CxfreezeParams" start tag.
 
279
        
 
280
        @param attrs list of tag attributes
 
281
        """
 
282
        self.defaultStartElement(attrs)
 
283
        if self.version >= '4.0':
 
284
            self._prepareBasics()
193
285
        
194
286
    def endCxfreezeParams(self):
195
287
        """
196
288
        Handler method for the "CxfreezeParams" end tag.
197
289
        """
198
 
        self.buffer = self.utf8_to_code(self.buffer)
199
 
        if self.buffer:
200
 
            if self.version > '3.8':
201
 
                self.project.pdata["CXFREEZEPARMS"] = [pickle.loads(self.buffer)]
 
290
        if self.version >= '4.0':
 
291
            try:
 
292
                self.project.pdata["CXFREEZEPARMS"] = [self.stack[-1]]
 
293
            except IndexError:
 
294
                self.project.pdata["CXFREEZEPARMS"] = []
 
295
        else:
 
296
            self.buffer = self.utf8_to_code(self.buffer)
 
297
            if self.buffer:
 
298
                if self.version > '3.8':
 
299
                    self.project.pdata["CXFREEZEPARMS"] = [pickle.loads(self.buffer)]
 
300
                else:
 
301
                    if self.project.checkSecurityString(self.buffer, 'CxfreezeParams'):
 
302
                        self.project.pdata["CXFREEZEPARMS"] = []
 
303
                    else:
 
304
                        self.project.pdata["CXFREEZEPARMS"] = [eval(self.buffer)]
202
305
            else:
203
 
                if self.project.checkSecurityString(self.buffer, 'CxfreezeParams'):
204
 
                    self.project.pdata["CXFREEZEPARMS"] = []
205
 
                else:
206
 
                    self.project.pdata["CXFREEZEPARMS"] = [eval(self.buffer)]
207
 
        else:
208
 
            self.project.pdata["CXFREEZEPARMS"] = []
 
306
                self.project.pdata["CXFREEZEPARMS"] = []
 
307
        
 
308
    def startPyLintParams(self, attrs):
 
309
        """
 
310
        Handler method for the "PyLintParams" start tag.
 
311
        
 
312
        @param attrs list of tag attributes
 
313
        """
 
314
        self.defaultStartElement(attrs)
 
315
        if self.version >= '4.0':
 
316
            self._prepareBasics()
209
317
        
210
318
    def endPyLintParams(self):
211
319
        """
212
320
        Handler method for the "PyLintParams" end tag.
213
321
        """
214
 
        self.buffer = self.utf8_to_code(self.buffer)
215
 
        if self.buffer:
216
 
            if self.version > '3.8':
217
 
                self.project.pdata["PYLINTPARMS"] = [pickle.loads(self.buffer)]
 
322
        if self.version >= '4.0':
 
323
            try:
 
324
                self.project.pdata["PYLINTPARMS"] = [self.stack[-1]]
 
325
            except IndexError:
 
326
                self.project.pdata["PYLINTPARMS"] = []
 
327
        else:
 
328
            self.buffer = self.utf8_to_code(self.buffer)
 
329
            if self.buffer:
 
330
                if self.version > '3.8':
 
331
                    self.project.pdata["PYLINTPARMS"] = [pickle.loads(self.buffer)]
 
332
                else:
 
333
                    if self.project.checkSecurityString(self.buffer, 'PyLintParams'):
 
334
                        self.project.pdata["PYLINTPARMS"] = []
 
335
                    else:
 
336
                        self.project.pdata["PYLINTPARMS"] = [eval(self.buffer)]
218
337
            else:
219
 
                if self.project.checkSecurityString(self.buffer, 'PyLintParams'):
220
 
                    self.project.pdata["PYLINTPARMS"] = []
221
 
                else:
222
 
                    self.project.pdata["PYLINTPARMS"] = [eval(self.buffer)]
223
 
        else:
224
 
            self.project.pdata["PYLINTPARMS"] = []
 
338
                self.project.pdata["PYLINTPARMS"] = []
225
339
        
226
340
    def endDir(self):
227
341
        """
249
363
        """
250
364
        Handler method for the "TranslationPrefix" end tag.
251
365
        """
252
 
        path = self.buildPath()
 
366
        path = self.__buildPath()
253
367
        self.project.pdata["TRANSLATIONPREFIX"].append(path)
254
368
        
 
369
    def startTranslationsBinPath(self, attrs):
 
370
        """
 
371
        Handler method for the "TranslationPrefix" start tag.
 
372
        
 
373
        @param attrs list of tag attributes
 
374
        """
 
375
        self.pathStack = []
 
376
        
 
377
    def endTranslationsBinPath(self):
 
378
        """
 
379
        Handler method for the "TranslationPrefix" end tag.
 
380
        """
 
381
        path = self.__buildPath()
 
382
        self.project.pdata["TRANSLATIONSBINPATH"].append(path)
 
383
        
255
384
    def startSource(self, attrs):
256
385
        """
257
386
        Handler method for the "Source" start tag.
264
393
        """
265
394
        Handler method for the "Source" end tag.
266
395
        """
267
 
        path = self.buildPath()
 
396
        path = self.__buildPath()
268
397
        self.project.pdata["SOURCES"].append(path)
269
398
        
270
399
    def startForm(self, attrs):
279
408
        """
280
409
        Handler method for the "Form" end tag.
281
410
        """
282
 
        path = self.buildPath()
 
411
        path = self.__buildPath()
283
412
        self.project.pdata["FORMS"].append(path)
284
413
        
285
414
    def startTranslation(self, attrs):
294
423
        """
295
424
        Handler method for the "Translation" end tag.
296
425
        """
297
 
        path = self.buildPath()
 
426
        path = self.__buildPath()
298
427
        self.project.pdata["TRANSLATIONS"].append(path)
299
428
        
 
429
    def startTranslationException(self, attrs):
 
430
        """
 
431
        Handler method for the "TranslationException" start tag.
 
432
        
 
433
        @param attrs list of tag attributes
 
434
        """
 
435
        self.pathStack = []
 
436
        
 
437
    def endTranslationException(self):
 
438
        """
 
439
        Handler method for the "TranslationException" end tag.
 
440
        """
 
441
        path = self.__buildPath()
 
442
        self.project.pdata["TRANSLATIONEXCEPTIONS"].append(path)
 
443
        
 
444
    def startResource(self, attrs):
 
445
        """
 
446
        Handler method for the "Resource" start tag.
 
447
        
 
448
        @param attrs list of tag attributes
 
449
        """
 
450
        self.pathStack = []
 
451
        
 
452
    def endResource(self):
 
453
        """
 
454
        Handler method for the "Resource" end tag.
 
455
        """
 
456
        path = self.__buildPath()
 
457
        self.project.pdata["RESOURCES"].append(path)
 
458
        
300
459
    def startInterface(self, attrs):
301
460
        """
302
461
        Handler method for the "Interface" start tag.
309
468
        """
310
469
        Handler method for the "Interface" end tag.
311
470
        """
312
 
        path = self.buildPath()
 
471
        path = self.__buildPath()
313
472
        self.project.pdata["INTERFACES"].append(path)
314
473
        
315
474
    def startOther(self, attrs):
324
483
        """
325
484
        Handler method for the "Other" end tag.
326
485
        """
327
 
        path = self.buildPath()
 
486
        path = self.__buildPath()
328
487
        self.project.pdata["OTHERS"].append(path)
329
488
        
330
489
    def startMainScript(self, attrs):
339
498
        """
340
499
        Handler method for the "MainScript" end tag.
341
500
        """
342
 
        path = self.buildPath()
 
501
        path = self.__buildPath()
343
502
        self.project.pdata["MAINSCRIPT"] = [path]
344
503
        
345
504
    def startFiletypeAssociation(self, attrs):
353
512
        if pattern:
354
513
            self.project.pdata["FILETYPES"][pattern] = filetype
355
514
        
356
 
    def buildPath(self):
 
515
    def __buildPath(self):
357
516
        """
358
517
        Private method to assemble a path.
359
518