robotframework-robocop 8.6.0__tar.gz → 8.7.0__tar.gz

robotframework_robocop-8.7.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "8.7.0"
+}

{robotframework_robocop-8.6.0 → robotframework_robocop-8.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: robotframework-robocop
-Version: 8.6.0
+Version: 8.7.0
 Summary: Static code analysis tool (linter) and code formatter for Robot Framework
 Project-URL: Bug tracker, https://github.com/MarketSquare/robotframework-robocop/issues
 Project-URL: Source code, https://github.com/MarketSquare/robotframework-robocop

{robotframework_robocop-8.6.0 → robotframework_robocop-8.7.0}/docs/releasenotes/changelog.md

@@ -1,5 +1,18 @@
 # Release notes
 
+## [8.7.0](https://github.com/MarketSquare/robotframework-robocop/compare/v8.6.0...v8.7.0) (2026-08-12)
+
+
+### Features
+
+* add --verbose option to list formatters command to print configurables ([#1802](https://github.com/MarketSquare/robotframework-robocop/issues/1802)) ([d425866](https://github.com/MarketSquare/robotframework-robocop/commit/d425866a062c7f22aca5ff680920104808e580e9))
+* Make list rules more verbose; print configurables (with --verbose) and default/modified values ([#1799](https://github.com/MarketSquare/robotframework-robocop/issues/1799)) ([5d94399](https://github.com/MarketSquare/robotframework-robocop/commit/5d9439917486c373fdef9f91dde204bc1c34b0ab))
+
+
+### Bug Fixes
+
+* robocop docs formatters fails to print non-default formatters ([#1801](https://github.com/MarketSquare/robotframework-robocop/issues/1801)) ([703ebeb](https://github.com/MarketSquare/robotframework-robocop/commit/703ebebe60b88e324b875eb99dfbdb9771bbfe07))
+
 ## [8.6.0](https://github.com/MarketSquare/robotframework-robocop/compare/v8.5.0...v8.6.0) (2026-08-06)
 
 

{robotframework_robocop-8.6.0 → robotframework_robocop-8.7.0}/pyproject.toml

@@ -249,4 +249,4 @@ ignore_missing_imports = true
 # Also uses untyped decorators from typer/click and subclasses from Any-typed base classes
 [[tool.mypy.overrides]]
 module = "robocop.run"
-disable_error_code = ["arg-type", "attr-defined", "unused-ignore", "misc"]
+disable_error_code = ["arg-type", "attr-defined", "unused-ignore", "misc"]

robotframework_robocop-8.7.0/src/robocop/__init__.py

@@ -0,0 +1 @@
+__version__ = "8.7.0"  # x-release-please-version

{robotframework_robocop-8.6.0 → robotframework_robocop-8.7.0}/src/robocop/formatter/formatters/__init__.py

@@ -80,9 +80,10 @@ IMPORTER = Importer()
 
 
 class FormatterParameter:
-    def __init__(self, name: str, default_value: Any) -> None:
+    def __init__(self, name: str, default_value: Any, configured_value: Any) -> None:
         self.name = name
         self.value = default_value
+        self.configured_value = configured_value
 
     def __str__(self) -> str:
         if self.value is not None and str(self.value) != "":
@@ -97,17 +98,17 @@ class FormatterContainer:
         self.instance = instance
         self.name = instance.__class__.__name__
         self.enabled_by_default = getattr(instance, "ENABLED", True)
-        self.parameters = self.get_parameters(argument_names, spec)
+        self.parameters = self.get_parameters(argument_names, spec, args)
         self.args = args
 
-    def get_parameters(self, argument_names: list[str], spec: Any) -> list[FormatterParameter]:
+    def get_parameters(self, argument_names: list[str], spec: Any, args: dict[str, Any]) -> list[FormatterParameter]:
         params = []
         for arg in argument_names:
             if arg == "enabled":
                 default = self.enabled_by_default
             else:
                 default = spec.defaults.get(arg, None)
-            params.append(FormatterParameter(arg, default))
+            params.append(FormatterParameter(arg, default, args.get(arg)))
         return params
 
     def __str__(self) -> str:
@@ -123,6 +124,7 @@ class Formatter(ModelTransformer):  # type: ignore[misc]
     # Injected at runtime
     skip: Skip
     formatting_config: WhitespaceConfig
+    default_parameters: list[FormatterParameter]
     disablers: DisablersInFile
     languages: Languages
     config_directory: Path

{robotframework_robocop-8.6.0 → robotframework_robocop-8.7.0}/src/robocop/linter/rules/__init__.py

@@ -170,12 +170,7 @@ class RuleParam:
         self.raw_value = None
         self._value = None
         self.value = default
-
-    def __str__(self) -> str:
-        s = f"{self.name} = {self.raw_value}\n        type: {self.converter.__name__}"
-        if self.desc:
-            s += f"\n        info: {self.desc}"
-        return s
+        self.default = default
 
     @property
     def value(self) -> Any:
@@ -195,6 +190,21 @@ class RuleParam:
             return self.converter.__name__
         return self.show_type
 
+    def __str__(self) -> str:
+        s = f"{self.name} = {self.raw_value}\n        type: {self.converter.__name__}"
+        if self.desc:
+            s += f"\n        info: {self.desc}"
+        return s
+
+    def get_desc(self, compare_default: bool) -> str:
+        value = str(self.raw_value)
+        if compare_default and self.raw_value != self.default:
+            value += f"[cyan]*[/cyan] (default: {self.default})"
+        s = f"{self.name} = {value}\n        type: {self.converter.__name__}"
+        if self.desc:
+            s += f"\n        info: {self.desc}"
+        return s
+
 
 class SeverityThreshold:
     """
@@ -293,6 +303,12 @@ class SeverityThreshold:
     def __str__(self) -> str:
         return self.name
 
+    def get_desc(self, compare_default: bool) -> str:  # noqa: ARG002
+        if not self.thresholds:
+            return f"{self.name} = None\n        type: severity_threshold"
+        value = ":".join(f"{sev.value}={threshold}" for sev, threshold in self.thresholds)
+        return f"{self.name} = {value}\n        type: severity_threshold"
+
 
 class Rule:
     """
@@ -309,6 +325,7 @@ class Rule:
         version (str): (class attribute) supported Robot Framework version (ie: >=4.0)
         added_in_version (str): (class attribute) version of the Robocop when the Rule was created
         enabled (bool): (class attribute) enable/disable rule by default using this parameter
+        default_enabled (bool): (class attribute) store default value of enabled parameter for documentation purpose
         deprecated (bool): (class attribute) deprecated rule. If rule is used in configuration, it will issue a warning
         file_wide_rule (bool): (class attribute) If set, rule is reported for whole file
         parameters: (class attribute) optional rule parameters
@@ -331,6 +348,7 @@ class Rule:
     version_spec: VersionSpecifier | None = None
     added_in_version: str | None = None
     enabled: bool = True
+    default_enabled: bool = True
     deprecated: bool = False
     file_wide_rule: bool = False
     parameters: list[RuleParam] | None = None
@@ -347,6 +365,7 @@ class Rule:
 
     def load_config(self) -> None:
         self.version_spec = VersionSpecifier(self.version) if self.version else None
+        self.default_enabled = self.enabled
         self.default_severity = self.severity  # used for defaultConfiguration in Sarif report
         self.config = self._parse_parameters()
         self.supported_version = self.version if self.version else "All"
@@ -396,13 +415,20 @@ class Rule:
         description += self.docs
         return description
 
+    @property
+    def configurables_description(self) -> str:
+        count, configurables = self.available_configurables(include_severity=False, compare_default=True)
+        if not count:
+            return ""
+        return f"\nConfigurables:\n    {configurables}\n"
+
     @property
     def description_with_configurables(self) -> str:
         description = self.description
-        count, configurables = self.available_configurables(include_severity=False)
-        if not count:
+        configurables_description = self.configurables_description
+        if not configurables_description:
             return description
-        return f"{description}\nConfigurables:\n    {configurables}\n"
+        return f"{description}{configurables_description}"
 
     @property
     def deprecation_warning(self) -> str:
@@ -428,21 +454,6 @@ class Rule:
     def is_disabled(self, target_version: Version) -> bool:
         return self.deprecated or not self.supported_in_target_version(target_version)
 
-    def rule_short_description(self, target_version: Version) -> str:
-        if self.deprecated:
-            enable_desc = "deprecated"
-        elif self.version and not self.supported_in_target_version(target_version):
-            enable_desc = f"disabled - supported only for RF version {self.version}"
-        elif self.enabled:
-            enable_desc = "enabled"
-        else:
-            enable_desc = "disabled"
-        if self.fix_availability in (FixAvailability.ALWAYS, FixAvailability.SOMETIMES):
-            fix_present = r" \[fixable]"
-        else:
-            fix_present = ""
-        return f"{self.rule_id} [{self.severity}]: {self.name}: {self.message} ({enable_desc}){fix_present}"
-
     def __str__(self) -> str:
         return f"Rule [{self.rule_id}]: {self.name} {self.message}"
 
@@ -459,12 +470,12 @@ class Rule:
             # To use parameter also as rule attribute (for example severity), you need to skip getattr
             self.severity = RuleSeverity.parser(value)
 
-    def available_configurables(self, include_severity: bool = True) -> tuple[int, str]:
+    def available_configurables(self, include_severity: bool = True, compare_default: bool = False) -> tuple[int, str]:
         params = []
         for param in self.config.values():
             if (param.name == "severity" and not include_severity) or param.name == "enabled":
                 continue
-            params.append(str(param))
+            params.append(param.get_desc(compare_default))
         if not params:
             return 0, ""
         count = len(params)

{robotframework_robocop-8.6.0 → robotframework_robocop-8.7.0}/src/robocop/linter/rules_list.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 from enum import Enum
 from typing import TYPE_CHECKING
 
+from rich.text import Text
+
 from robocop.linter.fix import FixAvailability
 
 if TYPE_CHECKING:
@@ -65,3 +67,24 @@ def filter_rules_by_category(rules: dict[str, Rule], category: RuleFilter, targe
 
 def filter_rules_by_fixability(rules: list[Rule]) -> list[Rule]:
     return [rule for rule in rules if rule.fix_availability in (FixAvailability.ALWAYS, FixAvailability.SOMETIMES)]
+
+
+def rule_short_description(rule: Rule, target_version: Version) -> Text:
+    desc = Text(f"{rule.rule_id} [{rule.severity}]: {rule.name}: {rule.message} (")
+    if rule.deprecated:
+        desc.append("deprecated", style="yellow")
+    elif rule.version and not rule.supported_in_target_version(target_version):
+        desc.append("disabled", style="red")
+        desc.append(f" - supported only for RF version {rule.version}")
+    elif rule.enabled:
+        desc.append("enabled", style="green")
+        if rule.default_enabled != rule.enabled:
+            desc.append("*", style="cyan")
+    else:
+        desc.append("disabled", style="red")
+        if rule.default_enabled != rule.enabled:
+            desc.append("*", style="cyan")
+    desc.append(")")
+    if rule.fix_availability in (FixAvailability.ALWAYS, FixAvailability.SOMETIMES):
+        desc.append(" [fixable]", style="blue")
+    return desc

{robotframework_robocop-8.6.0 → robotframework_robocop-8.7.0}/src/robocop/run.py

@@ -773,6 +773,7 @@ def list_rules(
     with_fix: Annotated[bool, typer.Option("--with-fix", help="Show only fixable rules")] = False,
     configuration_file: config_option = None,
     silent: silent_option = None,
+    verbose: verbose_option = None,
     return_result: Annotated[
         bool,
         typer.Option(
@@ -819,7 +820,9 @@ def list_rules(
         rule.enabled = rule.enabled and not rule.is_disabled(config_manager.default_config.linter.target_version)
         enabled += int(rule.enabled)
         if not silent:
-            console.print(rule.rule_short_description(config_manager.default_config.linter.target_version))
+            console.print(rules_list.rule_short_description(rule, config_manager.default_config.linter.target_version))
+            if verbose and (config_desc := rule.configurables_description):
+                console.print(config_desc)
         severity_counter[rule.severity.value] += 1
     configurable_rules_sum = sum(severity_counter.values())
     plural = get_plural_form(configurable_rules_sum)
@@ -871,9 +874,11 @@ def list_formatters(
     ] = rules_list.RuleFilter.ALL,
     target_version: formatter_target_version = None,
     configuration_file: config_option = None,
-    silent: silent_option = None,
+    silent: silent_option = None,  # TODO: why it's there
+    verbose: verbose_option = None,
 ) -> None:
     """List available formatters."""
+    from rich.box import MINIMAL  # noqa: PLC0415
     from rich.table import Table  # noqa: PLC0415
 
     console = Console(soft_wrap=True)
@@ -893,16 +898,28 @@ def list_formatters(
     else:
         raise ValueError(f"Unrecognized rule category '{filter_category}'")
     if not silent:
-        table = Table(title="Formatters", header_style="bold red")
+        table = Table(title="Formatters", header_style="bold", box=MINIMAL)
         table.add_column("Name", justify="left", no_wrap=True)
         table.add_column("Enabled")
         for formatter in formatters:
-            decorated_enable = "Yes" if formatter.ENABLED else "No"
-            table.add_row(formatter.__class__.__name__, decorated_enable)
+            decorated_enable = "[green]Yes[/green]" if formatter.ENABLED else "[red]No[/red]"
+            formatter_desc = formatter.__class__.__name__
+            if verbose:
+                for param in formatter.default_parameters:
+                    if param.name == "enabled":
+                        continue
+                    if param.configured_value is not None:
+                        value = f"\n    {param.name} = {param.configured_value}[cyan]*[/cyan] (default: {param.value})"
+                    else:
+                        value = f"\n    {param.name} = {param.value}"
+                    formatter_desc += value
+            table.add_row(formatter_desc, decorated_enable)
         console.print(table)
         console.print(
+            "To see configurable parameters run:\n"
+            "    [bold]robocop list formatters --verbose[/]\n"
             "To see detailed docs run:\n"
-            "    [bold]robocop docs [blue]formatter_name[/][/]\n"
+            "    [bold]robocop docs [blue]formatter_name[/][/]\n\n"
             "Non-default formatters needs to be selected explicitly with [bold cyan]--select[/] or "
             "configured with param `enabled=True`.\n"
         )
@@ -916,7 +933,8 @@ def print_resource_documentation(
     """Print formatter, rule or report documentation."""
     # TODO load external from cli
     console = Console(soft_wrap=True)
-    config_manager = manager.ConfigManager(config=configuration_file)
+    overwrite_config = schema.RawConfig(formatter=schema.RawFormatterConfig(allow_disabled=True))
+    config_manager = manager.ConfigManager(config=configuration_file, overwrite_config=overwrite_config)
     resolver = ConfigResolver(load_rules=True, load_formatters=True)
     resolved_config = resolver.resolve_config(config_manager.default_config)
 

{robotframework_robocop-8.6.0 → robotframework_robocop-8.7.0}/src/robocop/runtime/resolver.py

@@ -475,12 +475,17 @@ class RulesLoader:
 
         # map checker rules to global rules & check for disabled rule
         for rule_name_or_id, rule in checker.rules.items():
-            self.apply_configuration(rule, rule_name_or_id)
+            # dirty deduplication
+            if rule_name_or_id in self.rules:
+                continue
+            self.apply_configuration(rule, rule.name)
+            self.apply_configuration(rule, rule.rule_id)
             rule.enabled = self.rule_matcher.is_rule_enabled(rule)
             if rule.enabled:
                 any_enabled = True
                 rule.fixable = self.rule_matcher.is_rule_fixable(rule)
-            self.rules[rule_name_or_id] = rule
+            self.rules[rule.name] = rule
+            self.rules[rule.rule_id] = rule
             rule.checker = checker
         # if the checker does not have enabled rules, we skip it. Rules are registered anyway, for listing or docs
         if not any_enabled:  # let's not register disabled checkers
@@ -567,6 +572,7 @@ class FormattersLoader:
                     continue
                 container.instance.ENABLED = enabled_in_version and enabled
                 container.instance.formatting_config = self.whitespace_config
+                container.instance.default_parameters = container.parameters
                 container.instance.formatters = self.formatters
                 container.instance.languages = self.languages
                 self.formatters[container.name] = container.instance

{robotframework_robocop-8.6.0 → robotframework_robocop-8.7.0}/tests/linter/cli/test_list_rules.py

@@ -5,7 +5,7 @@ from unittest.mock import Mock, patch
 import pytest
 
 from robocop.config.parser import TargetVersion
-from robocop.linter.rules import Rule, RuleSeverity
+from robocop.linter.rules import Rule, RuleParam, RuleSeverity
 from robocop.linter.rules_list import RuleFilter
 from robocop.run import list_rules
 from robocop.runtime.resolver import ConfigResolver
@@ -43,6 +43,15 @@ def rule_0101() -> Rule:
     return get_mocked_rule(rule_id="0101")
 
 
+@pytest.fixture
+def rule_0101_configurable() -> Rule:
+    parameters = [
+        RuleParam(name="max_len", default=40, converter=int, desc="number of lines allowed in a keyword"),
+        RuleParam(name="ignore_docs", default=False, converter=str, show_type="bool", desc="Ignore documentation"),
+    ]
+    return get_mocked_rule(rule_id="0101", parameters=parameters)
+
+
 @pytest.fixture
 def rule_0102() -> Rule:
     return get_mocked_rule(
@@ -115,6 +124,71 @@ class TestListingRules:
             "Visit https://robocop.dev/stable/rules_list/ page for detailed documentation.\n"
         )
 
+    def test_list_rule_verbose(
+        self, capsys, tmp_path, rule_0101_configurable, rule_non_default, rule_deprecated, rule_deprecated_disabled
+    ):
+        """List rules with default options in verbose mode."""
+        mocked_config = get_resolved_config(
+            rule_0101_configurable, rule_non_default, rule_deprecated, rule_deprecated_disabled
+        )
+        resolver_mock = Mock(spec=ConfigResolver)
+        resolver_instance_mock = Mock()
+        resolver_mock.return_value = resolver_instance_mock
+        resolver_instance_mock.resolve_config.return_value = mocked_config
+
+        with (
+            working_directory(tmp_path),
+            patch("robocop.run.ConfigResolver", resolver_mock),
+        ):
+            list_rules(verbose=True)
+        out, _ = capsys.readouterr()
+        assert (
+            out == "0101 [W]: some-message: Some description (enabled)\n\n"
+            "Configurables:\n"
+            "    max_len = 40\n"
+            "        type: int\n"
+            "        info: number of lines allowed in a keyword\n"
+            "    ignore_docs = False\n"
+            "        type: str\n"
+            "        info: Ignore documentation\n\n"
+            "19999 [W]: non-default-rule: Some description (disabled)\n\n"
+            "Altogether 2 rules (1 enabled).\n\n"
+            "Visit https://robocop.dev/stable/rules_list/ page for detailed documentation.\n"
+        )
+
+    def test_list_rule_verbose_with_modified_value(
+        self, capsys, tmp_path, rule_0101_configurable, rule_non_default, rule_deprecated, rule_deprecated_disabled
+    ):
+        """List rules with default options in verbose mode."""
+        rule_0101_configurable.configure("max_len", "51")
+        mocked_config = get_resolved_config(
+            rule_0101_configurable, rule_non_default, rule_deprecated, rule_deprecated_disabled
+        )
+        resolver_mock = Mock(spec=ConfigResolver)
+        resolver_instance_mock = Mock()
+        resolver_mock.return_value = resolver_instance_mock
+        resolver_instance_mock.resolve_config.return_value = mocked_config
+
+        with (
+            working_directory(tmp_path),
+            patch("robocop.run.ConfigResolver", resolver_mock),
+        ):
+            list_rules(verbose=True)
+        out, _ = capsys.readouterr()
+        assert (
+            out == "0101 [W]: some-message: Some description (enabled)\n\n"
+            "Configurables:\n"
+            "    max_len = 51* (default: 40)\n"
+            "        type: int\n"
+            "        info: number of lines allowed in a keyword\n"
+            "    ignore_docs = False\n"
+            "        type: str\n"
+            "        info: Ignore documentation\n\n"
+            "19999 [W]: non-default-rule: Some description (disabled)\n\n"
+            "Altogether 2 rules (1 enabled).\n\n"
+            "Visit https://robocop.dev/stable/rules_list/ page for detailed documentation.\n"
+        )
+
     def test_list_disabled_rule(self, rule_0101, rule_disabled_after_4, capsys):
         rule_0101.enabled = False
         mocked_config = get_resolved_config(rule_0101, rule_disabled_after_4)
@@ -133,7 +207,7 @@ class TestListingRules:
             list_rules(filter_pattern="*")
         out, _ = capsys.readouterr()
         assert (
-            out == "0101 [W]: some-message: Some description (disabled)\n"
+            out == "0101 [W]: some-message: Some description (disabled*)\n"
             f"9999 [W]: disabled-in-four: This is desc ({enabled_for})\n\n"
             f"Altogether 2 rules ({enabled_count} enabled).\n\n"
             "Visit https://robocop.dev/stable/rules_list/ page for detailed documentation.\n"

robotframework_robocop-8.7.0/tests/linter/cli/test_rule.py

@@ -0,0 +1,117 @@
+import textwrap
+from unittest.mock import MagicMock, patch
+
+from robocop.run import print_resource_documentation
+
+
+class TestDescribeRule:
+    def test_describe_rule(self, loaded_linter, capsys):
+        with patch("robocop.run.RobocopLinter", MagicMock(return_value=loaded_linter)):
+            print_resource_documentation("duplicated-keyword")
+        out, _ = capsys.readouterr()
+        expected = textwrap.dedent("""
+        Rule: duplicated-keyword (DUP02)
+        Message: Multiple keywords with name '{name}' (first occurrence in line {first_occurrence_line})
+        Severity: E
+
+        Multiple keywords with the same name in the file.
+
+        Do not define keywords with the same name inside the same file. Name matching is case-insensitive and
+        ignores spaces and underscore characters.
+
+        Incorrect code example:
+
+            *** Keywords ***
+            Keyword
+                No Operation
+
+            keyword
+                No Operation
+
+            K_eywor d
+                No Operation
+
+
+        """).lstrip()
+        assert expected == out
+
+    def test_describe_rule_with_configurables(self, capsys):
+        from robocop.linter.rules.lengths import LineTooLongRule  # noqa: PLC0415
+
+        rule = LineTooLongRule()
+        mock_resolved_config = MagicMock()
+        mock_resolved_config.rules = {"line-too-long": rule}
+
+        with patch("robocop.run.ConfigResolver") as mock_resolver:
+            mock_resolver.return_value.resolve_config.return_value = mock_resolved_config
+            print_resource_documentation("line-too-long")
+        out, _ = capsys.readouterr()
+        expected = textwrap.dedent(r"""
+        Rule: line-too-long (LEN08)
+        Message: Line is too long ({line_length}/{allowed_length})
+        Severity: W
+
+        The line is too long.
+
+        Comments with disabler directives (such as ``# robocop: off``) are ignored. Lines that contain URLs are also
+        ignored.
+
+        It is possible to ignore lines that match the regex pattern. Configure it using the following option:
+
+            robocop check --configure line-too-long.ignore_pattern=pattern
+
+
+        Configurables:
+            severity_threshold = None
+                type: severity_threshold
+            line_length = 120
+                type: int
+                info: number of characters allowed in line
+            ignore_pattern = None
+                type: pattern_type
+                info: ignore lines that contain configured pattern
+
+        """).lstrip()
+        assert expected == out
+
+    def test_describe_rule_with_configurables_modified(self, capsys):
+        from robocop.linter.rules.lengths import LineTooLongRule  # noqa: PLC0415
+
+        rule = LineTooLongRule()
+        rule.configure("line_length", "200")
+        rule.configure("severity_threshold", "warning=100:error=150")
+
+        mock_resolved_config = MagicMock()
+        mock_resolved_config.rules = {"line-too-long": rule}
+
+        with patch("robocop.run.ConfigResolver") as mock_resolver:
+            mock_resolver.return_value.resolve_config.return_value = mock_resolved_config
+            print_resource_documentation("line-too-long")
+        out, _ = capsys.readouterr()
+        expected = textwrap.dedent(r"""
+        Rule: line-too-long (LEN08)
+        Message: Line is too long ({line_length}/{allowed_length})
+        Severity: W
+
+        The line is too long.
+
+        Comments with disabler directives (such as ``# robocop: off``) are ignored. Lines that contain URLs are also
+        ignored.
+
+        It is possible to ignore lines that match the regex pattern. Configure it using the following option:
+
+            robocop check --configure line-too-long.ignore_pattern=pattern
+
+
+        Configurables:
+            severity_threshold = E=150:W=100
+                type: severity_threshold
+            line_length = 200* (default: 120)
+                type: int
+                info: number of characters allowed in line
+            ignore_pattern = None
+                type: pattern_type
+                info: ignore lines that contain configured pattern
+
+        """).lstrip()
+        assert expected == out

{robotframework_robocop-8.6.0 → robotframework_robocop-8.7.0}/tests/linter/rules/lengths/line_too_long/test_rule.py

@@ -29,7 +29,8 @@ class TestRuleAcceptance(RuleAcceptance):
                 severity = W
                     type: parser
                     info: Rule severity (E = Error, W = Warning, I = Info)
-                severity_threshold
+                severity_threshold = None
+                    type: severity_threshold
                 line_length = 120
                     type: int
                     info: number of characters allowed in line

{robotframework_robocop-8.6.0 → robotframework_robocop-8.7.0}/tests/performance/generate_reports.py

@@ -48,7 +48,7 @@ def performance_report(runs: int = 100, cut_off: int = 0):
     def decorator(func):
         @wraps(func)
         def wrapper(*args, **kwargs):
-            report_name = kwargs.get("report_name", "")
+            report_name = kwargs.get("report_name", func.__name__)
             print(report_name)
             run_times = []
             counter = 0

{robotframework_robocop-8.6.0 → robotframework_robocop-8.7.0}/tests/test_cli.py

@@ -36,6 +36,13 @@ def test_print_docs_formatter():
     assert "All separators (pipes included) are converted to fixed length of 4 spaces " in result.stdout
 
 
+def test_print_docs_formatter_disabled():
+    """Print documentation for formatter disabled by default."""
+    runner = CliRunner()
+    result = runner.invoke(app, ["docs", "Translate"])
+    assert "Translate Robot Framework source files from one or many languages to different one." in result.stdout
+
+
 def test_print_docs_invalid():
     runner = CliRunner()
     result = runner.invoke(app, ["docs", "idontexist"])
@@ -222,6 +229,45 @@ class TestConfigOption:
         assert "NormalizeTags" in result.stdout
         assert "NormalizeNewLines" not in result.stdout
 
+    def test_list_formatters_default_hides_parameters(self):
+        runner = CliRunner()
+        result = runner.invoke(app, ["list", "formatters", "--filter", "ENABLED"])
+        assert result.exit_code == 0
+        assert "NormalizeSeparators" in result.stdout
+        assert "flatten_lines" not in result.stdout
+        assert "To see configurable parameters run:" in result.stdout
+
+    def test_list_formatters_verbose_shows_parameters(self):
+        runner = CliRunner()
+        result = runner.invoke(app, ["list", "formatters", "--filter", "ENABLED", "--verbose"])
+        assert result.exit_code == 0
+        assert "NormalizeSeparators" in result.stdout
+        assert "flatten_lines = False" in result.stdout
+        assert "align_new_line = False" in result.stdout
+        assert "skip_documentation = True" in result.stdout
+        # ``enabled`` parameter should be represented by the Enabled column, not listed as a parameter
+        assert "enabled =" not in result.stdout
+
+    def test_list_formatters_verbose_marks_configured_value(self, tmp_path):
+        config_file = tmp_path / "custom_config.toml"
+        config_file.write_text('[tool.robocop.format]\nconfigure = ["NormalizeSeparators.align_new_line=True"]\n')
+        with working_directory(tmp_path):
+            result = CliRunner().invoke(
+                app, ["list", "formatters", "--filter", "ENABLED", "--verbose", "--config", str(config_file)]
+            )
+        assert result.exit_code == 0
+        assert "align_new_line = True* (default: False)" in result.stdout
+
+    def test_list_formatters_default_ignores_configured_value(self, tmp_path):
+        config_file = tmp_path / "custom_config.toml"
+        config_file.write_text('[tool.robocop.format]\nconfigure = ["NormalizeSeparators.align_new_line=True"]\n')
+        with working_directory(tmp_path):
+            result = CliRunner().invoke(
+                app, ["list", "formatters", "--filter", "ENABLED", "--config", str(config_file)]
+            )
+        assert result.exit_code == 0
+        assert "align_new_line" not in result.stdout
+
     def test_docs_with_config_custom_rule(self, tmp_path):
         custom_rule = (
             Path(__file__).parent

robotframework_robocop-8.6.0/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "8.6.0"
-}