svn-gvsig-desktop / tags / v1_9_Build_1238 / docs / scripts / mkbook.py @ 47840
History | View | Annotate | Download (12.2 KB)
1 | 5604 | vacevedo | #!/usr/bin/python
|
---|---|---|---|
2 | import os |
||
3 | import sys |
||
4 | import shutil |
||
5 | 5739 | vacevedo | import re |
6 | 5604 | vacevedo | |
7 | 5739 | vacevedo | |
8 | 5745 | vacevedo | class RootDir(object): |
9 | def __init__(self,path): |
||
10 | self._path = os.path.abspath(path)
|
||
11 | |||
12 | def __str__(self): |
||
13 | return self._path |
||
14 | |||
15 | def data(self,*dirs): |
||
16 | return os.path.join(self._path,"datos",*dirs) |
||
17 | |||
18 | def docbook(self,*dirs): |
||
19 | return os.path.join(self._path,"docbook",*dirs) |
||
20 | |||
21 | 5746 | vacevedo | def __call__(self,*dirs): |
22 | return os.path.join(self._path,*dirs) |
||
23 | 5745 | vacevedo | |
24 | def getExtension(fname): |
||
25 | 5739 | vacevedo | """
|
26 | 5745 | vacevedo | Retorna la extension del fichero con punto,
|
27 | "fff.xxx" -> ".xxx"
|
||
28 | 5739 | vacevedo | """
|
29 | 5745 | vacevedo | return os.path.splitext(fname)[1] |
30 | |||
31 | def removeExtension(fname): |
||
32 | """
|
||
33 | Retorna el nombre del fichero sin la extension.
|
||
34 | Quita tambien el punto.
|
||
35 | "fff.xxx" -> "fff"
|
||
36 | """
|
||
37 | return os.path.splitext(fname)[0] |
||
38 | 5739 | vacevedo | |
39 | 5746 | vacevedo | def shell(cmd,head=None): |
40 | status = 0
|
||
41 | childstdin, childstdout, childstderr = os.popen3(cmd) |
||
42 | while True: |
||
43 | line = childstdout.readline() |
||
44 | if line in (None,""): |
||
45 | break
|
||
46 | print line
|
||
47 | if head == None: |
||
48 | head = "Error ejecutando '%s'" % (cmd)
|
||
49 | while True: |
||
50 | line = childstderr.readline() |
||
51 | if line in (None,""): |
||
52 | break
|
||
53 | if head != None: |
||
54 | print head
|
||
55 | head = None
|
||
56 | status=1
|
||
57 | print ">>> "+line |
||
58 | return status
|
||
59 | |||
60 | 5745 | vacevedo | class ProcessDocBook(object): |
61 | def __init__(self, sourceDir, tempDir, distDir): |
||
62 | self.sourceDir = RootDir(sourceDir)
|
||
63 | self.tempDir = RootDir(tempDir)
|
||
64 | self.distDir = RootDir(distDir)
|
||
65 | self.imageCounter = 1 |
||
66 | 5746 | vacevedo | self.status=0 |
67 | 5745 | vacevedo | |
68 | 5746 | vacevedo | def __str__(self): |
69 | return "ProcessDocBook( sourceDir =%s, tempDir=%s, distDir=%s, imageCounter=%s, status=%s)"%( |
||
70 | self.sourceDir,
|
||
71 | self.tempDir,
|
||
72 | self.distDir,
|
||
73 | self.imageCounter,
|
||
74 | self.status
|
||
75 | ) |
||
76 | 5779 | vacevedo | |
77 | 5745 | vacevedo | def nextImageCounter(self): |
78 | self.imageCounter += 1 |
||
79 | return self.imageCounter |
||
80 | |||
81 | def toTempPath(self,*path): |
||
82 | path = os.path.join(*path) |
||
83 | return os.path.join(
|
||
84 | str(self.tempDir), |
||
85 | path[ len(str(self.sourceDir))+1: ] |
||
86 | ) |
||
87 | 5739 | vacevedo | |
88 | 5779 | vacevedo | def copyFromTo(self,source,dest): |
89 | 5745 | vacevedo | |
90 | 5779 | vacevedo | try:
|
91 | shutil.copy(source,dest) |
||
92 | except OSError, e: |
||
93 | if e.errno!=1: |
||
94 | print "copyFromTo: Error copiando la fuente %s a destino %s. Error %s, %s"%( |
||
95 | sourceImage, |
||
96 | targetImage, |
||
97 | str(e.__class__),
|
||
98 | str(e)
|
||
99 | ) |
||
100 | raise
|
||
101 | |||
102 | return
|
||
103 | |||
104 | 5745 | vacevedo | def makedirs(self,*dirs): |
105 | path = os.path.join(*dirs) |
||
106 | try:
|
||
107 | os.makedirs(path) |
||
108 | except OSError, e: |
||
109 | if e.errno!=17: |
||
110 | print "makedirs: Se ha producido un error creando el directorio '%s', error %s, %s" % ( |
||
111 | path, |
||
112 | str(e.__class__),
|
||
113 | str(e)
|
||
114 | ) |
||
115 | raise
|
||
116 | return
|
||
117 | 5604 | vacevedo | |
118 | 5745 | vacevedo | def sxw2docbook(self, pathnameSXW): |
119 | """
|
||
120 | Copia el fichero SXW al temp, y lo transforma en un
|
||
121 | docbook.
|
||
122 | """
|
||
123 | pathnameSXWInTemp = self.toTempPath(pathnameSXW)
|
||
124 | 5746 | vacevedo | #print "Procesando %s --> %s" % (pathnameSXW,pathnameSXWInTemp)
|
125 | 5779 | vacevedo | #shutil.copyfile(pathnameSXW,pathnameSXWInTemp)
|
126 | self.copyFromTo(pathnameSXW,pathnameSXWInTemp)
|
||
127 | 5745 | vacevedo | os.chdir(os.path.dirname(pathnameSXWInTemp)) |
128 | 5746 | vacevedo | shell("ooo2dbk -a -c/etc/ooo2dbk.xml '%s'" % pathnameSXWInTemp)
|
129 | 5745 | vacevedo | os.unlink(pathnameSXWInTemp) |
130 | pathnameSXWInTempWhitoutExt = removeExtension(pathnameSXWInTemp).replace(" ","_") |
||
131 | os.rename(pathnameSXWInTempWhitoutExt+".docb.xml",pathnameSXWInTempWhitoutExt+".docbook") |
||
132 | |||
133 | def getImageListOfSXW(self, pathnameSXW): |
||
134 | """
|
||
135 | Retorna una lista con las imagenes extraidas
|
||
136 | del fichero SXW, y una propuesta de nombre para
|
||
137 | renombrarla.
|
||
138 | """
|
||
139 | 5746 | vacevedo | #print "obteniendo la lista de imagenes de %s" % (pathnameSXW)
|
140 | 5745 | vacevedo | imagesPath = os.path.join( |
141 | os.path.dirname(self.toTempPath(pathnameSXW)),
|
||
142 | "images"
|
||
143 | ) |
||
144 | images=list()
|
||
145 | files= os.listdir(imagesPath) |
||
146 | for fname in files: |
||
147 | if fname[:-4]!="_dbk": |
||
148 | image = ( |
||
149 | fname, |
||
150 | "_dbk%03d_%s"%(self.nextImageCounter(),fname) |
||
151 | ) |
||
152 | images.append(image) |
||
153 | return images
|
||
154 | 5739 | vacevedo | |
155 | 5745 | vacevedo | def moveImagesOfSXW(self, pathnameSXW, images): |
156 | """
|
||
157 | Recibe una lista de imagenes del fichero SXW con
|
||
158 | las propuestas para renombrarlas, y las renombra,
|
||
159 | las mueve a directorio data/images del temp.
|
||
160 | """
|
||
161 | 5746 | vacevedo | #print "Moviendo las imagenes de %s" % (pathnameSXW)
|
162 | 5745 | vacevedo | sourcePath = os.path.join( |
163 | os.path.dirname(self.toTempPath(pathnameSXW)),
|
||
164 | "images"
|
||
165 | ) |
||
166 | targetPath = self.tempDir.data("images") |
||
167 | self.makedirs(targetPath)
|
||
168 | for image in images: |
||
169 | shutil.move( |
||
170 | os.path.join(sourcePath,image[0]),
|
||
171 | os.path.join(targetPath,image[1])
|
||
172 | ) |
||
173 | return True |
||
174 | 5739 | vacevedo | |
175 | |||
176 | 5745 | vacevedo | def fixImagesInDocBookOfSXW(self, pathnameSXW, images): |
177 | """
|
||
178 | Actualiza los nombres de las imagenes del fichero
|
||
179 | docbook generado a partir del SXW.
|
||
180 | """
|
||
181 | pathname = removeExtension(self.toTempPath(pathnameSXW))+".docbook" |
||
182 | f=file(pathname,"r") |
||
183 | todo=f.readlines() |
||
184 | f.close() |
||
185 | f=file(pathname,"w") |
||
186 | for line in todo: |
||
187 | for oldName,newName in images: |
||
188 | oldStr="<imagedata fileref=\"images/%s\""%oldName
|
||
189 | newStr="<imagedata fileref=\"images/%s\""%newName
|
||
190 | line=line.replace(oldStr,newStr) |
||
191 | f.write(line) |
||
192 | f.close() |
||
193 | 5739 | vacevedo | |
194 | 5746 | vacevedo | def fixTagsHeaderFromSXW(self, pathnameSXW): |
195 | """
|
||
196 | """
|
||
197 | pathname = removeExtension(self.toTempPath(pathnameSXW))+".docbook" |
||
198 | f=file(pathname,"r") |
||
199 | todo=f.readlines() |
||
200 | f.close() |
||
201 | 5745 | vacevedo | |
202 | 5746 | vacevedo | del todo[0] # Eliminamos <? xml ... |
203 | del todo[0] # Eliminanos <ENTITY .... |
||
204 | |||
205 | if re.match("\s*[<]article[> ]",todo[0] )!= None and re.match("\s*[<]/articleinfo[>]\s*",todo[5] )!= None : |
||
206 | #print "Eliminando tag <article> de %s" % (pathname)
|
||
207 | |||
208 | del todo[0] # Eliminamos <article lang="es-ES"> |
||
209 | del todo[0] # Eliminamos <?ooogenerator Ope |
||
210 | del todo[0] # Eliminamos <?oooversion ?> |
||
211 | del todo[0] # Eliminamos <articleinfo> |
||
212 | del todo[0] # Eliminamos <authorgroup/> |
||
213 | del todo[0] # Eliminamos </articleinfo> |
||
214 | del todo[-1] # Eliminamos </article> |
||
215 | |||
216 | f=file(pathname,"w") |
||
217 | for line in todo: |
||
218 | f.write(line) |
||
219 | f.close() |
||
220 | |||
221 | 5745 | vacevedo | def SXWsToDocbookInTemp(self): |
222 | """
|
||
223 | Se recorre el directorio datos de los fuentes y convierte
|
||
224 | los ficheros sxw en docbook dejandolos en el directorio datos
|
||
225 | de temp.
|
||
226 | """
|
||
227 | |||
228 | for root, dirs, files in os.walk(self.sourceDir.data()): |
||
229 | #print "root %s\, dirs %s\n, files%s\n"%(root, dirs, files)
|
||
230 | if os.path.split(root)[1] !="CVS": |
||
231 | self.makedirs( self.toTempPath(root) ) |
||
232 | for fname in files: |
||
233 | 5846 | crodero | sys.stdout.write(".")
|
234 | sys.stdout.flush() |
||
235 | 5746 | vacevedo | #print fname
|
236 | 5745 | vacevedo | extension = getExtension(fname).lower() |
237 | if extension ==".sxw": |
||
238 | pathname = os.path.join(root,fname) |
||
239 | self.sxw2docbook(pathname)
|
||
240 | 5746 | vacevedo | self.fixTagsHeaderFromSXW(pathname)
|
241 | 5745 | vacevedo | images = self.getImageListOfSXW(pathname)
|
242 | self.moveImagesOfSXW(pathname, images)
|
||
243 | self.fixImagesInDocBookOfSXW(pathname, images)
|
||
244 | 5846 | crodero | print
|
245 | 5745 | vacevedo | return True |
246 | |||
247 | def copyDocbookFromSourceToTemp(self): |
||
248 | """
|
||
249 | Copia los ficheros docbook del directorio source al
|
||
250 | directorio temp, procesandolos a taves del CPP.
|
||
251 | """
|
||
252 | for root, dirs, files in os.walk(self.sourceDir.docbook()): |
||
253 | if os.path.split(root)[1] !="CVS": |
||
254 | self.makedirs( self.toTempPath(root) ) |
||
255 | for fname in files: |
||
256 | extension = getExtension(fname).lower() |
||
257 | if extension ==".docbook": |
||
258 | cmd = """cpp -I%s -CC %s""" %(
|
||
259 | str(self.tempDir), |
||
260 | os.path.join(root,fname) |
||
261 | 5739 | vacevedo | ) |
262 | 5745 | vacevedo | childstdin, childstdout, childstderr = os.popen3(cmd) |
263 | fout = file(self.toTempPath(root,fname),"w") |
||
264 | while True: |
||
265 | line = childstdout.readline() |
||
266 | if line in (None,""): |
||
267 | break
|
||
268 | if re.match("^#\s[0-9][0-9]*\s",line) == None: |
||
269 | fout.write(line) |
||
270 | head = "Error preprocesando el fichero '%s' (%s)" % (fname, cmd)
|
||
271 | while True: |
||
272 | 5846 | crodero | line = childstderr.readline() |
273 | 5745 | vacevedo | if line in (None,""): |
274 | break
|
||
275 | if head != None: |
||
276 | print head
|
||
277 | head = None
|
||
278 | 5746 | vacevedo | self.status=1 |
279 | 5745 | vacevedo | print " "+line |
280 | return True |
||
281 | |||
282 | def copyImagesToDocBookDirInTemp(self): |
||
283 | """
|
||
284 | Copia las imagenes referenciadas en el los ficheros
|
||
285 | docbook a un directorio "images" junto a cada docbook.
|
||
286 | """
|
||
287 | 5846 | crodero | |
288 | 5745 | vacevedo | for root, dirs, files in os.walk(self.tempDir.docbook()): |
289 | 5739 | vacevedo | for fname in files: |
290 | 5846 | crodero | try:
|
291 | #print "Moviendo imagenes de %s al directorio %s " %( fname,root)
|
||
292 | extension = getExtension(fname).lower() |
||
293 | if extension ==".docbook": |
||
294 | f=file(os.path.join(root,fname),"r") |
||
295 | todo=f.read() |
||
296 | f.close() |
||
297 | matchs=re.finditer('[<]imagedata fileref="([^"]*)"',todo)
|
||
298 | for match in matchs: |
||
299 | 5872 | crodero | imageName=match.group(1)
|
300 | 5846 | crodero | sourceImage = self.tempDir.data(
|
301 | "images",
|
||
302 | 5872 | crodero | os.path.basename(imageName) |
303 | 5846 | crodero | ) |
304 | 5872 | crodero | targetImage = os.path.join( root, imageName) |
305 | 5846 | crodero | self.makedirs(os.path.dirname(targetImage))
|
306 | #shutil.copyfile(sourceImage, targetImage)
|
||
307 | #shutil.copy(sourceImage,self.distDir("images"))
|
||
308 | self.copyFromTo(sourceImage, targetImage)
|
||
309 | self.copyFromTo(sourceImage,self.distDir("images")) |
||
310 | except Exception,e: |
||
311 | 5872 | crodero | print "Error: copyImagesToDocBookDirInTemp(procesisng file %s/%s imageName=%s), error %s, %s" % ( |
312 | root, |
||
313 | fname, |
||
314 | imageName, |
||
315 | 5846 | crodero | str(e.__class__),
|
316 | str(e)
|
||
317 | ) |
||
318 | 5779 | vacevedo | |
319 | 5745 | vacevedo | return True |
320 | |||
321 | def buildHtmlFromDocbookOfTemp(self,mainfname): |
||
322 | xsltFile="/usr/share/xml/docbook/stylesheet/nwalsh/xhtml/chunk.xsl"
|
||
323 | 5604 | vacevedo | |
324 | 5745 | vacevedo | if not os.path.isabs(mainfname): |
325 | mainfname = self.tempDir.docbook(mainfname)
|
||
326 | |||
327 | os.chdir( self.tempDir.docbook() )
|
||
328 | 5746 | vacevedo | cmd = "xsltproc -o %s/ %s %s 2>&1"% (
|
329 | self.distDir(),
|
||
330 | 5745 | vacevedo | xsltFile, |
331 | mainfname |
||
332 | 5739 | vacevedo | ) |
333 | 5745 | vacevedo | print os.path.abspath(os.curdir)
|
334 | print cmd
|
||
335 | 5746 | vacevedo | shell(cmd) |
336 | 5745 | vacevedo | |
337 | def process(self,mainfname="principal.docbook"): |
||
338 | 5746 | vacevedo | self.makedirs(self.distDir("images")) |
339 | 5745 | vacevedo | print "Procesando ficheros SXW" |
340 | self.SXWsToDocbookInTemp()
|
||
341 | 5746 | vacevedo | |
342 | 5745 | vacevedo | print "Preprocesando ficheros docbook" |
343 | self.copyDocbookFromSourceToTemp()
|
||
344 | |||
345 | print "Moviendo las imagenes" |
||
346 | self.copyImagesToDocBookDirInTemp()
|
||
347 | |||
348 | print "Construyendo el html" |
||
349 | self.buildHtmlFromDocbookOfTemp(mainfname)
|
||
350 | 5746 | vacevedo | |
351 | 5745 | vacevedo | return True |
352 | 5604 | vacevedo | |
353 | 5745 | vacevedo | def __call__(self,mainfname="principal.docbook"): |
354 | return self.process(mainfname) |
||
355 | |||
356 | 5739 | vacevedo | |
357 | 5604 | vacevedo | def main(): |
358 | 5745 | vacevedo | process = ProcessDocBook( |
359 | sourceDir=sys.argv[1],
|
||
360 | tempDir=sys.argv[2],
|
||
361 | distDir=sys.argv[3]
|
||
362 | ) |
||
363 | process() |
||
364 | 5746 | vacevedo | if process.status !=0: |
365 | sys.exit(process.status) |
||
366 | 5604 | vacevedo | |
367 | 5834 | crodero | if __name__ == "__main__": |
368 | main() |