Allow to disable selected transformers (#171)

* add missing lexer

* allow to disable selected transformers

* fix lexer name

Author: bhirsz

CHANGES.md

@@ -5,6 +5,7 @@
 ### Features
 - Add extra indent for arguments in Suite Setup/Teardown, Test Setup/Teardown in AlignSettingsSection [#155](https://github.com/MarketSquare/robotframework-tidy/issues/155)
 - OrderSettingsSection will now preserve order of imports. It can be configured to work as before and other settings order can be also preserved [#167](https://github.com/MarketSquare/robotframework-tidy/issues/167)
+- Allow to disable selected transformers [#170](https://github.com/MarketSquare/robotframework-tidy/issues/170)
 
 ### Fixes
 - Do not count documentation length when aligning all columns in settings section  [#156](https://github.com/MarketSquare/robotframework-tidy/issues/156)

docs/source/configuration/configuring_transformers.rst

@@ -13,6 +13,11 @@ transformers will be used. For example::
 In first command robotidy will run only ``NormalizeNewLines`` transformer and it will configure it with ``test_case_lines = 2``.
 In second command robotidy will run all of the transformers but will configure ``NormalizeNewLines`` with ``test_case_lines = 2``.
 
+You can also run all transformers except selected ones. For that you need to configure transformer you want to exclude
+with ``enabled`` parameter::
+
+   robotidy --configure TRANSFORMER_NAME:enabled=False
+
 .. note::
     To see list of available transformers run:
 

docs/source/transformers/AlignSettingsSection.rst

@@ -95,7 +95,7 @@ to 0.
 
 .. tabs::
 
-   .. code-tab:: argument_indent=4 (default)
+   .. code-tab:: robotframework argument_indent=4 (default)
 
         *** Settings ***
         Suite Setup         Start Session
@@ -104,7 +104,7 @@ to 0.
         ...                     password=${PASSWORD}
         Suite Teardown      Close Session
 
-   .. code-tab:: argument_indent=2
+   .. code-tab:: robotframework argument_indent=2
 
         *** Settings ***
         Suite Setup         Start Session
@@ -113,7 +113,7 @@ to 0.
         ...                   password=${PASSWORD}
         Suite Teardown      Close Session
 
-   .. code-tab:: argument_indent=0
+   .. code-tab:: robotframework argument_indent=0
 
         *** Settings ***
         Suite Setup         Start Session

docs/source/transformers/index.rst

@@ -10,6 +10,16 @@ Transformers
 
     *
 
+.. rubric:: List of transformers
+
+To see list of all transformers currently implemented in robotidy run::
+
+    robotidy --list
+
+To see brief docs for selected transformer run::
+
+    robotidy --desc TRANSFORMER_NAME
+
 See :ref:`configuring-transformers` to learn how transformers can be configured.
 
 .. rubric:: Order of transformers
@@ -32,19 +42,9 @@ It will transform files according to internal order (in this example ``ReplaceRu
    robotidy --transform SplitTooLongLine src
    robotidy --transform ReplaceRunKeywordIf src
 
-You can also add ``--force-order`` flag to use order provided in cli:
+You can also add ``--force-order`` flag to use order provided in cli::
+
    robotidy --force-order --transform SplitTooLongLine --transform ReplaceRunKeywordIf src
 
 External transformers are used last. If you want to change this behaviour (for example run your custom transformer
 before default ones) you need to use ``--force-order`` flag.
-
-.. rubric:: List of transformers
-
-To see list of all transformers currently implemented in robotidy run::
-
-    robotidy --list
-
-To see brief docs for selected transformer run::
-
-    robotidy --desc TRANSFORMER_NAME
-

robotidy/transformers/__init__.py

@@ -54,37 +54,41 @@ def import_transformer(name, args):
 def load_transformer(name, args, config):
     # if we configure the same parameter for both --transform and --configure we need to overwrite it
     # it is done by converting to dict and back to list in format of key=value
-    temp_args = {}
-    for arg in chain(args, config.get(name, ())):
-        param, value = arg.split('=', maxsplit=1)
-        temp_args[param] = value
-    args = [f'{key}={value}' for key, value in temp_args.items()]
+    args, enabled = parse_params(args, config)
+    if not enabled:
+        return None
     import_name = f'robotidy.transformers.{name}' if name in TRANSFORMERS else name
     return import_transformer(import_name, args)
 
 
+def parse_params(args, config):
+    temp_args = {}
+    enabled = True
+    for arg in chain(args, config):
+        param, value = arg.split('=', maxsplit=1)
+        if param == 'enabled':
+            enabled = value.lower() == 'true'
+        else:
+            temp_args[param] = value
+    return [f'{key}={value}' for key, value in temp_args.items()], enabled
+
+
 def load_transformers(allowed_transformers, config, allow_disabled=False, force_order=False):
     """ Dynamically load all classes from this file with attribute `name` defined in allowed_transformers """
     loaded_transformers = []
     allowed_mapped = {name: args for name, args in allowed_transformers} if allowed_transformers else {}
     if not force_order:
         for name in TRANSFORMERS:
-            if allowed_mapped:
-                if name in allowed_mapped:
-                    imported_class = load_transformer(name, allowed_mapped[name], config)
-                    if imported_class is None:
-                        return []
-                    loaded_transformers.append(imported_class)
-            else:
-                imported_class = import_transformer(f'robotidy.transformers.{name}', config.get(name, ()))
+            if not allowed_mapped or name in allowed_mapped:
+                imported_class = load_transformer(name, allowed_mapped.get(name, ()), config.get(name, ()))
                 if imported_class is None:
-                    return []
-                if allow_disabled or getattr(imported_class, 'ENABLED', True):
+                    continue
+                if allowed_mapped or allow_disabled or getattr(imported_class, 'ENABLED', True):
                     loaded_transformers.append(imported_class)
     for name in allowed_mapped:
         if force_order or name not in TRANSFORMERS:
-            imported_class = load_transformer(name, allowed_mapped[name], config)
+            imported_class = load_transformer(name, allowed_mapped[name], config.get(name, ()))
             if imported_class is None:
-                return []
+                continue
             loaded_transformers.append(imported_class)
     return loaded_transformers

tests/utest/test_cli.py

@@ -321,3 +321,30 @@ def test_line_sep(self, line_sep):
         with open(str(actual), newline='') as f:
             actual_str = f.read()
         assert actual_str == expected_str, 'Line endings does not match'
+
+    @pytest.mark.parametrize('force_order', [True, False])
+    @pytest.mark.parametrize('allow_disabled', [True, False])
+    @pytest.mark.parametrize('transformers, configure, present', [
+        (None, {}, True),
+        (None, {'AlignVariablesSection': ['enabled=True']}, True),
+        (None, {'AlignVariablesSection': ['enabled=false']}, False),
+        ([('NormalizeAssignments', [])], {}, False),
+        ([('NormalizeAssignments', []), ('AlignVariablesSection', [])], {}, True),
+        ([('NormalizeAssignments', []), ('AlignVariablesSection', ['up_to_column=4'])], {}, True),
+        ([('NormalizeAssignments', []), ('AlignVariablesSection', ['up_to_column=4', 'enabled=True'])], {}, True),
+        ([('NormalizeAssignments', []), ('AlignVariablesSection', ['up_to_column=4', 'enabled=False'])], {}, False),
+        ([('NormalizeAssignments', []), ('AlignVariablesSection', ['up_to_column=4'])],
+         {'AlignVariablesSection': ['enabled=True']}, True),
+        ([('NormalizeAssignments', []), ('AlignVariablesSection', ['up_to_column=4'])],
+         {'AlignVariablesSection': ['enabled=False']}, False)
+    ])
+    def test_disable_transformers(self, transformers, configure, present, force_order, allow_disabled):
+        if force_order and not transformers:
+            present = False
+        disabled_transformer = 'AlignVariablesSection'
+        transformers = load_transformers(transformers, configure, allow_disabled=allow_disabled,
+                                         force_order=force_order)
+        if present:
+            assert any(transformer.__class__.__name__ == disabled_transformer for transformer in transformers)
+        else:
+            assert all(transformer.__class__.__name__ != disabled_transformer for transformer in transformers)