Download as
Browse Code »

Commit f97f4db2002913e1a18d17d7988ff27e00b7b9c1

Authored by Edmar Moretti
1 parent 4c12b068
Exists in master and in 7 other branches composer, doc-root, docker, guia, licenca, readme, unmaintened

--no commit message

Showing 12 changed files with 0 additions and 3250 deletions   Show diff stats
pacotes/openlayers/tools/BeautifulSoup.py
View file @4c12b06
... ... @@ -1,1767 +0,0 @@
1   -"""Beautiful Soup
2   -Elixir and Tonic
3   -"The Screen-Scraper's Friend"
4   -http://www.crummy.com/software/BeautifulSoup/
5   -
6   -Beautiful Soup parses a (possibly invalid) XML or HTML document into a
7   -tree representation. It provides methods and Pythonic idioms that make
8   -it easy to navigate, search, and modify the tree.
9   -
10   -A well-formed XML/HTML document yields a well-formed data
11   -structure. An ill-formed XML/HTML document yields a correspondingly
12   -ill-formed data structure. If your document is only locally
13   -well-formed, you can use this library to find and process the
14   -well-formed part of it. The BeautifulSoup class
15   -
16   -Beautiful Soup works with Python 2.2 and up. It has no external
17   -dependencies, but you'll have more success at converting data to UTF-8
18   -if you also install these three packages:
19   -
20   -* chardet, for auto-detecting character encodings
21   - http://chardet.feedparser.org/
22   -* cjkcodecs and iconv_codec, which add more encodings to the ones supported
23   - by stock Python.
24   - http://cjkpython.i18n.org/
25   -
26   -Beautiful Soup defines classes for two main parsing strategies:
27   -
28   - * BeautifulStoneSoup, for parsing XML, SGML, or your domain-specific
29   - language that kind of looks like XML.
30   -
31   - * BeautifulSoup, for parsing run-of-the-mill HTML code, be it valid
32   - or invalid. This class has web browser-like heuristics for
33   - obtaining a sensible parse tree in the face of common HTML errors.
34   -
35   -Beautiful Soup also defines a class (UnicodeDammit) for autodetecting
36   -the encoding of an HTML or XML document, and converting it to
37   -Unicode. Much of this code is taken from Mark Pilgrim's Universal Feed Parser.
38   -
39   -For more than you ever wanted to know about Beautiful Soup, see the
40   -documentation:
41   -http://www.crummy.com/software/BeautifulSoup/documentation.html
42   -
43   -"""
44   -from __future__ import generators
45   -
46   -__author__ = "Leonard Richardson (leonardr@segfault.org)"
47   -__version__ = "3.0.4"
48   -__copyright__ = "Copyright (c) 2004-2007 Leonard Richardson"
49   -__license__ = "PSF"
50   -
51   -from sgmllib import SGMLParser, SGMLParseError
52   -import codecs
53   -import types
54   -import re
55   -import sgmllib
56   -try:
57   - from htmlentitydefs import name2codepoint
58   -except ImportError:
59   - name2codepoint = {}
60   -
61   -#This hack makes Beautiful Soup able to parse XML with namespaces
62   -sgmllib.tagfind = re.compile('[a-zA-Z][-_.:a-zA-Z0-9]*')
63   -
64   -DEFAULT_OUTPUT_ENCODING = "utf-8"
65   -
66   -# First, the classes that represent markup elements.
67   -
68   -class PageElement:
69   - """Contains the navigational information for some part of the page
70   - (either a tag or a piece of text)"""
71   -
72   - def setup(self, parent=None, previous=None):
73   - """Sets up the initial relations between this element and
74   - other elements."""
75   - self.parent = parent
76   - self.previous = previous
77   - self.next = None
78   - self.previousSibling = None
79   - self.nextSibling = None
80   - if self.parent and self.parent.contents:
81   - self.previousSibling = self.parent.contents[-1]
82   - self.previousSibling.nextSibling = self
83   -
84   - def replaceWith(self, replaceWith):
85   - oldParent = self.parent
86   - myIndex = self.parent.contents.index(self)
87   - if hasattr(replaceWith, 'parent') and replaceWith.parent == self.parent:
88   - # We're replacing this element with one of its siblings.
89   - index = self.parent.contents.index(replaceWith)
90   - if index and index < myIndex:
91   - # Furthermore, it comes before this element. That
92   - # means that when we extract it, the index of this
93   - # element will change.
94   - myIndex = myIndex - 1
95   - self.extract()
96   - oldParent.insert(myIndex, replaceWith)
97   -
98   - def extract(self):
99   - """Destructively rips this element out of the tree."""
100   - if self.parent:
101   - try:
102   - self.parent.contents.remove(self)
103   - except ValueError:
104   - pass
105   -
106   - #Find the two elements that would be next to each other if
107   - #this element (and any children) hadn't been parsed. Connect
108   - #the two.
109   - lastChild = self._lastRecursiveChild()
110   - nextElement = lastChild.next
111   -
112   - if self.previous:
113   - self.previous.next = nextElement
114   - if nextElement:
115   - nextElement.previous = self.previous
116   - self.previous = None
117   - lastChild.next = None
118   -
119   - self.parent = None
120   - if self.previousSibling:
121   - self.previousSibling.nextSibling = self.nextSibling
122   - if self.nextSibling:
123   - self.nextSibling.previousSibling = self.previousSibling
124   - self.previousSibling = self.nextSibling = None
125   -
126   - def _lastRecursiveChild(self):
127   - "Finds the last element beneath this object to be parsed."
128   - lastChild = self
129   - while hasattr(lastChild, 'contents') and lastChild.contents:
130   - lastChild = lastChild.contents[-1]
131   - return lastChild
132   -
133   - def insert(self, position, newChild):
134   - if (isinstance(newChild, basestring)
135   - or isinstance(newChild, unicode)) \
136   - and not isinstance(newChild, NavigableString):
137   - newChild = NavigableString(newChild)
138   -
139   - position = min(position, len(self.contents))
140   - if hasattr(newChild, 'parent') and newChild.parent != None:
141   - # We're 'inserting' an element that's already one
142   - # of this object's children.
143   - if newChild.parent == self:
144   - index = self.find(newChild)
145   - if index and index < position:
146   - # Furthermore we're moving it further down the
147   - # list of this object's children. That means that
148   - # when we extract this element, our target index
149   - # will jump down one.
150   - position = position - 1
151   - newChild.extract()
152   -
153   - newChild.parent = self
154   - previousChild = None
155   - if position == 0:
156   - newChild.previousSibling = None
157   - newChild.previous = self
158   - else:
159   - previousChild = self.contents[position-1]
160   - newChild.previousSibling = previousChild
161   - newChild.previousSibling.nextSibling = newChild
162   - newChild.previous = previousChild._lastRecursiveChild()
163   - if newChild.previous:
164   - newChild.previous.next = newChild
165   -
166   - newChildsLastElement = newChild._lastRecursiveChild()
167   -
168   - if position >= len(self.contents):
169   - newChild.nextSibling = None
170   -
171   - parent = self
172   - parentsNextSibling = None
173   - while not parentsNextSibling:
174   - parentsNextSibling = parent.nextSibling
175   - parent = parent.parent
176   - if not parent: # This is the last element in the document.
177   - break
178   - if parentsNextSibling:
179   - newChildsLastElement.next = parentsNextSibling
180   - else:
181   - newChildsLastElement.next = None
182   - else:
183   - nextChild = self.contents[position]
184   - newChild.nextSibling = nextChild
185   - if newChild.nextSibling:
186   - newChild.nextSibling.previousSibling = newChild
187   - newChildsLastElement.next = nextChild
188   -
189   - if newChildsLastElement.next:
190   - newChildsLastElement.next.previous = newChildsLastElement
191   - self.contents.insert(position, newChild)
192   -
193   - def findNext(self, name=None, attrs={}, text=None, **kwargs):
194   - """Returns the first item that matches the given criteria and
195   - appears after this Tag in the document."""
196   - return self._findOne(self.findAllNext, name, attrs, text, **kwargs)
197   -
198   - def findAllNext(self, name=None, attrs={}, text=None, limit=None,
199   - **kwargs):
200   - """Returns all items that match the given criteria and appear
201   - before after Tag in the document."""
202   - return self._findAll(name, attrs, text, limit, self.nextGenerator)
203   -
204   - def findNextSibling(self, name=None, attrs={}, text=None, **kwargs):
205   - """Returns the closest sibling to this Tag that matches the
206   - given criteria and appears after this Tag in the document."""
207   - return self._findOne(self.findNextSiblings, name, attrs, text,
208   - **kwargs)
209   -
210   - def findNextSiblings(self, name=None, attrs={}, text=None, limit=None,
211   - **kwargs):
212   - """Returns the siblings of this Tag that match the given
213   - criteria and appear after this Tag in the document."""
214   - return self._findAll(name, attrs, text, limit,
215   - self.nextSiblingGenerator, **kwargs)
216   - fetchNextSiblings = findNextSiblings # Compatibility with pre-3.x
217   -
218   - def findPrevious(self, name=None, attrs={}, text=None, **kwargs):
219   - """Returns the first item that matches the given criteria and
220   - appears before this Tag in the document."""
221   - return self._findOne(self.findAllPrevious, name, attrs, text, **kwargs)
222   -
223   - def findAllPrevious(self, name=None, attrs={}, text=None, limit=None,
224   - **kwargs):
225   - """Returns all items that match the given criteria and appear
226   - before this Tag in the document."""
227   - return self._findAll(name, attrs, text, limit, self.previousGenerator,
228   - **kwargs)
229   - fetchPrevious = findAllPrevious # Compatibility with pre-3.x
230   -
231   - def findPreviousSibling(self, name=None, attrs={}, text=None, **kwargs):
232   - """Returns the closest sibling to this Tag that matches the
233   - given criteria and appears before this Tag in the document."""
234   - return self._findOne(self.findPreviousSiblings, name, attrs, text,
235   - **kwargs)
236   -
237   - def findPreviousSiblings(self, name=None, attrs={}, text=None,
238   - limit=None, **kwargs):
239   - """Returns the siblings of this Tag that match the given
240   - criteria and appear before this Tag in the document."""
241   - return self._findAll(name, attrs, text, limit,
242   - self.previousSiblingGenerator, **kwargs)
243   - fetchPreviousSiblings = findPreviousSiblings # Compatibility with pre-3.x
244   -
245   - def findParent(self, name=None, attrs={}, **kwargs):
246   - """Returns the closest parent of this Tag that matches the given
247   - criteria."""
248   - # NOTE: We can't use _findOne because findParents takes a different
249   - # set of arguments.
250   - r = None
251   - l = self.findParents(name, attrs, 1)
252   - if l:
253   - r = l[0]
254   - return r
255   -
256   - def findParents(self, name=None, attrs={}, limit=None, **kwargs):
257   - """Returns the parents of this Tag that match the given
258   - criteria."""
259   -
260   - return self._findAll(name, attrs, None, limit, self.parentGenerator,
261   - **kwargs)
262   - fetchParents = findParents # Compatibility with pre-3.x
263   -
264   - #These methods do the real heavy lifting.
265   -
266   - def _findOne(self, method, name, attrs, text, **kwargs):
267   - r = None
268   - l = method(name, attrs, text, 1, **kwargs)
269   - if l:
270   - r = l[0]
271   - return r
272   -
273   - def _findAll(self, name, attrs, text, limit, generator, **kwargs):
274   - "Iterates over a generator looking for things that match."
275   -
276   - if isinstance(name, SoupStrainer):
277   - strainer = name
278   - else:
279   - # Build a SoupStrainer
280   - strainer = SoupStrainer(name, attrs, text, **kwargs)
281   - results = ResultSet(strainer)
282   - g = generator()
283   - while True:
284   - try:
285   - i = g.next()
286   - except StopIteration:
287   - break
288   - if i:
289   - found = strainer.search(i)
290   - if found:
291   - results.append(found)
292   - if limit and len(results) >= limit:
293   - break
294   - return results
295   -
296   - #These Generators can be used to navigate starting from both
297   - #NavigableStrings and Tags.
298   - def nextGenerator(self):
299   - i = self
300   - while i:
301   - i = i.next
302   - yield i
303   -
304   - def nextSiblingGenerator(self):
305   - i = self
306   - while i:
307   - i = i.nextSibling
308   - yield i
309   -
310   - def previousGenerator(self):
311   - i = self
312   - while i:
313   - i = i.previous
314   - yield i
315   -
316   - def previousSiblingGenerator(self):
317   - i = self
318   - while i:
319   - i = i.previousSibling
320   - yield i
321   -
322   - def parentGenerator(self):
323   - i = self
324   - while i:
325   - i = i.parent
326   - yield i
327   -
328   - # Utility methods
329   - def substituteEncoding(self, str, encoding=None):
330   - encoding = encoding or "utf-8"
331   - return str.replace("%SOUP-ENCODING%", encoding)
332   -
333   - def toEncoding(self, s, encoding=None):
334   - """Encodes an object to a string in some encoding, or to Unicode.
335   - ."""
336   - if isinstance(s, unicode):
337   - if encoding:
338   - s = s.encode(encoding)
339   - elif isinstance(s, str):
340   - if encoding:
341   - s = s.encode(encoding)
342   - else:
343   - s = unicode(s)
344   - else:
345   - if encoding:
346   - s = self.toEncoding(str(s), encoding)
347   - else:
348   - s = unicode(s)
349   - return s
350   -
351   -class NavigableString(unicode, PageElement):
352   -
353   - def __getattr__(self, attr):
354   - """text.string gives you text. This is for backwards
355   - compatibility for Navigable*String, but for CData* it lets you
356   - get the string without the CData wrapper."""
357   - if attr == 'string':
358   - return self
359   - else:
360   - raise AttributeError, "'%s' object has no attribute '%s'" % (self.__class__.__name__, attr)
361   -
362   - def __unicode__(self):
363   - return self.__str__(None)
364   -
365   - def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING):
366   - if encoding:
367   - return self.encode(encoding)
368   - else:
369   - return self
370   -
371   -class CData(NavigableString):
372   -
373   - def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING):
374   - return "<![CDATA[%s]]>" % NavigableString.__str__(self, encoding)
375   -
376   -class ProcessingInstruction(NavigableString):
377   - def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING):
378   - output = self
379   - if "%SOUP-ENCODING%" in output:
380   - output = self.substituteEncoding(output, encoding)
381   - return "<?%s?>" % self.toEncoding(output, encoding)
382   -
383   -class Comment(NavigableString):
384   - def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING):
385   - return "<!--%s-->" % NavigableString.__str__(self, encoding)
386   -
387   -class Declaration(NavigableString):
388   - def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING):
389   - return "<!%s>" % NavigableString.__str__(self, encoding)
390   -
391   -class Tag(PageElement):
392   -
393   - """Represents a found HTML tag with its attributes and contents."""
394   -
395   - XML_SPECIAL_CHARS_TO_ENTITIES = { "'" : "squot",
396   - '"' : "quote",
397   - "&" : "amp",
398   - "<" : "lt",
399   - ">" : "gt" }
400   -
401   - def __init__(self, parser, name, attrs=None, parent=None,
402   - previous=None):
403   - "Basic constructor."
404   -
405   - # We don't actually store the parser object: that lets extracted
406   - # chunks be garbage-collected
407   - self.parserClass = parser.__class__
408   - self.isSelfClosing = parser.isSelfClosingTag(name)
409   - self.name = name
410   - if attrs == None:
411   - attrs = []
412   - self.attrs = attrs
413   - self.contents = []
414   - self.setup(parent, previous)
415   - self.hidden = False
416   - self.containsSubstitutions = False
417   -
418   - def get(self, key, default=None):
419   - """Returns the value of the 'key' attribute for the tag, or
420   - the value given for 'default' if it doesn't have that
421   - attribute."""
422   - return self._getAttrMap().get(key, default)
423   -
424   - def has_key(self, key):
425   - return self._getAttrMap().has_key(key)
426   -
427   - def __getitem__(self, key):
428   - """tag[key] returns the value of the 'key' attribute for the tag,
429   - and throws an exception if it's not there."""
430   - return self._getAttrMap()[key]
431   -
432   - def __iter__(self):
433   - "Iterating over a tag iterates over its contents."
434   - return iter(self.contents)
435   -
436   - def __len__(self):
437   - "The length of a tag is the length of its list of contents."
438   - return len(self.contents)
439   -
440   - def __contains__(self, x):
441   - return x in self.contents
442   -
443   - def __nonzero__(self):
444   - "A tag is non-None even if it has no contents."
445   - return True
446   -
447   - def __setitem__(self, key, value):
448   - """Setting tag[key] sets the value of the 'key' attribute for the
449   - tag."""
450   - self._getAttrMap()
451   - self.attrMap[key] = value
452   - found = False
453   - for i in range(0, len(self.attrs)):
454   - if self.attrs[i][0] == key:
455   - self.attrs[i] = (key, value)
456   - found = True
457   - if not found:
458   - self.attrs.append((key, value))
459   - self._getAttrMap()[key] = value
460   -
461   - def __delitem__(self, key):
462   - "Deleting tag[key] deletes all 'key' attributes for the tag."
463   - for item in self.attrs:
464   - if item[0] == key:
465   - self.attrs.remove(item)
466   - #We don't break because bad HTML can define the same
467   - #attribute multiple times.
468   - self._getAttrMap()
469   - if self.attrMap.has_key(key):
470   - del self.attrMap[key]
471   -
472   - def __call__(self, *args, **kwargs):
473   - """Calling a tag like a function is the same as calling its
474   - findAll() method. Eg. tag('a') returns a list of all the A tags
475   - found within this tag."""
476   - return apply(self.findAll, args, kwargs)
477   -
478   - def __getattr__(self, tag):
479   - #print "Getattr %s.%s" % (self.__class__, tag)
480   - if len(tag) > 3 and tag.rfind('Tag') == len(tag)-3:
481   - return self.find(tag[:-3])
482   - elif tag.find('__') != 0:
483   - return self.find(tag)
484   -
485   - def __eq__(self, other):
486   - """Returns true iff this tag has the same name, the same attributes,
487   - and the same contents (recursively) as the given tag.
488   -
489   - NOTE: right now this will return false if two tags have the
490   - same attributes in a different order. Should this be fixed?"""
491   - if not hasattr(other, 'name') or not hasattr(other, 'attrs') or not hasattr(other, 'contents') or self.name != other.name or self.attrs != other.attrs or len(self) != len(other):
492   - return False
493   - for i in range(0, len(self.contents)):
494   - if self.contents[i] != other.contents[i]:
495   - return False
496   - return True
497   -
498   - def __ne__(self, other):
499   - """Returns true iff this tag is not identical to the other tag,
500   - as defined in __eq__."""
501   - return not self == other
502   -
503   - def __repr__(self, encoding=DEFAULT_OUTPUT_ENCODING):
504   - """Renders this tag as a string."""
505   - return self.__str__(encoding)
506   -
507   - def __unicode__(self):
508   - return self.__str__(None)
509   -
510   - def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING,
511   - prettyPrint=False, indentLevel=0):
512   - """Returns a string or Unicode representation of this tag and
513   - its contents. To get Unicode, pass None for encoding.
514   -
515   - NOTE: since Python's HTML parser consumes whitespace, this
516   - method is not certain to reproduce the whitespace present in
517   - the original string."""
518   -
519   - encodedName = self.toEncoding(self.name, encoding)
520   -
521   - attrs = []
522   - if self.attrs:
523   - for key, val in self.attrs:
524   - fmt = '%s="%s"'
525   - if isString(val):
526   - if self.containsSubstitutions and '%SOUP-ENCODING%' in val:
527   - val = self.substituteEncoding(val, encoding)
528   -
529   - # The attribute value either:
530   - #
531   - # * Contains no embedded double quotes or single quotes.
532   - # No problem: we enclose it in double quotes.
533   - # * Contains embedded single quotes. No problem:
534   - # double quotes work here too.
535   - # * Contains embedded double quotes. No problem:
536   - # we enclose it in single quotes.
537   - # * Embeds both single _and_ double quotes. This
538   - # can't happen naturally, but it can happen if
539   - # you modify an attribute value after parsing
540   - # the document. Now we have a bit of a
541   - # problem. We solve it by enclosing the
542   - # attribute in single quotes, and escaping any
543   - # embedded single quotes to XML entities.
544   - if '"' in val:
545   - fmt = "%s='%s'"
546   - # This can't happen naturally, but it can happen
547   - # if you modify an attribute value after parsing.
548   - if "'" in val:
549   - val = val.replace("'", "&squot;")
550   -
551   - # Now we're okay w/r/t quotes. But the attribute
552   - # value might also contain angle brackets, or
553   - # ampersands that aren't part of entities. We need
554   - # to escape those to XML entities too.
555   - val = re.sub("([<>]|&(?![^\s]+;))",
556   - lambda x: "&" + self.XML_SPECIAL_CHARS_TO_ENTITIES[x.group(0)[0]] + ";",
557   - val)
558   -
559   - attrs.append(fmt % (self.toEncoding(key, encoding),
560   - self.toEncoding(val, encoding)))
561   - close = ''
562   - closeTag = ''
563   - if self.isSelfClosing:
564   - close = ' /'
565   - else:
566   - closeTag = '</%s>' % encodedName
567   -
568   - indentTag, indentContents = 0, 0
569   - if prettyPrint:
570   - indentTag = indentLevel
571   - space = (' ' * (indentTag-1))
572   - indentContents = indentTag + 1
573   - contents = self.renderContents(encoding, prettyPrint, indentContents)
574   - if self.hidden:
575   - s = contents
576   - else:
577   - s = []
578   - attributeString = ''
579   - if attrs:
580   - attributeString = ' ' + ' '.join(attrs)
581   - if prettyPrint:
582   - s.append(space)
583   - s.append('<%s%s%s>' % (encodedName, attributeString, close))
584   - if prettyPrint:
585   - s.append("\n")
586   - s.append(contents)
587   - if prettyPrint and contents and contents[-1] != "\n":
588   - s.append("\n")
589   - if prettyPrint and closeTag:
590   - s.append(space)
591   - s.append(closeTag)
592   - if prettyPrint and closeTag and self.nextSibling:
593   - s.append("\n")
594   - s = ''.join(s)
595   - return s
596   -
597   - def prettify(self, encoding=DEFAULT_OUTPUT_ENCODING):
598   - return self.__str__(encoding, True)
599   -
600   - def renderContents(self, encoding=DEFAULT_OUTPUT_ENCODING,
601   - prettyPrint=False, indentLevel=0):
602   - """Renders the contents of this tag as a string in the given
603   - encoding. If encoding is None, returns a Unicode string.."""
604   - s=[]
605   - for c in self:
606   - text = None
607   - if isinstance(c, NavigableString):
608   - text = c.__str__(encoding)
609   - elif isinstance(c, Tag):
610   - s.append(c.__str__(encoding, prettyPrint, indentLevel))
611   - if text and prettyPrint:
612   - text = text.strip()
613   - if text:
614   - if prettyPrint:
615   - s.append(" " * (indentLevel-1))
616   - s.append(text)
617   - if prettyPrint:
618   - s.append("\n")
619   - return ''.join(s)
620   -
621   - #Soup methods
622   -
623   - def find(self, name=None, attrs={}, recursive=True, text=None,
624   - **kwargs):
625   - """Return only the first child of this Tag matching the given
626   - criteria."""
627   - r = None
628   - l = self.findAll(name, attrs, recursive, text, 1, **kwargs)
629   - if l:
630   - r = l[0]
631   - return r
632   - findChild = find
633   -
634   - def findAll(self, name=None, attrs={}, recursive=True, text=None,
635   - limit=None, **kwargs):
636   - """Extracts a list of Tag objects that match the given
637   - criteria. You can specify the name of the Tag and any
638   - attributes you want the Tag to have.
639   -
640   - The value of a key-value pair in the 'attrs' map can be a
641   - string, a list of strings, a regular expression object, or a
642   - callable that takes a string and returns whether or not the
643   - string matches for some custom definition of 'matches'. The
644   - same is true of the tag name."""
645   - generator = self.recursiveChildGenerator
646   - if not recursive:
647   - generator = self.childGenerator
648   - return self._findAll(name, attrs, text, limit, generator, **kwargs)
649   - findChildren = findAll
650   -
651   - # Pre-3.x compatibility methods
652   - first = find
653   - fetch = findAll
654   -
655   - def fetchText(self, text=None, recursive=True, limit=None):
656   - return self.findAll(text=text, recursive=recursive, limit=limit)
657   -
658   - def firstText(self, text=None, recursive=True):
659   - return self.find(text=text, recursive=recursive)
660   -
661   - #Utility methods
662   -
663   - def append(self, tag):
664   - """Appends the given tag to the contents of this tag."""
665   - self.contents.append(tag)
666   -
667   - #Private methods
668   -
669   - def _getAttrMap(self):
670   - """Initializes a map representation of this tag's attributes,
671   - if not already initialized."""
672   - if not getattr(self, 'attrMap'):
673   - self.attrMap = {}
674   - for (key, value) in self.attrs:
675   - self.attrMap[key] = value
676   - return self.attrMap
677   -
678   - #Generator methods
679   - def childGenerator(self):
680   - for i in range(0, len(self.contents)):
681   - yield self.contents[i]
682   - raise StopIteration
683   -
684   - def recursiveChildGenerator(self):
685   - stack = [(self, 0)]
686   - while stack:
687   - tag, start = stack.pop()
688   - if isinstance(tag, Tag):
689   - for i in range(start, len(tag.contents)):
690   - a = tag.contents[i]
691   - yield a
692   - if isinstance(a, Tag) and tag.contents:
693   - if i < len(tag.contents) - 1:
694   - stack.append((tag, i+1))
695   - stack.append((a, 0))
696   - break
697   - raise StopIteration
698   -
699   -# Next, a couple classes to represent queries and their results.
700   -class SoupStrainer:
701   - """Encapsulates a number of ways of matching a markup element (tag or
702   - text)."""
703   -
704   - def __init__(self, name=None, attrs={}, text=None, **kwargs):
705   - self.name = name
706   - if isString(attrs):
707   - kwargs['class'] = attrs
708   - attrs = None
709   - if kwargs:
710   - if attrs:
711   - attrs = attrs.copy()
712   - attrs.update(kwargs)
713   - else:
714   - attrs = kwargs
715   - self.attrs = attrs
716   - self.text = text
717   -
718   - def __str__(self):
719   - if self.text:
720   - return self.text
721   - else:
722   - return "%s|%s" % (self.name, self.attrs)
723   -
724   - def searchTag(self, markupName=None, markupAttrs={}):
725   - found = None
726   - markup = None
727   - if isinstance(markupName, Tag):
728   - markup = markupName
729   - markupAttrs = markup
730   - callFunctionWithTagData = callable(self.name) \
731   - and not isinstance(markupName, Tag)
732   -
733   - if (not self.name) \
734   - or callFunctionWithTagData \
735   - or (markup and self._matches(markup, self.name)) \
736   - or (not markup and self._matches(markupName, self.name)):
737   - if callFunctionWithTagData:
738   - match = self.name(markupName, markupAttrs)
739   - else:
740   - match = True
741   - markupAttrMap = None
742   - for attr, matchAgainst in self.attrs.items():
743   - if not markupAttrMap:
744   - if hasattr(markupAttrs, 'get'):
745   - markupAttrMap = markupAttrs
746   - else:
747   - markupAttrMap = {}
748   - for k,v in markupAttrs:
749   - markupAttrMap[k] = v
750   - attrValue = markupAttrMap.get(attr)
751   - if not self._matches(attrValue, matchAgainst):
752   - match = False
753   - break
754   - if match:
755   - if markup:
756   - found = markup
757   - else:
758   - found = markupName
759   - return found
760   -
761   - def search(self, markup):
762   - #print 'looking for %s in %s' % (self, markup)
763   - found = None
764   - # If given a list of items, scan it for a text element that
765   - # matches.
766   - if isList(markup) and not isinstance(markup, Tag):
767   - for element in markup:
768   - if isinstance(element, NavigableString) \
769   - and self.search(element):
770   - found = element
771   - break
772   - # If it's a Tag, make sure its name or attributes match.
773   - # Don't bother with Tags if we're searching for text.
774   - elif isinstance(markup, Tag):
775   - if not self.text:
776   - found = self.searchTag(markup)
777   - # If it's text, make sure the text matches.
778   - elif isinstance(markup, NavigableString) or \
779   - isString(markup):
780   - if self._matches(markup, self.text):
781   - found = markup
782   - else:
783   - raise Exception, "I don't know how to match against a %s" \
784   - % markup.__class__
785   - return found
786   -
787   - def _matches(self, markup, matchAgainst):
788   - #print "Matching %s against %s" % (markup, matchAgainst)
789   - result = False
790   - if matchAgainst == True and type(matchAgainst) == types.BooleanType:
791   - result = markup != None
792   - elif callable(matchAgainst):
793   - result = matchAgainst(markup)
794   - else:
795   - #Custom match methods take the tag as an argument, but all
796   - #other ways of matching match the tag name as a string.
797   - if isinstance(markup, Tag):
798   - markup = markup.name
799   - if markup and not isString(markup):
800   - markup = unicode(markup)
801   - #Now we know that chunk is either a string, or None.
802   - if hasattr(matchAgainst, 'match'):
803   - # It's a regexp object.
804   - result = markup and matchAgainst.search(markup)
805   - elif isList(matchAgainst):
806   - result = markup in matchAgainst
807   - elif hasattr(matchAgainst, 'items'):
808   - result = markup.has_key(matchAgainst)
809   - elif matchAgainst and isString(markup):
810   - if isinstance(markup, unicode):
811   - matchAgainst = unicode(matchAgainst)
812   - else:
813   - matchAgainst = str(matchAgainst)
814   -
815   - if not result:
816   - result = matchAgainst == markup
817   - return result
818   -
819   -class ResultSet(list):
820   - """A ResultSet is just a list that keeps track of the SoupStrainer
821   - that created it."""
822   - def __init__(self, source):
823   - list.__init__([])
824   - self.source = source
825   -
826   -# Now, some helper functions.
827   -
828   -def isList(l):
829   - """Convenience method that works with all 2.x versions of Python
830   - to determine whether or not something is listlike."""
831   - return hasattr(l, '__iter__') \
832   - or (type(l) in (types.ListType, types.TupleType))
833   -
834   -def isString(s):
835   - """Convenience method that works with all 2.x versions of Python
836   - to determine whether or not something is stringlike."""
837   - try:
838   - return isinstance(s, unicode) or isintance(s, basestring)
839   - except NameError:
840   - return isinstance(s, str)
841   -
842   -def buildTagMap(default, *args):
843   - """Turns a list of maps, lists, or scalars into a single map.
844   - Used to build the SELF_CLOSING_TAGS, NESTABLE_TAGS, and
845   - NESTING_RESET_TAGS maps out of lists and partial maps."""
846   - built = {}
847   - for portion in args:
848   - if hasattr(portion, 'items'):
849   - #It's a map. Merge it.
850   - for k,v in portion.items():
851   - built[k] = v
852   - elif isList(portion):
853   - #It's a list. Map each item to the default.
854   - for k in portion:
855   - built[k] = default
856   - else:
857   - #It's a scalar. Map it to the default.
858   - built[portion] = default
859   - return built
860   -
861   -# Now, the parser classes.
862   -
863   -class BeautifulStoneSoup(Tag, SGMLParser):
864   -
865   - """This class contains the basic parser and search code. It defines
866   - a parser that knows nothing about tag behavior except for the
867   - following:
868   -
869   - You can't close a tag without closing all the tags it encloses.
870   - That is, "<foo><bar></foo>" actually means
871   - "<foo><bar></bar></foo>".
872   -
873   - [Another possible explanation is "<foo><bar /></foo>", but since
874   - this class defines no SELF_CLOSING_TAGS, it will never use that
875   - explanation.]
876   -
877   - This class is useful for parsing XML or made-up markup languages,
878   - or when BeautifulSoup makes an assumption counter to what you were
879   - expecting."""
880   -
881   - XML_ENTITY_LIST = {}
882   - for i in Tag.XML_SPECIAL_CHARS_TO_ENTITIES.values():
883   - XML_ENTITY_LIST[i] = True
884   -
885   - SELF_CLOSING_TAGS = {}
886   - NESTABLE_TAGS = {}
887   - RESET_NESTING_TAGS = {}
888   - QUOTE_TAGS = {}
889   -
890   - MARKUP_MASSAGE = [(re.compile('(<[^<>]*)/>'),
891   - lambda x: x.group(1) + ' />'),
892   - (re.compile('<!\s+([^<>]*)>'),
893   - lambda x: '<!' + x.group(1) + '>')
894   - ]
895   -
896   - ROOT_TAG_NAME = u'[document]'
897   -
898   - HTML_ENTITIES = "html"
899   - XML_ENTITIES = "xml"
900   -
901   - def __init__(self, markup="", parseOnlyThese=None, fromEncoding=None,
902   - markupMassage=True, smartQuotesTo=XML_ENTITIES,
903   - convertEntities=None, selfClosingTags=None):
904   - """The Soup object is initialized as the 'root tag', and the
905   - provided markup (which can be a string or a file-like object)
906   - is fed into the underlying parser.
907   -
908   - sgmllib will process most bad HTML, and the BeautifulSoup
909   - class has some tricks for dealing with some HTML that kills
910   - sgmllib, but Beautiful Soup can nonetheless choke or lose data
911   - if your data uses self-closing tags or declarations
912   - incorrectly.
913   -
914   - By default, Beautiful Soup uses regexes to sanitize input,
915   - avoiding the vast majority of these problems. If the problems
916   - don't apply to you, pass in False for markupMassage, and
917   - you'll get better performance.
918   -
919   - The default parser massage techniques fix the two most common
920   - instances of invalid HTML that choke sgmllib:
921   -
922   - <br/> (No space between name of closing tag and tag close)
923   - <! --Comment--> (Extraneous whitespace in declaration)
924   -
925   - You can pass in a custom list of (RE object, replace method)
926   - tuples to get Beautiful Soup to scrub your input the way you
927   - want."""
928   -
929   - self.parseOnlyThese = parseOnlyThese
930   - self.fromEncoding = fromEncoding
931   - self.smartQuotesTo = smartQuotesTo
932   - self.convertEntities = convertEntities
933   - if self.convertEntities:
934   - # It doesn't make sense to convert encoded characters to
935   - # entities even while you're converting entities to Unicode.
936   - # Just convert it all to Unicode.
937   - self.smartQuotesTo = None
938   - self.instanceSelfClosingTags = buildTagMap(None, selfClosingTags)
939   - SGMLParser.__init__(self)
940   -
941   - if hasattr(markup, 'read'): # It's a file-type object.
942   - markup = markup.read()
943   - self.markup = markup
944   - self.markupMassage = markupMassage
945   - try:
946   - self._feed()
947   - except StopParsing:
948   - pass
949   - self.markup = None # The markup can now be GCed
950   -
951   - def _feed(self, inDocumentEncoding=None):
952   - # Convert the document to Unicode.
953   - markup = self.markup
954   - if isinstance(markup, unicode):
955   - if not hasattr(self, 'originalEncoding'):
956   - self.originalEncoding = None
957   - else:
958   - dammit = UnicodeDammit\
959   - (markup, [self.fromEncoding, inDocumentEncoding],
960   - smartQuotesTo=self.smartQuotesTo)
961   - markup = dammit.unicode
962   - self.originalEncoding = dammit.originalEncoding
963   - if markup:
964   - if self.markupMassage:
965   - if not isList(self.markupMassage):
966   - self.markupMassage = self.MARKUP_MASSAGE
967   - for fix, m in self.markupMassage:
968   - markup = fix.sub(m, markup)
969   - self.reset()
970   -
971   - SGMLParser.feed(self, markup)
972   - # Close out any unfinished strings and close all the open tags.
973   - self.endData()
974   - while self.currentTag.name != self.ROOT_TAG_NAME:
975   - self.popTag()
976   -
977   - def __getattr__(self, methodName):
978   - """This method routes method call requests to either the SGMLParser
979   - superclass or the Tag superclass, depending on the method name."""
980   - #print "__getattr__ called on %s.%s" % (self.__class__, methodName)
981   -
982   - if methodName.find('start_') == 0 or methodName.find('end_') == 0 \
983   - or methodName.find('do_') == 0:
984   - return SGMLParser.__getattr__(self, methodName)
985   - elif methodName.find('__') != 0:
986   - return Tag.__getattr__(self, methodName)
987   - else:
988   - raise AttributeError
989   -
990   - def isSelfClosingTag(self, name):
991   - """Returns true iff the given string is the name of a
992   - self-closing tag according to this parser."""
993   - return self.SELF_CLOSING_TAGS.has_key(name) \
994   - or self.instanceSelfClosingTags.has_key(name)
995   -
996   - def reset(self):
997   - Tag.__init__(self, self, self.ROOT_TAG_NAME)
998   - self.hidden = 1
999   - SGMLParser.reset(self)
1000   - self.currentData = []
1001   - self.currentTag = None
1002   - self.tagStack = []
1003   - self.quoteStack = []
1004   - self.pushTag(self)
1005   -
1006   - def popTag(self):
1007   - tag = self.tagStack.pop()
1008   - # Tags with just one string-owning child get the child as a
1009   - # 'string' property, so that soup.tag.string is shorthand for
1010   - # soup.tag.contents[0]
1011   - if len(self.currentTag.contents) == 1 and \
1012   - isinstance(self.currentTag.contents[0], NavigableString):
1013   - self.currentTag.string = self.currentTag.contents[0]
1014   -
1015   - #print "Pop", tag.name
1016   - if self.tagStack:
1017   - self.currentTag = self.tagStack[-1]
1018   - return self.currentTag
1019   -
1020   - def pushTag(self, tag):
1021   - #print "Push", tag.name
1022   - if self.currentTag:
1023   - self.currentTag.append(tag)
1024   - self.tagStack.append(tag)
1025   - self.currentTag = self.tagStack[-1]
1026   -
1027   - def endData(self, containerClass=NavigableString):
1028   - if self.currentData:
1029   - currentData = ''.join(self.currentData)
1030   - if not currentData.strip():
1031   - if '\n' in currentData:
1032   - currentData = '\n'
1033   - else:
1034   - currentData = ' '
1035   - self.currentData = []
1036   - if self.parseOnlyThese and len(self.tagStack) <= 1 and \
1037   - (not self.parseOnlyThese.text or \
1038   - not self.parseOnlyThese.search(currentData)):
1039   - return
1040   - o = containerClass(currentData)
1041   - o.setup(self.currentTag, self.previous)
1042   - if self.previous:
1043   - self.previous.next = o
1044   - self.previous = o
1045   - self.currentTag.contents.append(o)
1046   -
1047   -
1048   - def _popToTag(self, name, inclusivePop=True):
1049   - """Pops the tag stack up to and including the most recent
1050   - instance of the given tag. If inclusivePop is false, pops the tag
1051   - stack up to but *not* including the most recent instqance of
1052   - the given tag."""
1053   - #print "Popping to %s" % name
1054   - if name == self.ROOT_TAG_NAME:
1055   - return
1056   -
1057   - numPops = 0
1058   - mostRecentTag = None
1059   - for i in range(len(self.tagStack)-1, 0, -1):
1060   - if name == self.tagStack[i].name:
1061   - numPops = len(self.tagStack)-i
1062   - break
1063   - if not inclusivePop:
1064   - numPops = numPops - 1
1065   -
1066   - for i in range(0, numPops):
1067   - mostRecentTag = self.popTag()
1068   - return mostRecentTag
1069   -
1070   - def _smartPop(self, name):
1071   -
1072   - """We need to pop up to the previous tag of this type, unless
1073   - one of this tag's nesting reset triggers comes between this
1074   - tag and the previous tag of this type, OR unless this tag is a
1075   - generic nesting trigger and another generic nesting trigger
1076   - comes between this tag and the previous tag of this type.
1077   -
1078   - Examples:
1079   - <p>Foo<b>Bar<p> should pop to 'p', not 'b'.
1080   - <p>Foo<table>Bar<p> should pop to 'table', not 'p'.
1081   - <p>Foo<table><tr>Bar<p> should pop to 'tr', not 'p'.
1082   - <p>Foo<b>Bar<p> should pop to 'p', not 'b'.
1083   -
1084   - <li><ul><li> *<li>* should pop to 'ul', not the first 'li'.
1085   - <tr><table><tr> *<tr>* should pop to 'table', not the first 'tr'
1086   - <td><tr><td> *<td>* should pop to 'tr', not the first 'td'
1087   - """
1088   -
1089   - nestingResetTriggers = self.NESTABLE_TAGS.get(name)
1090   - isNestable = nestingResetTriggers != None
1091   - isResetNesting = self.RESET_NESTING_TAGS.has_key(name)
1092   - popTo = None
1093   - inclusive = True
1094   - for i in range(len(self.tagStack)-1, 0, -1):
1095   - p = self.tagStack[i]
1096   - if (not p or p.name == name) and not isNestable:
1097   - #Non-nestable tags get popped to the top or to their
1098   - #last occurance.
1099   - popTo = name
1100   - break
1101   - if (nestingResetTriggers != None
1102   - and p.name in nestingResetTriggers) \
1103   - or (nestingResetTriggers == None and isResetNesting
1104   - and self.RESET_NESTING_TAGS.has_key(p.name)):
1105   -
1106   - #If we encounter one of the nesting reset triggers
1107   - #peculiar to this tag, or we encounter another tag
1108   - #that causes nesting to reset, pop up to but not
1109   - #including that tag.
1110   - popTo = p.name
1111   - inclusive = False
1112   - break
1113   - p = p.parent
1114   - if popTo:
1115   - self._popToTag(popTo, inclusive)
1116   -
1117   - def unknown_starttag(self, name, attrs, selfClosing=0):
1118   - #print "Start tag %s: %s" % (name, attrs)
1119   - if self.quoteStack:
1120   - #This is not a real tag.
1121   - #print "<%s> is not real!" % name
1122   - attrs = ''.join(map(lambda(x, y): ' %s="%s"' % (x, y), attrs))
1123   - self.handle_data('<%s%s>' % (name, attrs))
1124   - return
1125   - self.endData()
1126   -
1127   - if not self.isSelfClosingTag(name) and not selfClosing:
1128   - self._smartPop(name)
1129   -
1130   - if self.parseOnlyThese and len(self.tagStack) <= 1 \
1131   - and (self.parseOnlyThese.text or not self.parseOnlyThese.searchTag(name, attrs)):
1132   - return
1133   -
1134   - tag = Tag(self, name, attrs, self.currentTag, self.previous)
1135   - if self.previous:
1136   - self.previous.next = tag
1137   - self.previous = tag
1138   - self.pushTag(tag)
1139   - if selfClosing or self.isSelfClosingTag(name):
1140   - self.popTag()
1141   - if name in self.QUOTE_TAGS:
1142   - #print "Beginning quote (%s)" % name
1143   - self.quoteStack.append(name)
1144   - self.literal = 1
1145   - return tag
1146   -
1147   - def unknown_endtag(self, name):
1148   - #print "End tag %s" % name
1149   - if self.quoteStack and self.quoteStack[-1] != name:
1150   - #This is not a real end tag.
1151   - #print "</%s> is not real!" % name
1152   - self.handle_data('</%s>' % name)
1153   - return
1154   - self.endData()
1155   - self._popToTag(name)
1156   - if self.quoteStack and self.quoteStack[-1] == name:
1157   - self.quoteStack.pop()
1158   - self.literal = (len(self.quoteStack) > 0)
1159   -
1160   - def handle_data(self, data):
1161   - self.currentData.append(data)
1162   -
1163   - def _toStringSubclass(self, text, subclass):
1164   - """Adds a certain piece of text to the tree as a NavigableString
1165   - subclass."""
1166   - self.endData()
1167   - self.handle_data(text)
1168   - self.endData(subclass)
1169   -
1170   - def handle_pi(self, text):
1171   - """Handle a processing instruction as a ProcessingInstruction
1172   - object, possibly one with a %SOUP-ENCODING% slot into which an
1173   - encoding will be plugged later."""
1174   - if text[:3] == "xml":
1175   - text = "xml version='1.0' encoding='%SOUP-ENCODING%'"
1176   - self._toStringSubclass(text, ProcessingInstruction)
1177   -
1178   - def handle_comment(self, text):
1179   - "Handle comments as Comment objects."
1180   - self._toStringSubclass(text, Comment)
1181   -
1182   - def handle_charref(self, ref):
1183   - "Handle character references as data."
1184   - if self.convertEntities in [self.HTML_ENTITIES,
1185   - self.XML_ENTITIES]:
1186   - data = unichr(int(ref))
1187   - else:
1188   - data = '&#%s;' % ref
1189   - self.handle_data(data)
1190   -
1191   - def handle_entityref(self, ref):
1192   - """Handle entity references as data, possibly converting known
1193   - HTML entity references to the corresponding Unicode
1194   - characters."""
1195   - data = None
1196   - if self.convertEntities == self.HTML_ENTITIES or \
1197   - (self.convertEntities == self.XML_ENTITIES and \
1198   - self.XML_ENTITY_LIST.get(ref)):
1199   - try:
1200   - data = unichr(name2codepoint[ref])
1201   - except KeyError:
1202   - pass
1203   - if not data:
1204   - data = '&%s;' % ref
1205   - self.handle_data(data)
1206   -
1207   - def handle_decl(self, data):
1208   - "Handle DOCTYPEs and the like as Declaration objects."
1209   - self._toStringSubclass(data, Declaration)
1210   -
1211   - def parse_declaration(self, i):
1212   - """Treat a bogus SGML declaration as raw data. Treat a CDATA
1213   - declaration as a CData object."""
1214   - j = None
1215   - if self.rawdata[i:i+9] == '<![CDATA[':
1216   - k = self.rawdata.find(']]>', i)
1217   - if k == -1:
1218   - k = len(self.rawdata)
1219   - data = self.rawdata[i+9:k]
1220   - j = k+3
1221   - self._toStringSubclass(data, CData)
1222   - else:
1223   - try:
1224   - j = SGMLParser.parse_declaration(self, i)
1225   - except SGMLParseError:
1226   - toHandle = self.rawdata[i:]
1227   - self.handle_data(toHandle)
1228   - j = i + len(toHandle)
1229   - return j
1230   -
1231   -class BeautifulSoup(BeautifulStoneSoup):
1232   -
1233   - """This parser knows the following facts about HTML:
1234   -
1235   - * Some tags have no closing tag and should be interpreted as being
1236   - closed as soon as they are encountered.
1237   -
1238   - * The text inside some tags (ie. 'script') may contain tags which
1239   - are not really part of the document and which should be parsed
1240   - as text, not tags. If you want to parse the text as tags, you can
1241   - always fetch it and parse it explicitly.
1242   -
1243   - * Tag nesting rules:
1244   -
1245   - Most tags can't be nested at all. For instance, the occurance of
1246   - a <p> tag should implicitly close the previous <p> tag.
1247   -
1248   - <p>Para1<p>Para2
1249   - should be transformed into:
1250   - <p>Para1</p><p>Para2
1251   -
1252   - Some tags can be nested arbitrarily. For instance, the occurance
1253   - of a <blockquote> tag should _not_ implicitly close the previous
1254   - <blockquote> tag.
1255   -
1256   - Alice said: <blockquote>Bob said: <blockquote>Blah
1257   - should NOT be transformed into:
1258   - Alice said: <blockquote>Bob said: </blockquote><blockquote>Blah
1259   -
1260   - Some tags can be nested, but the nesting is reset by the
1261   - interposition of other tags. For instance, a <tr> tag should
1262   - implicitly close the previous <tr> tag within the same <table>,
1263   - but not close a <tr> tag in another table.
1264   -
1265   - <table><tr>Blah<tr>Blah
1266   - should be transformed into:
1267   - <table><tr>Blah</tr><tr>Blah
1268   - but,
1269   - <tr>Blah<table><tr>Blah
1270   - should NOT be transformed into
1271   - <tr>Blah<table></tr><tr>Blah
1272   -
1273   - Differing assumptions about tag nesting rules are a major source
1274   - of problems with the BeautifulSoup class. If BeautifulSoup is not
1275   - treating as nestable a tag your page author treats as nestable,
1276   - try ICantBelieveItsBeautifulSoup, MinimalSoup, or
1277   - BeautifulStoneSoup before writing your own subclass."""
1278   -
1279   - def __init__(self, *args, **kwargs):
1280   - if not kwargs.has_key('smartQuotesTo'):
1281   - kwargs['smartQuotesTo'] = self.HTML_ENTITIES
1282   - BeautifulStoneSoup.__init__(self, *args, **kwargs)
1283   -
1284   - SELF_CLOSING_TAGS = buildTagMap(None,
1285   - ['br' , 'hr', 'input', 'img', 'meta',
1286   - 'spacer', 'link', 'frame', 'base'])
1287   -
1288   - QUOTE_TAGS = {'script': None}
1289   -
1290   - #According to the HTML standard, each of these inline tags can
1291   - #contain another tag of the same type. Furthermore, it's common
1292   - #to actually use these tags this way.
1293   - NESTABLE_INLINE_TAGS = ['span', 'font', 'q', 'object', 'bdo', 'sub', 'sup',
1294   - 'center']
1295   -
1296   - #According to the HTML standard, these block tags can contain
1297   - #another tag of the same type. Furthermore, it's common
1298   - #to actually use these tags this way.
1299   - NESTABLE_BLOCK_TAGS = ['blockquote', 'div', 'fieldset', 'ins', 'del']
1300   -
1301   - #Lists can contain other lists, but there are restrictions.
1302   - NESTABLE_LIST_TAGS = { 'ol' : [],
1303   - 'ul' : [],
1304   - 'li' : ['ul', 'ol'],
1305   - 'dl' : [],
1306   - 'dd' : ['dl'],
1307   - 'dt' : ['dl'] }
1308   -
1309   - #Tables can contain other tables, but there are restrictions.
1310   - NESTABLE_TABLE_TAGS = {'table' : [],
1311   - 'tr' : ['table', 'tbody', 'tfoot', 'thead'],
1312   - 'td' : ['tr'],
1313   - 'th' : ['tr'],
1314   - 'thead' : ['table'],
1315   - 'tbody' : ['table'],
1316   - 'tfoot' : ['table'],
1317   - }
1318   -
1319   - NON_NESTABLE_BLOCK_TAGS = ['address', 'form', 'p', 'pre']
1320   -
1321   - #If one of these tags is encountered, all tags up to the next tag of
1322   - #this type are popped.
1323   - RESET_NESTING_TAGS = buildTagMap(None, NESTABLE_BLOCK_TAGS, 'noscript',
1324   - NON_NESTABLE_BLOCK_TAGS,
1325   - NESTABLE_LIST_TAGS,
1326   - NESTABLE_TABLE_TAGS)
1327   -
1328   - NESTABLE_TAGS = buildTagMap([], NESTABLE_INLINE_TAGS, NESTABLE_BLOCK_TAGS,
1329   - NESTABLE_LIST_TAGS, NESTABLE_TABLE_TAGS)
1330   -
1331   - # Used to detect the charset in a META tag; see start_meta
1332   - CHARSET_RE = re.compile("((^|;)\s*charset=)([^;]*)")
1333   -
1334   - def start_meta(self, attrs):
1335   - """Beautiful Soup can detect a charset included in a META tag,
1336   - try to convert the document to that charset, and re-parse the
1337   - document from the beginning."""
1338   - httpEquiv = None
1339   - contentType = None
1340   - contentTypeIndex = None
1341   - tagNeedsEncodingSubstitution = False
1342   -
1343   - for i in range(0, len(attrs)):
1344   - key, value = attrs[i]
1345   - key = key.lower()
1346   - if key == 'http-equiv':
1347   - httpEquiv = value
1348   - elif key == 'content':
1349   - contentType = value
1350   - contentTypeIndex = i
1351   -
1352   - if httpEquiv and contentType: # It's an interesting meta tag.
1353   - match = self.CHARSET_RE.search(contentType)
1354   - if match:
1355   - if getattr(self, 'declaredHTMLEncoding') or \
1356   - (self.originalEncoding == self.fromEncoding):
1357   - # This is our second pass through the document, or
1358   - # else an encoding was specified explicitly and it
1359   - # worked. Rewrite the meta tag.
1360   - newAttr = self.CHARSET_RE.sub\
1361   - (lambda(match):match.group(1) +
1362   - "%SOUP-ENCODING%", value)
1363   - attrs[contentTypeIndex] = (attrs[contentTypeIndex][0],
1364   - newAttr)
1365   - tagNeedsEncodingSubstitution = True
1366   - else:
1367   - # This is our first pass through the document.
1368   - # Go through it again with the new information.
1369   - newCharset = match.group(3)
1370   - if newCharset and newCharset != self.originalEncoding:
1371   - self.declaredHTMLEncoding = newCharset
1372   - self._feed(self.declaredHTMLEncoding)
1373   - raise StopParsing
1374   - tag = self.unknown_starttag("meta", attrs)
1375   - if tag and tagNeedsEncodingSubstitution:
1376   - tag.containsSubstitutions = True
1377   -
1378   -class StopParsing(Exception):
1379   - pass
1380   -
1381   -class ICantBelieveItsBeautifulSoup(BeautifulSoup):
1382   -
1383   - """The BeautifulSoup class is oriented towards skipping over
1384   - common HTML errors like unclosed tags. However, sometimes it makes
1385   - errors of its own. For instance, consider this fragment:
1386   -
1387   - <b>Foo<b>Bar</b></b>
1388   -
1389   - This is perfectly valid (if bizarre) HTML. However, the
1390   - BeautifulSoup class will implicitly close the first b tag when it
1391   - encounters the second 'b'. It will think the author wrote
1392   - "<b>Foo<b>Bar", and didn't close the first 'b' tag, because
1393   - there's no real-world reason to bold something that's already
1394   - bold. When it encounters '</b></b>' it will close two more 'b'
1395   - tags, for a grand total of three tags closed instead of two. This
1396   - can throw off the rest of your document structure. The same is
1397   - true of a number of other tags, listed below.
1398   -
1399   - It's much more common for someone to forget to close a 'b' tag
1400   - than to actually use nested 'b' tags, and the BeautifulSoup class
1401   - handles the common case. This class handles the not-co-common
1402   - case: where you can't believe someone wrote what they did, but
1403   - it's valid HTML and BeautifulSoup screwed up by assuming it
1404   - wouldn't be."""
1405   -
1406   - I_CANT_BELIEVE_THEYRE_NESTABLE_INLINE_TAGS = \
1407   - ['em', 'big', 'i', 'small', 'tt', 'abbr', 'acronym', 'strong',
1408   - 'cite', 'code', 'dfn', 'kbd', 'samp', 'strong', 'var', 'b',
1409   - 'big']
1410   -
1411   - I_CANT_BELIEVE_THEYRE_NESTABLE_BLOCK_TAGS = ['noscript']
1412   -
1413   - NESTABLE_TAGS = buildTagMap([], BeautifulSoup.NESTABLE_TAGS,
1414   - I_CANT_BELIEVE_THEYRE_NESTABLE_BLOCK_TAGS,
1415   - I_CANT_BELIEVE_THEYRE_NESTABLE_INLINE_TAGS)
1416   -
1417   -class MinimalSoup(BeautifulSoup):
1418   - """The MinimalSoup class is for parsing HTML that contains
1419   - pathologically bad markup. It makes no assumptions about tag
1420   - nesting, but it does know which tags are self-closing, that
1421   - <script> tags contain Javascript and should not be parsed, that
1422   - META tags may contain encoding information, and so on.
1423   -
1424   - This also makes it better for subclassing than BeautifulStoneSoup
1425   - or BeautifulSoup."""
1426   -
1427   - RESET_NESTING_TAGS = buildTagMap('noscript')
1428   - NESTABLE_TAGS = {}
1429   -
1430   -class BeautifulSOAP(BeautifulStoneSoup):
1431   - """This class will push a tag with only a single string child into
1432   - the tag's parent as an attribute. The attribute's name is the tag
1433   - name, and the value is the string child. An example should give
1434   - the flavor of the change:
1435   -
1436   - <foo><bar>baz</bar></foo>
1437   - =>
1438   - <foo bar="baz"><bar>baz</bar></foo>
1439   -
1440   - You can then access fooTag['bar'] instead of fooTag.barTag.string.
1441   -
1442   - This is, of course, useful for scraping structures that tend to
1443   - use subelements instead of attributes, such as SOAP messages. Note
1444   - that it modifies its input, so don't print the modified version
1445   - out.
1446   -
1447   - I'm not sure how many people really want to use this class; let me
1448   - know if you do. Mainly I like the name."""
1449   -
1450   - def popTag(self):
1451   - if len(self.tagStack) > 1:
1452   - tag = self.tagStack[-1]
1453   - parent = self.tagStack[-2]
1454   - parent._getAttrMap()
1455   - if (isinstance(tag, Tag) and len(tag.contents) == 1 and
1456   - isinstance(tag.contents[0], NavigableString) and
1457   - not parent.attrMap.has_key(tag.name)):
1458   - parent[tag.name] = tag.contents[0]
1459   - BeautifulStoneSoup.popTag(self)
1460   -
1461   -#Enterprise class names! It has come to our attention that some people
1462   -#think the names of the Beautiful Soup parser classes are too silly
1463   -#and "unprofessional" for use in enterprise screen-scraping. We feel
1464   -#your pain! For such-minded folk, the Beautiful Soup Consortium And
1465   -#All-Night Kosher Bakery recommends renaming this file to
1466   -#"RobustParser.py" (or, in cases of extreme enterprisness,
1467   -#"RobustParserBeanInterface.class") and using the following
1468   -#enterprise-friendly class aliases:
1469   -class RobustXMLParser(BeautifulStoneSoup):
1470   - pass
1471   -class RobustHTMLParser(BeautifulSoup):
1472   - pass
1473   -class RobustWackAssHTMLParser(ICantBelieveItsBeautifulSoup):
1474   - pass
1475   -class RobustInsanelyWackAssHTMLParser(MinimalSoup):
1476   - pass
1477   -class SimplifyingSOAPParser(BeautifulSOAP):
1478   - pass
1479   -
1480   -######################################################
1481   -#
1482   -# Bonus library: Unicode, Dammit
1483   -#
1484   -# This class forces XML data into a standard format (usually to UTF-8
1485   -# or Unicode). It is heavily based on code from Mark Pilgrim's
1486   -# Universal Feed Parser. It does not rewrite the XML or HTML to
1487   -# reflect a new encoding: that happens in BeautifulStoneSoup.handle_pi
1488   -# (XML) and BeautifulSoup.start_meta (HTML).
1489   -
1490   -# Autodetects character encodings.
1491   -# Download from http://chardet.feedparser.org/
1492   -try:
1493   - import chardet
1494   -# import chardet.constants
1495   -# chardet.constants._debug = 1
1496   -except:
1497   - chardet = None
1498   -chardet = None
1499   -
1500   -# cjkcodecs and iconv_codec make Python know about more character encodings.
1501   -# Both are available from http://cjkpython.i18n.org/
1502   -# They're built in if you use Python 2.4.
1503   -try:
1504   - import cjkcodecs.aliases
1505   -except:
1506   - pass
1507   -try:
1508   - import iconv_codec
1509   -except:
1510   - pass
1511   -
1512   -class UnicodeDammit:
1513   - """A class for detecting the encoding of a *ML document and
1514   - converting it to a Unicode string. If the source encoding is
1515   - windows-1252, can replace MS smart quotes with their HTML or XML
1516   - equivalents."""
1517   -
1518   - # This dictionary maps commonly seen values for "charset" in HTML
1519   - # meta tags to the corresponding Python codec names. It only covers
1520   - # values that aren't in Python's aliases and can't be determined
1521   - # by the heuristics in find_codec.
1522   - CHARSET_ALIASES = { "macintosh" : "mac-roman",
1523   - "x-sjis" : "shift-jis" }
1524   -
1525   - def __init__(self, markup, overrideEncodings=[],
1526   - smartQuotesTo='xml'):
1527   - self.markup, documentEncoding, sniffedEncoding = \
1528   - self._detectEncoding(markup)
1529   - self.smartQuotesTo = smartQuotesTo
1530   - self.triedEncodings = []
1531   - if markup == '' or isinstance(markup, unicode):
1532   - self.originalEncoding = None
1533   - self.unicode = unicode(markup)
1534   - return
1535   -
1536   - u = None
1537   - for proposedEncoding in overrideEncodings:
1538   - u = self._convertFrom(proposedEncoding)
1539   - if u: break
1540   - if not u:
1541   - for proposedEncoding in (documentEncoding, sniffedEncoding):
1542   - u = self._convertFrom(proposedEncoding)
1543   - if u: break
1544   -
1545   - # If no luck and we have auto-detection library, try that:
1546   - if not u and chardet and not isinstance(self.markup, unicode):
1547   - u = self._convertFrom(chardet.detect(self.markup)['encoding'])
1548   -
1549   - # As a last resort, try utf-8 and windows-1252:
1550   - if not u:
1551   - for proposed_encoding in ("utf-8", "windows-1252"):
1552   - u = self._convertFrom(proposed_encoding)
1553   - if u: break
1554   - self.unicode = u
1555   - if not u: self.originalEncoding = None
1556   -
1557   - def _subMSChar(self, orig):
1558   - """Changes a MS smart quote character to an XML or HTML
1559   - entity."""
1560   - sub = self.MS_CHARS.get(orig)
1561   - if type(sub) == types.TupleType:
1562   - if self.smartQuotesTo == 'xml':
1563   - sub = '&#x%s;' % sub[1]
1564   - else:
1565   - sub = '&%s;' % sub[0]
1566   - return sub
1567   -
1568   - def _convertFrom(self, proposed):
1569   - proposed = self.find_codec(proposed)
1570   - if not proposed or proposed in self.triedEncodings:
1571   - return None
1572   - self.triedEncodings.append(proposed)
1573   - markup = self.markup
1574   -
1575   - # Convert smart quotes to HTML if coming from an encoding
1576   - # that might have them.
1577   - if self.smartQuotesTo and proposed.lower() in("windows-1252",
1578   - "iso-8859-1",
1579   - "iso-8859-2"):
1580   - markup = re.compile("([\x80-\x9f])").sub \
1581   - (lambda(x): self._subMSChar(x.group(1)),
1582   - markup)
1583   -
1584   - try:
1585   - # print "Trying to convert document to %s" % proposed
1586   - u = self._toUnicode(markup, proposed)
1587   - self.markup = u
1588   - self.originalEncoding = proposed
1589   - except Exception, e:
1590   - # print "That didn't work!"
1591   - # print e
1592   - return None
1593   - #print "Correct encoding: %s" % proposed
1594   - return self.markup
1595   -
1596   - def _toUnicode(self, data, encoding):
1597   - '''Given a string and its encoding, decodes the string into Unicode.
1598   - %encoding is a string recognized by encodings.aliases'''
1599   -
1600   - # strip Byte Order Mark (if present)
1601   - if (len(data) >= 4) and (data[:2] == '\xfe\xff') \
1602   - and (data[2:4] != '\x00\x00'):
1603   - encoding = 'utf-16be'
1604   - data = data[2:]
1605   - elif (len(data) >= 4) and (data[:2] == '\xff\xfe') \
1606   - and (data[2:4] != '\x00\x00'):
1607   - encoding = 'utf-16le'
1608   - data = data[2:]
1609   - elif data[:3] == '\xef\xbb\xbf':
1610   - encoding = 'utf-8'
1611   - data = data[3:]
1612   - elif data[:4] == '\x00\x00\xfe\xff':
1613   - encoding = 'utf-32be'
1614   - data = data[4:]
1615   - elif data[:4] == '\xff\xfe\x00\x00':
1616   - encoding = 'utf-32le'
1617   - data = data[4:]
1618   - newdata = unicode(data, encoding)
1619   - return newdata
1620   -
1621   - def _detectEncoding(self, xml_data):
1622   - """Given a document, tries to detect its XML encoding."""
1623   - xml_encoding = sniffed_xml_encoding = None
1624   - try:
1625   - if xml_data[:4] == '\x4c\x6f\xa7\x94':
1626   - # EBCDIC
1627   - xml_data = self._ebcdic_to_ascii(xml_data)
1628   - elif xml_data[:4] == '\x00\x3c\x00\x3f':
1629   - # UTF-16BE
1630   - sniffed_xml_encoding = 'utf-16be'
1631   - xml_data = unicode(xml_data, 'utf-16be').encode('utf-8')
1632   - elif (len(xml_data) >= 4) and (xml_data[:2] == '\xfe\xff') \
1633   - and (xml_data[2:4] != '\x00\x00'):
1634   - # UTF-16BE with BOM
1635   - sniffed_xml_encoding = 'utf-16be'
1636   - xml_data = unicode(xml_data[2:], 'utf-16be').encode('utf-8')
1637   - elif xml_data[:4] == '\x3c\x00\x3f\x00':
1638   - # UTF-16LE
1639   - sniffed_xml_encoding = 'utf-16le'
1640   - xml_data = unicode(xml_data, 'utf-16le').encode('utf-8')
1641   - elif (len(xml_data) >= 4) and (xml_data[:2] == '\xff\xfe') and \
1642   - (xml_data[2:4] != '\x00\x00'):
1643   - # UTF-16LE with BOM
1644   - sniffed_xml_encoding = 'utf-16le'
1645   - xml_data = unicode(xml_data[2:], 'utf-16le').encode('utf-8')
1646   - elif xml_data[:4] == '\x00\x00\x00\x3c':
1647   - # UTF-32BE
1648   - sniffed_xml_encoding = 'utf-32be'
1649   - xml_data = unicode(xml_data, 'utf-32be').encode('utf-8')
1650   - elif xml_data[:4] == '\x3c\x00\x00\x00':
1651   - # UTF-32LE
1652   - sniffed_xml_encoding = 'utf-32le'
1653   - xml_data = unicode(xml_data, 'utf-32le').encode('utf-8')
1654   - elif xml_data[:4] == '\x00\x00\xfe\xff':
1655   - # UTF-32BE with BOM
1656   - sniffed_xml_encoding = 'utf-32be'
1657   - xml_data = unicode(xml_data[4:], 'utf-32be').encode('utf-8')
1658   - elif xml_data[:4] == '\xff\xfe\x00\x00':
1659   - # UTF-32LE with BOM
1660   - sniffed_xml_encoding = 'utf-32le'
1661   - xml_data = unicode(xml_data[4:], 'utf-32le').encode('utf-8')
1662   - elif xml_data[:3] == '\xef\xbb\xbf':
1663   - # UTF-8 with BOM
1664   - sniffed_xml_encoding = 'utf-8'
1665   - xml_data = unicode(xml_data[3:], 'utf-8').encode('utf-8')
1666   - else:
1667   - sniffed_xml_encoding = 'ascii'
1668   - pass
1669   - xml_encoding_match = re.compile \
1670   - ('^<\?.*encoding=[\'"](.*?)[\'"].*\?>')\
1671   - .match(xml_data)
1672   - except:
1673   - xml_encoding_match = None
1674   - if xml_encoding_match:
1675   - xml_encoding = xml_encoding_match.groups()[0].lower()
1676   - if sniffed_xml_encoding and \
1677   - (xml_encoding in ('iso-10646-ucs-2', 'ucs-2', 'csunicode',
1678   - 'iso-10646-ucs-4', 'ucs-4', 'csucs4',
1679   - 'utf-16', 'utf-32', 'utf_16', 'utf_32',
1680   - 'utf16', 'u16')):
1681   - xml_encoding = sniffed_xml_encoding
1682   - return xml_data, xml_encoding, sniffed_xml_encoding
1683   -
1684   -
1685   - def find_codec(self, charset):
1686   - return self._codec(self.CHARSET_ALIASES.get(charset, charset)) \
1687   - or (charset and self._codec(charset.replace("-", ""))) \
1688   - or (charset and self._codec(charset.replace("-", "_"))) \
1689   - or charset
1690   -
1691   - def _codec(self, charset):
1692   - if not charset: return charset
1693   - codec = None
1694   - try:
1695   - codecs.lookup(charset)
1696   - codec = charset
1697   - except LookupError:
1698   - pass
1699   - return codec
1700   -
1701   - EBCDIC_TO_ASCII_MAP = None
1702   - def _ebcdic_to_ascii(self, s):
1703   - c = self.__class__
1704   - if not c.EBCDIC_TO_ASCII_MAP:
1705   - emap = (0,1,2,3,156,9,134,127,151,141,142,11,12,13,14,15,
1706   - 16,17,18,19,157,133,8,135,24,25,146,143,28,29,30,31,
1707   - 128,129,130,131,132,10,23,27,136,137,138,139,140,5,6,7,
1708   - 144,145,22,147,148,149,150,4,152,153,154,155,20,21,158,26,
1709   - 32,160,161,162,163,164,165,166,167,168,91,46,60,40,43,33,
1710   - 38,169,170,171,172,173,174,175,176,177,93,36,42,41,59,94,
1711   - 45,47,178,179,180,181,182,183,184,185,124,44,37,95,62,63,
1712   - 186,187,188,189,190,191,192,193,194,96,58,35,64,39,61,34,
1713   - 195,97,98,99,100,101,102,103,104,105,196,197,198,199,200,
1714   - 201,202,106,107,108,109,110,111,112,113,114,203,204,205,
1715   - 206,207,208,209,126,115,116,117,118,119,120,121,122,210,
1716   - 211,212,213,214,215,216,217,218,219,220,221,222,223,224,
1717   - 225,226,227,228,229,230,231,123,65,66,67,68,69,70,71,72,
1718   - 73,232,233,234,235,236,237,125,74,75,76,77,78,79,80,81,
1719   - 82,238,239,240,241,242,243,92,159,83,84,85,86,87,88,89,
1720   - 90,244,245,246,247,248,249,48,49,50,51,52,53,54,55,56,57,
1721   - 250,251,252,253,254,255)
1722   - import string
1723   - c.EBCDIC_TO_ASCII_MAP = string.maketrans( \
1724   - ''.join(map(chr, range(256))), ''.join(map(chr, emap)))
1725   - return s.translate(c.EBCDIC_TO_ASCII_MAP)
1726   -
1727   - MS_CHARS = { '\x80' : ('euro', '20AC'),
1728   - '\x81' : ' ',
1729   - '\x82' : ('sbquo', '201A'),
1730   - '\x83' : ('fnof', '192'),
1731   - '\x84' : ('bdquo', '201E'),
1732   - '\x85' : ('hellip', '2026'),
1733   - '\x86' : ('dagger', '2020'),
1734   - '\x87' : ('Dagger', '2021'),
1735   - '\x88' : ('circ', '2C6'),
1736   - '\x89' : ('permil', '2030'),
1737   - '\x8A' : ('Scaron', '160'),
1738   - '\x8B' : ('lsaquo', '2039'),
1739   - '\x8C' : ('OElig', '152'),
1740   - '\x8D' : '?',
1741   - '\x8E' : ('#x17D', '17D'),
1742   - '\x8F' : '?',
1743   - '\x90' : '?',
1744   - '\x91' : ('lsquo', '2018'),
1745   - '\x92' : ('rsquo', '2019'),
1746   - '\x93' : ('ldquo', '201C'),
1747   - '\x94' : ('rdquo', '201D'),
1748   - '\x95' : ('bull', '2022'),
1749   - '\x96' : ('ndash', '2013'),
1750   - '\x97' : ('mdash', '2014'),
1751   - '\x98' : ('tilde', '2DC'),
1752   - '\x99' : ('trade', '2122'),
1753   - '\x9a' : ('scaron', '161'),
1754   - '\x9b' : ('rsaquo', '203A'),
1755   - '\x9c' : ('oelig', '153'),
1756   - '\x9d' : '?',
1757   - '\x9e' : ('#x17E', '17E'),
1758   - '\x9f' : ('Yuml', ''),}
1759   -
1760   -#######################################################################
1761   -
1762   -
1763   -#By default, act as an HTML pretty-printer.
1764   -if __name__ == '__main__':
1765   - import sys
1766   - soup = BeautifulSoup(sys.stdin.read())
1767   - print soup.prettify()
pacotes/openlayers/tools/README.txt
View file @4c12b06
... ... @@ -1,14 +0,0 @@
1   -This directory contains tools used in the packaging or deployment of OpenLayers.
2   -
3   -Javascript minimizing tools:
4   -
5   - * jsmin.c, jsmin.py:
6   - jsmin.py is a direct translation of the jsmin.c code into Python. jsmin.py
7   - will therefore run anyplace Python runs... but at significantly slower speed.
8   -
9   - * shrinksafe.py
10   - shrinksafe.py calls out to a third party javascript shrinking service. This
11   - creates file sizes about 4% smaller (as of commit 501) of the OpenLayers
12   - code. However, this also has the side effect of making you dependant on the
13   - web service -- and since that service sometimes goes dead, it's risky to
14   - depend on it.
pacotes/openlayers/tools/exampleparser.py
View file @4c12b06
... ... @@ -1,251 +0,0 @@
1   -#!/usr/bin/env python
2   -
3   -import sys
4   -import os
5   -import re
6   -import urllib2
7   -import time
8   -from xml.dom.minidom import Document
9   -
10   -try:
11   - import xml.etree.ElementTree as ElementTree
12   -except ImportError:
13   - try:
14   - import cElementTree as ElementTree
15   - except ImportError:
16   - try:
17   - import elementtree.ElementTree as ElementTree
18   - except ImportError:
19   - import lxml.etree as ElementTree
20   -
21   -missing_deps = False
22   -try:
23   - import simplejson
24   - from BeautifulSoup import BeautifulSoup
25   -except ImportError, E:
26   - missing_deps = E
27   -
28   -feedName = "example-list.xml"
29   -feedPath = "http://openlayers.org/dev/examples/"
30   -
31   -def getListOfOnlineExamples(baseUrl):
32   - """
33   - useful if you want to get a list of examples a url. not used by default.
34   - """
35   - html = urllib2.urlopen(baseUrl)
36   - soup = BeautifulSoup(html)
37   - examples = soup.findAll('li')
38   - examples = [example.find('a').get('href') for example in examples]
39   - examples = [example for example in examples if example.endswith('.html')]
40   - examples = [example for example in examples]
41   - return examples
42   -
43   -def getListOfExamples(relPath):
44   - """
45   - returns list of .html filenames within a given path - excludes example-list.html
46   - """
47   - examples = os.listdir(relPath)
48   - examples = [example for example in examples if example.endswith('.html') and example != "example-list.html"]
49   - return examples
50   -
51   -
52   -def getExampleHtml(location):
53   - """
54   - returns html of a specific example that is available online or locally
55   - """
56   - print '.',
57   - if location.startswith('http'):
58   - return urllib2.urlopen(location).read()
59   - else:
60   - f = open(location)
61   - html = f.read()
62   - f.close()
63   - return html
64   -
65   -
66   -def extractById(soup, tagId, value=None):
67   - """
68   - returns full contents of a particular tag id
69   - """
70   - beautifulTag = soup.find(id=tagId)
71   - if beautifulTag:
72   - if beautifulTag.contents:
73   - value = str(beautifulTag.renderContents()).strip()
74   - value = value.replace('\t','')
75   - value = value.replace('\n','')
76   - return value
77   -
78   -def getRelatedClasses(html):
79   - """
80   - parses the html, and returns a list of all OpenLayers Classes
81   - used within (ie what parts of OL the javascript uses).
82   - """
83   - rawstr = r'''(?P<class>OpenLayers\..*?)\('''
84   - return re.findall(rawstr, html)
85   -
86   -def parseHtml(html,ids):
87   - """
88   - returns dictionary of items of interest
89   - """
90   - soup = BeautifulSoup(html)
91   - d = {}
92   - for tagId in ids:
93   - d[tagId] = extractById(soup,tagId)
94   - #classes should eventually be parsed from docs - not automatically created.
95   - classes = getRelatedClasses(html)
96   - d['classes'] = classes
97   - return d
98   -
99   -def getSvnInfo(path):
100   - h = os.popen("svn info %s --xml" % path)
101   - tree = ElementTree.fromstring(h.read())
102   - h.close()
103   - d = {
104   - 'url': tree.findtext('entry/url'),
105   - 'author': tree.findtext('entry/commit/author'),
106   - 'date': tree.findtext('entry/commit/date')
107   - }
108   - return d
109   -
110   -def createFeed(examples):
111   - doc = Document()
112   - atomuri = "http://www.w3.org/2005/Atom"
113   - feed = doc.createElementNS(atomuri, "feed")
114   - feed.setAttribute("xmlns", atomuri)
115   - title = doc.createElementNS(atomuri, "title")
116   - title.appendChild(doc.createTextNode("OpenLayers Examples"))
117   - feed.appendChild(title)
118   - link = doc.createElementNS(atomuri, "link")
119   - link.setAttribute("rel", "self")
120   - link.setAttribute("href", feedPath + feedName)
121   -
122   - modtime = time.strftime("%Y-%m-%dT%I:%M:%SZ", time.gmtime())
123   - id = doc.createElementNS(atomuri, "id")
124   - id.appendChild(doc.createTextNode("%s%s#%s" % (feedPath, feedName, modtime)))
125   - feed.appendChild(id)
126   -
127   - updated = doc.createElementNS(atomuri, "updated")
128   - updated.appendChild(doc.createTextNode(modtime))
129   - feed.appendChild(updated)
130   -
131   - examples.sort(key=lambda x:x["modified"])
132   - for example in sorted(examples, key=lambda x:x["modified"], reverse=True):
133   - entry = doc.createElementNS(atomuri, "entry")
134   -
135   - title = doc.createElementNS(atomuri, "title")
136   - title.appendChild(doc.createTextNode(example["title"] or example["example"]))
137   - entry.appendChild(title)
138   -
139   - link = doc.createElementNS(atomuri, "link")
140   - link.setAttribute("href", "%s%s" % (feedPath, example["example"]))
141   - entry.appendChild(link)
142   -
143   - summary = doc.createElementNS(atomuri, "summary")
144   - summary.appendChild(doc.createTextNode(example["shortdesc"] or example["example"]))
145   - entry.appendChild(summary)
146   -
147   - updated = doc.createElementNS(atomuri, "updated")
148   - updated.appendChild(doc.createTextNode(example["modified"]))
149   - entry.appendChild(updated)
150   -
151   - author = doc.createElementNS(atomuri, "author")
152   - name = doc.createElementNS(atomuri, "name")
153   - name.appendChild(doc.createTextNode(example["author"]))
154   - author.appendChild(name)
155   - entry.appendChild(author)
156   -
157   - id = doc.createElementNS(atomuri, "id")
158   - id.appendChild(doc.createTextNode("%s%s#%s" % (feedPath, example["example"], example["modified"])))
159   - entry.appendChild(id)
160   -
161   - feed.appendChild(entry)
162   -
163   - doc.appendChild(feed)
164   - return doc
165   -
166   -def wordIndex(examples):
167   - """
168   - Create an inverted index based on words in title and shortdesc. Keys are
169   - lower cased words. Values are dictionaries with example index keys and
170   - count values.
171   - """
172   - index = {}
173   - unword = re.compile("\\W+")
174   - keys = ["shortdesc", "title"]
175   - for i in range(len(examples)):
176   - for key in keys:
177   - text = examples[i][key]
178   - if text:
179   - words = unword.split(text)
180   - for word in words:
181   - if word:
182   - word = word.lower()
183   - if index.has_key(word):
184   - if index[word].has_key(i):
185   - index[word][i] += 1
186   - else:
187   - index[word][i] = 1
188   - else:
189   - index[word] = {i: 1}
190   - return index
191   -
192   -if __name__ == "__main__":
193   -
194   - if missing_deps:
195   - print "This script requires simplejson and BeautifulSoup. You don't have them. \n(%s)" % E
196   - sys.exit()
197   -
198   - if len(sys.argv) > 1:
199   - outFile = open(sys.argv[1],'w')
200   - else:
201   - outFile = open('../examples/example-list.js','w')
202   -
203   - examplesLocation = '../examples'
204   - print 'Reading examples from %s and writing out to %s' % (examplesLocation, outFile.name)
205   -
206   - exampleList = []
207   - docIds = ['title','shortdesc']
208   -
209   - #comment out option to create docs from online resource
210   - #examplesLocation = 'http://svn.openlayers.org/sandbox/docs/examples/'
211   - #examples = getListOfOnlineExamples(examplesLocation)
212   -
213   - examples = getListOfExamples(examplesLocation)
214   -
215   - modtime = time.strftime("%Y-%m-%dT%I:%M:%SZ", time.gmtime())
216   -
217   - for example in examples:
218   - url = os.path.join(examplesLocation,example)
219   - html = getExampleHtml(url)
220   - tagvalues = parseHtml(html,docIds)
221   - tagvalues['example'] = example
222   - # add in svn info
223   - d = getSvnInfo(url)
224   - tagvalues["modified"] = d["date"] or modtime
225   - tagvalues["author"] = d["author"] or "anonymous"
226   - tagvalues['link'] = example
227   -
228   - exampleList.append(tagvalues)
229   -
230   - print
231   -
232   - exampleList.sort(key=lambda x:x['example'].lower())
233   -
234   - index = wordIndex(exampleList)
235   -
236   - json = simplejson.dumps({"examples": exampleList, "index": index})
237   - #give the json a global variable we can use in our js. This should be replaced or made optional.
238   - json = 'var info=' + json
239   - outFile.write(json)
240   - outFile.close()
241   -
242   - print "writing feed to ../examples/%s " % feedName
243   - atom = open('../examples/%s' % feedName, 'w')
244   - doc = createFeed(exampleList)
245   - atom.write(doc.toxml())
246   - atom.close()
247   -
248   -
249   - print 'complete'
250   -
251   -
pacotes/openlayers/tools/jsmin.c
View file @4c12b06
... ... @@ -1,272 +0,0 @@
1   -/* jsmin.c
2   - 2006-05-04
3   -
4   -Copyright (c) 2002 Douglas Crockford (www.crockford.com)
5   -
6   -Permission is hereby granted, free of charge, to any person obtaining a copy of
7   -this software and associated documentation files (the "Software"), to deal in
8   -the Software without restriction, including without limitation the rights to
9   -use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
10   -of the Software, and to permit persons to whom the Software is furnished to do
11   -so, subject to the following conditions:
12   -
13   -The above copyright notice and this permission notice shall be included in all
14   -copies or substantial portions of the Software.
15   -
16   -The Software shall be used for Good, not Evil.
17   -
18   -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19   -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20   -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21   -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22   -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23   -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24   -SOFTWARE.
25   -*/
26   -
27   -#include <stdlib.h>
28   -#include <stdio.h>
29   -
30   -static int theA;
31   -static int theB;
32   -static int theLookahead = EOF;
33   -
34   -
35   -/* isAlphanum -- return true if the character is a letter, digit, underscore,
36   - dollar sign, or non-ASCII character.
37   -*/
38   -
39   -static int
40   -isAlphanum(int c)
41   -{
42   - return ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
43   - (c >= 'A' && c <= 'Z') || c == '_' || c == '$' || c == '\\' ||
44   - c > 126);
45   -}
46   -
47   -
48   -/* get -- return the next character from stdin. Watch out for lookahead. If
49   - the character is a control character, translate it to a space or
50   - linefeed.
51   -*/
52   -
53   -static int
54   -get()
55   -{
56   - int c = theLookahead;
57   - theLookahead = EOF;
58   - if (c == EOF) {
59   - c = getc(stdin);
60   - }
61   - if (c >= ' ' || c == '\n' || c == EOF) {
62   - return c;
63   - }
64   - if (c == '\r') {
65   - return '\n';
66   - }
67   - return ' ';
68   -}
69   -
70   -
71   -/* peek -- get the next character without getting it.
72   -*/
73   -
74   -static int
75   -peek()
76   -{
77   - theLookahead = get();
78   - return theLookahead;
79   -}
80   -
81   -
82   -/* next -- get the next character, excluding comments. peek() is used to see
83   - if a '/' is followed by a '/' or '*'.
84   -*/
85   -
86   -static int
87   -next()
88   -{
89   - int c = get();
90   - if (c == '/') {
91   - switch (peek()) {
92   - case '/':
93   - for (;;) {
94   - c = get();
95   - if (c <= '\n') {
96   - return c;
97   - }
98   - }
99   - case '*':
100   - get();
101   - for (;;) {
102   - switch (get()) {
103   - case '*':
104   - if (peek() == '/') {
105   - get();
106   - return ' ';
107   - }
108   - break;
109   - case EOF:
110   - fprintf(stderr, "Error: JSMIN Unterminated comment.\n");
111   - exit(1);
112   - }
113   - }
114   - default:
115   - return c;
116   - }
117   - }
118   - return c;
119   -}
120   -
121   -
122   -/* action -- do something! What you do is determined by the argument:
123   - 1 Output A. Copy B to A. Get the next B.
124   - 2 Copy B to A. Get the next B. (Delete A).
125   - 3 Get the next B. (Delete B).
126   - action treats a string as a single character. Wow!
127   - action recognizes a regular expression if it is preceded by ( or , or =.
128   -*/
129   -
130   -static void
131   -action(int d)
132   -{
133   - switch (d) {
134   - case 1:
135   - putc(theA, stdout);
136   - case 2:
137   - theA = theB;
138   - if (theA == '\'' || theA == '"') {
139   - for (;;) {
140   - putc(theA, stdout);
141   - theA = get();
142   - if (theA == theB) {
143   - break;
144   - }
145   - if (theA <= '\n') {
146   - fprintf(stderr,
147   -"Error: JSMIN unterminated string literal: %c\n", theA);
148   - exit(1);
149   - }
150   - if (theA == '\\') {
151   - putc(theA, stdout);
152   - theA = get();
153   - }
154   - }
155   - }
156   - case 3:
157   - theB = next();
158   - if (theB == '/' && (theA == '(' || theA == ',' || theA == '=' ||
159   - theA == ':' || theA == '[' || theA == '!' || theA == '&' ||
160   - theA == '|')) {
161   - putc(theA, stdout);
162   - putc(theB, stdout);
163   - for (;;) {
164   - theA = get();
165   - if (theA == '/') {
166   - break;
167   - } else if (theA =='\\') {
168   - putc(theA, stdout);
169   - theA = get();
170   - } else if (theA <= '\n') {
171   - fprintf(stderr,
172   -"Error: JSMIN unterminated Regular Expression literal.\n", theA);
173   - exit(1);
174   - }
175   - putc(theA, stdout);
176   - }
177   - theB = next();
178   - }
179   - }
180   -}
181   -
182   -
183   -/* jsmin -- Copy the input to the output, deleting the characters which are
184   - insignificant to JavaScript. Comments will be removed. Tabs will be
185   - replaced with spaces. Carriage returns will be replaced with linefeeds.
186   - Most spaces and linefeeds will be removed.
187   -*/
188   -
189   -static void
190   -jsmin()
191   -{
192   - theA = '\n';
193   - action(3);
194   - while (theA != EOF) {
195   - switch (theA) {
196   - case ' ':
197   - if (isAlphanum(theB)) {
198   - action(1);
199   - } else {
200   - action(2);
201   - }
202   - break;
203   - case '\n':
204   - switch (theB) {
205   - case '{':
206   - case '[':
207   - case '(':
208   - case '+':
209   - case '-':
210   - action(1);
211   - break;
212   - case ' ':
213   - action(3);
214   - break;
215   - default:
216   - if (isAlphanum(theB)) {
217   - action(1);
218   - } else {
219   - action(2);
220   - }
221   - }
222   - break;
223   - default:
224   - switch (theB) {
225   - case ' ':
226   - if (isAlphanum(theA)) {
227   - action(1);
228   - break;
229   - }
230   - action(3);
231   - break;
232   - case '\n':
233   - switch (theA) {
234   - case '}':
235   - case ']':
236   - case ')':
237   - case '+':
238   - case '-':
239   - case '"':
240   - case '\'':
241   - action(1);
242   - break;
243   - default:
244   - if (isAlphanum(theA)) {
245   - action(1);
246   - } else {
247   - action(3);
248   - }
249   - }
250   - break;
251   - default:
252   - action(1);
253   - break;
254   - }
255   - }
256   - }
257   -}
258   -
259   -
260   -/* main -- Output any command line arguments as comments
261   - and then minify the input.
262   -*/
263   -extern int
264   -main(int argc, char* argv[])
265   -{
266   - int i;
267   - for (i = 1; i < argc; i += 1) {
268   - fprintf(stdout, "// %s\n", argv[i]);
269   - }
270   - jsmin();
271   - return 0;
272   -}
pacotes/openlayers/tools/jsmin.py
View file @4c12b06
... ... @@ -1,216 +0,0 @@
1   -#!/usr/bin/python
2   -
3   -# This code is original from jsmin by Douglas Crockford, it was translated to
4   -# Python by Baruch Even. The original code had the following copyright and
5   -# license.
6   -#
7   -# /* jsmin.c
8   -# 2007-01-08
9   -#
10   -# Copyright (c) 2002 Douglas Crockford (www.crockford.com)
11   -#
12   -# Permission is hereby granted, free of charge, to any person obtaining a copy of
13   -# this software and associated documentation files (the "Software"), to deal in
14   -# the Software without restriction, including without limitation the rights to
15   -# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
16   -# of the Software, and to permit persons to whom the Software is furnished to do
17   -# so, subject to the following conditions:
18   -#
19   -# The above copyright notice and this permission notice shall be included in all
20   -# copies or substantial portions of the Software.
21   -#
22   -# The Software shall be used for Good, not Evil.
23   -#
24   -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25   -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26   -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
27   -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28   -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
29   -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30   -# SOFTWARE.
31   -# */
32   -
33   -from StringIO import StringIO
34   -
35   -def jsmin(js):
36   - ins = StringIO(js)
37   - outs = StringIO()
38   - JavascriptMinify().minify(ins, outs)
39   - str = outs.getvalue()
40   - if len(str) > 0 and str[0] == '\n':
41   - str = str[1:]
42   - return str
43   -
44   -def isAlphanum(c):
45   - """return true if the character is a letter, digit, underscore,
46   - dollar sign, or non-ASCII character.
47   - """
48   - return ((c >= 'a' and c <= 'z') or (c >= '0' and c <= '9') or
49   - (c >= 'A' and c <= 'Z') or c == '_' or c == '$' or c == '\\' or (c is not None and ord(c) > 126));
50   -
51   -class UnterminatedComment(Exception):
52   - pass
53   -
54   -class UnterminatedStringLiteral(Exception):
55   - pass
56   -
57   -class UnterminatedRegularExpression(Exception):
58   - pass
59   -
60   -class JavascriptMinify(object):
61   -
62   - def _outA(self):
63   - self.outstream.write(self.theA)
64   - def _outB(self):
65   - self.outstream.write(self.theB)
66   -
67   - def _get(self):
68   - """return the next character from stdin. Watch out for lookahead. If
69   - the character is a control character, translate it to a space or
70   - linefeed.
71   - """
72   - c = self.theLookahead
73   - self.theLookahead = None
74   - if c == None:
75   - c = self.instream.read(1)
76   - if c >= ' ' or c == '\n':
77   - return c
78   - if c == '': # EOF
79   - return '\000'
80   - if c == '\r':
81   - return '\n'
82   - return ' '
83   -
84   - def _peek(self):
85   - self.theLookahead = self._get()
86   - return self.theLookahead
87   -
88   - def _next(self):
89   - """get the next character, excluding comments. peek() is used to see
90   - if a '/' is followed by a '/' or '*'.
91   - """
92   - c = self._get()
93   - if c == '/':
94   - p = self._peek()
95   - if p == '/':
96   - c = self._get()
97   - while c > '\n':
98   - c = self._get()
99   - return c
100   - if p == '*':
101   - c = self._get()
102   - while 1:
103   - c = self._get()
104   - if c == '*':
105   - if self._peek() == '/':
106   - self._get()
107   - return ' '
108   - if c == '\000':
109   - raise UnterminatedComment()
110   -
111   - return c
112   -
113   - def _action(self, action):
114   - """do something! What you do is determined by the argument:
115   - 1 Output A. Copy B to A. Get the next B.
116   - 2 Copy B to A. Get the next B. (Delete A).
117   - 3 Get the next B. (Delete B).
118   - action treats a string as a single character. Wow!
119   - action recognizes a regular expression if it is preceded by ( or , or =.
120   - """
121   - if action <= 1:
122   - self._outA()
123   -
124   - if action <= 2:
125   - self.theA = self.theB
126   - if self.theA == "'" or self.theA == '"':
127   - while 1:
128   - self._outA()
129   - self.theA = self._get()
130   - if self.theA == self.theB:
131   - break
132   - if self.theA <= '\n':
133   - raise UnterminatedStringLiteral()
134   - if self.theA == '\\':
135   - self._outA()
136   - self.theA = self._get()
137   -
138   -
139   - if action <= 3:
140   - self.theB = self._next()
141   - if self.theB == '/' and (self.theA == '(' or self.theA == ',' or
142   - self.theA == '=' or self.theA == ':' or
143   - self.theA == '[' or self.theA == '?' or
144   - self.theA == '!' or self.theA == '&' or
145   - self.theA == '|'):
146   - self._outA()
147   - self._outB()
148   - while 1:
149   - self.theA = self._get()
150   - if self.theA == '/':
151   - break
152   - elif self.theA == '\\':
153   - self._outA()
154   - self.theA = self._get()
155   - elif self.theA <= '\n':
156   - raise UnterminatedRegularExpression()
157   - self._outA()
158   - self.theB = self._next()
159   -
160   -
161   - def _jsmin(self):
162   - """Copy the input to the output, deleting the characters which are
163   - insignificant to JavaScript. Comments will be removed. Tabs will be
164   - replaced with spaces. Carriage returns will be replaced with linefeeds.
165   - Most spaces and linefeeds will be removed.
166   - """
167   - self.theA = '\n'
168   - self._action(3)
169   -
170   - while self.theA != '\000':
171   - if self.theA == ' ':
172   - if isAlphanum(self.theB):
173   - self._action(1)
174   - else:
175   - self._action(2)
176   - elif self.theA == '\n':
177   - if self.theB in ['{', '[', '(', '+', '-']:
178   - self._action(1)
179   - elif self.theB == ' ':
180   - self._action(3)
181   - else:
182   - if isAlphanum(self.theB):
183   - self._action(1)
184   - else:
185   - self._action(2)
186   - else:
187   - if self.theB == ' ':
188   - if isAlphanum(self.theA):
189   - self._action(1)
190   - else:
191   - self._action(3)
192   - elif self.theB == '\n':
193   - if self.theA in ['}', ']', ')', '+', '-', '"', '\'']:
194   - self._action(1)
195   - else:
196   - if isAlphanum(self.theA):
197   - self._action(1)
198   - else:
199   - self._action(3)
200   - else:
201   - self._action(1)
202   -
203   - def minify(self, instream, outstream):
204   - self.instream = instream
205   - self.outstream = outstream
206   - self.theA = None
207   - self.thaB = None
208   - self.theLookahead = None
209   -
210   - self._jsmin()
211   - self.instream.close()
212   -
213   -if __name__ == '__main__':
214   - import sys
215   - jsm = JavascriptMinify()
216   - jsm.minify(sys.stdin, sys.stdout)
pacotes/openlayers/tools/mergejs.py
View file @4c12b06
... ... @@ -1,252 +0,0 @@
1   -#!/usr/bin/env python
2   -#
3   -# Merge multiple JavaScript source code files into one.
4   -#
5   -# Usage:
6   -# This script requires source files to have dependencies specified in them.
7   -#
8   -# Dependencies are specified with a comment of the form:
9   -#
10   -# // @requires <file path>
11   -#
12   -# e.g.
13   -#
14   -# // @requires Geo/DataSource.js
15   -#
16   -# This script should be executed like so:
17   -#
18   -# mergejs.py <output.js> <directory> [...]
19   -#
20   -# e.g.
21   -#
22   -# mergejs.py openlayers.js Geo/ CrossBrowser/
23   -#
24   -# This example will cause the script to walk the `Geo` and
25   -# `CrossBrowser` directories--and subdirectories thereof--and import
26   -# all `*.js` files encountered. The dependency declarations will be extracted
27   -# and then the source code from imported files will be output to
28   -# a file named `openlayers.js` in an order which fulfils the dependencies
29   -# specified.
30   -#
31   -#
32   -# Note: This is a very rough initial version of this code.
33   -#
34   -# -- Copyright 2005-2008 MetaCarta, Inc. / OpenLayers project --
35   -#
36   -
37   -# TODO: Allow files to be excluded. e.g. `Crossbrowser/DebugMode.js`?
38   -# TODO: Report error when dependency can not be found rather than KeyError.
39   -
40   -import re
41   -import os
42   -import sys
43   -
44   -SUFFIX_JAVASCRIPT = ".js"
45   -
46   -RE_REQUIRE = "@requires:? (.*)\n" # TODO: Ensure in comment?
47   -class SourceFile:
48   - """
49   - Represents a Javascript source code file.
50   - """
51   -
52   - def __init__(self, filepath, source):
53   - """
54   - """
55   - self.filepath = filepath
56   - self.source = source
57   -
58   - self.requiredBy = []
59   -
60   -
61   - def _getRequirements(self):
62   - """
63   - Extracts the dependencies specified in the source code and returns
64   - a list of them.
65   - """
66   - # TODO: Cache?
67   - return re.findall(RE_REQUIRE, self.source)
68   -
69   - requires = property(fget=_getRequirements, doc="")
70   -
71   -
72   -
73   -def usage(filename):
74   - """
75   - Displays a usage message.
76   - """
77   - print "%s [-c <config file>] <output.js> <directory> [...]" % filename
78   -
79   -
80   -class Config:
81   - """
82   - Represents a parsed configuration file.
83   -
84   - A configuration file should be of the following form:
85   -
86   - [first]
87   - 3rd/prototype.js
88   - core/application.js
89   - core/params.js
90   - # A comment
91   -
92   - [last]
93   - core/api.js # Another comment
94   -
95   - [exclude]
96   - 3rd/logger.js
97   -
98   - All headings are required.
99   -
100   - The files listed in the `first` section will be forced to load
101   - *before* all other files (in the order listed). The files in `last`
102   - section will be forced to load *after* all the other files (in the
103   - order listed).
104   -
105   - The files list in the `exclude` section will not be imported.
106   -
107   - Any text appearing after a # symbol indicates a comment.
108   -
109   - """
110   -
111   - def __init__(self, filename):
112   - """
113   - Parses the content of the named file and stores the values.
114   - """
115   - lines = [re.sub("#.*?$", "", line).strip() # Assumes end-of-line character is present
116   - for line in open(filename)
117   - if line.strip() and not line.strip().startswith("#")] # Skip blank lines and comments
118   -
119   - self.forceFirst = lines[lines.index("[first]") + 1:lines.index("[last]")]
120   -
121   - self.forceLast = lines[lines.index("[last]") + 1:lines.index("[include]")]
122   - self.include = lines[lines.index("[include]") + 1:lines.index("[exclude]")]
123   - self.exclude = lines[lines.index("[exclude]") + 1:]
124   -
125   -def run (sourceDirectory, outputFilename = None, configFile = None):
126   - cfg = None
127   - if configFile:
128   - cfg = Config(configFile)
129   -
130   - allFiles = []
131   -
132   - ## Find all the Javascript source files
133   - for root, dirs, files in os.walk(sourceDirectory):
134   - for filename in files:
135   - if filename.endswith(SUFFIX_JAVASCRIPT) and not filename.startswith("."):
136   - filepath = os.path.join(root, filename)[len(sourceDirectory)+1:]
137   - filepath = filepath.replace("\\", "/")
138   - if cfg and cfg.include:
139   - if filepath in cfg.include or filepath in cfg.forceFirst:
140   - allFiles.append(filepath)
141   - elif (not cfg) or (filepath not in cfg.exclude):
142   - allFiles.append(filepath)
143   -
144   - ## Header inserted at the start of each file in the output
145   - HEADER = "/* " + "=" * 70 + "\n %s\n" + " " + "=" * 70 + " */\n\n"
146   -
147   - files = {}
148   -
149   - order = [] # List of filepaths to output, in a dependency satisfying order
150   -
151   - ## Import file source code
152   - ## TODO: Do import when we walk the directories above?
153   - for filepath in allFiles:
154   - print "Importing: %s" % filepath
155   - fullpath = os.path.join(sourceDirectory, filepath).strip()
156   - content = open(fullpath, "U").read() # TODO: Ensure end of line @ EOF?
157   - files[filepath] = SourceFile(filepath, content) # TODO: Chop path?
158   -
159   - print
160   -
161   - from toposort import toposort
162   -
163   - complete = False
164   - resolution_pass = 1
165   -
166   - while not complete:
167   - order = [] # List of filepaths to output, in a dependency satisfying order
168   - nodes = []
169   - routes = []
170   - ## Resolve the dependencies
171   - print "Resolution pass %s... " % resolution_pass
172   - resolution_pass += 1
173   -
174   - for filepath, info in files.items():
175   - nodes.append(filepath)
176   - for neededFilePath in info.requires:
177   - routes.append((neededFilePath, filepath))
178   -
179   - for dependencyLevel in toposort(nodes, routes):
180   - for filepath in dependencyLevel:
181   - order.append(filepath)
182   - if not files.has_key(filepath):
183   - print "Importing: %s" % filepath
184   - fullpath = os.path.join(sourceDirectory, filepath).strip()
185   - content = open(fullpath, "U").read() # TODO: Ensure end of line @ EOF?
186   - files[filepath] = SourceFile(filepath, content) # TODO: Chop path?
187   -
188   -
189   -
190   - # Double check all dependencies have been met
191   - complete = True
192   - try:
193   - for fp in order:
194   - if max([order.index(rfp) for rfp in files[fp].requires] +
195   - [order.index(fp)]) != order.index(fp):
196   - complete = False
197   - except:
198   - complete = False
199   -
200   - print
201   -
202   -
203   - ## Move forced first and last files to the required position
204   - if cfg:
205   - print "Re-ordering files..."
206   - order = cfg.forceFirst + [item
207   - for item in order
208   - if ((item not in cfg.forceFirst) and
209   - (item not in cfg.forceLast))] + cfg.forceLast
210   -
211   - print
212   - ## Output the files in the determined order
213   - result = []
214   -
215   - for fp in order:
216   - f = files[fp]
217   - print "Exporting: ", f.filepath
218   - result.append(HEADER % f.filepath)
219   - source = f.source
220   - result.append(source)
221   - if not source.endswith("\n"):
222   - result.append("\n")
223   -
224   - print "\nTotal files merged: %d " % len(files)
225   -
226   - if outputFilename:
227   - print "\nGenerating: %s" % (outputFilename)
228   - open(outputFilename, "w").write("".join(result))
229   - return "".join(result)
230   -
231   -if __name__ == "__main__":
232   - import getopt
233   -
234   - options, args = getopt.getopt(sys.argv[1:], "-c:")
235   -
236   - try:
237   - outputFilename = args[0]
238   - except IndexError:
239   - usage(sys.argv[0])
240   - raise SystemExit
241   - else:
242   - sourceDirectory = args[1]
243   - if not sourceDirectory:
244   - usage(sys.argv[0])
245   - raise SystemExit
246   -
247   - configFile = None
248   - if options and options[0][0] == "-c":
249   - configFile = options[0][1]
250   - print "Parsing configuration file: %s" % filename
251   -
252   - run( sourceDirectory, outputFilename, configFile )
pacotes/openlayers/tools/minimize.py
View file @4c12b06
... ... @@ -1,47 +0,0 @@
1   -# Minimal Python Minimizer
2   -# Copyright 2008, Christopher Schmidt
3   -# Released under the MIT License
4   -#
5   -# Taken from: http://svn.crschmidt.net/personal/python/minimize.py
6   -# $Id: minimize.py 6 2008-01-03 06:33:35Z crschmidt $
7   -#
8   -# Permission is hereby granted, free of charge, to any person obtaining a copy
9   -# of this software and associated documentation files (the "Software"), to deal
10   -# in the Software without restriction, including without limitation the rights
11   -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12   -# copies of the Software, and to permit persons to whom the Software is
13   -# furnished to do so, subject to the following conditions:
14   -#
15   -# The above copyright notice and this permission notice shall be included in
16   -# all copies or substantial portions of the Software.
17   -#
18   -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19   -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20   -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21   -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22   -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23   -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24   -# THE SOFTWARE.
25   -
26   -import re
27   -
28   -def strip_comments_helper(data):
29   - """remove all /* */ format comments and surrounding whitespace."""
30   - p = re.compile(r'[\s]*/\*.*?\*/[\s]*', re.DOTALL)
31   - return p.sub('',data)
32   -
33   -def minimize(data, exclude=None):
34   - """Central function call. This will call all other compression
35   - functions. To add further compression algorithms, simply add
36   - functions whose names end in _helper which take a string as input
37   - and return a more compressed string as output."""
38   - for key, item in globals().iteritems():
39   - if key.endswith("_helper"):
40   - func_key = key[:-7]
41   - if not exclude or not func_key in exclude:
42   - data = item(data)
43   - return data
44   -
45   -if __name__ == "__main__":
46   - import sys
47   - print minimize(open(sys.argv[1]).read())
pacotes/openlayers/tools/oldot.py
View file @4c12b06
... ... @@ -1,43 +0,0 @@
1   -import re
2   -import os
3   -def run():
4   - sourceDirectory = "../lib/OpenLayers"
5   - allFiles = []
6   - SUFFIX_JAVASCRIPT = ".js"
7   - ## Find all the Javascript source files
8   - for root, dirs, files in os.walk(sourceDirectory):
9   - for filename in files:
10   - if filename.endswith(SUFFIX_JAVASCRIPT) and not filename.startswith("."):
11   - filepath = os.path.join(root, filename)[len(sourceDirectory)+1:]
12   - filepath = filepath.replace("\\", "/")
13   - data = open(os.path.join(sourceDirectory, filepath)).read()
14   - parents = re.search("OpenLayers.Class\((.*?){", data,
15   - re.DOTALL)
16   - if parents:
17   - parents = [x.strip() for x in parents.group(1).strip().strip(",").split(",")]
18   - else:
19   - parents = []
20   - cls = "OpenLayers.%s" % filepath.strip(".js").replace("/", ".")
21   - allFiles.append([cls, parents])
22   - return allFiles
23   -print """
24   -digraph name {
25   - fontname = "Helvetica"
26   - fontsize = 8
27   - K = 0.6
28   -
29   - node [
30   - fontname = "Helvetica"
31   - fontsize = 8
32   - shape = "plaintext"
33   - ]
34   -"""
35   -
36   -for i in run():
37   - print i[0].replace(".", "_")
38   - for item in i[1]:
39   - if not item: continue
40   - print "%s -> %s" % (i[0].replace(".","_"), item.replace(".", "_"))
41   - print "; "
42   -
43   -print """}"""
pacotes/openlayers/tools/release.sh
View file @4c12b06
... ... @@ -1,29 +0,0 @@
1   -#!/bin/sh
2   -
3   -VERSION=$1
4   -
5   -svn export http://svn.openlayers.org/tags/openlayers/release-$VERSION OpenLayers-$VERSION
6   -cd OpenLayers-$VERSION/build
7   -./build.py full
8   -cp OpenLayers.js ..
9   -
10   -cd ..
11   -
12   -mkdir doc/devdocs
13   -mkdir doc/apidocs
14   -rm tools/*.pyc
15   -
16   -mkdir /www/openlayers/htdocs/api/$VERSION
17   -cp OpenLayers.js /www/openlayers/htdocs/api/$VERSION
18   -cp -a img/ /www/openlayers/htdocs/api/$VERSION
19   -cp -a theme/ /www/openlayers/htdocs/api/$VERSION
20   -
21   -cd ..
22   -
23   -~/nd/NaturalDocs -i OpenLayers-$VERSION/lib -o HTML OpenLayers-$VERSION/doc/devdocs -p OpenLayers-$VERSION/doc_config -s Small OL
24   -~/nd/NaturalDocs -i OpenLayers-$VERSION/lib -o HTML OpenLayers-$VERSION/doc/apidocs -p OpenLayers-$VERSION/apidoc_config -s Small OL
25   -
26   -tar cvfz OpenLayers-$VERSION.tar.gz OpenLayers-$VERSION/
27   -zip -9r OpenLayers-$VERSION.zip OpenLayers-$VERSION/
28   -
29   -cp OpenLayers-$VERSION.* /www/openlayers/htdocs/download
pacotes/openlayers/tools/shrinksafe.py
View file @4c12b06
... ... @@ -1,54 +0,0 @@
1   -#!/usr/bin/env python
2   -#
3   -# Script to provide a wrapper around the ShrinkSafe "web service"
4   -# <http://shrinksafe.dojotoolkit.org/>
5   -#
6   -
7   -#
8   -# We use this script for two reasons:
9   -#
10   -# * This avoids having to install and configure Java and the standalone
11   -# ShrinkSafe utility.
12   -#
13   -# * The current ShrinkSafe standalone utility was broken when we last
14   -# used it.
15   -#
16   -
17   -import sys
18   -
19   -import urllib
20   -import urllib2
21   -
22   -URL_SHRINK_SAFE = "http://shrinksafe.dojotoolkit.org/shrinksafe.php"
23   -
24   -# This would normally be dynamically generated:
25   -BOUNDARY_MARKER = "---------------------------72288400411964641492083565382"
26   -
27   -if __name__ == "__main__":
28   - ## Grab the source code
29   - try:
30   - sourceFilename = sys.argv[1]
31   - except:
32   - print "Usage: %s (<source filename>|-)" % sys.argv[0]
33   - raise SystemExit
34   -
35   - if sourceFilename == "-":
36   - sourceCode = sys.stdin.read()
37   - sourceFilename = "stdin.js"
38   - else:
39   - sourceCode = open(sourceFilename).read()
40   -
41   - ## Create the request replicating posting of the form from the web page
42   - request = urllib2.Request(url=URL_SHRINK_SAFE)
43   - request.add_header("Content-Type",
44   - "multipart/form-data; boundary=%s" % BOUNDARY_MARKER)
45   - request.add_data("""
46   ---%s
47   -Content-Disposition: form-data; name="shrinkfile[]"; filename="%s"
48   -Content-Type: application/x-javascript
49   -
50   -%s
51   -""" % (BOUNDARY_MARKER, sourceFilename, sourceCode))
52   -
53   - ## Deliver the result
54   - print urllib2.urlopen(request).read(),
pacotes/openlayers/tools/toposort.py
View file @4c12b06
... ... @@ -1,260 +0,0 @@
1   -#
2   -# According to <http://www.vrplumber.com/programming/> this file
3   -# is licensed under a BSD-style license. We only use the section
4   -# originally by Tim Peters.
5   -#
6   -# TODO: The use of this code needs to be okayed by someone.
7   -#
8   -
9   -class RecursionError( OverflowError, ValueError ):
10   - '''Unable to calculate result because of recursive structure'''
11   -
12   -
13   -def sort(nodes, routes, noRecursion=1):
14   - '''Passed a list of node IDs and a list of source,dest ID routes
15   - attempt to create a list of stages where each sub list
16   - is one stage in a process.
17   - '''
18   - children, parents = _buildChildrenLists(routes)
19   - # first stage is those nodes
20   - # having no incoming routes...
21   - stage = []
22   - stages = [stage]
23   - taken = []
24   - for node in nodes:
25   - if (not parents.get(node)):
26   - stage.append (node)
27   - if nodes and not stage:
28   - # there is no element which does not depend on
29   - # some other element!!!
30   - stage.append( nodes[0])
31   - taken.extend( stage )
32   - nodes = filter ( lambda x, l=stage: x not in l, nodes )
33   - while nodes:
34   - previousStageChildren = []
35   - nodelen = len(nodes)
36   - # second stage are those nodes
37   - # which are direct children of the first stage
38   - for node in stage:
39   - for child in children.get (node, []):
40   - if child not in previousStageChildren and child not in taken:
41   - previousStageChildren.append(child)
42   - elif child in taken and noRecursion:
43   - raise RecursionError( (child, node) )
44   - # unless they are children of other direct children...
45   - # TODO, actually do that...
46   - stage = previousStageChildren
47   - removes = []
48   - for current in stage:
49   - currentParents = parents.get( current, [] )
50   - for parent in currentParents:
51   - if parent in stage and parent != current:
52   - # might wind up removing current...
53   - if not current in parents.get(parent, []):
54   - # is not mutually dependent...
55   - removes.append( current )
56   - for remove in removes:
57   - while remove in stage:
58   - stage.remove( remove )
59   - stages.append( stage)
60   - taken.extend( stage )
61   - nodes = filter ( lambda x, l=stage: x not in l, nodes )
62   - if nodelen == len(nodes):
63   - if noRecursion:
64   - raise RecursionError( nodes )
65   - else:
66   - stages.append( nodes[:] )
67   - nodes = []
68   - return stages
69   -
70   -def _buildChildrenLists (routes):
71   - childrenTable = {}
72   - parentTable = {}
73   - for sourceID,destinationID in routes:
74   - currentChildren = childrenTable.get( sourceID, [])
75   - currentParents = parentTable.get( destinationID, [])
76   - if not destinationID in currentChildren:
77   - currentChildren.append ( destinationID)
78   - if not sourceID in currentParents:
79   - currentParents.append ( sourceID)
80   - childrenTable[sourceID] = currentChildren
81   - parentTable[destinationID] = currentParents
82   - return childrenTable, parentTable
83   -
84   -
85   -def toposort (nodes, routes, noRecursion=1):
86   - '''Topological sort from Tim Peters, fairly efficient
87   - in comparison (it seems).'''
88   - #first calculate the recursion depth
89   -
90   - dependencies = {}
91   - inversedependencies = {}
92   - if not nodes:
93   - return []
94   - if not routes:
95   - return [nodes]
96   - for node in nodes:
97   - dependencies[ node ] = (0, node)
98   - inversedependencies[ node ] = []
99   -
100   -
101   - for depended, depends in routes:
102   - # is it a null rule
103   - try:
104   - newdependencylevel, object = dependencies.get ( depends, (0, depends))
105   - except TypeError:
106   - print depends
107   - raise
108   - dependencies[ depends ] = (newdependencylevel + 1, depends)
109   - # "dependency (existence) of depended-on"
110   - newdependencylevel,object = dependencies.get ( depended, (0, depended) )
111   - dependencies[ depended ] = (newdependencylevel, depended)
112   - # Inverse dependency set up
113   - dependencieslist = inversedependencies.get ( depended, [])
114   - dependencieslist.append (depends)
115   - inversedependencies[depended] = dependencieslist
116   - ### Now we do the actual sorting
117   - # The first task is to create the sortable
118   - # list of dependency-levels
119   - sortinglist = dependencies.values()
120   - sortinglist.sort ()
121   - output = []
122   - while sortinglist:
123   - deletelist = []
124   - generation = []
125   - output.append( generation)
126   - while sortinglist and sortinglist[0][0] == 0:
127   - number, object = sortinglist[0]
128   - generation.append ( object )
129   - deletelist.append( object )
130   - for inverse in inversedependencies.get(object, () ):
131   - try:
132   - oldcount, inverse = dependencies [ inverse]
133   - if oldcount > 0:
134   - # will be dealt with on later pass
135   - dependencies [ inverse] = (oldcount-1, inverse)
136   - else:
137   - # will be dealt with on this pass,
138   - # so needs not to be in the sorting list next time
139   - deletelist.append( inverse )
140   - # just in case a loop comes through
141   - inversedependencies[object] = []
142   - except KeyError:
143   - # dealing with a recursion-breaking run...
144   - pass
145   - del sortinglist [0]
146   - # if no elements could be deleted, then
147   - # there is something which depends upon itself
148   - if not deletelist:
149   - if noRecursion:
150   - raise RecursionError( sortinglist )
151   - else:
152   - # hack so that something gets deleted...
153   -## import pdb
154   -## pdb.set_trace()
155   - dependencies[sortinglist[0][1]] = (0,sortinglist[0][1])
156   - # delete the items that were dealt with
157   - for item in deletelist:
158   - try:
159   - del dependencies [ item ]
160   - except KeyError:
161   - pass
162   - # need to recreate the sortinglist
163   - sortinglist = dependencies.values()
164   - if not generation:
165   - output.remove( generation )
166   - sortinglist.sort ()
167   - return output
168   -
169   -
170   -
171   -
172   -
173   -if __name__ == "__main__":
174   -
175   - nodes = ['a', 'b', 'c', 'd', 'e', 'f']
176   - route = [('a', 'b'), ('b', 'c'), ('b', 'd'), ('e','f')]
177   -
178   - for x in toposort( nodes, route):
179   - for a in x:
180   - print a
181   -
182   - raise SystemExit
183   -
184   -
185   -
186   - import pprint, traceback
187   - nodes= [ 0,1,2,3,4,5 ]
188   - testingValues = [
189   - [ (0,1),(1,2),(2,3),(3,4),(4,5)],
190   - [ (0,1),(0,2),(1,2),(3,4),(4,5)],
191   - [
192   - (0,1),
193   - (0,2),
194   - (0,2),
195   - (2,4),
196   - (2,5),
197   - (3,2),
198   - (0,3)],
199   - [
200   - (0,1), # 3-element cycle test, no orphan nodes
201   - (1,2),
202   - (2,0),
203   - (2,4),
204   - (2,5),
205   - (3,2),
206   - (0,3)],
207   - [
208   - (0,1),
209   - (1,1),
210   - (1,1),
211   - (1,4),
212   - (1,5),
213   - (1,2),
214   - (3,1),
215   - (2,1),
216   - (2,0)],
217   - [
218   - (0,1),
219   - (1,0),
220   - (0,2),
221   - (0,3),
222   - ],
223   - [
224   - (0,1),
225   - (1,0),
226   - (0,2),
227   - (3,1),
228   - ],
229   - ]
230   - print 'sort, no recursion allowed'
231   - for index in range(len(testingValues)):
232   -## print ' %s -- %s'%( index, testingValues[index])
233   - try:
234   - print ' ', sort( nodes, testingValues[index] )
235   - except:
236   - print 'exception raised'
237   - print 'toposort, no recursion allowed'
238   - for index in range(len(testingValues)):
239   -## print ' %s -- %s'%( index, testingValues[index])
240   - try:
241   - print ' ', toposort( nodes, testingValues[index] )
242   - except:
243   - print 'exception raised'
244   - print 'sort, recursion allowed'
245   - for index in range(len(testingValues)):
246   -## print ' %s -- %s'%( index, testingValues[index])
247   - try:
248   - print ' ', sort( nodes, testingValues[index],0 )
249   - except:
250   - print 'exception raised'
251   - print 'toposort, recursion allowed'
252   - for index in range(len(testingValues)):
253   -## print ' %s -- %s'%( index, testingValues[index])
254   - try:
255   - print ' ', toposort( nodes, testingValues[index],0 )
256   - except:
257   - print 'exception raised'
258   -
259   -
260   -
pacotes/openlayers/tools/update_dev_dir.sh
View file @4c12b06
... ... @@ -1,45 +0,0 @@
1   -#!/bin/sh
2   -
3   -# Used to update http://openlayers.org/dev/
4   -
5   -svn up /www/openlayers/docs/dev;
6   -
7   -# Get current 'Last Changed Rev'
8   -REV=`svn info /www/openlayers/docs/dev/ | grep 'Last Changed Rev' | awk '{print $4}'`
9   -
10   -# Get the last svn rev
11   -touch /tmp/ol_svn_rev
12   -OLD_REV="o`cat /tmp/ol_svn_rev`"
13   -
14   -# If they're not equal, do some work.
15   -if [ ! o$REV = $OLD_REV ]; then
16   -
17   - cd /www/openlayers/docs/dev/tools/
18   - python exampleparser.py
19   - cd /www/openlayers/docs/dev/build
20   - ./build.py
21   -
22   - cp OpenLayers.js ..
23   - cd ..
24   -
25   - sed -i -e 's!../lib/OpenLayers.js!../OpenLayers.js!' examples/*.html
26   - perl /home/crschmidt/NaturalDocs -i /www/openlayers/docs/dev/lib -o HTML /www/openlayers/dev/apidocs -p /www/openlayers/docs/dev/apidoc_config -s Default OL >/dev/null
27   - perl /home/crschmidt/NaturalDocs -i /www/openlayers/docs/dev/lib -o HTML /www/openlayers/dev/docs -p /www/openlayers/docs/dev/doc_config -s Default OL >/dev/null
28   -
29   - # Record the revision
30   - echo -n $REV > /tmp/ol_svn_rev
31   -fi
32   -
33   -svn up /www/openlayers/documentation-checkout
34   -REV=`svn info /www/openlayers/documentation-checkout | grep 'Last Changed Rev' | awk '{print $4}'`
35   -# Get the last svn rev
36   -touch /tmp/ol_doc_rev
37   -OLD_REV="o`cat /tmp/ol_doc_rev`"
38   -# If they're not equal, do some work.
39   -if [ ! o$REV = $OLD_REV ]; then
40   - cd /www/openlayers/documentation-checkout
41   - make html > /dev/null
42   - cp -r _build/html/* /www/openlayers/documentation
43   -
44   - echo -n $REV > /tmp/ol_doc_rev
45   -fi