Add option to expand single star import

This patch add new feature to automatically expand a star 
(wildcard) import to specify all names that used inside the code.

A sample code like this

```python
from math import *
sin(1)
cos(0)
```

will be changed into 

```python
from math import cos, sin
sin(1)
cos(0)
```

Note that there are still 2 bugs regarding this feature, 
which mainly caused by related upstream bug from pyflakes:

1. A function/names that declared but later deleted by `del` 
   command will raise a false positive that the names is
   undeclared and could possibly come from a star import 
   (if present).
   PyCQA/pyflakes#175
2. pyflakes is "inconsistent" on defining an undefined var 
   in case of __all__ is used (like in module API files).
   
```python
from foo import * # contain function_1 and function_2

__all__ = ['function_1', 'function_2', 'function_3']

function_2() # just use it somewhere to trigger pyflake

def function_3:
    return 'something'
```

pyflakes will complain that function_2 is undefined and 
possibly come from module foo. The import then will be 
expanded into...

```python
from foo import function_2
```

But then pyflakes will complain function_1 is undefined 
because its used in `__all__`

Closes #14

autoflake.py

@@ -117,6 +117,20 @@ def unused_import_module_name(messages):
             if module_name:
                 yield (message.lineno, module_name)
 
+def star_import_used_line_numbers(messages):
+    """Yield line number of star import usage"""
+    pattern = r':\ (.+)$'
+    for message in messages:
+        if isinstance(message, pyflakes.messages.ImportStarUsed):
+            yield message.lineno
+
+def star_import_usage_undefined_name(messages):
+    """Yield line number, undefined name, and its possible origin module"""
+    for message in messages:
+        if isinstance(message, pyflakes.messages.ImportStarUsage):
+            undefined_name = message.message_args[0]
+            module_name = message.message_args[1]
+            yield (message.lineno, undefined_name, module_name)
 
 def unused_variable_line_numbers(messages):
     """Yield line numbers of unused variables."""
@@ -272,7 +286,8 @@ def break_up_import(line):
                     for i in sorted(imports.split(','))])
 
 
-def filter_code(source, additional_imports=None,
+def filter_code(source, additional_imports=None, 
+                expand_single_star_import=False,
                 remove_all_unused_imports=False,
                 remove_unused_variables=False):
     """Yield code with unused imports removed."""
@@ -289,6 +304,22 @@ def filter_code(source, additional_imports=None,
     for line_number, module_name in unused_import_module_name(messages):
         marked_unused_module[line_number].append(module_name)
 
+    if expand_single_star_import:
+        marked_star_import_line_numbers = frozenset(
+            star_import_used_line_numbers(messages))        
+        if len(marked_star_import_line_numbers) > 1:
+            # Auto expanding only possible for single star import
+            marked_star_import_line_numbers = frozenset()
+        else:
+            undefined_names = []
+            for line_number, undefined_name, _ \
+                 in star_import_usage_undefined_name(messages):
+                undefined_names.append(undefined_name)
+            if len(undefined_names) == 0:
+                marked_star_import_line_numbers = frozenset()
+    else:
+        marked_star_import_line_numbers = frozenset()
+
     if remove_unused_variables:
         marked_variable_line_numbers = frozenset(
             unused_variable_line_numbers(messages))
@@ -309,11 +340,16 @@ def filter_code(source, additional_imports=None,
                 previous_line=previous_line)
         elif line_number in marked_variable_line_numbers:
             yield filter_unused_variable(line)
+        elif line_number in marked_star_import_line_numbers:
+            yield filter_star_import(line, undefined_names)
         else:
             yield line
 
         previous_line = line
 
+def filter_star_import(line, marked_star_import_undefined_name):
+    undefined_name = sorted(set(marked_star_import_undefined_name))
+    return re.sub(r'\*', ', '.join(undefined_name), line)
 
 def filter_unused_import(line, unused_module, remove_all_unused_imports,
                          imports, previous_line=''):
@@ -448,8 +484,8 @@ def get_line_ending(line):
         return line[non_whitespace_index:]
 
 
-def fix_code(source, additional_imports=None, remove_all_unused_imports=False,
-             remove_unused_variables=False):
+def fix_code(source, additional_imports=None, expand_single_star_import=False,
+             remove_all_unused_imports=False, remove_unused_variables=False):
     """Return code with all filtering run on it."""
     if not source:
         return source
@@ -465,6 +501,7 @@ def fix_code(source, additional_imports=None, remove_all_unused_imports=False,
                 filter_code(
                     source,
                     additional_imports=additional_imports,
+                    expand_single_star_import=expand_single_star_import,
                     remove_all_unused_imports=remove_all_unused_imports,
                     remove_unused_variables=remove_unused_variables))))
 
