robotframework-robocop 9.0.0b2__tar.gz → 9.1.2__tar.gz

robotframework_robocop-9.1.2/.pre-commit-config.yaml

@@ -0,0 +1,41 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: mixed-line-ending
+        args: ["--fix=lf"]
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.14.8
+    hooks:
+      - id: ruff
+      - id: ruff-format
+
+  - repo: local
+    hooks:
+      - id: update-rules-list
+        name: update docs/rules_list.md
+        entry: python docs/update_rules_list.py
+        language: system
+        pass_filenames: false
+        files: ^(src/robocop/linter/rules/.*\.py|docs/(rules_list_generator|update_rules_list|rules_metadata)\.py)$
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.19.1
+    hooks:
+      - id: mypy
+        args: ["--config-file=pyproject.toml", "src/robocop"]
+        pass_filenames: false
+        additional_dependencies:
+          - typer>=0.12.5
+          - jinja2>=3.1.4
+          - rich>=10.11.0
+          - tomli>=2.0.0
+          - tomli-w>=1.0
+          - pathspec>=0.12
+          - platformdirs>=4.3
+          - pytz>=2022.7
+          - types-jinja2
+          - types-pytz
+          - fastmcp>=2.13.0
+          - msgpack-types

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

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

robotframework_robocop-9.1.2/CONTRIBUTING.md

