divmod-dev team mailing list archive
-
divmod-dev team
-
Mailing list archive
-
Message #00363
[Merge] lp:~divmod-dev/divmod.org/1095248-remove-pyflakes into lp:divmod.org
Florent has proposed merging lp:~divmod-dev/divmod.org/1095248-remove-pyflakes into lp:divmod.org.
Requested reviews:
Divmod-dev (divmod-dev)
Related bugs:
Bug #1095248 in Divmod: "move Pyflakes to its own repository"
https://bugs.launchpad.net/divmod.org/+bug/1095248
For more details, see:
https://code.launchpad.net/~divmod-dev/divmod.org/1095248-remove-pyflakes/+merge/141590
Move Pyflakes out of the divmod.org's repository
--
https://code.launchpad.net/~divmod-dev/divmod.org/1095248-remove-pyflakes/+merge/141590
Your team Divmod-dev is requested to review the proposed merge of lp:~divmod-dev/divmod.org/1095248-remove-pyflakes into lp:divmod.org.
=== modified file 'Divmod.pth'
--- Divmod.pth 2008-10-01 18:28:58 +0000
+++ Divmod.pth 2013-01-02 10:12:49 +0000
@@ -1,10 +1,9 @@
-# -*- test-case-name: axiom,combinator,epsilon,xmantissa,nevow,formless,pyflakes,xquotient,reverend,sine,vertex,hyperbola,imaginary,examplegame -*-
+# -*- test-case-name: axiom,combinator,epsilon,xmantissa,nevow,formless,xquotient,reverend,sine,vertex,hyperbola,imaginary,examplegame -*-
Axiom
Combinator
Epsilon
Mantissa
Nevow
-Pyflakes
Quotient
Reverend
Sine
=== removed directory 'Pyflakes'
=== removed file 'Pyflakes/LICENSE'
--- Pyflakes/LICENSE 2011-09-03 16:03:07 +0000
+++ Pyflakes/LICENSE 1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-Copyright 2005-2011 Divmod, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=== removed file 'Pyflakes/MANIFEST.in'
--- Pyflakes/MANIFEST.in 2011-09-03 16:06:14 +0000
+++ Pyflakes/MANIFEST.in 1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-include NEWS.txt
-include LICENSE
=== removed file 'Pyflakes/NEWS.txt'
--- Pyflakes/NEWS.txt 2011-09-03 16:03:28 +0000
+++ Pyflakes/NEWS.txt 1970-01-01 00:00:00 +0000
@@ -1,35 +0,0 @@
-0.5.0 (2011-09-02):
- - Convert pyflakes to use newer _ast infrastructure rather than compiler.
- - Support for new syntax in 2.7 (including set literals, set comprehensions,
- and dictionary comprehensions).
- - Make sure class names don't get bound until after class definition.
-
-0.4.0 (2009-11-25):
- - Fix reporting for certain SyntaxErrors which lack line number
- information.
- - Check for syntax errors more rigorously.
- - Support checking names used with the class decorator syntax in versions
- of Python which have it.
- - Detect local variables which are bound but never used.
- - Handle permission errors when trying to read source files.
- - Handle problems with the encoding of source files.
- - Support importing dotted names so as not to incorrectly report them as
- redefined unused names.
- - Support all forms of the with statement.
- - Consider static `__all__` definitions and avoid reporting unused names
- if the names are listed there.
- - Fix incorrect checking of class names with respect to the names of their
- bases in the class statement.
- - Support the `__path__` global in `__init__.py`.
-
-0.3.0 (2009-01-30):
- - Display more informative SyntaxError messages.
- - Don't hang flymake with unmatched triple quotes (only report a single
- line of source for a multiline syntax error).
- - Recognize __builtins__ as a defined name.
- - Improve pyflakes support for python versions 2.3-2.5
- - Support for if-else expressions and with statements.
- - Warn instead of error on non-existant file paths.
- - Check for __future__ imports after other statements.
- - Add reporting for some types of import shadowing.
- - Improve reporting of unbound locals
=== removed directory 'Pyflakes/bin'
=== removed file 'Pyflakes/bin/pyflakes'
--- Pyflakes/bin/pyflakes 2012-07-08 13:48:46 +0000
+++ Pyflakes/bin/pyflakes 1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-#!/usr/bin/python
-from pyflakes.scripts.pyflakes import main
-main()
=== removed directory 'Pyflakes/pyflakes'
=== removed file 'Pyflakes/pyflakes/__init__.py'
--- Pyflakes/pyflakes/__init__.py 2011-09-03 16:06:14 +0000
+++ Pyflakes/pyflakes/__init__.py 1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-
-__version__ = '0.5.0'
=== removed file 'Pyflakes/pyflakes/checker.py'
--- Pyflakes/pyflakes/checker.py 2012-01-10 19:09:22 +0000
+++ Pyflakes/pyflakes/checker.py 1970-01-01 00:00:00 +0000
@@ -1,634 +0,0 @@
-# -*- test-case-name: pyflakes -*-
-# (c) 2005-2010 Divmod, Inc.
-# See LICENSE file for details
-
-import __builtin__
-import os.path
-import _ast
-
-from pyflakes import messages
-
-
-# utility function to iterate over an AST node's children, adapted
-# from Python 2.6's standard ast module
-try:
- import ast
- iter_child_nodes = ast.iter_child_nodes
-except (ImportError, AttributeError):
- def iter_child_nodes(node, astcls=_ast.AST):
- """
- Yield all direct child nodes of *node*, that is, all fields that are nodes
- and all items of fields that are lists of nodes.
- """
- for name in node._fields:
- field = getattr(node, name, None)
- if isinstance(field, astcls):
- yield field
- elif isinstance(field, list):
- for item in field:
- yield item
-
-
-class Binding(object):
- """
- Represents the binding of a value to a name.
-
- The checker uses this to keep track of which names have been bound and
- which names have not. See L{Assignment} for a special type of binding that
- is checked with stricter rules.
-
- @ivar used: pair of (L{Scope}, line-number) indicating the scope and
- line number that this binding was last used
- """
-
- def __init__(self, name, source):
- self.name = name
- self.source = source
- self.used = False
-
-
- def __str__(self):
- return self.name
-
-
- def __repr__(self):
- return '<%s object %r from line %r at 0x%x>' % (self.__class__.__name__,
- self.name,
- self.source.lineno,
- id(self))
-
-
-
-class UnBinding(Binding):
- '''Created by the 'del' operator.'''
-
-
-
-class Importation(Binding):
- """
- A binding created by an import statement.
-
- @ivar fullName: The complete name given to the import statement,
- possibly including multiple dotted components.
- @type fullName: C{str}
- """
- def __init__(self, name, source):
- self.fullName = name
- name = name.split('.')[0]
- super(Importation, self).__init__(name, source)
-
-
-
-class Argument(Binding):
- """
- Represents binding a name as an argument.
- """
-
-
-class Definition(Binding):
- """
- A binding that defines a function or class.
- """
-
-
-class Assignment(Binding):
- """
- Represents binding a name with an explicit assignment.
-
- The checker will raise warnings for any Assignment that isn't used. Also,
- the checker does not consider assignments in tuple/list unpacking to be
- Assignments, rather it treats them as simple Bindings.
- """
-
-
-
-class FunctionDefinition(Definition):
- pass
-
-
-
-class ClassDefinition(Definition):
- pass
-
-
-
-class ExportBinding(Binding):
- """
- A binding created by an C{__all__} assignment. If the names in the list
- can be determined statically, they will be treated as names for export and
- additional checking applied to them.
-
- The only C{__all__} assignment that can be recognized is one which takes
- the value of a literal list containing literal strings. For example::
-
- __all__ = ["foo", "bar"]
-
- Names which are imported and not otherwise used but appear in the value of
- C{__all__} will not have an unused import warning reported for them.
- """
- def names(self):
- """
- Return a list of the names referenced by this binding.
- """
- names = []
- if isinstance(self.source, _ast.List):
- for node in self.source.elts:
- if isinstance(node, _ast.Str):
- names.append(node.s)
- return names
-
-
-
-class Scope(dict):
- importStarred = False # set to True when import * is found
-
-
- def __repr__(self):
- return '<%s at 0x%x %s>' % (self.__class__.__name__, id(self), dict.__repr__(self))
-
-
- def __init__(self):
- super(Scope, self).__init__()
-
-
-
-class ClassScope(Scope):
- pass
-
-
-
-class FunctionScope(Scope):
- """
- I represent a name scope for a function.
-
- @ivar globals: Names declared 'global' in this function.
- """
- def __init__(self):
- super(FunctionScope, self).__init__()
- self.globals = {}
-
-
-
-class ModuleScope(Scope):
- pass
-
-
-# Globally defined names which are not attributes of the __builtin__ module, or
-# are only present on some platforms.
-_MAGIC_GLOBALS = ['__file__', '__builtins__', 'WindowsError']
-
-
-
-class Checker(object):
- """
- I check the cleanliness and sanity of Python code.
-
- @ivar _deferredFunctions: Tracking list used by L{deferFunction}. Elements
- of the list are two-tuples. The first element is the callable passed
- to L{deferFunction}. The second element is a copy of the scope stack
- at the time L{deferFunction} was called.
-
- @ivar _deferredAssignments: Similar to C{_deferredFunctions}, but for
- callables which are deferred assignment checks.
- """
-
- nodeDepth = 0
- traceTree = False
-
- def __init__(self, tree, filename='(none)'):
- self._deferredFunctions = []
- self._deferredAssignments = []
- self.dead_scopes = []
- self.messages = []
- self.filename = filename
- self.scopeStack = [ModuleScope()]
- self.futuresAllowed = True
- self.handleChildren(tree)
- self._runDeferred(self._deferredFunctions)
- # Set _deferredFunctions to None so that deferFunction will fail
- # noisily if called after we've run through the deferred functions.
- self._deferredFunctions = None
- self._runDeferred(self._deferredAssignments)
- # Set _deferredAssignments to None so that deferAssignment will fail
- # noisly if called after we've run through the deferred assignments.
- self._deferredAssignments = None
- del self.scopeStack[1:]
- self.popScope()
- self.check_dead_scopes()
-
-
- def deferFunction(self, callable):
- '''
- Schedule a function handler to be called just before completion.
-
- This is used for handling function bodies, which must be deferred
- because code later in the file might modify the global scope. When
- `callable` is called, the scope at the time this is called will be
- restored, however it will contain any new bindings added to it.
- '''
- self._deferredFunctions.append((callable, self.scopeStack[:]))
-
-
- def deferAssignment(self, callable):
- """
- Schedule an assignment handler to be called just after deferred
- function handlers.
- """
- self._deferredAssignments.append((callable, self.scopeStack[:]))
-
-
- def _runDeferred(self, deferred):
- """
- Run the callables in C{deferred} using their associated scope stack.
- """
- for handler, scope in deferred:
- self.scopeStack = scope
- handler()
-
-
- def scope(self):
- return self.scopeStack[-1]
- scope = property(scope)
-
- def popScope(self):
- self.dead_scopes.append(self.scopeStack.pop())
-
-
- def check_dead_scopes(self):
- """
- Look at scopes which have been fully examined and report names in them
- which were imported but unused.
- """
- for scope in self.dead_scopes:
- export = isinstance(scope.get('__all__'), ExportBinding)
- if export:
- all = scope['__all__'].names()
- if os.path.split(self.filename)[1] != '__init__.py':
- # Look for possible mistakes in the export list
- undefined = set(all) - set(scope)
- for name in undefined:
- self.report(
- messages.UndefinedExport,
- scope['__all__'].source.lineno,
- name)
- else:
- all = []
-
- # Look for imported names that aren't used.
- for importation in scope.itervalues():
- if isinstance(importation, Importation):
- if not importation.used and importation.name not in all:
- self.report(
- messages.UnusedImport,
- importation.source.lineno,
- importation.name)
-
-
- def pushFunctionScope(self):
- self.scopeStack.append(FunctionScope())
-
- def pushClassScope(self):
- self.scopeStack.append(ClassScope())
-
- def report(self, messageClass, *args, **kwargs):
- self.messages.append(messageClass(self.filename, *args, **kwargs))
-
- def handleChildren(self, tree):
- for node in iter_child_nodes(tree):
- self.handleNode(node, tree)
-
- def isDocstring(self, node):
- """
- Determine if the given node is a docstring, as long as it is at the
- correct place in the node tree.
- """
- return isinstance(node, _ast.Str) or \
- (isinstance(node, _ast.Expr) and
- isinstance(node.value, _ast.Str))
-
- def handleNode(self, node, parent):
- node.parent = parent
- if self.traceTree:
- print ' ' * self.nodeDepth + node.__class__.__name__
- self.nodeDepth += 1
- if self.futuresAllowed and not \
- (isinstance(node, _ast.ImportFrom) or self.isDocstring(node)):
- self.futuresAllowed = False
- nodeType = node.__class__.__name__.upper()
- try:
- handler = getattr(self, nodeType)
- handler(node)
- finally:
- self.nodeDepth -= 1
- if self.traceTree:
- print ' ' * self.nodeDepth + 'end ' + node.__class__.__name__
-
- def ignore(self, node):
- pass
-
- # "stmt" type nodes
- RETURN = DELETE = PRINT = WHILE = IF = WITH = RAISE = TRYEXCEPT = \
- TRYFINALLY = ASSERT = EXEC = EXPR = handleChildren
-
- CONTINUE = BREAK = PASS = ignore
-
- # "expr" type nodes
- BOOLOP = BINOP = UNARYOP = IFEXP = DICT = SET = YIELD = COMPARE = \
- CALL = REPR = ATTRIBUTE = SUBSCRIPT = LIST = TUPLE = handleChildren
-
- NUM = STR = ELLIPSIS = ignore
-
- # "slice" type nodes
- SLICE = EXTSLICE = INDEX = handleChildren
-
- # expression contexts are node instances too, though being constants
- LOAD = STORE = DEL = AUGLOAD = AUGSTORE = PARAM = ignore
-
- # same for operators
- AND = OR = ADD = SUB = MULT = DIV = MOD = POW = LSHIFT = RSHIFT = \
- BITOR = BITXOR = BITAND = FLOORDIV = INVERT = NOT = UADD = USUB = \
- EQ = NOTEQ = LT = LTE = GT = GTE = IS = ISNOT = IN = NOTIN = ignore
-
- # additional node types
- COMPREHENSION = EXCEPTHANDLER = KEYWORD = handleChildren
-
- def addBinding(self, lineno, value, reportRedef=True):
- '''Called when a binding is altered.
-
- - `lineno` is the line of the statement responsible for the change
- - `value` is the optional new value, a Binding instance, associated
- with the binding; if None, the binding is deleted if it exists.
- - if `reportRedef` is True (default), rebinding while unused will be
- reported.
- '''
- if not isinstance(self.scope, ClassScope):
- for scope in self.scopeStack[::-1]:
- existing = scope.get(value.name)
- if (isinstance(existing, Importation)
- and not existing.used
- and (not isinstance(value, Importation) or value.fullName == existing.fullName)
- and reportRedef):
-
- self.report(messages.RedefinedWhileUnused,
- lineno, value.name, scope[value.name].source.lineno)
-
- existing = self.scope.get(value.name)
- if isinstance(value, UnBinding):
- try:
- del self.scope[value.name]
- except KeyError:
- self.report(messages.UndefinedName, lineno, value.name)
- elif isinstance(existing, Definition) and not existing.used:
- self.report(messages.RedefinedWhileUnused,
- lineno, value.name, existing.source.lineno)
- else:
- self.scope[value.name] = value
-
- def GLOBAL(self, node):
- """
- Keep track of globals declarations.
- """
- if isinstance(self.scope, FunctionScope):
- self.scope.globals.update(dict.fromkeys(node.names))
-
- def LISTCOMP(self, node):
- # handle generators before element
- for gen in node.generators:
- self.handleNode(gen, node)
- self.handleNode(node.elt, node)
-
- GENERATOREXP = SETCOMP = LISTCOMP
-
- # dictionary comprehensions; introduced in Python 2.7
- def DICTCOMP(self, node):
- for gen in node.generators:
- self.handleNode(gen, node)
- self.handleNode(node.key, node)
- self.handleNode(node.value, node)
-
- def FOR(self, node):
- """
- Process bindings for loop variables.
- """
- vars = []
- def collectLoopVars(n):
- if isinstance(n, _ast.Name):
- vars.append(n.id)
- elif isinstance(n, _ast.expr_context):
- return
- else:
- for c in iter_child_nodes(n):
- collectLoopVars(c)
-
- collectLoopVars(node.target)
- for varn in vars:
- if (isinstance(self.scope.get(varn), Importation)
- # unused ones will get an unused import warning
- and self.scope[varn].used):
- self.report(messages.ImportShadowedByLoopVar,
- node.lineno, varn, self.scope[varn].source.lineno)
-
- self.handleChildren(node)
-
- def NAME(self, node):
- """
- Handle occurrence of Name (which can be a load/store/delete access.)
- """
- # Locate the name in locals / function / globals scopes.
- if isinstance(node.ctx, (_ast.Load, _ast.AugLoad)):
- # try local scope
- importStarred = self.scope.importStarred
- try:
- self.scope[node.id].used = (self.scope, node.lineno)
- except KeyError:
- pass
- else:
- return
-
- # try enclosing function scopes
-
- for scope in self.scopeStack[-2:0:-1]:
- importStarred = importStarred or scope.importStarred
- if not isinstance(scope, FunctionScope):
- continue
- try:
- scope[node.id].used = (self.scope, node.lineno)
- except KeyError:
- pass
- else:
- return
-
- # try global scope
-
- importStarred = importStarred or self.scopeStack[0].importStarred
- try:
- self.scopeStack[0][node.id].used = (self.scope, node.lineno)
- except KeyError:
- if ((not hasattr(__builtin__, node.id))
- and node.id not in _MAGIC_GLOBALS
- and not importStarred):
- if (os.path.basename(self.filename) == '__init__.py' and
- node.id == '__path__'):
- # the special name __path__ is valid only in packages
- pass
- else:
- self.report(messages.UndefinedName, node.lineno, node.id)
- elif isinstance(node.ctx, (_ast.Store, _ast.AugStore)):
- # if the name hasn't already been defined in the current scope
- if isinstance(self.scope, FunctionScope) and node.id not in self.scope:
- # for each function or module scope above us
- for scope in self.scopeStack[:-1]:
- if not isinstance(scope, (FunctionScope, ModuleScope)):
- continue
- # if the name was defined in that scope, and the name has
- # been accessed already in the current scope, and hasn't
- # been declared global
- if (node.id in scope
- and scope[node.id].used
- and scope[node.id].used[0] is self.scope
- and node.id not in self.scope.globals):
- # then it's probably a mistake
- self.report(messages.UndefinedLocal,
- scope[node.id].used[1],
- node.id,
- scope[node.id].source.lineno)
- break
-
- if isinstance(node.parent,
- (_ast.For, _ast.comprehension, _ast.Tuple, _ast.List)):
- binding = Binding(node.id, node)
- elif (node.id == '__all__' and
- isinstance(self.scope, ModuleScope)):
- binding = ExportBinding(node.id, node.parent.value)
- else:
- binding = Assignment(node.id, node)
- if node.id in self.scope:
- binding.used = self.scope[node.id].used
- self.addBinding(node.lineno, binding)
- elif isinstance(node.ctx, _ast.Del):
- if isinstance(self.scope, FunctionScope) and \
- node.id in self.scope.globals:
- del self.scope.globals[node.id]
- else:
- self.addBinding(node.lineno, UnBinding(node.id, node))
- else:
- # must be a Param context -- this only happens for names in function
- # arguments, but these aren't dispatched through here
- raise RuntimeError(
- "Got impossible expression context: %r" % (node.ctx,))
-
-
- def FUNCTIONDEF(self, node):
- # the decorators attribute is called decorator_list as of Python 2.6
- if hasattr(node, 'decorators'):
- for deco in node.decorators:
- self.handleNode(deco, node)
- else:
- for deco in node.decorator_list:
- self.handleNode(deco, node)
- self.addBinding(node.lineno, FunctionDefinition(node.name, node))
- self.LAMBDA(node)
-
- def LAMBDA(self, node):
- for default in node.args.defaults:
- self.handleNode(default, node)
-
- def runFunction():
- args = []
-
- def addArgs(arglist):
- for arg in arglist:
- if isinstance(arg, _ast.Tuple):
- addArgs(arg.elts)
- else:
- if arg.id in args:
- self.report(messages.DuplicateArgument,
- node.lineno, arg.id)
- args.append(arg.id)
-
- self.pushFunctionScope()
- addArgs(node.args.args)
- # vararg/kwarg identifiers are not Name nodes
- if node.args.vararg:
- args.append(node.args.vararg)
- if node.args.kwarg:
- args.append(node.args.kwarg)
- for name in args:
- self.addBinding(node.lineno, Argument(name, node), reportRedef=False)
- if isinstance(node.body, list):
- # case for FunctionDefs
- for stmt in node.body:
- self.handleNode(stmt, node)
- else:
- # case for Lambdas
- self.handleNode(node.body, node)
- def checkUnusedAssignments():
- """
- Check to see if any assignments have not been used.
- """
- for name, binding in self.scope.iteritems():
- if (not binding.used and not name in self.scope.globals
- and isinstance(binding, Assignment)):
- self.report(messages.UnusedVariable,
- binding.source.lineno, name)
- self.deferAssignment(checkUnusedAssignments)
- self.popScope()
-
- self.deferFunction(runFunction)
-
-
- def CLASSDEF(self, node):
- """
- Check names used in a class definition, including its decorators, base
- classes, and the body of its definition. Additionally, add its name to
- the current scope.
- """
- # decorator_list is present as of Python 2.6
- for deco in getattr(node, 'decorator_list', []):
- self.handleNode(deco, node)
- for baseNode in node.bases:
- self.handleNode(baseNode, node)
- self.pushClassScope()
- for stmt in node.body:
- self.handleNode(stmt, node)
- self.popScope()
- self.addBinding(node.lineno, ClassDefinition(node.name, node))
-
- def ASSIGN(self, node):
- self.handleNode(node.value, node)
- for target in node.targets:
- self.handleNode(target, node)
-
- def AUGASSIGN(self, node):
- # AugAssign is awkward: must set the context explicitly and visit twice,
- # once with AugLoad context, once with AugStore context
- node.target.ctx = _ast.AugLoad()
- self.handleNode(node.target, node)
- self.handleNode(node.value, node)
- node.target.ctx = _ast.AugStore()
- self.handleNode(node.target, node)
-
- def IMPORT(self, node):
- for alias in node.names:
- name = alias.asname or alias.name
- importation = Importation(name, node)
- self.addBinding(node.lineno, importation)
-
- def IMPORTFROM(self, node):
- if node.module == '__future__':
- if not self.futuresAllowed:
- self.report(messages.LateFutureImport, node.lineno,
- [n.name for n in node.names])
- else:
- self.futuresAllowed = False
-
- for alias in node.names:
- if alias.name == '*':
- self.scope.importStarred = True
- self.report(messages.ImportStarUsed, node.lineno, node.module)
- continue
- name = alias.asname or alias.name
- importation = Importation(name, node)
- if node.module == '__future__':
- importation.used = (self.scope, node.lineno)
- self.addBinding(node.lineno, importation)
=== removed file 'Pyflakes/pyflakes/messages.py'
--- Pyflakes/pyflakes/messages.py 2011-10-31 15:19:35 +0000
+++ Pyflakes/pyflakes/messages.py 1970-01-01 00:00:00 +0000
@@ -1,94 +0,0 @@
-# (c) 2005 Divmod, Inc. See LICENSE file for details
-
-class Message(object):
- message = ''
- message_args = ()
- def __init__(self, filename, lineno):
- self.filename = filename
- self.lineno = lineno
- def __str__(self):
- return '%s:%s: %s' % (self.filename, self.lineno, self.message % self.message_args)
-
-
-class UnusedImport(Message):
- message = '%r imported but unused'
- def __init__(self, filename, lineno, name):
- Message.__init__(self, filename, lineno)
- self.message_args = (name,)
-
-
-class RedefinedWhileUnused(Message):
- message = 'redefinition of unused %r from line %r'
- def __init__(self, filename, lineno, name, orig_lineno):
- Message.__init__(self, filename, lineno)
- self.message_args = (name, orig_lineno)
-
-
-class ImportShadowedByLoopVar(Message):
- message = 'import %r from line %r shadowed by loop variable'
- def __init__(self, filename, lineno, name, orig_lineno):
- Message.__init__(self, filename, lineno)
- self.message_args = (name, orig_lineno)
-
-
-class ImportStarUsed(Message):
- message = "'from %s import *' used; unable to detect undefined names"
- def __init__(self, filename, lineno, modname):
- Message.__init__(self, filename, lineno)
- self.message_args = (modname,)
-
-
-class UndefinedName(Message):
- message = 'undefined name %r'
- def __init__(self, filename, lineno, name):
- Message.__init__(self, filename, lineno)
- self.message_args = (name,)
-
-
-
-class UndefinedExport(Message):
- message = 'undefined name %r in __all__'
- def __init__(self, filename, lineno, name):
- Message.__init__(self, filename, lineno)
- self.message_args = (name,)
-
-
-
-class UndefinedLocal(Message):
- message = "local variable %r (defined in enclosing scope on line %r) referenced before assignment"
- def __init__(self, filename, lineno, name, orig_lineno):
- Message.__init__(self, filename, lineno)
- self.message_args = (name, orig_lineno)
-
-
-class DuplicateArgument(Message):
- message = 'duplicate argument %r in function definition'
- def __init__(self, filename, lineno, name):
- Message.__init__(self, filename, lineno)
- self.message_args = (name,)
-
-
-class Redefined(Message):
- message = 'redefinition of %r from line %r'
- def __init__(self, filename, lineno, name, orig_lineno):
- Message.__init__(self, filename, lineno)
- self.message_args = (name, orig_lineno)
-
-
-class LateFutureImport(Message):
- message = 'future import(s) %r after other statements'
- def __init__(self, filename, lineno, names):
- Message.__init__(self, filename, lineno)
- self.message_args = (names,)
-
-
-class UnusedVariable(Message):
- """
- Indicates that a variable has been explicity assigned to but not actually
- used.
- """
-
- message = 'local variable %r is assigned to but never used'
- def __init__(self, filename, lineno, names):
- Message.__init__(self, filename, lineno)
- self.message_args = (names,)
=== removed file 'Pyflakes/pyflakes/reporter.py'
--- Pyflakes/pyflakes/reporter.py 2012-10-23 13:07:35 +0000
+++ Pyflakes/pyflakes/reporter.py 1970-01-01 00:00:00 +0000
@@ -1,79 +0,0 @@
-# (c) 2005-2012 Divmod, Inc.
-# See LICENSE file for details
-
-import sys
-
-
-class Reporter(object):
- """
- Formats the results of pyflakes checks to users.
- """
-
- def __init__(self, warningStream, errorStream):
- """
- Construct a L{Reporter}.
-
- @param warningStream: A file-like object where warnings will be
- written to. The stream's C{write} method must accept unicode.
- C{sys.stdout} is a good value.
- @param errorStream: A file-like object where error output will be
- written to. The stream's C{write} method must accept unicode.
- C{sys.stderr} is a good value.
- """
- self._stdout = warningStream
- self._stderr = errorStream
-
-
- def unexpectedError(self, filename, msg):
- """
- An unexpected error occurred trying to process C{filename}.
-
- @param filename: The path to a file that we could not process.
- @ptype filename: C{unicode}
- @param msg: A message explaining the problem.
- @ptype msg: C{unicode}
- """
- self._stderr.write(u"%s: %s\n" % (filename, msg))
-
-
- def syntaxError(self, filename, msg, lineno, offset, text):
- """
- There was a syntax errror in C{filename}.
-
- @param filename: The path to the file with the syntax error.
- @ptype filename: C{unicode}
- @param msg: An explanation of the syntax error.
- @ptype msg: C{unicode}
- @param lineno: The line number where the syntax error occurred.
- @ptype lineno: C{int}
- @param offset: The column on which the syntax error occurred.
- @ptype offset: C{int}
- @param text: The source code containing the syntax error.
- @ptype text: C{unicode}
- """
- line = text.splitlines()[-1]
- if offset is not None:
- offset = offset - (len(text) - len(line))
- self._stderr.write(u'%s:%d: %s\n' % (filename, lineno, msg))
- self._stderr.write(line)
- self._stderr.write(u'\n')
- if offset is not None:
- self._stderr.write(u" " * (offset + 1) + u"^\n")
-
-
- def flake(self, message):
- """
- pyflakes found something wrong with the code.
-
- @param: A L{pyflakes.messages.Message}.
- """
- self._stdout.write(unicode(message))
- self._stdout.write(u'\n')
-
-
-
-def _makeDefaultReporter():
- """
- Make a reporter that can be used when no reporter is specified.
- """
- return Reporter(sys.stdout, sys.stderr)
=== removed directory 'Pyflakes/pyflakes/scripts'
=== removed file 'Pyflakes/pyflakes/scripts/__init__.py'
=== removed file 'Pyflakes/pyflakes/scripts/pyflakes.py'
--- Pyflakes/pyflakes/scripts/pyflakes.py 2012-10-23 11:48:54 +0000
+++ Pyflakes/pyflakes/scripts/pyflakes.py 1970-01-01 00:00:00 +0000
@@ -1,122 +0,0 @@
-"""
-Implementation of the command-line I{pyflakes} tool.
-"""
-
-from __future__ import absolute_import
-
-import sys
-import os
-import _ast
-
-from pyflakes import checker
-from pyflakes import reporter as modReporter
-
-
-def check(codeString, filename, reporter=None):
- """
- Check the Python source given by C{codeString} for flakes.
-
- @param codeString: The Python source to check.
- @type codeString: C{str}
-
- @param filename: The name of the file the source came from, used to report
- errors.
- @type filename: C{str}
-
- @param reporter: A L{Reporter} instance, where errors and warnings will be
- reported.
-
- @return: The number of warnings emitted.
- @rtype: C{int}
- """
- if reporter is None:
- reporter = modReporter._makeDefaultReporter()
- # First, compile into an AST and handle syntax errors.
- try:
- tree = compile(codeString, filename, "exec", _ast.PyCF_ONLY_AST)
- except SyntaxError, value:
- msg = value.args[0]
-
- (lineno, offset, text) = value.lineno, value.offset, value.text
-
- # If there's an encoding problem with the file, the text is None.
- if text is None:
- # Avoid using msg, since for the only known case, it contains a
- # bogus message that claims the encoding the file declared was
- # unknown.
- reporter.unexpectedError(filename, u'problem decoding source')
- else:
- reporter.syntaxError(filename, msg, lineno, offset, text)
- return 1
- else:
- # Okay, it's syntactically valid. Now check it.
- w = checker.Checker(tree, filename)
- w.messages.sort(lambda a, b: cmp(a.lineno, b.lineno))
- for warning in w.messages:
- reporter.flake(warning)
- return len(w.messages)
-
-
-def checkPath(filename, reporter=None):
- """
- Check the given path, printing out any warnings detected.
-
- @param reporter: A L{Reporter} instance, where errors and warnings will be
- reported.
-
- @return: the number of warnings printed
- """
- if reporter is None:
- reporter = modReporter._makeDefaultReporter()
- try:
- return check(file(filename, 'U').read() + '\n', filename, reporter)
- except IOError, msg:
- reporter.unexpectedError(filename, msg.args[1])
- return 1
-
-
-
-def iterSourceCode(paths):
- """
- Iterate over all Python source files in C{paths}.
-
- @param paths: A list of paths. Directories will be recursed into and
- any .py files found will be yielded. Any non-directories will be
- yielded as-is.
- """
- for path in paths:
- if os.path.isdir(path):
- for dirpath, dirnames, filenames in os.walk(path):
- for filename in filenames:
- if filename.endswith('.py'):
- yield os.path.join(dirpath, filename)
- else:
- yield path
-
-
-
-def checkRecursive(paths, reporter):
- """
- Recursively check all source files in C{paths}.
-
- @param paths: A list of paths to Python source files and directories
- containing Python source files.
- @param reporter: A L{Reporter} where all of the warnings and errors
- will be reported to.
- @return: The number of warnings found.
- """
- warnings = 0
- for sourcePath in iterSourceCode(paths):
- warnings += checkPath(sourcePath, reporter)
- return warnings
-
-
-
-def main():
- args = sys.argv[1:]
- reporter = modReporter._makeDefaultReporter()
- if args:
- warnings = checkRecursive(args, reporter)
- else:
- warnings = check(sys.stdin.read(), '<stdin>', reporter)
- raise SystemExit(warnings > 0)
=== removed directory 'Pyflakes/pyflakes/test'
=== removed file 'Pyflakes/pyflakes/test/__init__.py'
=== removed file 'Pyflakes/pyflakes/test/harness.py'
--- Pyflakes/pyflakes/test/harness.py 2010-04-13 14:53:04 +0000
+++ Pyflakes/pyflakes/test/harness.py 1970-01-01 00:00:00 +0000
@@ -1,27 +0,0 @@
-
-import textwrap
-import _ast
-
-from twisted.trial import unittest
-
-from pyflakes import checker
-
-
-class Test(unittest.TestCase):
-
- def flakes(self, input, *expectedOutputs, **kw):
- ast = compile(textwrap.dedent(input), "<test>", "exec",
- _ast.PyCF_ONLY_AST)
- w = checker.Checker(ast, **kw)
- outputs = [type(o) for o in w.messages]
- expectedOutputs = list(expectedOutputs)
- outputs.sort()
- expectedOutputs.sort()
- self.assert_(outputs == expectedOutputs, '''\
-for input:
-%s
-expected outputs:
-%s
-but got:
-%s''' % (input, repr(expectedOutputs), '\n'.join([str(o) for o in w.messages])))
- return w
=== removed file 'Pyflakes/pyflakes/test/test_imports.py'
--- Pyflakes/pyflakes/test/test_imports.py 2011-10-31 15:19:35 +0000
+++ Pyflakes/pyflakes/test/test_imports.py 1970-01-01 00:00:00 +0000
@@ -1,670 +0,0 @@
-
-from sys import version_info
-
-from pyflakes import messages as m
-from pyflakes.test import harness
-
-class Test(harness.Test):
-
- def test_unusedImport(self):
- self.flakes('import fu, bar', m.UnusedImport, m.UnusedImport)
- self.flakes('from baz import fu, bar', m.UnusedImport, m.UnusedImport)
-
- def test_aliasedImport(self):
- self.flakes('import fu as FU, bar as FU', m.RedefinedWhileUnused, m.UnusedImport)
- self.flakes('from moo import fu as FU, bar as FU', m.RedefinedWhileUnused, m.UnusedImport)
-
- def test_usedImport(self):
- self.flakes('import fu; print fu')
- self.flakes('from baz import fu; print fu')
-
- def test_redefinedWhileUnused(self):
- self.flakes('import fu; fu = 3', m.RedefinedWhileUnused)
- self.flakes('import fu; del fu', m.RedefinedWhileUnused)
- self.flakes('import fu; fu, bar = 3', m.RedefinedWhileUnused)
- self.flakes('import fu; [fu, bar] = 3', m.RedefinedWhileUnused)
-
- def test_redefinedByFunction(self):
- self.flakes('''
- import fu
- def fu():
- pass
- ''', m.RedefinedWhileUnused)
-
- def test_redefinedInNestedFunction(self):
- """
- Test that shadowing a global name with a nested function definition
- generates a warning.
- """
- self.flakes('''
- import fu
- def bar():
- def baz():
- def fu():
- pass
- ''', m.RedefinedWhileUnused, m.UnusedImport)
-
- def test_redefinedByClass(self):
- self.flakes('''
- import fu
- class fu:
- pass
- ''', m.RedefinedWhileUnused)
-
-
- def test_redefinedBySubclass(self):
- """
- If an imported name is redefined by a class statement which also uses
- that name in the bases list, no warning is emitted.
- """
- self.flakes('''
- from fu import bar
- class bar(bar):
- pass
- ''')
-
-
- def test_redefinedInClass(self):
- """
- Test that shadowing a global with a class attribute does not produce a
- warning.
- """
- self.flakes('''
- import fu
- class bar:
- fu = 1
- print fu
- ''')
-
- def test_usedInFunction(self):
- self.flakes('''
- import fu
- def fun():
- print fu
- ''')
-
- def test_shadowedByParameter(self):
- self.flakes('''
- import fu
- def fun(fu):
- print fu
- ''', m.UnusedImport)
-
- self.flakes('''
- import fu
- def fun(fu):
- print fu
- print fu
- ''')
-
- def test_newAssignment(self):
- self.flakes('fu = None')
-
- def test_usedInGetattr(self):
- self.flakes('import fu; fu.bar.baz')
- self.flakes('import fu; "bar".fu.baz', m.UnusedImport)
-
- def test_usedInSlice(self):
- self.flakes('import fu; print fu.bar[1:]')
-
- def test_usedInIfBody(self):
- self.flakes('''
- import fu
- if True: print fu
- ''')
-
- def test_usedInIfConditional(self):
- self.flakes('''
- import fu
- if fu: pass
- ''')
-
- def test_usedInElifConditional(self):
- self.flakes('''
- import fu
- if False: pass
- elif fu: pass
- ''')
-
- def test_usedInElse(self):
- self.flakes('''
- import fu
- if False: pass
- else: print fu
- ''')
-
- def test_usedInCall(self):
- self.flakes('import fu; fu.bar()')
-
- def test_usedInClass(self):
- self.flakes('''
- import fu
- class bar:
- bar = fu
- ''')
-
- def test_usedInClassBase(self):
- self.flakes('''
- import fu
- class bar(object, fu.baz):
- pass
- ''')
-
- def test_notUsedInNestedScope(self):
- self.flakes('''
- import fu
- def bleh():
- pass
- print fu
- ''')
-
- def test_usedInFor(self):
- self.flakes('''
- import fu
- for bar in range(9):
- print fu
- ''')
-
- def test_usedInForElse(self):
- self.flakes('''
- import fu
- for bar in range(10):
- pass
- else:
- print fu
- ''')
-
- def test_redefinedByFor(self):
- self.flakes('''
- import fu
- for fu in range(2):
- pass
- ''', m.RedefinedWhileUnused)
-
- def test_shadowedByFor(self):
- """
- Test that shadowing a global name with a for loop variable generates a
- warning.
- """
- self.flakes('''
- import fu
- fu.bar()
- for fu in ():
- pass
- ''', m.ImportShadowedByLoopVar)
-
- def test_shadowedByForDeep(self):
- """
- Test that shadowing a global name with a for loop variable nested in a
- tuple unpack generates a warning.
- """
- self.flakes('''
- import fu
- fu.bar()
- for (x, y, z, (a, b, c, (fu,))) in ():
- pass
- ''', m.ImportShadowedByLoopVar)
-
- def test_usedInReturn(self):
- self.flakes('''
- import fu
- def fun():
- return fu
- ''')
-
- def test_usedInOperators(self):
- self.flakes('import fu; 3 + fu.bar')
- self.flakes('import fu; 3 % fu.bar')
- self.flakes('import fu; 3 - fu.bar')
- self.flakes('import fu; 3 * fu.bar')
- self.flakes('import fu; 3 ** fu.bar')
- self.flakes('import fu; 3 / fu.bar')
- self.flakes('import fu; 3 // fu.bar')
- self.flakes('import fu; -fu.bar')
- self.flakes('import fu; ~fu.bar')
- self.flakes('import fu; 1 == fu.bar')
- self.flakes('import fu; 1 | fu.bar')
- self.flakes('import fu; 1 & fu.bar')
- self.flakes('import fu; 1 ^ fu.bar')
- self.flakes('import fu; 1 >> fu.bar')
- self.flakes('import fu; 1 << fu.bar')
-
- def test_usedInAssert(self):
- self.flakes('import fu; assert fu.bar')
-
- def test_usedInSubscript(self):
- self.flakes('import fu; fu.bar[1]')
-
- def test_usedInLogic(self):
- self.flakes('import fu; fu and False')
- self.flakes('import fu; fu or False')
- self.flakes('import fu; not fu.bar')
-
- def test_usedInList(self):
- self.flakes('import fu; [fu]')
-
- def test_usedInTuple(self):
- self.flakes('import fu; (fu,)')
-
- def test_usedInTry(self):
- self.flakes('''
- import fu
- try: fu
- except: pass
- ''')
-
- def test_usedInExcept(self):
- self.flakes('''
- import fu
- try: fu
- except: pass
- ''')
-
- def test_redefinedByExcept(self):
- self.flakes('''
- import fu
- try: pass
- except Exception, fu: pass
- ''', m.RedefinedWhileUnused)
-
- def test_usedInRaise(self):
- self.flakes('''
- import fu
- raise fu.bar
- ''')
-
- def test_usedInYield(self):
- self.flakes('''
- import fu
- def gen():
- yield fu
- ''')
-
- def test_usedInDict(self):
- self.flakes('import fu; {fu:None}')
- self.flakes('import fu; {1:fu}')
-
- def test_usedInParameterDefault(self):
- self.flakes('''
- import fu
- def f(bar=fu):
- pass
- ''')
-
- def test_usedInAttributeAssign(self):
- self.flakes('import fu; fu.bar = 1')
-
- def test_usedInKeywordArg(self):
- self.flakes('import fu; fu.bar(stuff=fu)')
-
- def test_usedInAssignment(self):
- self.flakes('import fu; bar=fu')
- self.flakes('import fu; n=0; n+=fu')
-
- def test_usedInListComp(self):
- self.flakes('import fu; [fu for _ in range(1)]')
- self.flakes('import fu; [1 for _ in range(1) if fu]')
-
- def test_redefinedByListComp(self):
- self.flakes('import fu; [1 for fu in range(1)]', m.RedefinedWhileUnused)
-
-
- def test_usedInTryFinally(self):
- self.flakes('''
- import fu
- try: pass
- finally: fu
- ''')
-
- self.flakes('''
- import fu
- try: fu
- finally: pass
- ''')
-
- def test_usedInWhile(self):
- self.flakes('''
- import fu
- while 0:
- fu
- ''')
-
- self.flakes('''
- import fu
- while fu: pass
- ''')
-
- def test_usedInGlobal(self):
- self.flakes('''
- import fu
- def f(): global fu
- ''', m.UnusedImport)
-
- def test_usedInBackquote(self):
- self.flakes('import fu; `fu`')
-
- def test_usedInExec(self):
- self.flakes('import fu; exec "print 1" in fu.bar')
-
- def test_usedInLambda(self):
- self.flakes('import fu; lambda: fu')
-
- def test_shadowedByLambda(self):
- self.flakes('import fu; lambda fu: fu', m.UnusedImport)
-
- def test_usedInSliceObj(self):
- self.flakes('import fu; "meow"[::fu]')
-
- def test_unusedInNestedScope(self):
- self.flakes('''
- def bar():
- import fu
- fu
- ''', m.UnusedImport, m.UndefinedName)
-
- def test_methodsDontUseClassScope(self):
- self.flakes('''
- class bar:
- import fu
- def fun(self):
- fu
- ''', m.UnusedImport, m.UndefinedName)
-
- def test_nestedFunctionsNestScope(self):
- self.flakes('''
- def a():
- def b():
- fu
- import fu
- ''')
-
- def test_nestedClassAndFunctionScope(self):
- self.flakes('''
- def a():
- import fu
- class b:
- def c(self):
- print fu
- ''')
-
- def test_importStar(self):
- self.flakes('from fu import *', m.ImportStarUsed)
-
-
- def test_packageImport(self):
- """
- If a dotted name is imported and used, no warning is reported.
- """
- self.flakes('''
- import fu.bar
- fu.bar
- ''')
-
-
- def test_unusedPackageImport(self):
- """
- If a dotted name is imported and not used, an unused import warning is
- reported.
- """
- self.flakes('import fu.bar', m.UnusedImport)
-
-
- def test_duplicateSubmoduleImport(self):
- """
- If a submodule of a package is imported twice, an unused import warning
- and a redefined while unused warning are reported.
- """
- self.flakes('''
- import fu.bar, fu.bar
- fu.bar
- ''', m.RedefinedWhileUnused)
- self.flakes('''
- import fu.bar
- import fu.bar
- fu.bar
- ''', m.RedefinedWhileUnused)
-
-
- def test_differentSubmoduleImport(self):
- """
- If two different submodules of a package are imported, no duplicate
- import warning is reported for the package.
- """
- self.flakes('''
- import fu.bar, fu.baz
- fu.bar, fu.baz
- ''')
- self.flakes('''
- import fu.bar
- import fu.baz
- fu.bar, fu.baz
- ''')
-
- def test_assignRHSFirst(self):
- self.flakes('import fu; fu = fu')
- self.flakes('import fu; fu, bar = fu')
- self.flakes('import fu; [fu, bar] = fu')
- self.flakes('import fu; fu += fu')
-
- def test_tryingMultipleImports(self):
- self.flakes('''
- try:
- import fu
- except ImportError:
- import bar as fu
- ''')
- test_tryingMultipleImports.todo = ''
-
- def test_nonGlobalDoesNotRedefine(self):
- self.flakes('''
- import fu
- def a():
- fu = 3
- return fu
- fu
- ''')
-
- def test_functionsRunLater(self):
- self.flakes('''
- def a():
- fu
- import fu
- ''')
-
- def test_functionNamesAreBoundNow(self):
- self.flakes('''
- import fu
- def fu():
- fu
- fu
- ''', m.RedefinedWhileUnused)
-
- def test_importingForImportError(self):
- self.flakes('''
- try:
- import fu
- except ImportError:
- pass
- ''')
- test_importingForImportError.todo = ''
-
- def test_importedInClass(self):
- '''Imports in class scope can be used through self'''
- self.flakes('''
- class c:
- import i
- def __init__(self):
- self.i
- ''')
- test_importedInClass.todo = 'requires evaluating attribute access'
-
- def test_futureImport(self):
- '''__future__ is special'''
- self.flakes('from __future__ import division')
- self.flakes('''
- "docstring is allowed before future import"
- from __future__ import division
- ''')
-
- def test_futureImportFirst(self):
- """
- __future__ imports must come before anything else.
- """
- self.flakes('''
- x = 5
- from __future__ import division
- ''', m.LateFutureImport)
- self.flakes('''
- from foo import bar
- from __future__ import division
- bar
- ''', m.LateFutureImport)
-
-
-
-class TestSpecialAll(harness.Test):
- """
- Tests for suppression of unused import warnings by C{__all__}.
- """
- def test_ignoredInFunction(self):
- """
- An C{__all__} definition does not suppress unused import warnings in a
- function scope.
- """
- self.flakes('''
- def foo():
- import bar
- __all__ = ["bar"]
- ''', m.UnusedImport, m.UnusedVariable)
-
-
- def test_ignoredInClass(self):
- """
- An C{__all__} definition does not suppress unused import warnings in a
- class scope.
- """
- self.flakes('''
- class foo:
- import bar
- __all__ = ["bar"]
- ''', m.UnusedImport)
-
-
- def test_warningSuppressed(self):
- """
- If a name is imported and unused but is named in C{__all__}, no warning
- is reported.
- """
- self.flakes('''
- import foo
- __all__ = ["foo"]
- ''')
-
-
- def test_unrecognizable(self):
- """
- If C{__all__} is defined in a way that can't be recognized statically,
- it is ignored.
- """
- self.flakes('''
- import foo
- __all__ = ["f" + "oo"]
- ''', m.UnusedImport)
- self.flakes('''
- import foo
- __all__ = [] + ["foo"]
- ''', m.UnusedImport)
-
-
- def test_unboundExported(self):
- """
- If C{__all__} includes a name which is not bound, a warning is emitted.
- """
- self.flakes('''
- __all__ = ["foo"]
- ''', m.UndefinedExport)
-
- # Skip this in __init__.py though, since the rules there are a little
- # different.
- for filename in ["foo/__init__.py", "__init__.py"]:
- self.flakes('''
- __all__ = ["foo"]
- ''', filename=filename)
-
-
- def test_usedInGenExp(self):
- """
- Using a global in a generator expression results in no warnings.
- """
- self.flakes('import fu; (fu for _ in range(1))')
- self.flakes('import fu; (1 for _ in range(1) if fu)')
-
-
- def test_redefinedByGenExp(self):
- """
- Re-using a global name as the loop variable for a generator
- expression results in a redefinition warning.
- """
- self.flakes('import fu; (1 for fu in range(1))', m.RedefinedWhileUnused)
-
-
- def test_usedAsDecorator(self):
- """
- Using a global name in a decorator statement results in no warnings,
- but using an undefined name in a decorator statement results in an
- undefined name warning.
- """
- self.flakes('''
- from interior import decorate
- @decorate
- def f():
- return "hello"
- ''')
-
- self.flakes('''
- from interior import decorate
- @decorate('value')
- def f():
- return "hello"
- ''')
-
- self.flakes('''
- @decorate
- def f():
- return "hello"
- ''', m.UndefinedName)
-
-
-class Python26Tests(harness.Test):
- """
- Tests for checking of syntax which is valid in PYthon 2.6 and newer.
- """
- if version_info < (2, 6):
- skip = "Python 2.6 required for class decorator tests."
-
-
- def test_usedAsClassDecorator(self):
- """
- Using an imported name as a class decorator results in no warnings,
- but using an undefined name as a class decorator results in an
- undefined name warning.
- """
- self.flakes('''
- from interior import decorate
- @decorate
- class foo:
- pass
- ''')
-
- self.flakes('''
- from interior import decorate
- @decorate("foo")
- class bar:
- pass
- ''')
-
- self.flakes('''
- @decorate
- class foo:
- pass
- ''', m.UndefinedName)
=== removed file 'Pyflakes/pyflakes/test/test_other.py'
--- Pyflakes/pyflakes/test/test_other.py 2011-11-17 16:21:58 +0000
+++ Pyflakes/pyflakes/test/test_other.py 1970-01-01 00:00:00 +0000
@@ -1,654 +0,0 @@
-# (c) 2005-2010 Divmod, Inc.
-# See LICENSE file for details
-
-"""
-Tests for various Pyflakes behavior.
-"""
-
-from sys import version_info
-
-from pyflakes import messages as m
-from pyflakes.test import harness
-
-
-class Test(harness.Test):
-
- def test_duplicateArgs(self):
- self.flakes('def fu(bar, bar): pass', m.DuplicateArgument)
-
- def test_localReferencedBeforeAssignment(self):
- self.flakes('''
- a = 1
- def f():
- a; a=1
- f()
- ''', m.UndefinedName)
- test_localReferencedBeforeAssignment.todo = 'this requires finding all assignments in the function body first'
-
- def test_redefinedFunction(self):
- """
- Test that shadowing a function definition with another one raises a
- warning.
- """
- self.flakes('''
- def a(): pass
- def a(): pass
- ''', m.RedefinedWhileUnused)
-
- def test_redefinedClassFunction(self):
- """
- Test that shadowing a function definition in a class suite with another
- one raises a warning.
- """
- self.flakes('''
- class A:
- def a(): pass
- def a(): pass
- ''', m.RedefinedWhileUnused)
-
- def test_functionDecorator(self):
- """
- Test that shadowing a function definition with a decorated version of
- that function does not raise a warning.
- """
- self.flakes('''
- from somewhere import somedecorator
-
- def a(): pass
- a = somedecorator(a)
- ''')
-
- def test_classFunctionDecorator(self):
- """
- Test that shadowing a function definition in a class suite with a
- decorated version of that function does not raise a warning.
- """
- self.flakes('''
- class A:
- def a(): pass
- a = classmethod(a)
- ''')
-
- def test_unaryPlus(self):
- '''Don't die on unary +'''
- self.flakes('+1')
-
-
- def test_undefinedBaseClass(self):
- """
- If a name in the base list of a class definition is undefined, a
- warning is emitted.
- """
- self.flakes('''
- class foo(foo):
- pass
- ''', m.UndefinedName)
-
-
- def test_classNameUndefinedInClassBody(self):
- """
- If a class name is used in the body of that class's definition and
- the name is not already defined, a warning is emitted.
- """
- self.flakes('''
- class foo:
- foo
- ''', m.UndefinedName)
-
-
- def test_classNameDefinedPreviously(self):
- """
- If a class name is used in the body of that class's definition and
- the name was previously defined in some other way, no warning is
- emitted.
- """
- self.flakes('''
- foo = None
- class foo:
- foo
- ''')
-
-
- def test_classRedefinition(self):
- """
- If a class is defined twice in the same module, a warning is emitted.
- """
- self.flakes(
- '''
- class Foo:
- pass
- class Foo:
- pass
- ''', m.RedefinedWhileUnused)
-
-
- def test_functionRedefinedAsClass(self):
- """
- If a function is redefined as a class, a warning is emitted.
- """
- self.flakes(
- '''
- def Foo():
- pass
- class Foo:
- pass
- ''', m.RedefinedWhileUnused)
-
-
- def test_classRedefinedAsFunction(self):
- """
- If a class is redefined as a function, a warning is emitted.
- """
- self.flakes(
- '''
- class Foo:
- pass
- def Foo():
- pass
- ''', m.RedefinedWhileUnused)
-
-
- def test_doubleAssignment(self):
- """
- If a variable is re-assigned to without being used, no warning is
- emitted.
- """
- self.flakes(
- '''
- x = 10
- x = 20
- ''', m.RedefinedWhileUnused)
- test_doubleAssignment.todo = (
- "Too hard to make this warn but other cases stay silent")
-
-
- def test_doubleAssignmentConditionally(self):
- """
- If a variable is re-assigned within a conditional, no warning is
- emitted.
- """
- self.flakes(
- '''
- x = 10
- if True:
- x = 20
- ''')
-
-
- def test_doubleAssignmentWithUse(self):
- """
- If a variable is re-assigned to after being used, no warning is
- emitted.
- """
- self.flakes(
- '''
- x = 10
- y = x * 2
- x = 20
- ''')
-
-
- def test_comparison(self):
- """
- If a defined name is used on either side of any of the six comparison
- operators, no warning is emitted.
- """
- self.flakes('''
- x = 10
- y = 20
- x < y
- x <= y
- x == y
- x != y
- x >= y
- x > y
- ''')
-
-
- def test_identity(self):
- """
- If a defined name is used on either side of an identity test, no
- warning is emitted.
- """
- self.flakes('''
- x = 10
- y = 20
- x is y
- x is not y
- ''')
-
-
- def test_containment(self):
- """
- If a defined name is used on either side of a containment test, no
- warning is emitted.
- """
- self.flakes('''
- x = 10
- y = 20
- x in y
- x not in y
- ''')
-
-
- def test_loopControl(self):
- """
- break and continue statements are supported.
- """
- self.flakes('''
- for x in [1, 2]:
- break
- ''')
- self.flakes('''
- for x in [1, 2]:
- continue
- ''')
-
-
- def test_ellipsis(self):
- """
- Ellipsis in a slice is supported.
- """
- self.flakes('''
- [1, 2][...]
- ''')
-
-
- def test_extendedSlice(self):
- """
- Extended slices are supported.
- """
- self.flakes('''
- x = 3
- [1, 2][x,:]
- ''')
-
-
-
-class TestUnusedAssignment(harness.Test):
- """
- Tests for warning about unused assignments.
- """
-
- def test_unusedVariable(self):
- """
- Warn when a variable in a function is assigned a value that's never
- used.
- """
- self.flakes('''
- def a():
- b = 1
- ''', m.UnusedVariable)
-
-
- def test_assignToGlobal(self):
- """
- Assigning to a global and then not using that global is perfectly
- acceptable. Do not mistake it for an unused local variable.
- """
- self.flakes('''
- b = 0
- def a():
- global b
- b = 1
- ''')
-
-
- def test_assignToMember(self):
- """
- Assigning to a member of another object and then not using that member
- variable is perfectly acceptable. Do not mistake it for an unused
- local variable.
- """
- # XXX: Adding this test didn't generate a failure. Maybe not
- # necessary?
- self.flakes('''
- class b:
- pass
- def a():
- b.foo = 1
- ''')
-
-
- def test_assignInForLoop(self):
- """
- Don't warn when a variable in a for loop is assigned to but not used.
- """
- self.flakes('''
- def f():
- for i in range(10):
- pass
- ''')
-
-
- def test_assignInListComprehension(self):
- """
- Don't warn when a variable in a list comprehension is assigned to but
- not used.
- """
- self.flakes('''
- def f():
- [None for i in range(10)]
- ''')
-
-
- def test_generatorExpression(self):
- """
- Don't warn when a variable in a generator expression is assigned to but not used.
- """
- self.flakes('''
- def f():
- (None for i in range(10))
- ''')
-
-
- def test_assignmentInsideLoop(self):
- """
- Don't warn when a variable assignment occurs lexically after its use.
- """
- self.flakes('''
- def f():
- x = None
- for i in range(10):
- if i > 2:
- return x
- x = i * 2
- ''')
-
-
- def test_tupleUnpacking(self):
- """
- Don't warn when a variable included in tuple unpacking is unused. It's
- very common for variables in a tuple unpacking assignment to be unused
- in good Python code, so warning will only create false positives.
- """
- self.flakes('''
- def f():
- (x, y) = 1, 2
- ''')
-
-
- def test_listUnpacking(self):
- """
- Don't warn when a variable included in list unpacking is unused.
- """
- self.flakes('''
- def f():
- [x, y] = [1, 2]
- ''')
-
-
- def test_closedOver(self):
- """
- Don't warn when the assignment is used in an inner function.
- """
- self.flakes('''
- def barMaker():
- foo = 5
- def bar():
- return foo
- return bar
- ''')
-
-
- def test_doubleClosedOver(self):
- """
- Don't warn when the assignment is used in an inner function, even if
- that inner function itself is in an inner function.
- """
- self.flakes('''
- def barMaker():
- foo = 5
- def bar():
- def baz():
- return foo
- return bar
- ''')
-
-
-
-class Python25Test(harness.Test):
- """
- Tests for checking of syntax only available in Python 2.5 and newer.
- """
- if version_info < (2, 5):
- skip = "Python 2.5 required for if-else and with tests"
-
- def test_ifexp(self):
- """
- Test C{foo if bar else baz} statements.
- """
- self.flakes("a = 'moo' if True else 'oink'")
- self.flakes("a = foo if True else 'oink'", m.UndefinedName)
- self.flakes("a = 'moo' if True else bar", m.UndefinedName)
-
-
- def test_withStatementNoNames(self):
- """
- No warnings are emitted for using inside or after a nameless C{with}
- statement a name defined beforehand.
- """
- self.flakes('''
- from __future__ import with_statement
- bar = None
- with open("foo"):
- bar
- bar
- ''')
-
- def test_withStatementSingleName(self):
- """
- No warnings are emitted for using a name defined by a C{with} statement
- within the suite or afterwards.
- """
- self.flakes('''
- from __future__ import with_statement
- with open('foo') as bar:
- bar
- bar
- ''')
-
-
- def test_withStatementAttributeName(self):
- """
- No warnings are emitted for using an attribute as the target of a
- C{with} statement.
- """
- self.flakes('''
- from __future__ import with_statement
- import foo
- with open('foo') as foo.bar:
- pass
- ''')
-
-
- def test_withStatementSubscript(self):
- """
- No warnings are emitted for using a subscript as the target of a
- C{with} statement.
- """
- self.flakes('''
- from __future__ import with_statement
- import foo
- with open('foo') as foo[0]:
- pass
- ''')
-
-
- def test_withStatementSubscriptUndefined(self):
- """
- An undefined name warning is emitted if the subscript used as the
- target of a C{with} statement is not defined.
- """
- self.flakes('''
- from __future__ import with_statement
- import foo
- with open('foo') as foo[bar]:
- pass
- ''', m.UndefinedName)
-
-
- def test_withStatementTupleNames(self):
- """
- No warnings are emitted for using any of the tuple of names defined by
- a C{with} statement within the suite or afterwards.
- """
- self.flakes('''
- from __future__ import with_statement
- with open('foo') as (bar, baz):
- bar, baz
- bar, baz
- ''')
-
-
- def test_withStatementListNames(self):
- """
- No warnings are emitted for using any of the list of names defined by a
- C{with} statement within the suite or afterwards.
- """
- self.flakes('''
- from __future__ import with_statement
- with open('foo') as [bar, baz]:
- bar, baz
- bar, baz
- ''')
-
-
- def test_withStatementComplicatedTarget(self):
- """
- If the target of a C{with} statement uses any or all of the valid forms
- for that part of the grammar (See
- U{http://docs.python.org/reference/compound_stmts.html#the-with-statement}),
- the names involved are checked both for definedness and any bindings
- created are respected in the suite of the statement and afterwards.
- """
- self.flakes('''
- from __future__ import with_statement
- c = d = e = g = h = i = None
- with open('foo') as [(a, b), c[d], e.f, g[h:i]]:
- a, b, c, d, e, g, h, i
- a, b, c, d, e, g, h, i
- ''')
-
-
- def test_withStatementSingleNameUndefined(self):
- """
- An undefined name warning is emitted if the name first defined by a
- C{with} statement is used before the C{with} statement.
- """
- self.flakes('''
- from __future__ import with_statement
- bar
- with open('foo') as bar:
- pass
- ''', m.UndefinedName)
-
-
- def test_withStatementTupleNamesUndefined(self):
- """
- An undefined name warning is emitted if a name first defined by a the
- tuple-unpacking form of the C{with} statement is used before the
- C{with} statement.
- """
- self.flakes('''
- from __future__ import with_statement
- baz
- with open('foo') as (bar, baz):
- pass
- ''', m.UndefinedName)
-
-
- def test_withStatementSingleNameRedefined(self):
- """
- A redefined name warning is emitted if a name bound by an import is
- rebound by the name defined by a C{with} statement.
- """
- self.flakes('''
- from __future__ import with_statement
- import bar
- with open('foo') as bar:
- pass
- ''', m.RedefinedWhileUnused)
-
-
- def test_withStatementTupleNamesRedefined(self):
- """
- A redefined name warning is emitted if a name bound by an import is
- rebound by one of the names defined by the tuple-unpacking form of a
- C{with} statement.
- """
- self.flakes('''
- from __future__ import with_statement
- import bar
- with open('foo') as (bar, baz):
- pass
- ''', m.RedefinedWhileUnused)
-
-
- def test_withStatementUndefinedInside(self):
- """
- An undefined name warning is emitted if a name is used inside the
- body of a C{with} statement without first being bound.
- """
- self.flakes('''
- from __future__ import with_statement
- with open('foo') as bar:
- baz
- ''', m.UndefinedName)
-
-
- def test_withStatementNameDefinedInBody(self):
- """
- A name defined in the body of a C{with} statement can be used after
- the body ends without warning.
- """
- self.flakes('''
- from __future__ import with_statement
- with open('foo') as bar:
- baz = 10
- baz
- ''')
-
-
- def test_withStatementUndefinedInExpression(self):
- """
- An undefined name warning is emitted if a name in the I{test}
- expression of a C{with} statement is undefined.
- """
- self.flakes('''
- from __future__ import with_statement
- with bar as baz:
- pass
- ''', m.UndefinedName)
-
- self.flakes('''
- from __future__ import with_statement
- with bar as bar:
- pass
- ''', m.UndefinedName)
-
-
-
-class Python27Test(harness.Test):
- """
- Tests for checking of syntax only available in Python 2.7 and newer.
- """
- if version_info < (2, 7):
- skip = "Python 2.7 required for dict/set comprehension tests"
-
- def test_dictComprehension(self):
- """
- Dict comprehensions are properly handled.
- """
- self.flakes('''
- a = {1: x for x in range(10)}
- ''')
-
- def test_setComprehensionAndLiteral(self):
- """
- Set comprehensions are properly handled.
- """
- self.flakes('''
- a = {1, 2, 3}
- b = {x for x in range(10)}
- ''')
=== removed file 'Pyflakes/pyflakes/test/test_script.py'
--- Pyflakes/pyflakes/test/test_script.py 2012-10-23 11:52:32 +0000
+++ Pyflakes/pyflakes/test/test_script.py 1970-01-01 00:00:00 +0000
@@ -1,563 +0,0 @@
-"""
-Tests for L{pyflakes.scripts.pyflakes}.
-"""
-
-import os
-import sys
-from StringIO import StringIO
-
-from twisted.internet import protocol
-from twisted.internet.utils import (
- _callProtocolWithDeferred,
- getProcessOutputAndValue,
- )
-from twisted.python.filepath import FilePath
-from twisted.trial.unittest import TestCase
-
-from pyflakes.messages import UnusedImport
-from pyflakes.reporter import Reporter
-from pyflakes.scripts.pyflakes import (
- checkPath,
- checkRecursive,
- iterSourceCode,
- )
-
-
-def withStderrTo(stderr, f, *args, **kwargs):
- """
- Call C{f} with C{sys.stderr} redirected to C{stderr}.
- """
- (outer, sys.stderr) = (sys.stderr, stderr)
- try:
- return f(*args, **kwargs)
- finally:
- sys.stderr = outer
-
-
-
-class LoggingReporter(object):
- """
- Implementation of Reporter that just appends any errors to a list.
- """
-
- def __init__(self, log):
- """
- Construct a C{LoggingReporter}.
-
- @param log: A list to append log messages to.
- """
- self.log = log
-
-
- def flake(self, message):
- self.log.append(('flake', str(message)))
-
-
- def unexpectedError(self, filename, message):
- self.log.append(('unexpectedError', filename, message))
-
-
- def syntaxError(self, filename, msg, lineno, offset, line):
- self.log.append(('syntaxError', filename, msg, lineno, offset, line))
-
-
-
-class TestIterSourceCode(TestCase):
- """
- Tests for L{iterSourceCode}.
- """
-
- def test_emptyDirectory(self):
- """
- There are no Python files in an empty directory.
- """
- tempdir = FilePath(self.mktemp())
- tempdir.createDirectory()
- self.assertEqual(list(iterSourceCode([tempdir.path])), [])
-
-
- def test_singleFile(self):
- """
- If the directory contains one Python file, C{iterSourceCode} will find
- it.
- """
- tempdir = FilePath(self.mktemp())
- tempdir.createDirectory()
- tempdir.child('foo.py').touch()
- self.assertEqual(
- list(iterSourceCode([tempdir.path])),
- [tempdir.child('foo.py').path])
-
-
- def test_onlyPythonSource(self):
- """
- Files that are not Python source files are not included.
- """
- tempdir = FilePath(self.mktemp())
- tempdir.createDirectory()
- tempdir.child('foo.pyc').touch()
- self.assertEqual(list(iterSourceCode([tempdir.path])), [])
-
-
- def test_recurses(self):
- """
- If the Python files are hidden deep down in child directories, we will
- find them.
- """
- tempdir = FilePath(self.mktemp())
- tempdir.createDirectory()
- tempdir.child('foo').createDirectory()
- tempdir.child('foo').child('a.py').touch()
- tempdir.child('bar').createDirectory()
- tempdir.child('bar').child('b.py').touch()
- tempdir.child('c.py').touch()
- self.assertEqual(
- sorted(iterSourceCode([tempdir.path])),
- sorted([tempdir.child('foo').child('a.py').path,
- tempdir.child('bar').child('b.py').path,
- tempdir.child('c.py').path]))
-
-
- def test_multipleDirectories(self):
- """
- L{iterSourceCode} can be given multiple directories. It will recurse
- into each of them.
- """
- tempdir = FilePath(self.mktemp())
- tempdir.createDirectory()
- foo = tempdir.child('foo')
- foo.createDirectory()
- foo.child('a.py').touch()
- bar = tempdir.child('bar')
- bar.createDirectory()
- bar.child('b.py').touch()
- self.assertEqual(
- sorted(iterSourceCode([foo.path, bar.path])),
- sorted([foo.child('a.py').path,
- bar.child('b.py').path]))
-
-
- def test_explicitFiles(self):
- """
- If one of the paths given to L{iterSourceCode} is not a directory but
- a file, it will include that in its output.
- """
- tempfile = FilePath(self.mktemp())
- tempfile.touch()
- self.assertEqual(list(iterSourceCode([tempfile.path])),
- [tempfile.path])
-
-
-
-class TestReporter(TestCase):
- """
- Tests for L{Reporter}.
- """
-
- def test_syntaxError(self):
- """
- C{syntaxError} reports that there was a syntax error in the source
- file. It reports to the error stream and includes the filename, line
- number, error message, actual line of source and a caret pointing to
- where the error is.
- """
- err = StringIO()
- reporter = Reporter(None, err)
- reporter.syntaxError('foo.py', 'a problem', 3, 4, 'bad line of source')
- self.assertEquals(
- ("foo.py:3: a problem\n"
- "bad line of source\n"
- " ^\n"),
- err.getvalue())
-
-
- def test_syntaxErrorNoOffset(self):
- """
- C{syntaxError} doesn't include a caret pointing to the error if
- C{offset} is passed as C{None}.
- """
- err = StringIO()
- reporter = Reporter(None, err)
- reporter.syntaxError('foo.py', 'a problem', 3, None,
- 'bad line of source')
- self.assertEquals(
- ("foo.py:3: a problem\n"
- "bad line of source\n"),
- err.getvalue())
-
-
- def test_multiLineSyntaxError(self):
- """
- If there's a multi-line syntax error, then we only report the last
- line. The offset is adjusted so that it is relative to the start of
- the last line.
- """
- err = StringIO()
- lines = [
- 'bad line of source',
- 'more bad lines of source',
- ]
- reporter = Reporter(None, err)
- reporter.syntaxError('foo.py', 'a problem', 3, len(lines[0]) + 5,
- '\n'.join(lines))
- self.assertEquals(
- ("foo.py:3: a problem\n" +
- lines[-1] + "\n" +
- " ^\n"),
- err.getvalue())
-
-
- def test_unexpectedError(self):
- """
- C{unexpectedError} reports an error processing a source file.
- """
- err = StringIO()
- reporter = Reporter(None, err)
- reporter.unexpectedError(u'source.py', u'error message')
- self.assertEquals(u'source.py: error message\n', err.getvalue())
-
-
- def test_flake(self):
- """
- C{flake} reports a code warning from Pyflakes. It is exactly the
- str() of a L{pyflakes.messages.Message}.
- """
- out = StringIO()
- reporter = Reporter(out, None)
- message = UnusedImport('foo.py', 42, 'bar')
- reporter.flake(message)
- self.assertEquals(out.getvalue(), "%s\n" % (message,))
-
-
-
-class CheckTests(TestCase):
- """
- Tests for L{check} and L{checkPath} which check a file for flakes.
- """
-
- def makeTempFile(self, content):
- """
- Make a temporary file containing C{content} and return a path to it.
- """
- path = FilePath(self.mktemp())
- path.setContent(content)
- return path.path
-
-
- def assertHasErrors(self, path, errorList):
- """
- Assert that C{path} causes errors.
-
- @param path: A path to a file to check.
- @param errorList: A list of errors expected to be printed to stderr.
- """
- err = StringIO()
- count = withStderrTo(err, checkPath, path)
- self.assertEquals(
- (count, err.getvalue()), (len(errorList), ''.join(errorList)))
-
-
- def getErrors(self, path):
- """
- Get any warnings or errors reported by pyflakes for the file at C{path}.
-
- @param path: The path to a Python file on disk that pyflakes will check.
- @return: C{(count, log)}, where C{count} is the number of warnings or
- errors generated, and log is a list of those warnings, presented
- as structured data. See L{LoggingReporter} for more details.
- """
- log = []
- reporter = LoggingReporter(log)
- count = checkPath(path, reporter)
- return count, log
-
-
- def test_missingTrailingNewline(self):
- """
- Source which doesn't end with a newline shouldn't cause any
- exception to be raised nor an error indicator to be returned by
- L{check}.
- """
- fName = self.makeTempFile("def foo():\n\tpass\n\t")
- self.assertHasErrors(fName, [])
-
-
- def test_checkPathNonExisting(self):
- """
- L{checkPath} handles non-existing files.
- """
- count, errors = self.getErrors('extremo')
- self.assertEquals(count, 1)
- self.assertEquals(
- errors,
- [('unexpectedError', 'extremo', 'No such file or directory')])
-
-
- def test_multilineSyntaxError(self):
- """
- Source which includes a syntax error which results in the raised
- L{SyntaxError.text} containing multiple lines of source are reported
- with only the last line of that source.
- """
- source = """\
-def foo():
- '''
-
-def bar():
- pass
-
-def baz():
- '''quux'''
-"""
-
- # Sanity check - SyntaxError.text should be multiple lines, if it
- # isn't, something this test was unprepared for has happened.
- def evaluate(source):
- exec source
- exc = self.assertRaises(SyntaxError, evaluate, source)
- self.assertTrue(exc.text.count('\n') > 1)
-
- sourcePath = self.makeTempFile(source)
- self.assertHasErrors(
- sourcePath, ["""\
-%s:8: invalid syntax
- '''quux'''
- ^
-"""
- % (sourcePath,)])
-
-
- def test_eofSyntaxError(self):
- """
- The error reported for source files which end prematurely causing a
- syntax error reflects the cause for the syntax error.
- """
- sourcePath = self.makeTempFile("def foo(")
- self.assertHasErrors(
- sourcePath,
- ["""\
-%s:1: unexpected EOF while parsing
-def foo(
- ^
-""" % (sourcePath,)])
-
-
- def test_nonDefaultFollowsDefaultSyntaxError(self):
- """
- Source which has a non-default argument following a default argument
- should include the line number of the syntax error. However these
- exceptions do not include an offset.
- """
- source = """\
-def foo(bar=baz, bax):
- pass
-"""
- sourcePath = self.makeTempFile(source)
- self.assertHasErrors(
- sourcePath,
- ["""\
-%s:1: non-default argument follows default argument
-def foo(bar=baz, bax):
-""" % (sourcePath,)])
-
-
- def test_nonKeywordAfterKeywordSyntaxError(self):
- """
- Source which has a non-keyword argument after a keyword argument should
- include the line number of the syntax error. However these exceptions
- do not include an offset.
- """
- source = """\
-foo(bar=baz, bax)
-"""
- sourcePath = self.makeTempFile(source)
- self.assertHasErrors(
- sourcePath,
- ["""\
-%s:1: non-keyword arg after keyword arg
-foo(bar=baz, bax)
-""" % (sourcePath,)])
-
-
- def test_permissionDenied(self):
- """
- If the source file is not readable, this is reported on standard
- error.
- """
- sourcePath = FilePath(self.mktemp())
- sourcePath.setContent('')
- sourcePath.chmod(0)
- count, errors = self.getErrors(sourcePath.path)
- self.assertEquals(count, 1)
- self.assertEquals(
- errors,
- [('unexpectedError', sourcePath.path, "Permission denied")])
-
-
- def test_pyflakesWarning(self):
- """
- If the source file has a pyflakes warning, this is reported as a
- 'flake'.
- """
- sourcePath = self.makeTempFile("import foo")
- count, errors = self.getErrors(sourcePath)
- self.assertEquals(count, 1)
- self.assertEquals(
- errors, [('flake', str(UnusedImport(sourcePath, 1, 'foo')))])
-
-
- def test_misencodedFile(self):
- """
- If a source file contains bytes which cannot be decoded, this is
- reported on stderr.
- """
- source = u"""\
-# coding: ascii
-x = "\N{SNOWMAN}"
-""".encode('utf-8')
- sourcePath = self.makeTempFile(source)
- self.assertHasErrors(
- sourcePath, ["%s: problem decoding source\n" % (sourcePath,)])
-
-
- def test_checkRecursive(self):
- """
- L{checkRecursive} descends into each directory, finding Python files
- and reporting problems.
- """
- tempdir = FilePath(self.mktemp())
- tempdir.createDirectory()
- tempdir.child('foo').createDirectory()
- file1 = tempdir.child('foo').child('bar.py')
- file1.setContent("import baz\n")
- file2 = tempdir.child('baz.py')
- file2.setContent("import contraband")
- log = []
- reporter = LoggingReporter(log)
- warnings = checkRecursive([tempdir.path], reporter)
- self.assertEqual(warnings, 2)
- self.assertEqual(
- sorted(log),
- sorted([('flake', str(UnusedImport(file1.path, 1, 'baz'))),
- ('flake',
- str(UnusedImport(file2.path, 1, 'contraband')))]))
-
-
-
-class _EverythingGetterWithStdin(protocol.ProcessProtocol):
- """
- C{ProcessProtocol} that writes to stdin and gathers exit code, stdout and
- stderr.
- """
-
- # Although Twisted provides a helper that spawns a subprocess, gathers its
- # exit code, standard output and standard error
- # (i.e. getProcessOutputAndValue), it does *not* provide one that data to
- # be written to stdin first.
-
- def __init__(self, deferred, stdin):
- self.deferred = deferred
- self.outBuf = StringIO()
- self.errBuf = StringIO()
- self.outReceived = self.outBuf.write
- self.errReceived = self.errBuf.write
- self.stdin = stdin
-
-
- def connectionMade(self):
- self.transport.write(self.stdin)
- self.transport.closeStdin()
-
-
- def processEnded(self, reason):
- out = self.outBuf.getvalue()
- err = self.errBuf.getvalue()
- e = reason.value
- code = e.exitCode
- if e.signal:
- code = -e.signal
- self.deferred.callback((out, err, code))
-
-
-
-class IntegrationTests(TestCase):
- """
- Tests of the pyflakes script that actually spawn the script.
- """
-
- def getPyflakesBinary(self):
- """
- Return the path to the pyflakes binary.
- """
- import pyflakes
- package_dir = FilePath(pyflakes.__file__).parent()
- return package_dir.sibling('bin').child('pyflakes').path
-
-
- def runPyflakes(self, paths, stdin=None):
- """
- Launch a subprocess running C{pyflakes}.
-
- @param args: Command-line arguments to pass to pyflakes.
- @param kwargs: Options passed on to C{subprocess.Popen}.
- @return: C{(returncode, stdout, stderr)} of the completed pyflakes
- process.
- """
- env = dict(os.environ)
- env['PYTHONPATH'] = os.pathsep.join(sys.path)
- command = [self.getPyflakesBinary()]
- command.extend(paths)
- if stdin:
- d = _callProtocolWithDeferred(
- lambda d: _EverythingGetterWithStdin(d, stdin),
- sys.executable, command, env=env, path=None)
- else:
- d = getProcessOutputAndValue(sys.executable, command, env=env)
- return d
-
-
- def test_goodFile(self):
- """
- When a Python source file is all good, the return code is zero and no
- messages are printed to either stdout or stderr.
- """
- tempfile = FilePath(self.mktemp())
- tempfile.touch()
- d = self.runPyflakes([tempfile.path])
- return d.addCallback(self.assertEqual, ('', '', 0))
-
-
- def test_fileWithFlakes(self):
- """
- When a Python source file has warnings, the return code is non-zero
- and the warnings are printed to stdout.
- """
- tempfile = FilePath(self.mktemp())
- tempfile.setContent("import contraband\n")
- d = self.runPyflakes([tempfile.path])
- return d.addCallback(
- self.assertEqual,
- ("%s\n" % UnusedImport(tempfile.path, 1, 'contraband'), '', 1))
-
-
- def test_errors(self):
- """
- When pyflakes finds errors with the files it's given, (if they don't
- exist, say), then the return code is non-zero and the errors are
- printed to stderr.
- """
- tempfile = FilePath(self.mktemp())
- d = self.runPyflakes([tempfile.path])
- return d.addCallback(
- self.assertEqual,
- ('', '%s: No such file or directory\n' % (tempfile.path,), 1))
-
-
- def test_readFromStdin(self):
- """
- If no arguments are passed to C{pyflakes} then it reads from stdin.
- """
- d = self.runPyflakes([], stdin='import contraband')
- return d.addCallback(
- self.assertEqual,
- ("%s\n" % UnusedImport('<stdin>', 1, 'contraband'), '', 1))
=== removed file 'Pyflakes/pyflakes/test/test_undefined_names.py'
--- Pyflakes/pyflakes/test/test_undefined_names.py 2011-12-04 20:27:45 +0000
+++ Pyflakes/pyflakes/test/test_undefined_names.py 1970-01-01 00:00:00 +0000
@@ -1,273 +0,0 @@
-
-from _ast import PyCF_ONLY_AST
-
-from twisted.trial.unittest import TestCase
-
-from pyflakes import messages as m, checker
-from pyflakes.test import harness
-
-
-class Test(harness.Test):
- def test_undefined(self):
- self.flakes('bar', m.UndefinedName)
-
- def test_definedInListComp(self):
- self.flakes('[a for a in range(10) if a]')
-
-
- def test_functionsNeedGlobalScope(self):
- self.flakes('''
- class a:
- def b():
- fu
- fu = 1
- ''')
-
- def test_builtins(self):
- self.flakes('range(10)')
-
-
- def test_builtinWindowsError(self):
- """
- C{WindowsError} is sometimes a builtin name, so no warning is emitted
- for using it.
- """
- self.flakes('WindowsError')
-
-
- def test_magicGlobalsFile(self):
- """
- Use of the C{__file__} magic global should not emit an undefined name
- warning.
- """
- self.flakes('__file__')
-
-
- def test_magicGlobalsBuiltins(self):
- """
- Use of the C{__builtins__} magic global should not emit an undefined
- name warning.
- """
- self.flakes('__builtins__')
-
-
- def test_magicGlobalsName(self):
- """
- Use of the C{__name__} magic global should not emit an undefined name
- warning.
- """
- self.flakes('__name__')
-
-
- def test_magicGlobalsPath(self):
- """
- Use of the C{__path__} magic global should not emit an undefined name
- warning, if you refer to it from a file called __init__.py.
- """
- self.flakes('__path__', m.UndefinedName)
- self.flakes('__path__', filename='package/__init__.py')
-
-
- def test_globalImportStar(self):
- '''Can't find undefined names with import *'''
- self.flakes('from fu import *; bar', m.ImportStarUsed)
-
- def test_localImportStar(self):
- '''A local import * still allows undefined names to be found in upper scopes'''
- self.flakes('''
- def a():
- from fu import *
- bar
- ''', m.ImportStarUsed, m.UndefinedName)
-
- def test_unpackedParameter(self):
- '''Unpacked function parameters create bindings'''
- self.flakes('''
- def a((bar, baz)):
- bar; baz
- ''')
-
- def test_definedByGlobal(self):
- '''"global" can make an otherwise undefined name in another function defined'''
- self.flakes('''
- def a(): global fu; fu = 1
- def b(): fu
- ''')
- test_definedByGlobal.todo = ''
-
- def test_globalInGlobalScope(self):
- """
- A global statement in the global scope is ignored.
- """
- self.flakes('''
- global x
- def foo():
- print x
- ''', m.UndefinedName)
-
- def test_del(self):
- '''del deletes bindings'''
- self.flakes('a = 1; del a; a', m.UndefinedName)
-
- def test_delGlobal(self):
- '''del a global binding from a function'''
- self.flakes('''
- a = 1
- def f():
- global a
- del a
- a
- ''')
-
- def test_delUndefined(self):
- '''del an undefined name'''
- self.flakes('del a', m.UndefinedName)
-
- def test_globalFromNestedScope(self):
- '''global names are available from nested scopes'''
- self.flakes('''
- a = 1
- def b():
- def c():
- a
- ''')
-
- def test_laterRedefinedGlobalFromNestedScope(self):
- """
- Test that referencing a local name that shadows a global, before it is
- defined, generates a warning.
- """
- self.flakes('''
- a = 1
- def fun():
- a
- a = 2
- return a
- ''', m.UndefinedLocal)
-
- def test_laterRedefinedGlobalFromNestedScope2(self):
- """
- Test that referencing a local name in a nested scope that shadows a
- global declared in an enclosing scope, before it is defined, generates
- a warning.
- """
- self.flakes('''
- a = 1
- def fun():
- global a
- def fun2():
- a
- a = 2
- return a
- ''', m.UndefinedLocal)
-
-
- def test_intermediateClassScopeIgnored(self):
- """
- If a name defined in an enclosing scope is shadowed by a local variable
- and the name is used locally before it is bound, an unbound local
- warning is emitted, even if there is a class scope between the enclosing
- scope and the local scope.
- """
- self.flakes('''
- def f():
- x = 1
- class g:
- def h(self):
- a = x
- x = None
- print x, a
- print x
- ''', m.UndefinedLocal)
-
-
- def test_doubleNestingReportsClosestName(self):
- """
- Test that referencing a local name in a nested scope that shadows a
- variable declared in two different outer scopes before it is defined
- in the innermost scope generates an UnboundLocal warning which
- refers to the nearest shadowed name.
- """
- exc = self.flakes('''
- def a():
- x = 1
- def b():
- x = 2 # line 5
- def c():
- x
- x = 3
- return x
- return x
- return x
- ''', m.UndefinedLocal).messages[0]
- self.assertEqual(exc.message_args, ('x', 5))
-
-
- def test_laterRedefinedGlobalFromNestedScope3(self):
- """
- Test that referencing a local name in a nested scope that shadows a
- global, before it is defined, generates a warning.
- """
- self.flakes('''
- def fun():
- a = 1
- def fun2():
- a
- a = 1
- return a
- return a
- ''', m.UndefinedLocal)
-
- def test_nestedClass(self):
- '''nested classes can access enclosing scope'''
- self.flakes('''
- def f(foo):
- class C:
- bar = foo
- def f(self):
- return foo
- return C()
-
- f(123).f()
- ''')
-
- def test_badNestedClass(self):
- '''free variables in nested classes must bind at class creation'''
- self.flakes('''
- def f():
- class C:
- bar = foo
- foo = 456
- return foo
- f()
- ''', m.UndefinedName)
-
- def test_definedAsStarArgs(self):
- '''star and double-star arg names are defined'''
- self.flakes('''
- def f(a, *b, **c):
- print a, b, c
- ''')
-
- def test_definedInGenExp(self):
- """
- Using the loop variable of a generator expression results in no
- warnings.
- """
- self.flakes('(a for a in xrange(10) if a)')
-
-
-
-class NameTests(TestCase):
- """
- Tests for some extra cases of name handling.
- """
- def test_impossibleContext(self):
- """
- A Name node with an unrecognized context results in a RuntimeError being
- raised.
- """
- tree = compile("x = 10", "<test>", "exec", PyCF_ONLY_AST)
- # Make it into something unrecognizable.
- tree.body[0].targets[0].ctx = object()
- self.assertRaises(RuntimeError, checker.Checker, tree)
=== removed file 'Pyflakes/setup.py'
--- Pyflakes/setup.py 2011-09-03 16:31:04 +0000
+++ Pyflakes/setup.py 1970-01-01 00:00:00 +0000
@@ -1,29 +0,0 @@
-#!/usr/bin/python
-# Copyright 2005-2011 Divmod, Inc. See LICENSE file for details
-
-from distutils.core import setup
-
-setup(
- name="pyflakes",
- license="MIT",
- version="0.5.0",
- description="passive checker of Python programs",
- author="Phil Frost",
- author_email="indigo@xxxxxxxxxxx",
- maintainer="Divmod developers",
- maintainer_email="divmod-dev@xxxxxxxxxxxxxxxxxxx",
- url="https://launchpad.net/pyflakes";,
- packages=["pyflakes", "pyflakes.scripts", "pyflakes.test"],
- scripts=["bin/pyflakes"],
- long_description="""Pyflakes is program to analyze Python programs and detect various errors. It
-works by parsing the source file, not importing it, so it is safe to use on
-modules with side effects. It's also much faster.""",
- classifiers=[
- "Development Status :: 6 - Mature",
- "Environment :: Console",
- "Intended Audience :: Developers",
- "License :: OSI Approved :: MIT License",
- "Programming Language :: Python",
- "Topic :: Software Development",
- "Topic :: Utilities",
- ])
Follow ups
