move from optparse to argparse

tests/unit/conftest.py

@@ -1,5 +1,5 @@
 """Shared fixtures between unit tests."""
-import optparse
+import argparse
 
 import pytest
 
@@ -11,7 +11,7 @@ def options_from(**kwargs):
     kwargs.setdefault('max_doc_length', None)
     kwargs.setdefault('verbose', False)
     kwargs.setdefault('stdin_display_name', 'stdin')
-    return optparse.Values(kwargs)
+    return argparse.Namespace(**kwargs)
 
 
 @pytest.fixture

tests/unit/test_application.py

@@ -1,5 +1,5 @@
 """Tests for the Application class."""
-import optparse
+import argparse
 import sys
 
 import mock
@@ -9,12 +9,12 @@ from flake8.main import application as app
 
 
 def options(**kwargs):
-    """Generate optparse.Values for our Application."""
+    """Generate argparse.Namespace for our Application."""
     kwargs.setdefault('verbose', 0)
     kwargs.setdefault('output_file', None)
     kwargs.setdefault('count', False)
     kwargs.setdefault('exit_zero', False)
-    return optparse.Values(kwargs)
+    return argparse.Namespace(**kwargs)
 
 
 @pytest.fixture

tests/unit/test_base_formatter.py

@@ -1,5 +1,5 @@
 """Tests for the BaseFormatter object."""
-import optparse
+import argparse
 
 import mock
 import pytest
@@ -9,10 +9,10 @@ from flake8.formatting import base
 
 
 def options(**kwargs):
-    """Create an optparse.Values instance."""
+    """Create an argparse.Namespace instance."""
     kwargs.setdefault('output_file', None)
     kwargs.setdefault('tee', False)
-    return optparse.Values(kwargs)
+    return argparse.Namespace(**kwargs)
 
 
 @pytest.mark.parametrize('filename', [None, 'out.txt'])

tests/unit/test_debug.py

@@ -73,9 +73,10 @@ def test_information(system, pyversion, pyimpl):
 def test_print_information_no_plugins(dumps, information, print_mock):
     """Verify we print and exit only when we have plugins."""
     option_manager = mock.Mock(registered_plugins=set())
-    assert debug.print_information(
-        None, None, None, None, option_manager=option_manager,
-    ) is None
+    action = debug.DebugAction(
+        "--bug-report", dest="bug_report", option_manager=option_manager,
+    )
+    assert action(None, None, None, None) is None
     assert dumps.called is False
     assert information.called is False
     assert print_mock.called is False
@@ -91,10 +92,11 @@ def test_print_information(dumps, information, print_mock):
         manager.PluginVersion('mccabe', '0.5.9', False),
     ]
     option_manager = mock.Mock(registered_plugins=set(plugins))
+    action = debug.DebugAction(
+        "--bug-report", dest="bug_report", option_manager=option_manager,
+    )
     with pytest.raises(SystemExit):
-        debug.print_information(
-            None, None, None, None, option_manager=option_manager,
-        )
+        action(None, None, None, None)
     print_mock.assert_called_once_with('{}')
     dumps.assert_called_once_with({}, indent=2, sort_keys=True)
     information.assert_called_once_with(option_manager)

tests/unit/test_decision_engine.py

@@ -1,5 +1,5 @@
 """Tests for the flake8.style_guide.DecisionEngine class."""
-import optparse
+import argparse
 
 import pytest
 
@@ -8,14 +8,14 @@ from flake8 import style_guide
 
 
 def create_options(**kwargs):
-    """Create and return an instance of optparse.Values."""
+    """Create and return an instance of argparse.Namespace."""
     kwargs.setdefault('select', [])
     kwargs.setdefault('extended_default_select', [])
     kwargs.setdefault('ignore', [])
     kwargs.setdefault('extend_ignore', [])
     kwargs.setdefault('disable_noqa', False)
     kwargs.setdefault('enable_extensions', [])
