check-errors:

name:check-errors (${{ matrix.module.path }})

needs:run-determination

if:needs.run-determination.outputs.result == 'true'

runs-on:ubuntu-latest

strategy:

fail-fast:false

matrix:

module:

-path:./

-path:docsgen

-path:ruledocsgen

steps:

-name:Checkout repository

uses:actions/checkout@v2

version:3.x

-name:Check for errors

env:

GO_MODULE_PATH:${{ matrix.module.path }}

run:task go:vet

check-outdated:

name:check-outdated (${{ matrix.module.path }})

needs:run-determination

if:needs.run-determination.outputs.result == 'true'

runs-on:ubuntu-latest

strategy:

fail-fast:false

matrix:

module:

-path:./

-path:docsgen

-path:ruledocsgen

steps:

-name:Checkout repository

uses:actions/checkout@v2

version:3.x

-name:Modernize usages of outdated APIs

env:

GO_MODULE_PATH:${{ matrix.module.path }}

run:task go:fix

-name:Check if any fixes were needed

run:git diff --color --exit-code

check-style:

name:check-style (${{ matrix.module.path }})

needs:run-determination

if:needs.run-determination.outputs.result == 'true'

runs-on:ubuntu-latest

strategy:

fail-fast:false

matrix:

module:

-path:./

-path:docsgen

-path:ruledocsgen

steps:

-name:Checkout repository

uses:actions/checkout@v2

run:go install golang.org/x/lint/golint@latest

-name:Check style

env:

GO_MODULE_PATH:${{ matrix.module.path }}

run:task --silent go:lint

check-formatting:

name:check-formatting (${{ matrix.module.path }})

needs:run-determination

if:needs.run-determination.outputs.result == 'true'

runs-on:ubuntu-latest

strategy:

fail-fast:false

matrix:

module:

-path:./

-path:docsgen

-path:ruledocsgen

steps:

-name:Checkout repository

uses:actions/checkout@v2

version:3.x

-name:Format code

env:

GO_MODULE_PATH:${{ matrix.module.path }}

run:task go:format

-name:Check formatting

module:

-path:./

-path:docsgen

-path:ruledocsgen

steps:

-name:Checkout repository

-"pyproject.toml"

-"docs/**"

-"docsgen/**"

-"ruledocsgen/**"

-"**.go"

pull_request:

paths:

-"pyproject.toml"

-"docs/**"

-"docsgen/**"

-"ruledocsgen/**"

-"**.go"

workflow_dispatch:

repository_dispatch:

-"Taskfile.ya?ml"

-"**.go"

-"docsgen/**"

-"ruledocsgen/**"

-"mkdocs.ya?ml"

-"poetry.lock"

-"pyproject.toml"

paths:

-".github/workflows/test-go-task.ya?ml"

-"codecov.ya?ml"

-"go.mod"

-"go.sum"

-"**/go.mod"

-"**/go.sum"

-"Taskfile.ya?ml"

-"**.go"

-"**/testdata/**"

pull_request:

paths:

-".github/workflows/test-go-task.ya?ml"

-"codecov.ya?ml"

-"go.mod"

-"go.sum"

-"**/go.mod"

-"**/go.sum"

-"Taskfile.ya?ml"

-"**.go"

-"**/testdata/**"

test:

name:test (${{ matrix.module.path }} - ${{ matrix.operating-system }})

needs:run-determination

if:needs.run-determination.outputs.result == 'true'

strategy:

fail-fast:false

matrix:

operating-system:

-ubuntu-latest

-windows-latest

-macos-latest

module:

-path:./

codecov-flags:unit

-path:ruledocsgen/

codecov-flags:unit

runs-on:${{ matrix.operating-system }}

version:3.x

-name:Run tests

env:

GO_MODULE_PATH:${{ matrix.module.path }}

run:task go:test

-name:Send unit tests coverage to Codecov

if:matrix.operating-system == 'ubuntu-latest'

if:runner.os == 'Linux'

uses:codecov/codecov-action@v2

with:

file:./coverage_unit.txt

flags:unit

file:${{ matrix.module.path }}coverage_unit.txt

flags:${{ matrix.module.codecov-flags }}

fail_ci_if_error:${{ github.repository == 'arduino/arduino-lint' }}

/docsgen/arduino-cli

/docsgen/arduino-cli.exe