@@ -486,6 +523,7 @@ def fix_file(filename, args, standard_out):
     filtered_source = fix_code(
         source,
         additional_imports=args.imports.split(',') if args.imports else None,
+        expand_single_star_import=args.expand_single_star_import,
         remove_all_unused_imports=args.remove_all_unused_imports,
         remove_unused_variables=args.remove_unused_variables)
 
@@ -561,6 +599,8 @@ def _main(argv, standard_out, standard_error):
     """
     import argparse
     parser = argparse.ArgumentParser(description=__doc__, prog='autoflake')
+    parser.add_argument('--expand-single-star-import', action='store_true',
+                        help='expand wildcard star import with undefined names')
     parser.add_argument('-i', '--in-place', action='store_true',
                         help='make changes to files instead of printing diffs')
     parser.add_argument('-r', '--recursive', action='store_true',

test_autoflake.py

@@ -96,6 +96,17 @@ def test_get_indentation(self):
         self.assertEqual(' \t ', autoflake.get_indentation(' \t abc  \n\t'))
         self.assertEqual('', autoflake.get_indentation('    '))
 
+    def test_filter_star_import(self):
+        self.assertEqual(
+            'from math import cos',
+            autoflake.filter_star_import('from math import *',
+                                         ['cos']))
+
+        self.assertEqual(
+            'from math import cos, sin',
+            autoflake.filter_star_import('from math import *',
+                                         ['sin', 'cos']))
+
     def test_filter_unused_variable(self):
         self.assertEqual('foo()',
                          autoflake.filter_unused_variable('x = foo()'))
@@ -292,6 +303,35 @@ def test_filter_code_should_respect_noqa(self):
 x = 1
 """)))
 
+    def test_filter_code_expand_single_star_import(self):
+        self.assertEqual(
+            """\
+from math import cos, sin
+sin(1)
+cos(1)
+""",
+            ''.join(autoflake.filter_code("""\
+from math import *
+sin(1)
+cos(1)
+""")))
+
+    def test_filter_code_ignore_multiple_star_import(self):
+        self.assertEqual(
+            """\
+from math import *
+from re import *
+sin(1)
+cos(1)
+""",
+            ''.join(autoflake.filter_code("""\
+from math import *
+from re import *
+sin(1)
+cos(1)
+""")))
+
+
     def test_multiline_import(self):
         self.assertTrue(autoflake.multiline_import(r"""\
 import os, \

test_fuzz.py

@@ -142,6 +142,9 @@ def process_args():
     parser.add_argument('--command', default=AUTOFLAKE_BIN,
                         help='autoflake command (default: %(default)s)')
 
+    parser.add_argument('--expand-single-star-import', action='store_true',
+                        help='expand wildcard star import with undefined names')
+
     parser.add_argument('--imports',
                         help='pass to the autoflake "--imports" option')
 
@@ -174,6 +177,9 @@ def check(args):
                      if os.path.isdir(path)]
 
     options = []
+    if args.expand_single_star_import:
+        options.append('--expand-single-star-import')
+
     if args.imports:
         options.append('--imports=' + args.imports)