Refactor importing transformers (#481)

* Remove unused version

* Refactor importing transformers

Author: bhirsz

robotidy/api.py

@@ -1,10 +1,11 @@
 """
 Methods for transforming Robot Framework ast model programmatically.
 """
-from typing import Optional
+from typing import Dict, List, Optional
 
 from robotidy import app, disablers, files, skip, transformers, utils
 from robotidy.config import Config, FormattingConfig
+from robotidy.transformers import TransformConfig, TransformConfigMap
 
 
 def get_skip_config(config):
@@ -54,17 +55,28 @@ def get_formatting_config(config, kwargs):
 
 
 def get_robotidy(src: str, output: Optional[str], **kwargs):
-    def convert_transformers_config(param_name, config):
-        return [converter.convert(tr, None, None) for tr in config.get(param_name, ())]
+    def convert_transformers_config(
+        param_name: str,
+        config: Dict,
+        force_included: bool = False,
+        custom_transformer: bool = False,
+        is_config: bool = False,
+    ) -> List[TransformConfig]:
+        return [
+            TransformConfig(
+                tr, force_include=force_included, custom_transformer=custom_transformer, is_config=is_config
+            )
+            for tr in config.get(param_name, ())
+        ]
 
     # TODO Refactor - Config should be read in one place both for API and CLI
     # TODO Remove kwargs usage - other SDKs are not using this feature
     config = files.find_and_read_config((src,))
     config = {k: str(v) if not isinstance(v, (list, dict)) else v for k, v in config.items()}
-    converter = transformers.TransformType()
-    transformer_list = convert_transformers_config("transform", config)
-    custom_transformers = convert_transformers_config("load-transformers", config)
-    configurations = convert_transformers_config("configure", config)
+    transformer_list = convert_transformers_config("transform", config, force_included=True)
+    custom_transformers = convert_transformers_config("load-transformers", config, custom_transformer=True)
+    configurations = convert_transformers_config("configure", config, is_config=True)
+    transformer_config = TransformConfigMap(transformer_list, custom_transformers, configurations)
     formatting_config = get_formatting_config(config, kwargs)
     exclude = config.get("exclude", None)
     extend_exclude = config.get("extend_exclude", None)
@@ -74,9 +86,7 @@ def convert_transformers_config(param_name, config):
     global_skip = get_skip_config(config)
     language = config.get("language", None)
     configuration = Config(
-        transformers=transformer_list,
-        custom_transformers=custom_transformers,
-        transformers_config=configurations,
+        transformers_config=transformer_config,
         skip=global_skip,
         src=(),
         exclude=exclude,

robotidy/cli.py

@@ -13,10 +13,10 @@
 
     RICH_PRESENT = False
 
-from robotidy import app, decorators, exceptions, files, skip, utils, version
+from robotidy import app, decorators, files, skip, utils, version
 from robotidy.config import Config, FormattingConfig
 from robotidy.rich_console import console
-from robotidy.transformers import TransformType, load_transformers
+from robotidy.transformers import TransformConfig, TransformConfigMap, TransformConfigParameter, load_transformers
 
 CLI_OPTIONS_LIST = [
     {
@@ -170,7 +170,7 @@ def print_transformer_docs(transformer):
 @decorators.optional_rich
 def print_description(name: str, target_version: int):
     # TODO: --desc works only for default transformers, it should also print custom transformer desc
-    transformers = load_transformers([], [], {}, allow_disabled=True, target_version=target_version)
+    transformers = load_transformers(TransformConfigMap([], [], []), allow_disabled=True, target_version=target_version)
     transformer_by_names = {transformer.name: transformer for transformer in transformers}
     if name == "all":
         for transformer in transformers:
@@ -185,19 +185,10 @@ def print_description(name: str, target_version: int):
     return 0
 
 
-def _load_external_transformers(
-    transformers: List,
-    custom_transformers: List[Tuple[str, List]],
-    transformers_from_config: List[Tuple[str, List]],
-    transformer_config: List[Tuple[str, List]],
-    target_version: int,
-):
+def _load_external_transformers(transformers: List, transformers_config: TransformConfigMap, target_version: int):
     external = []
     transformers_names = {transformer.name for transformer in transformers}
-    transformer_config_converted = Config.convert_configure(transformer_config)
-    transformers_from_conf = load_transformers(
-        transformers_from_config, custom_transformers, transformer_config_converted, target_version=target_version
-    )
+    transformers_from_conf = load_transformers(transformers_config, target_version=target_version)
     for transformer in transformers_from_conf:
         if transformer.name not in transformers_names:
             external.append(transformer)
@@ -206,24 +197,15 @@ def _load_external_transformers(
 
 @decorators.optional_rich
 def print_transformers_list(
-    transformers_from_config: List[Tuple[str, List]],
-    custom_transformers: List[Tuple[str, List]],
-    transformer_config: List[Tuple[str, List]],
-    config: Config,
-    target_version: int,
-    list_transformers: str,
+    transformers_config: TransformConfigMap, config: Config, target_version: int, list_transformers: str
 ):
     from rich.table import Table
 
     table = Table(title="Transformers", header_style="bold red")
     table.add_column("Name", justify="left", no_wrap=True)
     table.add_column("Enabled")
-    transformers = load_transformers([], [], {}, allow_disabled=True, target_version=target_version)
-    transformers.extend(
-        _load_external_transformers(
-            transformers, custom_transformers, transformers_from_config, transformer_config, target_version
-        )
-    )
+    transformers = load_transformers(TransformConfigMap([], [], []), allow_disabled=True, target_version=target_version)
+    transformers.extend(_load_external_transformers(transformers, transformers_config, target_version))
 
     for transformer in transformers:
         enabled = transformer.name in config.transformers_lookup
@@ -254,23 +236,23 @@ def print_transformers_list(
 @click.option(
     "--transform",
     "-t",
-    type=TransformType(),
+    type=TransformConfigParameter(),
     multiple=True,
     metavar="TRANSFORMER_NAME",
     help="Transform files from [PATH(S)] with given transformer",
 )
 @click.option(
     "--load-transformers",
     "custom_transformers",
-    type=TransformType(),
+    type=TransformConfigParameter(),
     multiple=True,
     metavar="TRANSFORMER_NAME",
     help="Load custom transformer from the path and run them after default ones.",
 )
 @click.option(
     "--configure",
     "-c",
-    type=TransformType(),
+    type=TransformConfigParameter(),
     multiple=True,
     metavar="TRANSFORMER_NAME:PARAM=VALUE",
     help="Configure transformers",
@@ -490,9 +472,9 @@ def print_transformers_list(
 @decorators.catch_exceptions
 def cli(
     ctx: click.Context,
-    transform: List[Tuple[str, List]],
-    custom_transformers: List[Tuple[str, List]],
-    configure: List[Tuple[str, List]],
+    transform: List[TransformConfig],
+    custom_transformers: List[TransformConfig],
+    configure: List[TransformConfig],
     src: Tuple[str, ...],
     exclude: Optional[Pattern],
     extend_exclude: Optional[Pattern],
@@ -584,14 +566,12 @@ def cli(
         end_line=endline,
         line_length=line_length,
     )
-    # array of some class, that holds info if it's forced, configure or custom
-    # or just name:args TODO
+
+    transformers_config = TransformConfigMap(transform, custom_transformers, configure)
     config = Config(
         formatting=formatting,
         skip=skip_config,
-        transformers=transform,
-        custom_transformers=custom_transformers,
-        transformers_config=configure,
+        transformers_config=transformers_config,
         src=src,
         exclude=exclude,
         extend_exclude=extend_exclude,
@@ -609,7 +589,7 @@ def cli(
     )
 
     if list_transformers:
-        print_transformers_list(transform, custom_transformers, configure, config, target_version, list_transformers)
+        print_transformers_list(transformers_config, config, target_version, list_transformers)
         sys.exit(0)
     if desc is not None:
         return_code = print_description(desc, target_version)

robotidy/config.py

@@ -9,7 +9,7 @@
     Languages = None
 
 from robotidy.files import get_paths
-from robotidy.transformers import load_transformers
+from robotidy.transformers import TransformConfig, TransformConfigMap, load_transformers
 
 
 class FormattingConfig:
@@ -62,9 +62,7 @@ def __init__(
         self,
         formatting: FormattingConfig,
         skip,
-        transformers: List[Tuple[str, List]],
-        custom_transformers: List[Tuple[str, List]],
-        transformers_config: List[Tuple[str, List]],
+        transformers_config: TransformConfigMap,
         src: Tuple[str, ...],
         exclude: Optional[Pattern],
         extend_exclude: Optional[Pattern],
@@ -90,19 +88,12 @@ def __init__(
         self.color = color
         self.reruns = reruns
         self.language = self.get_languages(language)
-        transformers_config = self.convert_configure(transformers_config)
         self.transformers = []
         self.transformers_lookup = dict()
-        self.load_transformers(
-            transformers, custom_transformers, transformers_config, force_order, target_version, skip
-        )
+        self.load_transformers(transformers_config, force_order, target_version, skip)
 
-    def load_transformers(
-        self, transformers, custom_transformers, transformers_config, force_order, target_version, skip
-    ):
+    def load_transformers(self, transformers_config: TransformConfigMap, force_order, target_version, skip):
         transformers = load_transformers(
-            transformers,
-            custom_transformers,
             transformers_config,
             force_order=force_order,
             target_version=target_version,
@@ -116,13 +107,6 @@ def load_transformers(
             self.transformers.append(transformer.instance)
             self.transformers_lookup[transformer.name] = transformer.instance
 
-    @staticmethod
-    def convert_configure(configure: List[Tuple[str, List]]) -> Dict[str, List]:
-        config_map = defaultdict(list)
-        for transformer, args in configure:
-            config_map[transformer].extend(args)
-        return config_map
-
     @staticmethod
     def get_languages(lang):
         if Languages is None:

robotidy/decorators.py

@@ -20,9 +20,6 @@ def wrapper(*args, **kwargs):
             return functools.partial(catch_exceptions)
         try:
             return func(*args, **kwargs)
-        except exceptions.RobotidyConfigError as err:
-            print(f"Error: {err}")
-            sys.exit(1)
         except (click.exceptions.ClickException, click.exceptions.Exit):
             raise
         except Exception as err:

robotidy/exceptions.py

@@ -1,5 +1,10 @@
+import sys
+
+
 class RobotidyConfigError(Exception):
-    pass
+    def __init__(self, err):
+        print(f"Error: {err}")
+        sys.exit(1)
 
 
 class InvalidParameterValueError(RobotidyConfigError):