/docs/commands/*.md

/ruledocsgen/ruledocsgen

/ruledocsgen/ruledocsgen.exe

/docs/rules/

/dist

/internal/project/projectdata/testdata/packageindexes/invalid-JSON/package_foo_index.json

/internal/rule/rulefunction/testdata/packageindexes/invalid-JSON/package_foo_index.json

/internal/rule/rulefunction/testdata/sketches/InvalidJSONMetadataFile/sketch.json

/ruledocsgen/testdata/golden

PROJECT_NAME:"arduino-lint"

DIST_DIR:"dist"

DEFAULT_GO_MODULE_PATH:./

DEFAULT_GO_PACKAGES:

sh:echo $(go list ./... | grep --invert-match 'github.com/arduino/arduino-lint/internal/rule/schema/schemadata' | tr '\n' ' ')

sh:|

COMMIT:

sh:echo "$(git log --no-show-signature -n 1 --format=%h)"

desc:Create all generated documentation content

deps:

-task:go:cli-docs

-task:go:rule-docs

-task:general:format-prettier

go:build:

desc:Build the Go code

dir:"{{.DEFAULT_GO_MODULE_PATH}}"

cmds:

-go build -v {{.LDFLAGS}}

go:fix:

desc:Modernize usages of outdated APIs

dir:"{{default .DEFAULT_GO_MODULE_PATH .GO_MODULE_PATH}}"

cmds:

-go fix {{default .DEFAULT_GO_PACKAGES .GO_PACKAGES}}

go:format:

desc:Format Go code

dir:"{{default .DEFAULT_GO_MODULE_PATH .GO_MODULE_PATH}}"

cmds:

-go fmt {{default .DEFAULT_GO_PACKAGES .GO_PACKAGES}}

go:lint:

desc:Lint Go code

dir:"{{default .DEFAULT_GO_MODULE_PATH .GO_MODULE_PATH}}"

cmds:

-|

go:rule-docs:

desc:Generate rules documentation

dir:./ruledocsgen

deps:

-task:go:rule-docs:build

cmds:

-./ruledocsgen ../docs/rules

go:rule-docs:build:

desc:Generate rules documentation

dir:./ruledocsgen

cmds:

-go build

go:test:

desc:Run unit tests

dir:"{{default .DEFAULT_GO_MODULE_PATH .GO_MODULE_PATH}}"

cmds:

-|

desc:Run integration tests

deps:

-task:go:build

-task:go:rule-docs:build

-task:poetry:install-deps

cmds:

-poetry run pytest tests

-poetry run pytest ruledocsgen/tests

go:vet:

desc:Check for errors in Go code

dir:"{{default .DEFAULT_GO_MODULE_PATH .GO_MODULE_PATH}}"

cmds:

-go vet {{default .DEFAULT_GO_PACKAGES .GO_PACKAGES}}

**Arduino Lint** is a command line tool that checks for common problems with[Arduino](https://www.arduino.cc/)

projects.

Its focus is on the structure, metadata, and configuration of Arduino projects, rather than the code. Rules cover

specification compliance, Library Manager submission requirements, and best practices.

Its focus is on the structure, metadata, and configuration of Arduino projects, rather than the code.[Rules](rules.md)

coverspecification compliance, Library Manager submission requirements, and best practices.

**Arduino Lint** inspects Arduino projects for common problems. This is done by checking the project against a series of

"rules", each of which is targeted to detecting a specific potential issue. Only the rules of relevance to the project

being linted are applied.

Additional information is available for each of the**Arduino Lint** rules, organized by project type:

-[Sketch](rules/sketch.md)

-[Library](rules/library.md)

-[Boards platform](rules/platform.md)

-[Package index](rules/package-index.md)

In order to allow particular rules to be referenced unequivocally, each has been assigned a permanent unique

identification code (e.g.,`SS001`).

In addition to checking for critical flaws,**Arduino Lint** also advocates for best practices in Arduino projects. For

this reason, not all rule violations are treated as fatal linting errors.

A violation of a rule is assigned a level according to its severity. In cases where a rule violation indicates a serious

problem with the project, the violation is treated as an error, and will result in a non-zero exit status from the

`arduino-lint` command. In cases where the violation indicates a possible problem, or where the rule is a recommendation

for an optional improvement to enhance the project user's experience, the violation is treated as a warning. It is hoped

that these warning-level violations will be given consideration by the user, but they do not affect the`arduino-lint`

exit status.

Of the hundreds of rules provided by**Arduino Lint**, only the ones relevant to the current target project are applied,

with the rest disabled.

The rule levels and enabled subset of rules is dependent on the target project type and how the user has configured

Arduino Lint via the[command line flags](commands/arduino-lint.md) and

[environment variables](index.md#environment-variables).

Arduino projects may contain other Arduino projects as subprojects. For example, the libraries

[bundled](https://arduino.github.io/arduino-cli/latest/platform-specification/#platform-bundled-libraries) with an

Arduino boards platform. These subprojects may, in turn, contain their own subprojects, such as the example sketches

included with a platform bundled library.

**Arduino Lint** also lints any subprojects the target project might contain. The type of the top level "superproject"

is a factor in the configuration of some rules. For example, there is no need to take Library Manager requirements into

consideration in the case of a platform bundled library, since it will never be distributed via that system.

ifruleResult==ruleresult.Fail {

ruleMessage=message(ruleConfiguration.MessageTemplate,ruleOutput)

ifruleConfiguration.Reference!="" {

ruleMessage=fmt.Sprintf("%s\nSee: %s",ruleMessage,ruleConfiguration.Reference)

}

}else {