@@ -0,0 +1,190 @@
+# CONTRIBUTING
+
+All contributions are welcome.
+
+Contributing may be anything starting from an idea or bug reported in our issues, discussion on our Slack channel
+[#robocop-linter](https://robotframework.slack.com/archives/C01AWSNKC2H) located in
+[Robot Framework workspace](https://robotframework.slack.com/>) or finally code change directly in the Robocop
+repository.
+
+## Submitting issues
+
+Bugs and enhancements are tracked in the [issue tracker](https://github.com/MarketSquare/robotframework-robocop/issues).
+
+Before submitting a new issue, it is always a good idea to check if the
+same bug or enhancement is already reported. If it is, please add your comments
+to the existing issue instead of creating a new one.
+
+## Code contributions
+
+### Development environment
+
+To set up your local development environment, use install uv first:
+
+```commandline
+pip install uv
+```
+
+You can now run our tests with:
+
+```commandline
+uv run pytest tests
+```
+
+``uv``` will create a local environment for you. You can use it in your IDE for type hinting or to run selected tests
+from the UI.
+
+To test Robocop on multiple Python and Robot versions, you need to create multiple environments and run tests
+through nox. You will need nox:
+
+```commandline
+pip install nox
+```
+
+And multiple Python versions:
+
+```commandline
+uv python install 3.10 3.11 3.12 3.13
+```
+
+To run all nox sessions (defined in ``noxfile.py``), run in the root of the project:
+
+```commandline
+nox -s tests
+```
+
+Running all combinations may take a while. Instead, you can run all major supported Robot versions using
+a selected Python version with:
+
+```commandline
+nox -s --python 3.13 tests
+```
+
+## Coding conventions
+
+Robocop uses ruff as a basic tool for formatting and linting code. Run it using pre-commit to ensure that
+every commit follows our code conventions:
+
+```commandline
+pip install pre-commit
+```
+
+Run from the root of the project:
+
+```commandline
+pre-commit install
+```
+
+You can run tools used in pre-commit manually:
+
+- ruff check (``uv run ruff check``)
+- ruff format (``uv run ruff format``)
+- mypy (``uv run mypy --config-file=pyproject.toml .\src\robocop\``)
+
+
+## Testing
+
+We are using pytest for our test framework. While it would be possible to use Robot Framework, it's easier for us
+to use a different test framework as we can easily mock in unit tests and set up different robot framework versions
+for acceptance testing.
+
+Our tests structure around main features in Robocop:
+
+```text
+tests/
+    formatter/ - formatting tests
+    linter/ - linting tests
+    config/ - config related tests (note that some of the config related tests may be still inside linter/formatter)
+    migrate_config/ - tests for robocop migrate command
+```
+
+Typically, users are contributing in the following areas:
+
+- adding / updating existing rules
+- adding / updating reports
+- adding / updating formatters
+- core functions changes
+
+We will cover how to approach testing for each category.
+
+## Adding / updating existing rules
+
+After you update or add new rule, or even better before you do it, you need to create tests for it under
+``tests/linter/rules/<rule_category>/<rule_name>``. Rule name has replaced ``-`` characters with ``_`` so it's
+recognised by default by pytest.
+
+For example, rule ``invalid-argument`` has tests placed under ``tests/linter/rules/arguments/invalid_argument``
+directory.
+
+Each such directory has at least the following files:
+
+- empty ``__init__.py`` file (for tests discovery)
+- ``test_rule.py`` file that describes tests
+- ``test.robot`` file (name can be different) with Robot Framework code to be linted
+- ``expected_output.txt`` with content of output which Robocop is expected to print
+
+Depending on tested features, you may have multiple robot files with one expected file, or several expected files
+(for example, one for every robot version, if rule behaviour changes over versions).
+
+Example Python file:
+
+```Python
+from tests.linter.utils import RuleAcceptance
+
+
+class TestRuleAcceptance(RuleAcceptance):
+    def test_rule(self):
+        self.check_rule(
+            src_files=["test.robot"], expected_file="expected_output.txt", test_on_version=">=4"
+        )
+
+```
+
+It will select and run only one rule (name will be taken from the directory name) on ``test.robot`` file, compare
+output with ``expected_output.txt``. Tests will only run on versions ``>=4``.
+
+Default output format in Robocop is ``extended`` view. Most tests use ``simple`` view by default (for simplicity).
+It's highly recommended to check how the rule behaves with both views. You can configure to run on different view
+using ``configure``:
+
+```Python
+def test_rule(self):
+    self.check_rule(
+        src_files=["test.robot"], expected_file="expected_output.txt", output_format="extended"
+    )
+```
+
+## Documentation
+
+Robocop uses both dynamically and statically loaded documentation.
+
+For documentation backend we are using mkdocs with the material theme. Documentation source files are stored in ``docs``.
+
+After merging the changes, documentation is rebuilt and deployed at [https://robocop.dev/](https://robocop.dev/). It is advised to build
+documentation locally to check it.
+
+If you are adding or updating new features, you may need to update relevant sections in the documentation. For example,
+if you're changing how external rules works, you may need to update ``docs/linter/custom_rules.md`` document.
+
+If you are adding or updating formatter, you need to add or modify a file at ``docs/formatter/formatters/<formatter_name>.md``.
+
+If you are adding or updating a rule, you need to update the rule docstring and check how the rule documentation
+generates at [https://robocop.dev/stable/rules_list/](https://robocop.dev/stable/rules_list/).
+
+The rules list is also committed as ``docs/rules_list.md`` (a materialized copy of the generated page, so tools that
+read the raw repository sources, such as Context7, get the complete, up-to-date rule reference). Regenerate it after
+changing any rule with:
+
+```bash
+uv run python docs/update_rules_list.py
+```
+
+A pre-commit hook regenerates the file, and a CI job verifies it stays up to date.
+
+### Build documentation locally
+
+If you have a Robocop development environment ready (with uv installed), run:
+
+```bash
+uv run mkdocs serve
+```

robotframework_robocop-9.1.2/PKG-INFO

@@ -0,0 +1,316 @@
+Metadata-Version: 2.5
+Name: robotframework-robocop
+Version: 9.1.2
+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
+Project-URL: Documentation, https://robocop.dev/
+Project-URL: Homepage, https://robocop.dev/
+Author-email: Bartlomiej Hirsz <bartek.hirsz@gmail.com>, Mateusz Nojek <matnojek@gmail.com>
+Maintainer-email: Bartlomiej Hirsz <bartek.hirsz@gmail.com>
+License-File: LICENSE
+Keywords: automation,formatter,formatting,linter,qa,robotframework,testautomation,testing
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Robot Framework
+Classifier: Framework :: Robot Framework :: Tool
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: jinja2>=3.1.4
+Requires-Dist: msgpack>=1.0.0
+Requires-Dist: pathspec>=0.12
+Requires-Dist: platformdirs>=4.3
+Requires-Dist: rich>=10.11.0
+Requires-Dist: robotframework<7.6,>=5.0
+Requires-Dist: tomli-w>=1.0
+Requires-Dist: tomli==2.2.1; python_version < '3.11'
+Requires-Dist: typer>=0.26.0
+Requires-Dist: typing-extensions>=4.15.0
+Requires-Dist: tzdata; sys_platform == 'win32'
+Provides-Extra: mcp
+Requires-Dist: fastmcp>=3.0.0; extra == 'mcp'
+Requires-Dist: pydantic>=2.13.4; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# Robocop
+
+[![Unit tests](https://github.com/MarketSquare/robotframework-robocop/actions/workflows/tests.yml/badge.svg)](https://github.com/MarketSquare/robotframework-robocop/actions/workflows/unit-tests.yml "GitHub Workflow Unit Tests Status")
+![Codecov](https://img.shields.io/codecov/c/github/MarketSquare/robotframework-robocop/master "Code coverage on master branch")
+![PyPI](https://img.shields.io/pypi/v/robotframework-robocop?label=version "PyPI package version")
+![Python versions](https://img.shields.io/pypi/pyversions/robotframework-robocop "Supported Python versions")
+![License](https://img.shields.io/pypi/l/robotframework-robocop "PyPI - License")
+[![Downloads](https://static.pepy.tech/personalized-badge/robotframework-robocop?period=total&units=international_system&left_color=grey&right_color=orange&left_text=downloads)](https://pepy.tech/project/robotframework-robocop)
+
+---
+
+<img style="float:right" src="https://raw.githubusercontent.com/MarketSquare/robotframework-robocop/main/docs/source/images/robocop_logo_small.png">
+
+
+- [Introduction](#introduction)
+- [Documentation](#documentation)
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Example Output](#example-output)
+- [MCP Server](#mcp-server)
+- [Values](#values)
+- [FAQ](#faq)
+
+---
+
+## Introduction
+
+Robocop is a tool that performs static code analysis and formatting of [Robot Framework](https://github.com/robotframework/robotframework) code.
+
+It uses official [Robot Framework parsing API](https://robot-framework.readthedocs.io/en/stable/) to parse files and
+runs a number of checks, looking for potential errors or violations to code quality standards (commonly referred to as
+*linting issues*).
+
+> Hosted on [GitHub](https://github.com/MarketSquare/robotframework-robocop).
+
+## Documentation
+
+Full documentation is available at [https://robocop.dev](https://robocop.dev). :open_book:
+
+The most common questions with answers can be found at the bottom ⬇ of this README file.
+
+## Requirements
+
+Python 3.10+ :snake: and Robot Framework 5.0+ :robot:.
+
+## Installation
+
+You can install the latest version of Robocop simply by running:
+
+```commandline
+pip install -U robotframework-robocop
+```
+
+
+## Usage
+
+Robocop runs by default from the current directory, and it discovers supported files recursively.
+To lint the files, you can run:
+
+```
+robocop check
+```
+
+To format the files, you can run:
+
+```commandline
+robocop format
+```
+
+All command line options can be displayed in a help message by executing:
+
+```commandline
+robocop -h
+```
+
+## Example Output
+
+Executing command:
+
+```commandline
+robocop check --reports rules_by_error_type test.robot
+```
+
+
+Will result in the following output:
+
+```text
+test.robot:17:1 SPC22 Not enough whitespace after 'Test Teardown' setting
+    |
+ 15 |
+ 16 | Test Setup Keyword
+ 17 | Test Teardown Keyword2
+    | ^ SPC22
+ 18 | Testtimeout 1min
+ 19 | Documentation this is doc
+    |
+
+test.robot:28:1 SPC14 Variable in Variables section is not left aligned
+   |
+ 1 | *** Variables ***
+ 2 | ${VAR} 1
+ 3 |  ${VAR}  1
+   | ^ SPC14
+ 4 |   ${VAR}  1
+ 5 | VALUE  1
+
+Found 2 issues: 2 ERRORs, 0 WARNINGs, 0 INFO.
+```
+
+## MCP Server
+
+Robocop provides an [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) server that allows AI assistants like Claude and GitHub Copilot to lint and format Robot Framework code directly.
+
+Install with MCP support:
+
+```bash
+pip install robotframework-robocop[mcp]
+```
+
+Run the server:
+
+```bash
+robocop-mcp
+```
+
+Full documentation: [MCP Server](https://robocop.dev/stable/integrations/ai/)
+
+## Values
+
+Original *RoboCop* - a fictional cybernetic police officer - was the following three prime directives
+which also drive the progress of Robocop linter:
+
+First Directive: **Serve the public trust**
+
+Which lies behind the creation of the project - to **serve** developers and testers as a tool to build applications they can **trust**.
+
+Second Directive: **Protect the innocent**
+
+**The innocent** testers and developers have no intention of producing ugly code, but sometimes, you know, it just happens,
+so Robocop is there to **protect** them.
+
+Third Directive: **Uphold the law**
+
+Following the coding guidelines established in the project are something crucial to keep the code clean,
+readable and understandable by others, and Robocop can help to **uphold the law**.
+
+## FAQ
+
+<details>
+  <summary>Can I integrate Robocop with my code editor (IDE)?</summary>
+
+  **Yes**, Robocop integrates nicely with popular IDEs like PyCharm or VSCode
+  thanks to [the RobotCode](https://robotcode.io/) plugin.
+  Read a simple manual (README) in that project to figure out how to install and use it.
+
+</details>
+
+<details>
+  <summary>Can I load configuration from a file?</summary>
+
+  **Yes**, you can use toml-based configuration files:
+
+  **`pyproject.toml` file**
+  **`robocop.toml` file**
+  **`robot.toml` file**
+
+  Example configuration file:
+
+  ```toml
+  [tool.robocop]
+  exclude = ["deprecated.robot"]
+  
+  [tool.robocop.lint]
+  select = [
+    "rulename",
+    "ruleid"
+  ]
+  configure = [
+      "line-too-long.line_length=110"
+  ]
+  
+  [tool.robocop.format]
+  select = ["NormalizeNewLines"]
+  configure = [
+      "NormalizeNewLines.flatten_lines=True"
+  ]
+  ```
+
+  Multiple configuration files are supported. However, global-like options such as ``--verbose`` or ``--reports`` are
+  only loaded from a top configuration file. Read more in
+  [configuration](https://robocop.dev/stable/configuration/).
+
+</details>
+
+<details>
+  <summary>I use different coding standards. Can I configure rules so that they fit my needs?</summary>
+
+  **Yes**, some rules and formatters are configurable. You can find the configuration details in the documentation or
+  by running:
+
+  ```commandline
+  robocop docs rule_name_or_id
+  robocop docs formatter_name
+  ```
+
+  Configuring is done by using `-c / --configure` command line option followed by pattern
+  `<name>.<param_name>=<value>` where:
+  - `<name>` can either be rule name or its id, or formatter name
+  - `<param_name>` is a public name of the parameter
+  - `<value>` is a desired value of the parameter
+
+  For example:
+
+  ```commandline
+  robocop check --configure line-too-long.line_length=140
+  ```
+
+  ---
+  Each rule's severity can also be overwritten. Possible values are
+  `e/error`, `w/warning` or `i/info` and are case-insensitive. Example:
+
+  ```commandline
+  robocop check -c too-long-test-case.severity=e
+  ```
+
+  ---
+  If there are special cases in your code that violate the rules,
+  you can also exclude them in the source code.
+
+  Example:
+
+  ```robotframework
+  Keyword with lowercased name  # robocop: off
+  ```
+
+  More about it in
+  [our documentation](https://robocop.dev/stable/configuration/configuration_reference/#selecting-rules).
+
+</details>
+
+<details>
+  <summary>Can I define custom rules?</summary>
+
+  **Yes**, you can define and include custom rules using `--custom-rules` command line option
+  by providing a path to a file containing your rule(s):
+
+  ```commandline
+  robocop --custom-rules my/own/rule.py --custom-rules external_rules.py
+  ```
+
+  If you feel that your rule is very helpful and should be included in Robocop permanently,
+  you can always share your solution by
+  [submitting a pull request](https://github.com/MarketSquare/robotframework-robocop/pulls).
+  You can also share your idea by
+  [creating an issue](https://github.com/MarketSquare/robotframework-robocop/issues/new/choose).
+
+  More about custom rules with code examples in
+  [our documentation](https://robocop.dev/stable/linter/custom_rules/).
+</details>
+
+<details>
+  <summary>Can I use Robocop in continuous integration (CI) tools?</summary>
+
+  **Yes**, Robocop is able to produce different kinds of reports that are supported by most popular platforms such as
+  GitHub, Gitlab, Sonar Qube, etc. Read more in [integrations](https://robocop.dev/stable/integrations/precommit/).
+
+</details>
+
+---
+
+> Excuse me, I have to go. Somewhere there is a crime happening. - Robocop

robotframework_robocop-9.1.2/context7.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "https://context7.com/schema/context7.json",
+  "url": "https://context7.com/marketsquare/robotframework-robocop",
+  "public_key": "pk_oD2T1uAaCx7gs6z8qeDot",
+  "projectTitle": "Robocop",
+  "description": "Static code analysis tool (linter) and code formatter for Robot Framework",
+  "folders": ["docs"],
+  "excludeFolders": [
+    "docs/releasenotes",
+    "docs/images",
+    "docs/css",
+    "docs/public",
+    "docs/__pycache__"
+  ],
+  "excludeFiles": [],
+  "rules": [
+    "Robocop is both a linter AND a formatter for Robot Framework (.robot and .resource) files; the formatter replaced the standalone 'robotidy' project.",
+    "Requires Python 3.10+ and Robot Framework 5.0+.",
+    "Lint code with `robocop check` and format code with `robocop format`. `robocop list` shows rules/formatters and `robocop docs <name>` shows documentation.",
+    "Select rules or formatters with `--select` and configure them with `--configure <name>.<param>=<value>` (for example `--configure line-too-long.line_length=140`).",
+    "Configuration lives in pyproject.toml, robocop.toml, or robot.toml under [tool.robocop.lint] and [tool.robocop.format].",
+    "Rules have a name (kebab-case, e.g. `line-too-long`) and a rule id (category prefix + number, e.g. `LEN08`); both can be used with `--select`.",
+    "The full, always-current rule reference (ids, messages, parameters, examples) is in docs/rules_list.md.",
+    "For AI-generated Robot Framework code, extend the opinionated `robocop:minimal` ruleset for a less noisy baseline, e.g. `extends = [\"robocop:minimal\"]` under [tool.robocop.lint]."
+  ],
+  "previousVersions": [
+    {
+      "tag": "v8.8.0"
+    }
+  ]
+}