-    return optparse.Values(kwargs)
+    return argparse.Namespace(**kwargs)
 
 
 @pytest.mark.parametrize('ignore_list,extend_ignore,error_code', [

tests/unit/test_filenameonly_formatter.py

@@ -1,15 +1,15 @@
 """Tests for the FilenameOnly formatter object."""
-import optparse
+import argparse
 
 from flake8 import style_guide
 from flake8.formatting import default
 
 
 def options(**kwargs):
-    """Create an optparse.Values instance."""
+    """Create an argparse.Namespace instance."""
     kwargs.setdefault('output_file', None)
     kwargs.setdefault('tee', False)
-    return optparse.Values(kwargs)
+    return argparse.Namespace(**kwargs)
 
 
 def test_caches_filenames_already_printed():

tests/unit/test_merged_config_parser.py

@@ -215,7 +215,7 @@ def test_parsed_hyphenated_and_underscored_names(
     max_line_length in our config files.
     """
     optmanager.add_option('--max-line-length', parse_from_config=True,
-                          type='int')
+                          type=int)
     optmanager.add_option('--enable-extensions', parse_from_config=True,
                           comma_separated_list=True)
     parser = config.MergedConfigParser(optmanager, config_finder)

tests/unit/test_nothing_formatter.py

@@ -1,15 +1,15 @@
 """Tests for the Nothing formatter obbject."""
-import optparse
+import argparse
 
 from flake8 import style_guide
 from flake8.formatting import default
 
 
 def options(**kwargs):
-    """Create an optparse.Values instance."""
+    """Create an argparse.Namespace instance."""
     kwargs.setdefault('output_file', None)
     kwargs.setdefault('tee', False)
-    return optparse.Values(kwargs)
+    return argparse.Namespace(**kwargs)
 
 
 def test_format_returns_nothing():

tests/unit/test_option.py

@@ -1,12 +1,14 @@
 """Unit tests for flake8.options.manager.Option."""
+import functools
+
 import mock
 import pytest
 
 from flake8.options import manager
 
 
-def test_to_optparse():
-    """Test conversion to an optparse.Option class."""
+def test_to_argparse():
+    """Test conversion to an argparse arguments."""
     opt = manager.Option(
         short_option_name='-t',
         long_option_name='--test',
@@ -17,45 +19,26 @@ def test_to_optparse():
     assert opt.normalize_paths is True
     assert opt.parse_from_config is True
 
-    optparse_opt = opt.to_optparse()
-    assert not hasattr(optparse_opt, 'parse_from_config')
-    assert not hasattr(optparse_opt, 'normalize_paths')
-    assert optparse_opt.action == 'count'
+    args, kwargs = opt.to_argparse()
+    assert args == ['-t', '--test']
+    assert kwargs == {'action': 'count', 'type': mock.ANY}
+    assert isinstance(kwargs['type'], functools.partial)
 
 
-@pytest.mark.parametrize('opttype,str_val,expected', [
-    ('float', '2', 2.0),
-    ('complex', '2', (2 + 0j)),
-])
-def test_to_support_optparses_standard_types(opttype, str_val, expected):
-    """Show that optparse converts float and complex types correctly."""
-    opt = manager.Option('-t', '--test', type=opttype)
-    assert opt.normalize_from_setuptools(str_val) == expected
+def test_to_optparse():
+    """Test that .to_optparse() produces a useful error message."""
+    with pytest.raises(AttributeError) as excinfo:
+        manager.Option('--foo').to_optparse()
+    msg, = excinfo.value.args
+    assert msg == 'to_optparse: flake8 now uses argparse'
 
 
-@mock.patch('optparse.Option')
-def test_to_optparse_creates_an_option_as_we_expect(Option):  # noqa: N803
-    """Show that we pass all keyword args to optparse.Option."""
+def test_to_argparse_creates_an_option_as_we_expect():
+    """Show that we pass all keyword args to argparse."""
     opt = manager.Option('-t', '--test', action='count')
-    opt.to_optparse()
-    option_kwargs = {
-        'action': 'count',
-        'default': None,
-        'type': None,
-        'dest': 'test',
-        'nargs': None,
-        'const': None,
-        'choices': None,
-        'callback': None,
-        'callback_args': None,
-        'callback_kwargs': None,
-        'help': None,
-        'metavar': None,
-    }
-
-    Option.assert_called_once_with(
-        '-t', '--test', **option_kwargs
-    )
+    args, kwargs = opt.to_argparse()
+    assert args == ['-t', '--test']
+    assert kwargs == {'action': 'count'}
 
 
 def test_config_name_generation():

tests/unit/test_option_manager.py

@@ -1,5 +1,5 @@
 """Unit tests for flake.options.manager.OptionManager."""
-import optparse
+import argparse
 import os
 
 import mock
@@ -19,8 +19,7 @@ def optmanager():
 
 def test_option_manager_creates_option_parser(optmanager):
     """Verify that a new manager creates a new parser."""
-    assert optmanager.parser is not None
-    assert isinstance(optmanager.parser, optparse.OptionParser) is True
+    assert isinstance(optmanager.parser, argparse.ArgumentParser)
 
 
 def test_add_option_short_option_only(optmanager):
@@ -38,7 +37,7 @@ def test_add_option_long_option_only(optmanager):
     assert optmanager.config_options_dict == {}
 
     optmanager.add_option('--long', help='Test long opt')
-    assert optmanager.options[0].short_option_name is None
+    assert optmanager.options[0].short_option_name is manager._NOARG
     assert optmanager.options[0].long_option_name == '--long'
 
 
@@ -171,7 +170,7 @@ def test_generate_versions_with_format_string(optmanager):
 def test_update_version_string(optmanager):
     """Verify we update the version string idempotently."""
     assert optmanager.version == TEST_VERSION
-    assert optmanager.parser.version == TEST_VERSION
+    assert optmanager.version_action.version == TEST_VERSION
 
     optmanager.registered_plugins = [
         manager.PluginVersion('Testing 100', '0.0.0', False),
@@ -182,7 +181,7 @@ def test_update_version_string(optmanager):
     optmanager.update_version_string()
 
     assert optmanager.version == TEST_VERSION
-    assert (optmanager.parser.version == TEST_VERSION
+    assert (optmanager.version_action.version == TEST_VERSION
             + ' (Testing 100: 0.0.0, Testing 101: 0.0.0, Testing 300: 0.0.0) '
             + utils.get_python_version())
 
@@ -211,9 +210,7 @@ def test_extend_default_ignore(optmanager):
     assert optmanager.extended_default_ignore == set()
 
     optmanager.extend_default_ignore(['T100', 'T101', 'T102'])
-    assert optmanager.extended_default_ignore == {'T100',
-                                                  'T101',
-                                                  'T102'}
+    assert optmanager.extended_default_ignore == {'T100', 'T101', 'T102'}
 
 
 def test_parse_known_args(optmanager):
@@ -222,3 +219,91 @@ def test_parse_known_args(optmanager):
         optmanager.parse_known_args(['--max-complexity', '5'])
 
     assert sysexit.called is False
+
+
+def test_optparse_normalize_callback_option_legacy(optmanager):
+    """Test the optparse shim for `callback=`."""
+    callback_foo = mock.Mock()
+    optmanager.add_option(
+        '--foo',
+        action='callback',
+        callback=callback_foo,
+        callback_args=(1, 2),
+        callback_kwargs={'a': 'b'},
+    )
+    callback_bar = mock.Mock()
+    optmanager.add_option(
+        '--bar',
+        action='callback',
+        type='string',
+        callback=callback_bar,
+    )
+    callback_baz = mock.Mock()
+    optmanager.add_option(
+        '--baz',
+        action='callback',
+        type='string',
+        nargs=2,
+        callback=callback_baz,
+    )
+
+    optmanager.parse_args(['--foo', '--bar', 'bararg', '--baz', '1', '2'])
+
+    callback_foo.assert_called_once_with(
+        mock.ANY,  # the option / action instance
+        '--foo',
+        None,
+        mock.ANY,  # the OptionParser / ArgumentParser
+        1,
+        2,
+        a='b',
+    )
+    callback_bar.assert_called_once_with(
+        mock.ANY,  # the option / action instance
+        '--bar',
+        'bararg',
+        mock.ANY,  # the OptionParser / ArgumentParser
+    )
+    callback_baz.assert_called_once_with(
+        mock.ANY,  # the option / action instance
+        '--baz',
+        ('1', '2'),
+        mock.ANY,  # the OptionParser / ArgumentParser
+    )
+
+
+@pytest.mark.parametrize(
+    ('type_s', 'input_val', 'expected'),
+    (
+        ('int', '5', 5),
+        ('long', '6', 6),
+        ('string', 'foo', 'foo'),
+        ('float', '1.5', 1.5),
+        ('complex', '1+5j', 1 + 5j),
+    ),
+)
+def test_optparse_normalize_types(optmanager, type_s, input_val, expected):
+    """Test the optparse shim for type="typename"."""
+    optmanager.add_option('--foo', type=type_s)
+    opts, args = optmanager.parse_args(['--foo', input_val])
+    assert opts.foo == expected
+
+
+def test_optparse_normalize_choice_type(optmanager):
+    """Test the optparse shim for type="choice"."""
+    optmanager.add_option('--foo', type='choice', choices=('1', '2', '3'))
+    opts, args = optmanager.parse_args(['--foo', '1'])
+    assert opts.foo == '1'
+    # fails to parse
+    with pytest.raises(SystemExit):
+        optmanager.parse_args(['--foo', '4'])
+
+
+def test_optparse_normalize_help(optmanager, capsys):
+    """Test the optparse shim for %default in help text."""
+    optmanager.add_option('--foo', default='bar', help='default: %default')
+    with pytest.raises(SystemExit):
+        optmanager.parse_args(['--help'])
+    out, err = capsys.readouterr()
+    output = out + err
+    assert 'default: bar' in output

tests/unit/test_plugin.py

@@ -1,5 +1,5 @@
 """Tests for flake8.plugins.manager.Plugin."""
-import optparse
+import argparse
 
 import mock
 import pytest
@@ -124,7 +124,7 @@ def test_provide_options():
     entry_point = mock.Mock(spec=['load'])
     plugin_obj = mock.Mock(spec_set=['name', 'version', 'add_options',
                                      'parse_options'])
-    option_values = optparse.Values({'enable_extensions': []})
+    option_values = argparse.Namespace(enable_extensions=[])
     option_manager = mock.Mock()
     plugin = manager.Plugin('T000', entry_point)
     plugin._plugin = plugin_obj

tests/unit/test_style_guide.py

@@ -1,5 +1,5 @@
 """Tests for the flake8.style_guide.StyleGuide class."""
-import optparse
+import argparse
 
 import mock
 import pytest
@@ -11,7 +11,7 @@ from flake8.formatting import base
 
 
 def create_options(**kwargs):
-    """Create and return an instance of optparse.Values."""
+    """Create and return an instance of argparse.Namespace."""
     kwargs.setdefault('select', [])
     kwargs.setdefault('extended_default_select', [])
     kwargs.setdefault('ignore', [])
@@ -19,7 +19,7 @@ def create_options(**kwargs):
     kwargs.setdefault('disable_noqa', False)
     kwargs.setdefault('enable_extensions', [])
     kwargs.setdefault('per_file_ignores', [])
-    return optparse.Values(kwargs)
+    return argparse.Namespace(**kwargs)
 
 
 def test_handle_error_does_not_raise_type_errors():