libv8 7.8.279.23.0beta1 → 8.4.255.0

data/vendor/depot_tools/third_party/pylint/pyreverse/utils.py

@@ -1,210 +0,0 @@
-# Copyright (c) 2002-2013 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation; either version 2 of the License, or (at your option) any later
-# version.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""
-generic classes/functions for pyreverse core/extensions
-"""
-from __future__ import print_function
-
-import os
-import re
-import sys
-
-########### pyreverse option utils ##############################
-
-
-RCFILE = '.pyreverserc'
-
-def get_default_options():
-    """
-    Read config file and return list of options
-    """
-    options = []
-    home = os.environ.get('HOME', '')
-    if home:
-        rcfile = os.path.join(home, RCFILE)
-        try:
-            options = open(rcfile).read().split()
-        except IOError:
-            pass # ignore if no config file found
-    return options
-
-def insert_default_options():
-    """insert default options to sys.argv
-    """
-    options = get_default_options()
-    options.reverse()
-    for arg in options:
-        sys.argv.insert(1, arg)
-
-
-
-# astroid utilities ###########################################################
-
-SPECIAL = re.compile('^__[A-Za-z0-9]+[A-Za-z0-9_]*__$')
-PRIVATE = re.compile('^__[_A-Za-z0-9]*[A-Za-z0-9]+_?$')
-PROTECTED = re.compile('^_[_A-Za-z0-9]*$')
-
-def get_visibility(name):
-    """return the visibility from a name: public, protected, private or special
-    """
-    if SPECIAL.match(name):
-        visibility = 'special'
-    elif PRIVATE.match(name):
-        visibility = 'private'
-    elif PROTECTED.match(name):
-        visibility = 'protected'
-
-    else:
-        visibility = 'public'
-    return visibility
-
-ABSTRACT = re.compile('^.*Abstract.*')
-FINAL = re.compile('^[A-Z_]*$')
-
-def is_abstract(node):
-    """return true if the given class node correspond to an abstract class
-    definition
-    """
-    return ABSTRACT.match(node.name)
-
-def is_final(node):
-    """return true if the given class/function node correspond to final
-    definition
-    """
-    return FINAL.match(node.name)
-
-def is_interface(node):
-    # bw compat
-    return node.type == 'interface'
-
-def is_exception(node):
-    # bw compat
-    return node.type == 'exception'
-
-
-# Helpers #####################################################################
-
-_CONSTRUCTOR = 1
-_SPECIAL = 2
-_PROTECTED = 4
-_PRIVATE = 8
-MODES = {
-    'ALL'       : 0,
-    'PUB_ONLY'  : _SPECIAL + _PROTECTED + _PRIVATE,
-    'SPECIAL'   : _SPECIAL,
-    'OTHER'     : _PROTECTED + _PRIVATE,
-}
-VIS_MOD = {'special': _SPECIAL, 'protected': _PROTECTED,
-           'private': _PRIVATE, 'public': 0}
-
-
-class FilterMixIn(object):
-    """filter nodes according to a mode and nodes' visibility
-    """
-    def __init__(self, mode):
-        "init filter modes"
-        __mode = 0
-        for nummod in mode.split('+'):
-            try:
-                __mode += MODES[nummod]
-            except KeyError as ex:
-                print('Unknown filter mode %s' % ex, file=sys.stderr)
-        self.__mode = __mode
-
-
-    def show_attr(self, node):
-        """return true if the node should be treated
-        """
-        visibility = get_visibility(getattr(node, 'name', node))
-        return not self.__mode & VIS_MOD[visibility]
-
-
-class ASTWalker(object):
-    """a walker visiting a tree in preorder, calling on the handler:
-
-    * visit_<class name> on entering a node, where class name is the class of
-    the node in lower case
-
-    * leave_<class name> on leaving a node, where class name is the class of
-    the node in lower case
-    """
-
-    def __init__(self, handler):
-        self.handler = handler
-        self._cache = {}
-
-    def walk(self, node, _done=None):
-        """walk on the tree from <node>, getting callbacks from handler"""
-        if _done is None:
-            _done = set()
-        if node in _done:
-            raise AssertionError((id(node), node, node.parent))
-        _done.add(node)
-        self.visit(node)
-        for child_node in node.get_children():
-            assert child_node is not node
-            self.walk(child_node, _done)
-        self.leave(node)
-        assert node.parent is not node
-
-    def get_callbacks(self, node):
-        """get callbacks from handler for the visited node"""
-        klass = node.__class__
-        methods = self._cache.get(klass)
-        if methods is None:
-            handler = self.handler
-            kid = klass.__name__.lower()
-            e_method = getattr(handler, 'visit_%s' % kid,
-                               getattr(handler, 'visit_default', None))
-            l_method = getattr(handler, 'leave_%s' % kid,
-                               getattr(handler, 'leave_default', None))
-            self._cache[klass] = (e_method, l_method)
-        else:
-            e_method, l_method = methods
-        return e_method, l_method
-
-    def visit(self, node):
-        """walk on the tree from <node>, getting callbacks from handler"""
-        method = self.get_callbacks(node)[0]
-        if method is not None:
-            method(node)
-
-    def leave(self, node):
-        """walk on the tree from <node>, getting callbacks from handler"""
-        method = self.get_callbacks(node)[1]
-        if method is not None:
-            method(node)
-
-
-class LocalsVisitor(ASTWalker):
-    """visit a project by traversing the locals dictionary"""
-    def __init__(self):
-        ASTWalker.__init__(self, self)
-        self._visited = {}
-
-    def visit(self, node):
-        """launch the visit starting from the given node"""
-        if node in self._visited:
-            return
-        self._visited[node] = 1 # FIXME: use set ?
-        methods = self.get_callbacks(node)
-        if methods[0] is not None:
-            methods[0](node)
-        if hasattr(node, 'locals'): # skip Instance and other proxy
-            for local_node in node.values():
-                self.visit(local_node)
-        if methods[1] is not None:
-            return methods[1](node)

data/vendor/depot_tools/third_party/pylint/pyreverse/vcgutils.py

@@ -1,198 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) 2008-2013 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation; either version 2 of the License, or (at your option) any later
-# version.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# This file was copied from logilab-common with the same license:
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-
-"""Functions to generate files readable with Georg Sander's vcg
-(Visualization of Compiler Graphs).
-
-You can download vcg at http://rw4.cs.uni-sb.de/~sander/html/gshome.html
-Note that vcg exists as a debian package.
-
-See vcg's documentation for explanation about the different values that
-maybe used for the functions parameters.
-"""
-
-ATTRS_VAL = {
-    'algos':       ('dfs', 'tree', 'minbackward',
-                    'left_to_right', 'right_to_left',
-                    'top_to_bottom', 'bottom_to_top',
-                    'maxdepth', 'maxdepthslow', 'mindepth', 'mindepthslow',
-                    'mindegree', 'minindegree', 'minoutdegree',
-                    'maxdegree', 'maxindegree', 'maxoutdegree'),
-    'booleans':    ('yes', 'no'),
-    'colors':      ('black', 'white', 'blue', 'red', 'green', 'yellow',
-                    'magenta', 'lightgrey',
-                    'cyan', 'darkgrey', 'darkblue', 'darkred', 'darkgreen',
-                    'darkyellow', 'darkmagenta', 'darkcyan', 'gold',
-                    'lightblue', 'lightred', 'lightgreen', 'lightyellow',
-                    'lightmagenta', 'lightcyan', 'lilac', 'turquoise',
-                    'aquamarine', 'khaki', 'purple', 'yellowgreen', 'pink',
-                    'orange', 'orchid'),
-    'shapes':      ('box', 'ellipse', 'rhomb', 'triangle'),
-    'textmodes':   ('center', 'left_justify', 'right_justify'),
-    'arrowstyles': ('solid', 'line', 'none'),
-    'linestyles':  ('continuous', 'dashed', 'dotted', 'invisible'),
-    }
-
-# meaning of possible values:
-#   O    -> string
-#   1    -> int
-#   list -> value in list
-GRAPH_ATTRS = {
-    'title':              0,
-    'label':              0,
-    'color':               ATTRS_VAL['colors'],
-    'textcolor':           ATTRS_VAL['colors'],
-    'bordercolor':         ATTRS_VAL['colors'],
-    'width':               1,
-    'height':              1,
-    'borderwidth':         1,
-    'textmode':            ATTRS_VAL['textmodes'],
-    'shape':               ATTRS_VAL['shapes'],
-    'shrink':              1,
-    'stretch':             1,
-    'orientation':         ATTRS_VAL['algos'],
-    'vertical_order':      1,
-    'horizontal_order':    1,
-    'xspace':              1,
-    'yspace':              1,
-    'layoutalgorithm':    ATTRS_VAL['algos'],
-    'late_edge_labels':   ATTRS_VAL['booleans'],
-    'display_edge_labels': ATTRS_VAL['booleans'],
-    'dirty_edge_labels':  ATTRS_VAL['booleans'],
-    'finetuning':          ATTRS_VAL['booleans'],
-    'manhattan_edges':     ATTRS_VAL['booleans'],
-    'smanhattan_edges':    ATTRS_VAL['booleans'],
-    'port_sharing':        ATTRS_VAL['booleans'],
-    'edges':               ATTRS_VAL['booleans'],
-    'nodes':               ATTRS_VAL['booleans'],
-    'splines':             ATTRS_VAL['booleans'],
-    }
-NODE_ATTRS = {
-    'title':              0,
-    'label':              0,
-    'color':               ATTRS_VAL['colors'],
-    'textcolor':           ATTRS_VAL['colors'],
-    'bordercolor':         ATTRS_VAL['colors'],
-    'width':               1,
-    'height':              1,
-    'borderwidth':         1,
-    'textmode':            ATTRS_VAL['textmodes'],
-    'shape':               ATTRS_VAL['shapes'],
-    'shrink':              1,
-    'stretch':             1,
-    'vertical_order':      1,
-    'horizontal_order':    1,
-    }
-EDGE_ATTRS = {
-    'sourcename':         0,
-    'targetname':         0,
-    'label':              0,
-    'linestyle':          ATTRS_VAL['linestyles'],
-    'class':              1,
-    'thickness':          0,
-    'color':               ATTRS_VAL['colors'],
-    'textcolor':           ATTRS_VAL['colors'],
-    'arrowcolor':          ATTRS_VAL['colors'],
-    'backarrowcolor':      ATTRS_VAL['colors'],
-    'arrowsize':           1,
-    'backarrowsize':       1,
-    'arrowstyle':          ATTRS_VAL['arrowstyles'],
-    'backarrowstyle':      ATTRS_VAL['arrowstyles'],
-    'textmode':            ATTRS_VAL['textmodes'],
-    'priority':            1,
-    'anchor':              1,
-    'horizontal_order':    1,
-    }
-
-
-# Misc utilities ###############################################################
-
-class VCGPrinter(object):
-    """A vcg graph writer.
-    """
-
-    def __init__(self, output_stream):
-        self._stream = output_stream
-        self._indent = ''
-
-    def open_graph(self, **args):
-        """open a vcg graph
-        """
-        self._stream.write('%sgraph:{\n'%self._indent)
-        self._inc_indent()
-        self._write_attributes(GRAPH_ATTRS, **args)
-
-    def close_graph(self):
-        """close a vcg graph
-        """
-        self._dec_indent()
-        self._stream.write('%s}\n'%self._indent)
-
-
-    def node(self, title, **args):
-        """draw a node
-        """
-        self._stream.write('%snode: {title:"%s"' % (self._indent, title))
-        self._write_attributes(NODE_ATTRS, **args)
-        self._stream.write('}\n')
-
-
-    def edge(self, from_node, to_node, edge_type='', **args):
-        """draw an edge from a node to another.
-        """
-        self._stream.write(
-            '%s%sedge: {sourcename:"%s" targetname:"%s"' % (
-                self._indent, edge_type, from_node, to_node))
-        self._write_attributes(EDGE_ATTRS, **args)
-        self._stream.write('}\n')
-
-
-    # private ##################################################################
-
-    def _write_attributes(self, attributes_dict, **args):
-        """write graph, node or edge attributes
-        """
-        for key, value in args.items():
-            try:
-                _type = attributes_dict[key]
-            except KeyError:
-                raise Exception('''no such attribute %s
-possible attributes are %s''' % (key, attributes_dict.keys()))
-
-            if not _type:
-                self._stream.write('%s%s:"%s"\n' % (self._indent, key, value))
-            elif _type == 1:
-                self._stream.write('%s%s:%s\n' % (self._indent, key,
-                                                  int(value)))
-            elif value in _type:
-                self._stream.write('%s%s:%s\n' % (self._indent, key, value))
-            else:
-                raise Exception('''value %s isn\'t correct for attribute %s
-correct values are %s''' % (value, key, _type))
-
-    def _inc_indent(self):
-        """increment indentation
-        """
-        self._indent = '  %s' % self._indent
-
-    def _dec_indent(self):
-        """decrement indentation
-        """
-        self._indent = self._indent[:-2]

data/vendor/depot_tools/third_party/pylint/pyreverse/writer.py

@@ -1,198 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) 2008-2013 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation; either version 2 of the License, or (at your option) any later
-# version.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""Utilities for creating VCG and Dot diagrams"""
-
-from pylint.pyreverse.utils import is_exception
-from pylint.pyreverse.vcgutils import VCGPrinter
-from pylint.graph import DotBackend
-
-class DiagramWriter(object):
-    """base class for writing project diagrams
-    """
-    def __init__(self, config, styles):
-        self.config = config
-        self.pkg_edges, self.inh_edges, self.imp_edges, self.ass_edges = styles
-        self.printer = None # defined in set_printer
-
-    def write(self, diadefs):
-        """write files for <project> according to <diadefs>
-        """
-        for diagram in diadefs:
-            basename = diagram.title.strip().replace(' ', '_')
-            file_name = '%s.%s' % (basename, self.config.output_format)
-            self.set_printer(file_name, basename)
-            if diagram.TYPE == 'class':
-                self.write_classes(diagram)
-            else:
-                self.write_packages(diagram)
-            self.close_graph()
-
-    def write_packages(self, diagram):
-        """write a package diagram"""
-        # sorted to get predictable (hence testable) results
-        for i, obj in enumerate(sorted(diagram.modules(), key=lambda x: x.title)):
-            self.printer.emit_node(i, label=self.get_title(obj), shape='box')
-            obj.fig_id = i
-        # package dependencies
-        for rel in diagram.get_relationships('depends'):
-            self.printer.emit_edge(rel.from_object.fig_id, rel.to_object.fig_id,
-                                   **self.pkg_edges)
-
-    def write_classes(self, diagram):
-        """write a class diagram"""
-        # sorted to get predictable (hence testable) results
-        for i, obj in enumerate(sorted(diagram.objects, key=lambda x: x.title)):
-            self.printer.emit_node(i, **self.get_values(obj))
-            obj.fig_id = i
-        # inheritance links
-        for rel in diagram.get_relationships('specialization'):
-            self.printer.emit_edge(rel.from_object.fig_id, rel.to_object.fig_id,
-                                   **self.inh_edges)
-        # implementation links
-        for rel in diagram.get_relationships('implements'):
-            self.printer.emit_edge(rel.from_object.fig_id, rel.to_object.fig_id,
-                                   **self.imp_edges)
-        # generate associations
-        for rel in diagram.get_relationships('association'):
-            self.printer.emit_edge(rel.from_object.fig_id, rel.to_object.fig_id,
-                                   label=rel.name, **self.ass_edges)
-
-    def set_printer(self, file_name, basename):
-        """set printer"""
-        raise NotImplementedError
-
-    def get_title(self, obj):
-        """get project title"""
-        raise NotImplementedError
-
-    def get_values(self, obj):
-        """get label and shape for classes."""
-        raise NotImplementedError
-
-    def close_graph(self):
-        """finalize the graph"""
-        raise NotImplementedError
-
-
-class DotWriter(DiagramWriter):
-    """write dot graphs from a diagram definition and a project
-    """
-
-    def __init__(self, config):
-        styles = [dict(arrowtail='none', arrowhead="open"),
-                  dict(arrowtail='none', arrowhead='empty'),
-                  dict(arrowtail='node', arrowhead='empty', style='dashed'),
-                  dict(fontcolor='green', arrowtail='none',
-                       arrowhead='diamond', style='solid'),
-                 ]
-        DiagramWriter.__init__(self, config, styles)
-
-    def set_printer(self, file_name, basename):
-        """initialize DotWriter and add options for layout.
-        """
-        layout = dict(rankdir="BT")
-        self.printer = DotBackend(basename, additional_param=layout)
-        self.file_name = file_name
-
-    def get_title(self, obj):
-        """get project title"""
-        return obj.title
-
-    def get_values(self, obj):
-        """get label and shape for classes.
-
-        The label contains all attributes and methods
-        """
-        label = obj.title
-        if obj.shape == 'interface':
-            label = u'«interface»\\n%s' % label
-        if not self.config.only_classnames:
-            label = r'%s|%s\l|' % (label, r'\l'.join(obj.attrs))
-            for func in obj.methods:
-                label = r'%s%s()\l' % (label, func.name)
-            label = '{%s}' % label
-        if is_exception(obj.node):
-            return dict(fontcolor='red', label=label, shape='record')
-        return dict(label=label, shape='record')
-
-    def close_graph(self):
-        """print the dot graph into <file_name>"""
-        self.printer.generate(self.file_name)
-
-
-class VCGWriter(DiagramWriter):
-    """write vcg graphs from a diagram definition and a project
-    """
-    def __init__(self, config):
-        styles = [dict(arrowstyle='solid', backarrowstyle='none',
-                       backarrowsize=0),
-                  dict(arrowstyle='solid', backarrowstyle='none',
-                       backarrowsize=10),
-                  dict(arrowstyle='solid', backarrowstyle='none',
-                       linestyle='dotted', backarrowsize=10),
-                  dict(arrowstyle='solid', backarrowstyle='none',
-                       textcolor='green'),
-                 ]
-        DiagramWriter.__init__(self, config, styles)
-
-    def set_printer(self, file_name, basename):
-        """initialize VCGWriter for a UML graph"""
-        self.graph_file = open(file_name, 'w+')
-        self.printer = VCGPrinter(self.graph_file)
-        self.printer.open_graph(title=basename, layoutalgorithm='dfs',
-                                late_edge_labels='yes', port_sharing='no',
-                                manhattan_edges='yes')
-        self.printer.emit_node = self.printer.node
-        self.printer.emit_edge = self.printer.edge
-
-    def get_title(self, obj):
-        """get project title in vcg format"""
-        return r'\fb%s\fn' % obj.title
-
-    def get_values(self, obj):
-        """get label and shape for classes.
-
-        The label contains all attributes and methods
-        """
-        if is_exception(obj.node):
-            label = r'\fb\f09%s\fn' % obj.title
-        else:
-            label = r'\fb%s\fn' % obj.title
-        if obj.shape == 'interface':
-            shape = 'ellipse'
-        else:
-            shape = 'box'
-        if not self.config.only_classnames:
-            attrs = obj.attrs
-            methods = [func.name for func in obj.methods]
-            # box width for UML like diagram
-            maxlen = max(len(name) for name in [obj.title] + methods + attrs)
-            line = '_' * (maxlen + 2)
-            label = r'%s\n\f%s' % (label, line)
-            for attr in attrs:
-                label = r'%s\n\f08%s' % (label, attr)
-            if attrs:
-                label = r'%s\n\f%s' % (label, line)
-            for func in methods:
-                label = r'%s\n\f10%s()' % (label, func)
-        return dict(label=label, shape=shape)
-
-    def close_graph(self):
-        """close graph and file"""
-        self.printer.close_graph()
-        self.graph_file.close()
-