from sets import Set as set
# Local imports
-from ..patcomp import PatternCompiler
-from .. import pygram
-from .util import does_tree_import
+from .patcomp import PatternCompiler
+from . import pygram
+from .fixer_util import does_tree_import
class BaseFix(object):
# Author: Collin Winter
# Local imports
-from ..pgen2 import token
-from ..pytree import Leaf, Node
-from ..pygram import python_symbols as syms
-from .. import patcomp
+from .pgen2 import token
+from .pytree import Leaf, Node
+from .pygram import python_symbols as syms
+from . import patcomp
###########################################################
elif imp.type == token.NAME and imp.value == name:
return node
elif node.type == syms.import_from:
- # unicode(...) is used to make life easier here, because
+ # str(...) is used to make life easier here, because
# from a.b import parses to ['import', ['a', '.', 'b'], ...]
if package and str(node.children[1]).strip() != package:
return None
# Local imports
from .. import pytree
from ..pgen2 import token
-from . import basefix
-from .util import Call, Comma
+from .. import fixer_base
+from ..fixer_util import Call, Comma
-class FixApply(basefix.BaseFix):
+class FixApply(fixer_base.BaseFix):
PATTERN = """
power< 'apply'
# Author: Christian Heimes
# Local imports
-from . import basefix
-from .util import Name
+from .. import fixer_base
+from ..fixer_util import Name
-class FixBasestring(basefix.BaseFix):
+class FixBasestring(fixer_base.BaseFix):
PATTERN = "'basestring'"
"""Fixer that changes buffer(...) into memoryview(...)."""
# Local imports
-from . import basefix
-from .util import Name
+from .. import fixer_base
+from ..fixer_util import Name
-class FixBuffer(basefix.BaseFix):
+class FixBuffer(fixer_base.BaseFix):
explicit = True # The user must ask for this fixer
# Local imports
from .. import pytree
-from . import basefix
-from .util import Call, Name, String
+from .. import fixer_base
+from ..fixer_util import Call, Name, String
-class FixCallable(basefix.BaseFix):
+class FixCallable(fixer_base.BaseFix):
# Ignore callable(*args) or use of keywords.
# Either could be a hint that the builtin callable() is not being used.
from .. import pytree
from .. import patcomp
from ..pgen2 import token
-from . import basefix
-from .util import Name, Call, LParen, RParen, ArgList, Dot, set
-from . import util
+from .. import fixer_base
+from ..fixer_util import Name, Call, LParen, RParen, ArgList, Dot, set
+from .. import fixer_util
-iter_exempt = util.consuming_calls | set(["iter"])
+iter_exempt = fixer_util.consuming_calls | set(["iter"])
-class FixDict(basefix.BaseFix):
+class FixDict(fixer_base.BaseFix):
PATTERN = """
power< head=any+
trailer< '.' method=('keys'|'items'|'values'|
return results["func"].value in iter_exempt
else:
# list(d.keys()) -> list(d.keys()), etc.
- return results["func"].value in util.consuming_calls
+ return results["func"].value in fixer_util.consuming_calls
if not isiter:
return False
# for ... in d.iterkeys() -> for ... in d.keys(), etc.
# Local imports
from .. import pytree
from ..pgen2 import token
-from . import basefix
-from .util import Assign, Attr, Name, is_tuple, is_list, reversed
+from .. import fixer_base
+from ..fixer_util import Assign, Attr, Name, is_tuple, is_list, reversed
def find_excepts(nodes):
for i, n in enumerate(nodes):
if n.children[0].value == 'except':
yield (n, nodes[i+2])
-class FixExcept(basefix.BaseFix):
+class FixExcept(fixer_base.BaseFix):
PATTERN = """
try_stmt< 'try' ':' suite
# Local imports
from .. import pytree
-from . import basefix
-from .util import Comma, Name, Call
+from .. import fixer_base
+from ..fixer_util import Comma, Name, Call
-class FixExec(basefix.BaseFix):
+class FixExec(fixer_base.BaseFix):
PATTERN = """
exec_stmt< 'exec' a=any 'in' b=any [',' c=any] >
"""
from .. import pytree
-from . import basefix
-from .util import Comma, Name, Call, LParen, RParen, Dot
+from .. import fixer_base
+from ..fixer_util import Comma, Name, Call, LParen, RParen, Dot
-class FixExecfile(basefix.BaseFix):
+class FixExecfile(fixer_base.BaseFix):
PATTERN = """
power< 'execfile' trailer< '(' arglist< filename=any [',' globals=any [',' locals=any ] ] > ')' > >
# Local imports
from ..pgen2 import token
-from . import basefix
-from .util import Name, Call, ListComp, in_special_context
+from .. import fixer_base
+from ..fixer_util import Name, Call, ListComp, in_special_context
-class FixFilter(basefix.ConditionalFix):
+class FixFilter(fixer_base.ConditionalFix):
PATTERN = """
filter_lambda=power<
# Author: Collin Winter
# Local imports
-from . import basefix
-from .util import Name
+from .. import fixer_base
+from ..fixer_util import Name
-class FixFuncattrs(basefix.BaseFix):
+class FixFuncattrs(fixer_base.BaseFix):
PATTERN = """
power< any+ trailer< '.' attr=('func_closure' | 'func_doc' | 'func_globals'
| 'func_name' | 'func_defaults' | 'func_code'
# Author: Christian Heimes
# Local imports
-from . import basefix
-from .util import BlankLine
+from .. import fixer_base
+from ..fixer_util import BlankLine
-class FixFuture(basefix.BaseFix):
+class FixFuture(fixer_base.BaseFix):
PATTERN = """import_from< 'from' module_name="__future__" 'import' any >"""
# This should be run last -- some things check for the import
# Local imports
from .. import pytree
from ..pgen2 import token
-from . import basefix
-from .util import Name
+from .. import fixer_base
+from ..fixer_util import Name
-class FixHasKey(basefix.BaseFix):
+class FixHasKey(fixer_base.BaseFix):
PATTERN = """
anchor=power<
# Author: Jacques Frechet, Collin Winter
# Local imports
-from . import basefix
-from .util import Call, Comma, Name, Node, syms
+from .. import fixer_base
+from ..fixer_util import Call, Comma, Name, Node, syms
CMP = "(n='!=' | '==' | 'is' | n=comp_op< 'is' 'not' >)"
TYPE = "power< 'type' trailer< '(' x=any ')' > >"
-class FixIdioms(basefix.BaseFix):
+class FixIdioms(fixer_base.BaseFix):
explicit = True # The user must ask for this fixer
"""
# Local imports
-from . import basefix
+from .. import fixer_base
from os.path import dirname, join, exists, pathsep
-from .util import FromImport
+from ..fixer_util import FromImport
-class FixImport(basefix.BaseFix):
+class FixImport(fixer_base.BaseFix):
PATTERN = """
import_from< type='from' imp=any 'import' any >
# Author: Collin Winter
# Local imports
-from . import basefix
-from .util import Name, attr_chain, any, set
+from .. import fixer_base
+from ..fixer_util import Name, attr_chain, any, set
import builtins
builtin_names = [name for name in dir(builtins)
if name not in ("__name__", "__doc__")]
'error', 'exit', 'exit_thread', 'get_ident',
'interrupt_main', 'stack_size', 'start_new',
'start_new_thread']),
+ 'whichdb': ('dbm', ['whichdb']),
+ 'anydbm': ('dbm', ['error', 'open']),
+ 'dbhash': ('dbm.bsd', ['error', 'open']),
+ 'dumbdbm': ('dbm.dumb', ['error', 'open', '_Database']),
+ 'dbm': ('dbm.ndbm', ['error', 'open', 'library']),
+ 'gdbm': ('dbm.gnu', ['error', 'open', 'open_flags']),
+ 'xmlrpclib': ('xmlrpc.client',
+ ['Error', 'ProtocolError', 'ResponseError', 'Fault',
+ 'ServerProxy', 'Boolean', 'DateTime', 'Binary',
+ 'ExpatParser', 'FastMarshaller', 'FastParser',
+ 'FastUnmarshaller', 'MultiCall', 'MultiCallIterator',
+ 'SlowParser', 'Marshaller', 'Unmarshaller', 'Server',
+ 'Transport', 'SafeTransport', 'SgmlopParser',
+ 'boolean', 'getparser', 'dumps', 'loads', 'escape',
+ 'PARSE_ERROR', 'SERVER_ERROR', 'WRAPPERS',
+ 'APPLICATION_ERROR', 'SYSTEM_ERROR',
+ 'TRANSPORT_ERROR', 'NOT_WELLFORMED_ERROR',
+ 'UNSUPPORTED_ENCODING', 'INVALID_ENCODING_CHAR',
+ 'INVALID_XMLRPC', 'METHOD_NOT_FOUND',
+ 'INVALID_METHOD_PARAMS', 'INTERNAL_ERROR',
+ 'MININT', 'MAXINT']),
+ 'DocXMLRPCServer': ('xmlrpc.server',
+ ['CGIXMLRPCRequestHandler',
+ 'DocCGIXMLRPCRequestHandler',
+ 'DocXMLRPCRequestHandler', 'DocXMLRPCServer',
+ 'ServerHTMLDoc', 'SimpleXMLRPCRequestHandler',
+ 'SimpleXMLRPCServer', 'XMLRPCDocGenerator',
+ 'resolve_dotted_attribute']),
+ 'SimpleXMLRPCServer': ('xmlrpc.server',
+ ['CGIXMLRPCRequestHandler',
+ 'Fault', 'SimpleXMLRPCDispatcher',
+ 'SimpleXMLRPCRequestHandler',
+ 'SimpleXMLRPCServer', 'SocketServer',
+ 'list_public_methods',
+ 'remove_duplicates',
+ 'resolve_dotted_attribute']),
+ 'httplib': ('http.client',
+ ['ACCEPTED', 'BAD_GATEWAY', 'BAD_REQUEST',
+ 'BadStatusLine', 'CONFLICT', 'CONTINUE', 'CREATED',
+ 'CannotSendHeader', 'CannotSendRequest',
+ 'EXPECTATION_FAILED', 'FAILED_DEPENDENCY', 'FORBIDDEN',
+ 'FOUND', 'FakeSocket', 'GATEWAY_TIMEOUT', 'GONE',
+ 'HTTP', 'HTTPConnection', 'HTTPException',
+ 'HTTPMessage', 'HTTPResponse', 'HTTPS',
+ 'HTTPSConnection', 'HTTPS_PORT', 'HTTP_PORT',
+ 'HTTP_VERSION_NOT_SUPPORTED', 'IM_USED',
+ 'INSUFFICIENT_STORAGE', 'INTERNAL_SERVER_ERROR',
+ 'ImproperConnectionState', 'IncompleteRead',
+ 'InvalidURL', 'LENGTH_REQUIRED', 'LOCKED',
+ 'LineAndFileWrapper', 'MAXAMOUNT', 'METHOD_NOT_ALLOWED',
+ 'MOVED_PERMANENTLY', 'MULTIPLE_CHOICES', 'MULTI_STATUS',
+ 'NON_AUTHORITATIVE_INFORMATION', 'NOT_ACCEPTABLE',
+ 'NOT_EXTENDED', 'NOT_FOUND', 'NOT_IMPLEMENTED',
+ 'NOT_MODIFIED', 'NO_CONTENT', 'NotConnected', 'OK',
+ 'PARTIAL_CONTENT', 'PAYMENT_REQUIRED',
+ 'PRECONDITION_FAILED', 'PROCESSING',
+ 'PROXY_AUTHENTICATION_REQUIRED',
+ 'REQUESTED_RANGE_NOT_SATISFIABLE',
+ 'REQUEST_ENTITY_TOO_LARGE', 'REQUEST_TIMEOUT',
+ 'REQUEST_URI_TOO_LONG', 'RESET_CONTENT',
+ 'ResponseNotReady', 'SEE_OTHER', 'SERVICE_UNAVAILABLE',
+ 'SSLFile', 'SWITCHING_PROTOCOLS', 'SharedSocket',
+ 'SharedSocketClient', 'StringIO', 'TEMPORARY_REDIRECT',
+ 'UNAUTHORIZED', 'UNPROCESSABLE_ENTITY',
+ 'UNSUPPORTED_MEDIA_TYPE', 'UPGRADE_REQUIRED',
+ 'USE_PROXY', 'UnimplementedFileMode', 'UnknownProtocol',
+ 'UnknownTransferEncoding', 'error', 'responses']),
+ 'Cookie': ('http.cookies',
+ ['BaseCookie', 'Cookie', 'CookieError', 'Morsel',
+ 'SerialCookie', 'SimpleCookie', 'SmartCookie']),
+ 'cookielib': ('http.cookiejar',
+ ['Absent', 'Cookie', 'CookieJar', 'CookiePolicy',
+ 'DAYS', 'DEFAULT_HTTP_PORT', 'DefaultCookiePolicy',
+ 'EPOCH_YEAR', 'ESCAPED_CHAR_RE', 'FileCookieJar',
+ 'HEADER_ESCAPE_RE', 'HEADER_JOIN_ESCAPE_RE',
+ 'HEADER_QUOTED_VALUE_RE', 'HEADER_TOKEN_RE',
+ 'HEADER_VALUE_RE', 'HTTP_PATH_SAFE', 'IPV4_RE',
+ 'ISO_DATE_RE', 'LOOSE_HTTP_DATE_RE', 'LWPCookieJar',
+ 'LoadError', 'MISSING_FILENAME_TEXT', 'MONTHS',
+ 'MONTHS_LOWER', 'MozillaCookieJar', 'STRICT_DATE_RE',
+ 'TIMEZONE_RE', 'UTC_ZONES', 'WEEKDAY_RE',
+ 'cut_port_re', 'deepvalues', 'domain_match',
+ 'eff_request_host', 'escape_path', 'http2time',
+ 'is_HDN', 'is_third_party', 'iso2time',
+ 'join_header_words', 'liberal_is_HDN', 'logger',
+ 'lwp_cookie_str', 'month', 'offset_from_tz_string',
+ 'parse_ns_headers', 'reach', 'request_host',
+ 'request_path', 'request_port', 'split_header_words',
+ 'time', 'time2isoz', 'time2netscape', 'unmatched',
+ 'uppercase_escaped_char', 'urllib',
+ 'user_domain_match', 'vals_sorted_by_key']),
+ 'BaseHTTPServer': ('http.server',
+ ['BaseHTTPRequestHandler',
+ 'DEFAULT_ERROR_MESSAGE', 'HTTPServer']),
+ 'SimpleHTTPServer': ('http.server', ['SimpleHTTPRequestHandler']),
+ 'CGIHTTPServer': ('http.server',
+ ['CGIHTTPRequestHandler', 'executable',
+ 'nobody_uid', 'nobody']),
+ 'test.test_support': ('test.support',
+ ["Error", "TestFailed", "TestSkipped", "ResourceDenied",
+ "import_module", "verbose", "use_resources",
+ "max_memuse", "record_original_stdout",
+ "get_original_stdout", "unload", "unlink", "rmtree",
+ "forget", "is_resource_enabled", "requires",
+ "find_unused_port", "bind_port",
+ "fcmp", "is_jython", "TESTFN", "HOST",
+ "FUZZ", "findfile", "verify", "vereq", "sortdict",
+ "check_syntax_error", "open_urlresource", "WarningMessage",
+ "catch_warning", "CleanImport", "EnvironmentVarGuard",
+ "TransientResource", "captured_output", "captured_stdout",
+ "TransientResource", "transient_internet", "run_with_locale",
+ "set_memlimit", "bigmemtest", "bigaddrspacetest",
+ "BasicTestRunner", "run_unittest", "run_doctest",
+ "threading_setup", "threading_cleanup", "reap_children"]),
+ 'commands': ('subprocess', ['getstatusoutput', 'getoutput']),
+ 'UserString' : ('collections', ['UserString']),
+ 'UserList' : ('collections', ['UserList']),
}
yield """bare_name=%s""" % alternates(bare)
-class FixImports(basefix.BaseFix):
+class FixImports(fixer_base.BaseFix):
PATTERN = "|".join(build_pattern())
order = "pre" # Pre-order tree traversal
# Author: Andre Roberge
# Local imports
-from . import basefix
-from .util import Call, Name
+from .. import fixer_base
+from ..fixer_util import Call, Name
from .. import patcomp
context = patcomp.compile_pattern("power< 'eval' trailer< '(' any ')' > >")
-class FixInput(basefix.BaseFix):
+class FixInput(fixer_base.BaseFix):
PATTERN = """
power< 'input' args=trailer< '(' [any] ')' > >
# Local imports
from .. import pytree
-from . import basefix
-from .util import Name, Attr
+from .. import fixer_base
+from ..fixer_util import Name, Attr
-class FixIntern(basefix.BaseFix):
+class FixIntern(fixer_base.BaseFix):
PATTERN = """
power< 'intern'
"""
# Local imports
-from . import basefix
-from .util import Name
+from .. import fixer_base
+from ..fixer_util import Name
-class FixItertools(basefix.BaseFix):
+class FixItertools(fixer_base.BaseFix):
it_funcs = "('imap'|'ifilter'|'izip'|'ifilterfalse')"
PATTERN = """
power< it='itertools'
""" Fixer for imports of itertools.(imap|ifilter|izip|ifilterfalse) """
# Local imports
-from . import basefix
-from .util import BlankLine
+from .. import fixer_base
+from ..fixer_util import BlankLine
-class FixItertoolsImports(basefix.BaseFix):
+class FixItertoolsImports(fixer_base.BaseFix):
PATTERN = """
import_from< 'from' 'itertools' 'import' imports=any >
""" %(locals())
# Local imports
from .. import pytree
-from . import basefix
-from .util import Name, Number
+from .. import fixer_base
+from ..fixer_util import Name, Number
-class FixLong(basefix.BaseFix):
+class FixLong(fixer_base.BaseFix):
PATTERN = """
(long_type = 'long' | number = NUMBER)
# Local imports
from ..pgen2 import token
-from . import basefix
-from .util import Name, Call, ListComp, in_special_context
+from .. import fixer_base
+from ..fixer_util import Name, Call, ListComp, in_special_context
from ..pygram import python_symbols as syms
-class FixMap(basefix.ConditionalFix):
+class FixMap(fixer_base.ConditionalFix):
PATTERN = """
map_none=power<
# Author: Christian Heimes
# Local imports
-from . import basefix
-from .util import Name
+from .. import fixer_base
+from ..fixer_util import Name
MAP = {
"im_func" : "__func__",
"im_class" : "__self__.__class__"
}
-class FixMethodattrs(basefix.BaseFix):
+class FixMethodattrs(fixer_base.BaseFix):
PATTERN = """
power< any+ trailer< '.' attr=('im_func' | 'im_self' | 'im_class') > any* >
"""
# Local imports
from .. import pytree
from ..pgen2 import token
-from . import basefix
+from .. import fixer_base
-class FixNe(basefix.BaseFix):
+class FixNe(fixer_base.BaseFix):
# This is so simple that we don't need the pattern compiler.
def match(self, node):
# Local imports
from ..pgen2 import token
from ..pygram import python_symbols as syms
-from . import basefix
-from .util import Name, Call, find_binding, any
+from .. import fixer_base
+from ..fixer_util import Name, Call, find_binding, any
bind_warning = "Calls to builtin next() possibly shadowed by global binding"
-class FixNext(basefix.BaseFix):
+class FixNext(fixer_base.BaseFix):
PATTERN = """
power< base=any+ trailer< '.' attr='next' > trailer< '(' ')' > >
|
# Author: Collin Winter
# Local imports
-from .import basefix
-from .util import Name, syms
+from .. import fixer_base
+from ..fixer_util import Name, syms
-class FixNonzero(basefix.BaseFix):
+class FixNonzero(fixer_base.BaseFix):
PATTERN = """
classdef< 'class' any+ ':'
suite< any*
# Local imports
from ..pgen2 import token
-from .import basefix
-from .util import Number, set
+from .. import fixer_base
+from ..fixer_util import Number, set
-class FixNumliterals(basefix.BaseFix):
+class FixNumliterals(fixer_base.BaseFix):
# This is so simple that we don't need the pattern compiler.
def match(self, node):
from .. import patcomp
from .. import pytree
from ..pgen2 import token
-from .import basefix
-from .util import Name, Call, Comma, String, is_tuple
+from .. import fixer_base
+from ..fixer_util import Name, Call, Comma, String, is_tuple
parend_expr = patcomp.compile_pattern(
)
-class FixPrint(basefix.ConditionalFix):
+class FixPrint(fixer_base.ConditionalFix):
PATTERN = """
simple_stmt< bare='print' any > | print_stmt
# Local imports
from .. import pytree
from ..pgen2 import token
-from .import basefix
-from .util import Name, Call, Attr, ArgList, is_tuple
+from .. import fixer_base
+from ..fixer_util import Name, Call, Attr, ArgList, is_tuple
-class FixRaise(basefix.BaseFix):
+class FixRaise(fixer_base.BaseFix):
PATTERN = """
raise_stmt< 'raise' exc=any [',' val=any [',' tb=any]] >
# Author: Andre Roberge
# Local imports
-from .import basefix
-from .util import Name
+from .. import fixer_base
+from ..fixer_util import Name
-class FixRawInput(basefix.BaseFix):
+class FixRawInput(fixer_base.BaseFix):
PATTERN = """
power< name='raw_input' trailer< '(' [any] ')' > >
# based on Collin Winter's fix_import
# Local imports
-from .import basefix
-from .util import Name, attr_chain, any, set
+from .. import fixer_base
+from ..fixer_util import Name, attr_chain, any, set
MAPPING = {"sys": {"maxint" : "maxsize"},
}
#yield """bare_name=%s""" % alternates(bare)
-class FixRenames(basefix.BaseFix):
+class FixRenames(fixer_base.BaseFix):
PATTERN = "|".join(build_pattern())
order = "pre" # Pre-order tree traversal
"""Fixer that transforms `xyzzy` into repr(xyzzy)."""
# Local imports
-from .import basefix
-from .util import Call, Name
+from .. import fixer_base
+from ..fixer_util import Call, Name
-class FixRepr(basefix.BaseFix):
+class FixRepr(fixer_base.BaseFix):
PATTERN = """
atom < '`' expr=any '`' >
"""Fixer for StandardError -> Exception."""
# Local imports
-from .import basefix
-from .util import Name
+from .. import fixer_base
+from ..fixer_util import Name
-class FixStandarderror(basefix.BaseFix):
+class FixStandarderror(fixer_base.BaseFix):
PATTERN = """
'StandardError'
# Local imports
from .. import pytree
from ..pgen2 import token
-from .import basefix
-from .util import Name, Call, ArgList, Attr, is_tuple
+from .. import fixer_base
+from ..fixer_util import Name, Call, ArgList, Attr, is_tuple
-class FixThrow(basefix.BaseFix):
+class FixThrow(fixer_base.BaseFix):
PATTERN = """
power< any trailer< '.' 'throw' >
# Local imports
from .. import pytree
from ..pgen2 import token
-from .import basefix
-from .util import Assign, Name, Newline, Number, Subscript, syms
+from .. import fixer_base
+from ..fixer_util import Assign, Name, Newline, Number, Subscript, syms
def is_docstring(stmt):
return isinstance(stmt, pytree.Node) and \
stmt.children[0].type == token.STRING
-class FixTupleParams(basefix.BaseFix):
+class FixTupleParams(fixer_base.BaseFix):
PATTERN = """
funcdef< 'def' any parameters< '(' args=any ')' >
['->' any] ':' suite=any+ >
# Local imports
from ..pgen2 import token
-from .import basefix
-from .util import Name
+from .. import fixer_base
+from ..fixer_util import Name
_TYPE_MAPPING = {
'BooleanType' : 'bool',
_pats = ["power< 'types' trailer< '.' name='%s' > >" % t for t in _TYPE_MAPPING]
-class FixTypes(basefix.BaseFix):
+class FixTypes(fixer_base.BaseFix):
PATTERN = '|'.join(_pats)
import re
from ..pgen2 import token
-from .import basefix
+from .. import fixer_base
-class FixUnicode(basefix.BaseFix):
+class FixUnicode(fixer_base.BaseFix):
PATTERN = "STRING | NAME<'unicode' | 'unichr'>"
from .. import pytree
from ..pgen2 import token
-from .import basefix
+from .. import fixer_base
-class FixWsComma(basefix.BaseFix):
+class FixWsComma(fixer_base.BaseFix):
explicit = True # The user must ask for this fixers
"""Fixer that changes xrange(...) into range(...)."""
# Local imports
-from .import basefix
-from .util import Name, Call, consuming_calls
+from .. import fixer_base
+from ..fixer_util import Name, Call, consuming_calls
from .. import patcomp
-class FixXrange(basefix.BaseFix):
+class FixXrange(fixer_base.BaseFix):
PATTERN = """
power< (name='range'|name='xrange') trailer< '(' [any] ')' > any* >
# Author: Collin Winter
# Local imports
-from .import basefix
-from .util import Name
+from .. import fixer_base
+from ..fixer_util import Name
-class FixXreadlines(basefix.BaseFix):
+class FixXreadlines(fixer_base.BaseFix):
PATTERN = """
power< call=any+ trailer< '.' 'xreadlines' > trailer< '(' ')' > >
|
"""
# Local imports
-from . import basefix
-from .util import Name, Call, in_special_context
+from .. import fixer_base
+from ..fixer_util import Name, Call, in_special_context
-class FixZip(basefix.ConditionalFix):
+class FixZip(fixer_base.ConditionalFix):
PATTERN = """
power< 'zip' args=trailer< '(' [any] ')' >
from . import fixes
from . import pygram
-def main(args=None):
+def main(fixer_dir, args=None):
"""Main program.
- Call without arguments to use sys.argv[1:] as the arguments; or
- call with a list of arguments (excluding sys.argv[0]).
+ Args:
+ fixer_dir: directory where fixer modules are located.
+ args: optional; a list of command line arguments. If omitted,
+ sys.argv[1:] is used.
Returns a suggested exit status (0, 1, 2).
"""
options, args = parser.parse_args(args)
if options.list_fixes:
print("Available transformations for the -f/--fix option:")
- for fixname in get_all_fix_names():
+ for fixname in get_all_fix_names(fixer_dir):
print(fixname)
if not args:
return 0
logging.basicConfig(format='%(name)s: %(message)s', level=logging.INFO)
# Initialize the refactoring tool
- rt = RefactoringTool(options)
+ rt = RefactoringTool(fixer_dir, options)
# Refactor all files and directories passed as arguments
if not rt.errors:
return int(bool(rt.errors))
-def get_all_fix_names():
+def get_all_fix_names(fixer_dir):
"""Return a sorted list of all available fix names."""
fix_names = []
- names = os.listdir(os.path.dirname(fixes.__file__))
+ names = os.listdir(fixer_dir)
names.sort()
for name in names:
if name.startswith("fix_") and name.endswith(".py"):
class RefactoringTool(object):
- def __init__(self, options):
+ def __init__(self, fixer_dir, options):
"""Initializer.
- The argument is an optparse.Values instance.
+ Args:
+ fixer_dir: directory in which to find fixer modules.
+ options: an optparse.Values instance.
"""
+ self.fixer_dir = fixer_dir
self.options = options
self.errors = []
self.logger = logging.getLogger("RefactoringTool")
want a pre-order AST traversal, and post_order is the list that want
post-order traversal.
"""
+ fixer_pkg = ".".join(self.fixer_dir.split(os.path.sep))
pre_order_fixers = []
post_order_fixers = []
fix_names = self.options.fix
if not fix_names or "all" in fix_names:
- fix_names = get_all_fix_names()
+ fix_names = get_all_fix_names(self.fixer_dir)
for fix_name in fix_names:
try:
- mod = __import__("lib2to3.fixes.fix_" + fix_name, {}, {}, ["*"])
+ mod = __import__(fixer_pkg + ".fix_" + fix_name, {}, {}, ["*"])
except ImportError:
self.log_error("Can't find transformation %s", fix_name)
continue
def setUp(self):
options = Options(fix=["all", "idioms", "ws_comma", "buffer"],
print_function=False)
- self.refactor = refactor.RefactoringTool(options)
+ self.refactor = refactor.RefactoringTool("lib2to3/fixes", options)
def test_all_project_files(self):
for filepath in support.all_project_files():
# Python imports
import unittest
+from itertools import chain
from os.path import dirname, pathsep
# Local imports
from .. import pygram
from .. import pytree
from .. import refactor
-from ..fixes import util
+from .. import fixer_util
class Options:
class FixerTestCase(support.TestCase):
def setUp(self):
options = Options(fix=[self.fixer], print_function=False)
- self.refactor = refactor.RefactoringTool(options)
+ self.refactor = refactor.RefactoringTool("lib2to3/fixes", options)
self.fixer_log = []
self.filename = "<string>"
- from itertools import chain
for order in (self.refactor.pre_order.values(),\
self.refactor.post_order.values()):
for fixer in chain(*order):
fix = [self.fixer]
fix.extend(names)
options = Options(fix=fix, print_function=False)
- r = refactor.RefactoringTool(options)
+ r = refactor.RefactoringTool("lib2to3/fixes", options)
(pre, post) = r.get_fixers()
n = "fix_" + self.fixer
if post and post[-1].__class__.__module__.endswith(n):
self.check(b, a)
def test_unchanged(self):
- for wrapper in util.consuming_calls:
+ for wrapper in fixer_util.consuming_calls:
s = "s = %s(d.keys())" % wrapper
self.unchanged(s)
self.unchanged("x in range(10, 3, 9)")
def test_in_consuming_context(self):
- for call in util.consuming_calls:
+ for call in fixer_util.consuming_calls:
self.unchanged("a = %s(range(10))" % call)
class Test_raw_input(FixerTestCase):
# Local imports
from .. import pytree
-from ..fixes import util
+from .. import fixer_util
+from ..fixer_util import Attr, Name
def parse(code, strip_levels=0):
class MacroTestCase(support.TestCase):
def assertStr(self, node, string):
if isinstance(node, (tuple, list)):
- node = pytree.Node(util.syms.simple_stmt, node)
+ node = pytree.Node(fixer_util.syms.simple_stmt, node)
self.assertEqual(str(node), string)
class Test_is_tuple(support.TestCase):
def is_tuple(self, string):
- return util.is_tuple(parse(string, strip_levels=2))
+ return fixer_util.is_tuple(parse(string, strip_levels=2))
def test_valid(self):
self.failUnless(self.is_tuple("(a, b)"))
class Test_is_list(support.TestCase):
def is_list(self, string):
- return util.is_list(parse(string, strip_levels=2))
+ return fixer_util.is_list(parse(string, strip_levels=2))
def test_valid(self):
self.failUnless(self.is_list("[]"))
class Test_Attr(MacroTestCase):
def test(self):
- from ..fixes.util import Attr, Name
call = parse("foo()", strip_levels=2)
self.assertStr(Attr(Name("a"), Name("b")), "a.b")
self.assertStr(Attr(call, Name("b")), "foo().b")
def test_returns(self):
- from ..fixes.util import Attr, Name
-
attr = Attr(Name("a"), Name("b"))
self.assertEqual(type(attr), list)
class Test_Name(MacroTestCase):
def test(self):
- from ..fixes.util import Name
-
self.assertStr(Name("a"), "a")
self.assertStr(Name("foo.foo().bar"), "foo.foo().bar")
self.assertStr(Name("a", prefix="b"), "ba")
def _find_bind_rec(self, name, node):
# Search a tree for a binding -- used to find the starting
# point for these tests.
- c = util.find_binding(name, node)
+ c = fixer_util.find_binding(name, node)
if c: return c
for child in node.children:
c = self._find_bind_rec(name, child)
node = parse(string)
# Find the binding of start -- that's what we'll go from
node = self._find_bind_rec('start', node)
- return util.does_tree_import(package, name, node)
+ return fixer_util.does_tree_import(package, name, node)
def try_with(self, string):
failing_tests = (("a", "a", "from a import b"),
class Test_find_binding(support.TestCase):
def find_binding(self, name, string, package=None):
- return util.find_binding(name, parse(string), package)
+ return fixer_util.find_binding(name, parse(string), package)
def test_simple_assignment(self):
self.failUnless(self.find_binding("a", "a = b"))
projects / python / commitdiff