Add explicit -f/--fix=FIX option to futurize script (issue #39)

Author: edschofield

libfuturize/fixes/__init__.py

@@ -6,6 +6,7 @@
 # projects that are happy to drop support for Py2.5 and below. Applying
 # them first will reduce the size of the patch set for the real porting.
 lib2to3_fix_names_stage1 = set([
+    'lib2to3.fixes.fix_absolute_import',   # FAKE: TESTING ONLY
     'lib2to3.fixes.fix_apply',
     'lib2to3.fixes.fix_except',
     'lib2to3.fixes.fix_exitfunc',

libfuturize/main.py

@@ -49,6 +49,16 @@
 This adds the declaration ``from __future__ import unicode_literals`` to the
 top of each file, which implicitly declares all unadorned string literals to be
 unicode strings (``unicode`` on Py2).
+
+All imports
+-----------
+
+The --all-imports option forces adding all ``__future__`` imports and ``from
+future import standard_library``, even if they don't seem necessary for
+the current state of each module. (This can simplify testing, and can
+reduce the need to think about Py2 compatibility when editing the code
+further.)
+
 """
 
 from __future__ import (absolute_import, print_function, unicode_literals)
@@ -57,6 +67,7 @@
 import sys
 import logging
 import optparse
+import os
 
 from lib2to3.main import main, warn, StdoutRefactoringTool
 from lib2to3 import refactor
@@ -66,12 +77,20 @@
                                libfuturize_fix_names_stage1,
                                libfuturize_fix_names_stage2)
 
+fixer_pkg = 'libfuturize.fixes'
+
 
 def main(args=None):
     """Main program.
 
+    Args:
+        fixer_pkg: the name of a package where the fixers 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).
     """
+
     # Set up option parser
     parser = optparse.OptionParser(usage="futurize [options] file|dir ...")
     parser.add_option("-a", "--all-imports", action="store_true",
@@ -87,15 +106,15 @@ def main(args=None):
     parser.add_option("-u", "--unicode-literals", action="store_true",
                       help="Add ``from __future__ import unicode_literals`` to implicitly convert all unadorned string literals '' into unicode strings")
     parser.add_option("-f", "--fix", action="append", default=[],
-                      help="Each FIX specifies a transformation; default: all")
+                      help="Each FIX specifies a transformation; default: all.\nEither use '-f division -f metaclass' etc. or use the fully-qualified module name: '-f lib2to3.fixes.fix_types -f libfuturize.fixes.fix_unicode_keep_u'")
     parser.add_option("-j", "--processes", action="store", default=1,
                       type="int", help="Run 2to3 concurrently")
     parser.add_option("-x", "--nofix", action="append", default=[],
                       help="Prevent a fixer from being run.")
     parser.add_option("-l", "--list-fixes", action="store_true",
                       help="List available transformations")
-    # parser.add_option("-p", "--print-function", action="store_true",
-    #                   help="Modify the grammar so that print() is a function")
+    parser.add_option("-p", "--print-function", action="store_true",
+                      help="Modify the grammar so that print() is a function")
     parser.add_option("-v", "--verbose", action="store_true",
                       help="More verbose logging")
     parser.add_option("--no-diffs", action="store_true",
@@ -104,13 +123,51 @@ def main(args=None):
                       help="Write back modified files")
     parser.add_option("-n", "--nobackups", action="store_true", default=False,
                       help="Don't write backups for modified files.")
+    parser.add_option("-o", "--output-dir", action="store", type="str",
+                      default="", help="Put output files in this directory "
+                      "instead of overwriting the input files.  Requires -n.")
+    parser.add_option("-W", "--write-unchanged-files", action="store_true",
+                      help="Also write files even if no changes were required"
+                      " (useful with --output-dir); implies -w.")
+    parser.add_option("--add-suffix", action="store", type="str", default="",
+                      help="Append this string to all output filenames."
+                      " Requires -n if non-empty.  "
+                      "ex: --add-suffix='3' will generate .py3 files.")
+
+    avail_fixes = set()
 
     # Parse command line arguments
     refactor_stdin = False
-    flags = {}
     options, args = parser.parse_args(args)
-    fixer_pkg = 'libfuturize.fixes'
-    avail_fixes = set()
+    if options.write_unchanged_files:
+        flags["write_unchanged_files"] = True
+        if not options.write:
+            warn("--write-unchanged-files/-W implies -w.")
+        options.write = True
+    # If we allowed these, the original files would be renamed to backup names
+    # but not replaced.
+    if options.output_dir and not options.nobackups:
+        parser.error("Can't use --output-dir/-o without -n.")
+    if options.add_suffix and not options.nobackups:
+        parser.error("Can't use --add-suffix without -n.")
+
+    if not options.write and options.no_diffs:
+        warn("not writing files and not printing diffs; that's not very useful")
+    if not options.write and options.nobackups:
+        parser.error("Can't use -n without -w")
+    if "-" in args:
+        refactor_stdin = True
+        if options.write:
+            print("Can't write to stdin.", file=sys.stderr)
+            return 2
+    # Is this ever necessary?
+    if options.print_function:
+        flags["print_function"] = True
+
+    # Set up logging handler
+    level = logging.DEBUG if options.verbose else logging.INFO
+    logging.basicConfig(format='%(name)s: %(message)s', level=level)
+
     if options.stage1 or options.stage2:
         assert options.both_stages is None
         options.both_stages = False
@@ -123,16 +180,12 @@ def main(args=None):
         avail_fixes.update(lib2to3_fix_names_stage2)
         avail_fixes.update(libfuturize_fix_names_stage2)
 
-    # if options.tobytes:
-    #     avail_fixes.add('libfuturize.fixes.fix_bytes')
     if options.unicode_literals:
         avail_fixes.add('libfuturize.fixes.fix_unicode_literals_import')
-    if not options.write and options.no_diffs:
-        warn("not writing files and not printing diffs; that's not very useful")
-    if not options.write and options.nobackups:
-        parser.error("Can't use -n without -w")
+
     if options.list_fixes:
         print("Available transformations for the -f/--fix option:")
+        # for fixname in sorted(refactor.get_all_fix_names(fixer_pkg)):
         for fixname in sorted(avail_fixes):
             print(fixname)
         if not args:
@@ -142,24 +195,12 @@ def main(args=None):
               file=sys.stderr)
         print("Use --help to show usage.", file=sys.stderr)
         return 2
-    if "-" in args:
-        refactor_stdin = True
-        if options.write:
-            print("Can't write to stdin.", file=sys.stderr)
-            return 2
 
-    # Is this ever necessary?
-    # if options.print_function:
-    #     flags["print_function"] = True
-
-    # Set up logging handler
-    level = logging.DEBUG if options.verbose else logging.INFO
-    logging.basicConfig(format='%(name)s: %(message)s', level=level)
+    flags = {}
 
-    # Initialize the refactoring tool
     unwanted_fixes = set(fixer_pkg + ".fix_" + fix for fix in options.nofix)
 
-    # The 'all-imports' option forces adding all imports __future__ and "from
+    # The 'all-imports' option forces adding all __future__ imports and "from
     # future import standard_library", even if they don't seem necessary for
     # the current state of each module. (This can simplify testing, and can
     # reduce the need to think about Py2 compatibility when editing the code
@@ -175,11 +216,51 @@ def main(args=None):
             extra_fixes.add(prefix + 'fix_add__future__imports')
             extra_fixes.add(prefix + 'fix_add_future_standard_library_import')
             extra_fixes.add(prefix + 'fix_add_all_future_builtins')
+    explicit = set()
+    if options.fix:
+        all_present = False
+        for fix in options.fix:
+            if fix == 'all':
+                all_present = True
+            else:
+                if ".fix_" in fix:
+                    explicit.add(fix)
+                else:
+                    # Infer the full module name for the fixer.
+                    # First ensure that no names clash (e.g.
+                    # lib2to3.fixes.fix_blah and libfuturize.fixes.fix_blah):
+                    found = [f for f in avail_fixes if 'fix_{}'.format(fix) in f]
+                    if len(found) > 1:
+                        print("Ambiguous fixer name. Choose a fully qualified "
+                              "module name instead from these:\n" +
+                              "\n".join("  " + myf for myf in found),
+                              file=sys.stderr)
+                        return 2
+                    explicit.add(found[0])
+        requested = avail_fixes.union(explicit) if all_present else explicit
+    else:
+        requested = avail_fixes.union(explicit)
+    fixer_names = requested | extra_fixes - unwanted_fixes
+
+    input_base_dir = os.path.commonprefix(args)
+    if (input_base_dir and not input_base_dir.endswith(os.sep)
+        and not os.path.isdir(input_base_dir)):
+        # One or more similar names were passed, their directory is the base.
+        # os.path.commonprefix() is ignorant of path elements, this corrects
+        # for that weird API.
+        input_base_dir = os.path.dirname(input_base_dir)
+    if options.output_dir:
+        input_base_dir = input_base_dir.rstrip(os.sep)
+        logger.info('Output in %r will mirror the input directory %r layout.',
+                    options.output_dir, input_base_dir)
 
-    fixer_names = avail_fixes | extra_fixes - unwanted_fixes
-
-    rt = StdoutRefactoringTool(sorted(fixer_names), flags, set(),
-                               options.nobackups, not options.no_diffs)
+    # Initialize the refactoring tool
+    rt = StdoutRefactoringTool(
+            sorted(fixer_names), flags, sorted(explicit),
+            options.nobackups, not options.no_diffs,
+            input_base_dir=input_base_dir,
+            output_dir=options.output_dir,
+            append_suffix=options.add_suffix)
 
     # Refactor all files and directories passed as arguments
     if not rt.errors:
@@ -198,4 +279,3 @@ def main(args=None):
 
     # Return error status (0 if rt.errors is zero)
     return int(bool(rt.errors))
-