mirror of
https://github.com/koalaman/shellcheck
synced 2025-08-23 14:45:40 -07:00
Compare commits
No commits in common. "master" and "stable" have entirely different histories.
89 changed files with 934 additions and 23972 deletions
|
|
@ -1,6 +0,0 @@
|
|||
*
|
||||
!LICENSE
|
||||
!Setup.hs
|
||||
!ShellCheck.cabal
|
||||
!shellcheck.hs
|
||||
!src
|
||||
1
.ghci
1
.ghci
|
|
@ -1 +0,0 @@
|
|||
:set -idist/build/autogen -isrc
|
||||
27
.github/ISSUE_TEMPLATE.md
vendored
27
.github/ISSUE_TEMPLATE.md
vendored
|
|
@ -1,27 +0,0 @@
|
|||
#### For bugs
|
||||
- Rule Id (if any, e.g. SC1000):
|
||||
- My shellcheck version (`shellcheck --version` or "online"):
|
||||
- [ ] The rule's wiki page does not already cover this (e.g. https://shellcheck.net/wiki/SC2086)
|
||||
- [ ] I tried on https://www.shellcheck.net/ and verified that this is still a problem on the latest commit
|
||||
|
||||
#### For new checks and feature suggestions
|
||||
- [ ] https://www.shellcheck.net/ (i.e. the latest commit) currently gives no useful warnings about this
|
||||
- [ ] I searched through https://github.com/koalaman/shellcheck/issues and didn't find anything related
|
||||
|
||||
|
||||
#### Here's a snippet or screenshot that shows the problem:
|
||||
|
||||
```sh
|
||||
|
||||
#!/your/interpreter
|
||||
your script here
|
||||
|
||||
```
|
||||
|
||||
#### Here's what shellcheck currently says:
|
||||
|
||||
|
||||
|
||||
#### Here's what I wanted or expected to see:
|
||||
|
||||
|
||||
28
.github/ISSUE_TEMPLATE/bug_report.md
vendored
28
.github/ISSUE_TEMPLATE/bug_report.md
vendored
|
|
@ -1,28 +0,0 @@
|
|||
---
|
||||
name: Bug report
|
||||
about: Create a new bug report
|
||||
title: ''
|
||||
labels: ''
|
||||
assignees: ''
|
||||
|
||||
---
|
||||
|
||||
#### For bugs with existing features
|
||||
|
||||
- Rule Id (if any, e.g. SC1000):
|
||||
- My shellcheck version (`shellcheck --version` or "online"):
|
||||
- [ ] The rule's wiki page does not already cover this (e.g. https://shellcheck.net/wiki/SC2086)
|
||||
- [ ] I tried on https://www.shellcheck.net/ and verified that this is still a problem on the latest commit
|
||||
|
||||
#### Here's a snippet or screenshot that shows the problem:
|
||||
|
||||
```sh
|
||||
#!/bin/sh
|
||||
your script here
|
||||
```
|
||||
|
||||
#### Here's what shellcheck currently says:
|
||||
|
||||
|
||||
|
||||
#### Here's what I wanted or expected to see:
|
||||
25
.github/ISSUE_TEMPLATE/feature_request.md
vendored
25
.github/ISSUE_TEMPLATE/feature_request.md
vendored
|
|
@ -1,25 +0,0 @@
|
|||
---
|
||||
name: Feature request
|
||||
about: Suggest an idea for this project
|
||||
title: ''
|
||||
labels: ''
|
||||
assignees: ''
|
||||
|
||||
---
|
||||
|
||||
#### For new checks and feature suggestions
|
||||
- [ ] https://www.shellcheck.net/ (i.e. the latest commit) currently gives no useful warnings about this
|
||||
- [ ] I searched through https://github.com/koalaman/shellcheck/issues and didn't find anything related
|
||||
|
||||
#### Here's a snippet or screenshot that shows a potential problem:
|
||||
|
||||
```sh
|
||||
#!/bin/sh
|
||||
your script here
|
||||
```
|
||||
|
||||
#### Here's what shellcheck currently says:
|
||||
|
||||
|
||||
|
||||
#### Here's what I wanted to see:
|
||||
7
.github/dependabot.yml
vendored
7
.github/dependabot.yml
vendored
|
|
@ -1,7 +0,0 @@
|
|||
version: 2
|
||||
|
||||
updates:
|
||||
- package-ecosystem: "github-actions"
|
||||
directory: "/"
|
||||
schedule:
|
||||
interval: "daily"
|
||||
159
.github/workflows/build.yml
vendored
159
.github/workflows/build.yml
vendored
|
|
@ -1,159 +0,0 @@
|
|||
name: Build ShellCheck
|
||||
|
||||
# Run this workflow every time a new commit pushed to your repository
|
||||
on: push
|
||||
|
||||
jobs:
|
||||
package_source:
|
||||
name: Package Source Code
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Install Dependencies
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-mark manual ghc # Don't bother installing ghc just to tar up source
|
||||
sudo apt-get install cabal-install
|
||||
|
||||
- name: Checkout repository
|
||||
uses: actions/checkout@v4
|
||||
with:
|
||||
fetch-depth: 0
|
||||
|
||||
- name: Deduce tags
|
||||
run: |
|
||||
mkdir source
|
||||
echo "latest" > source/tags
|
||||
if tag=$(git describe --exact-match --tags)
|
||||
then
|
||||
echo "stable" >> source/tags
|
||||
echo "$tag" >> source/tags
|
||||
fi
|
||||
cat source/tags
|
||||
|
||||
- name: Package Source
|
||||
run: |
|
||||
grep "stable" source/tags || ./setgitversion
|
||||
cabal sdist
|
||||
mv dist-newstyle/sdist/*.tar.gz source/source.tar.gz
|
||||
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: source
|
||||
path: source/
|
||||
|
||||
run_tests:
|
||||
name: Run tests
|
||||
needs: package_source
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Download artifacts
|
||||
uses: actions/download-artifact@v4
|
||||
|
||||
- name: Install dependencies
|
||||
run: |
|
||||
sudo apt-get update && sudo apt-get install ghc cabal-install
|
||||
cabal update
|
||||
|
||||
- name: Unpack source
|
||||
run: |
|
||||
cd source
|
||||
tar xvf source.tar.gz --strip-components=1
|
||||
|
||||
- name: Build and run tests
|
||||
run: |
|
||||
cd source
|
||||
cabal test
|
||||
|
||||
build_source:
|
||||
name: Build
|
||||
needs: package_source
|
||||
strategy:
|
||||
matrix:
|
||||
build: [linux.x86_64, linux.aarch64, linux.armv6hf, linux.riscv64, darwin.x86_64, darwin.aarch64, windows.x86_64]
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout repository
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Download artifacts
|
||||
uses: actions/download-artifact@v4
|
||||
|
||||
- name: Build source
|
||||
run: |
|
||||
mkdir -p bin
|
||||
mkdir -p bin/${{matrix.build}}
|
||||
( cd bin && ../builders/run_builder ../source/source.tar.gz ../builders/${{matrix.build}} )
|
||||
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: ${{matrix.build}}.bin
|
||||
path: bin/
|
||||
|
||||
package_binary:
|
||||
name: Package Binaries
|
||||
needs: build_source
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout repository
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Download artifacts
|
||||
uses: actions/download-artifact@v4
|
||||
|
||||
- name: Work around GitHub permissions bug
|
||||
run: chmod +x *.bin/*/shellcheck*
|
||||
|
||||
- name: Package binaries
|
||||
run: |
|
||||
export TAGS="$(cat source/tags)"
|
||||
mkdir -p deploy
|
||||
cp -r *.bin/* deploy
|
||||
cd deploy
|
||||
../.prepare_deploy
|
||||
rm -rf */ README* LICENSE*
|
||||
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: deploy
|
||||
path: deploy/
|
||||
|
||||
deploy:
|
||||
name: Deploy binaries
|
||||
needs: package_binary
|
||||
runs-on: ubuntu-latest
|
||||
environment: Deploy
|
||||
steps:
|
||||
- name: Install Dependencies
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install hub
|
||||
|
||||
- name: Checkout repository
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Download artifacts
|
||||
uses: actions/download-artifact@v4
|
||||
|
||||
- name: Upload to GitHub
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
run: |
|
||||
export TAGS="$(cat source/tags)"
|
||||
./.github_deploy
|
||||
|
||||
- name: Waiting for GitHub to replicate uploaded releases
|
||||
run: |
|
||||
sleep 300
|
||||
|
||||
- name: Upload to Docker Hub
|
||||
env:
|
||||
DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
|
||||
DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
|
||||
DOCKER_EMAIL: ${{ secrets.DOCKER_EMAIL }}
|
||||
DOCKER_BASE: ${{ secrets.DOCKER_USERNAME }}/shellcheck
|
||||
run: |
|
||||
export TAGS="$(cat source/tags)"
|
||||
( source ./.multi_arch_docker && set -eux && multi_arch_docker::main )
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
#!/bin/bash
|
||||
set -x
|
||||
shopt -s extglob
|
||||
|
||||
export EDITOR="touch"
|
||||
|
||||
# Sanity check
|
||||
gh --version || exit 1
|
||||
hub release show latest || exit 1
|
||||
|
||||
for tag in $TAGS
|
||||
do
|
||||
if ! hub release show "$tag"
|
||||
then
|
||||
echo "Creating new release $tag"
|
||||
git show --no-patch --format='format:%B' > description
|
||||
hub release create -F description "$tag"
|
||||
fi
|
||||
|
||||
files=()
|
||||
for file in deploy/*
|
||||
do
|
||||
[[ $file == *.@(xz|gz|zip) ]] || continue
|
||||
[[ $file == *"$tag"* ]] || continue
|
||||
files+=("$file")
|
||||
done
|
||||
gh release upload "$tag" "${files[@]}" --clobber || exit 1
|
||||
done
|
||||
24
.gitignore
vendored
24
.gitignore
vendored
|
|
@ -1,24 +0,0 @@
|
|||
# Created by https://www.gitignore.io
|
||||
|
||||
### Haskell ###
|
||||
dist
|
||||
cabal-dev
|
||||
*.o
|
||||
*.hi
|
||||
*.chi
|
||||
*.chs.h
|
||||
.virtualenv
|
||||
.hsenv
|
||||
.cabal-sandbox/
|
||||
cabal.sandbox.config
|
||||
cabal.config
|
||||
cabal.project.freeze
|
||||
.stack-work
|
||||
|
||||
### Snap ###
|
||||
/snap/.snapcraft/
|
||||
/stage/
|
||||
/parts/
|
||||
/prime/
|
||||
*.snap
|
||||
/dist-newstyle/
|
||||
|
|
@ -1,89 +0,0 @@
|
|||
#!/bin/bash
|
||||
# This script builds and deploys multi-architecture docker images from the
|
||||
# binaries previously built and deployed to GitHub.
|
||||
|
||||
function multi_arch_docker::install_docker_buildx() {
|
||||
# Install QEMU multi-architecture support for docker buildx.
|
||||
docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
|
||||
|
||||
# Instantiate docker buildx builder with multi-architecture support.
|
||||
docker buildx create --name mybuilder
|
||||
docker buildx use mybuilder
|
||||
# Start up buildx and verify that all is OK.
|
||||
docker buildx inspect --bootstrap
|
||||
}
|
||||
|
||||
# Log in to Docker Hub for deployment.
|
||||
function multi_arch_docker::login_to_docker_hub() {
|
||||
echo "$DOCKER_PASSWORD" | docker login -u="$DOCKER_USERNAME" --password-stdin
|
||||
}
|
||||
|
||||
# Run buildx build and push. Passed in arguments augment the command line.
|
||||
function multi_arch_docker::buildx() {
|
||||
mkdir -p /tmp/empty
|
||||
docker buildx build \
|
||||
--platform "${DOCKER_PLATFORMS// /,}" \
|
||||
--push \
|
||||
--progress plain \
|
||||
-f Dockerfile.multi-arch \
|
||||
"$@" \
|
||||
/tmp/empty
|
||||
rmdir /tmp/empty
|
||||
}
|
||||
|
||||
# Build and push plain and alpine docker images for all tags.
|
||||
function multi_arch_docker::build_and_push_all() {
|
||||
for tag in $TAGS; do
|
||||
multi_arch_docker::buildx -t "$DOCKER_BASE:$tag" --build-arg "tag=$tag"
|
||||
multi_arch_docker::buildx -t "$DOCKER_BASE-alpine:$tag" \
|
||||
--build-arg "tag=$tag" --target alpine
|
||||
done
|
||||
}
|
||||
|
||||
# Test all pushed docker images.
|
||||
function multi_arch_docker::test_all() {
|
||||
printf '%s\n' "#!/bin/sh" "echo 'hello world'" > myscript
|
||||
|
||||
for platform in $DOCKER_PLATFORMS; do
|
||||
for tag in $TAGS; do
|
||||
for ext in '-alpine' ''; do
|
||||
image="${DOCKER_BASE}${ext}:${tag}"
|
||||
msg="Testing docker image $image on platform $platform"
|
||||
line="${msg//?/=}"
|
||||
printf '\n%s\n%s\n%s\n' "${line}" "${msg}" "${line}"
|
||||
docker pull -q --platform "$platform" "$image"
|
||||
if [ -n "$ext" ]; then
|
||||
echo -n "Image architecture: "
|
||||
docker run --rm --entrypoint /bin/sh "$image" -c 'uname -m'
|
||||
version=$(docker run --rm "$image" shellcheck --version \
|
||||
| grep 'version:')
|
||||
else
|
||||
version=$(docker run --rm "$image" --version | grep 'version:')
|
||||
fi
|
||||
version=${version/#version: /v}
|
||||
echo "shellcheck version: $version"
|
||||
if [[ ! ("$tag" =~ ^(latest|stable)$) && "$tag" != "$version" ]]; then
|
||||
echo "Version mismatch: shellcheck $version tagged as $tag"
|
||||
exit 1
|
||||
fi
|
||||
if [ -n "$ext" ]; then
|
||||
docker run --rm -v "$PWD:/mnt" -w /mnt "$image" shellcheck myscript
|
||||
else
|
||||
docker run --rm -v "$PWD:/mnt" "$image" myscript
|
||||
fi
|
||||
done
|
||||
done
|
||||
done
|
||||
}
|
||||
|
||||
function multi_arch_docker::main() {
|
||||
export DOCKER_PLATFORMS='linux/amd64'
|
||||
DOCKER_PLATFORMS+=' linux/arm64'
|
||||
DOCKER_PLATFORMS+=' linux/arm/v6'
|
||||
DOCKER_PLATFORMS+=' linux/riscv64'
|
||||
|
||||
multi_arch_docker::install_docker_buildx
|
||||
multi_arch_docker::login_to_docker_hub
|
||||
multi_arch_docker::build_and_push_all
|
||||
multi_arch_docker::test_all
|
||||
}
|
||||
|
|
@ -1,54 +0,0 @@
|
|||
#!/bin/bash
|
||||
# This script packages up compiled binaries
|
||||
set -ex
|
||||
shopt -s nullglob extglob
|
||||
|
||||
ls -l
|
||||
|
||||
cp ../LICENSE LICENSE.txt
|
||||
sed -e $'s/$/\r/' > README.txt << END
|
||||
This is a precompiled ShellCheck binary.
|
||||
https://www.shellcheck.net/
|
||||
|
||||
ShellCheck is a static analysis tool for shell scripts.
|
||||
It's licensed under the GNU General Public License v3.0.
|
||||
Information and source code is available on the website.
|
||||
|
||||
This binary was compiled on $(date -u).
|
||||
|
||||
|
||||
|
||||
====== Latest commits ======
|
||||
|
||||
$(git log -n 3)
|
||||
END
|
||||
|
||||
for dir in */
|
||||
do
|
||||
cp LICENSE.txt README.txt "$dir"
|
||||
done
|
||||
|
||||
echo "Tags are $TAGS"
|
||||
|
||||
for tag in $TAGS
|
||||
do
|
||||
|
||||
for dir in windows.*/
|
||||
do
|
||||
( cd "$dir" && zip "../shellcheck-$tag.zip" * )
|
||||
done
|
||||
|
||||
for dir in {linux,darwin}.*/
|
||||
do
|
||||
base="${dir%/}"
|
||||
( cd "$dir" && tar -cJf "../shellcheck-$tag.$base.tar.xz" --transform="s:^:shellcheck-$tag/:" * )
|
||||
done
|
||||
done
|
||||
|
||||
for file in ./*
|
||||
do
|
||||
[[ -f "$file" ]] || continue
|
||||
sha512sum "$file" > "$file.sha512sum"
|
||||
done
|
||||
|
||||
ls -l
|
||||
566
CHANGELOG.md
566
CHANGELOG.md
|
|
@ -1,566 +0,0 @@
|
|||
## Git
|
||||
### Added
|
||||
|
||||
### Changed
|
||||
|
||||
### Fixed
|
||||
|
||||
### Removed
|
||||
|
||||
|
||||
## v0.11.0 - 2025-08-03
|
||||
### Added
|
||||
- SC2327/SC2328: Warn about capturing the output of redirected commands.
|
||||
- SC2329: Warn when (non-escaping) functions are never invoked.
|
||||
- SC2330: Warn about unsupported glob matches with [[ .. ]] in BusyBox.
|
||||
- SC2331: Suggest using standard -e instead of unary -a in tests.
|
||||
- SC2332: Warn about `[ ! -o opt ]` being unconditionally true in Bash.
|
||||
- SC3062: Warn about bashism `[ -o opt ]`.
|
||||
- Optional `avoid-negated-conditions`: suggest replacing `[ ! a -eq b ]`
|
||||
with `[ a -ne b ]`, and similar for -ge/-lt/=/!=/etc (SC2335).
|
||||
- Precompiled binaries for Linux riscv64 (linux.riscv64)
|
||||
|
||||
### Changed
|
||||
- SC2002 about Useless Use Of Cat is now disabled by default. It can be
|
||||
re-enabled with `--enable=useless-use-of-cat` or equivalent directive.
|
||||
- SC2236/SC2237 about replacing `[ ! -n .. ]` with `[ -z ]` and vice versa
|
||||
is now optional under `avoid-negated-conditions`.
|
||||
- SC2015 about `A && B || C` no longer triggers when B is a test command.
|
||||
- SC3012: Do not warn about `\<` and `\>` in test/[] as specified in POSIX.1-2024
|
||||
- Diff output now uses / as path separator on Windows
|
||||
|
||||
### Fixed
|
||||
- SC2218 about function use-before-define is now more accurate.
|
||||
- SC2317 about unreachable commands is now less spammy for nested ones.
|
||||
- SC2292, optional suggestion for [[ ]], now triggers for Busybox.
|
||||
- Updates for Bash 5.3, including `${| cmd; }` and `source -p`
|
||||
|
||||
### Removed
|
||||
- SC3013: removed since the operators `-ot/-nt/-ef` are specified in POSIX.1-2024
|
||||
|
||||
|
||||
## v0.10.0 - 2024-03-07
|
||||
### Added
|
||||
- Precompiled binaries for macOS ARM64 (darwin.aarch64)
|
||||
- Added support for busybox sh
|
||||
- Added flag --rcfile to specify an rc file by name.
|
||||
- Added `extended-analysis=true` directive to enable/disable dataflow analysis
|
||||
(with a corresponding --extended-analysis flag).
|
||||
- SC2324: Warn when x+=1 appends instead of increments
|
||||
- SC2325: Warn about multiple `!`s in dash/sh.
|
||||
- SC2326: Warn about `foo | ! bar` in bash/dash/sh.
|
||||
- SC3012: Warn about lexicographic-compare bashism in test like in [ ]
|
||||
- SC3013: Warn bashism `test _ -op/-nt/-ef _` like in [ ]
|
||||
- SC3014: Warn bashism `test _ == _` like in [ ]
|
||||
- SC3015: Warn bashism `test _ =~ _` like in [ ]
|
||||
- SC3016: Warn bashism `test -v _` like in [ ]
|
||||
- SC3017: Warn bashism `test -a _` like in [ ]
|
||||
|
||||
### Fixed
|
||||
- source statements with here docs now work correctly
|
||||
- "(Array.!): undefined array element" error should no longer occur
|
||||
|
||||
|
||||
## v0.9.0 - 2022-12-12
|
||||
### Added
|
||||
- SC2316: Warn about 'local readonly foo' and similar (thanks, patrickxia!)
|
||||
- SC2317: Warn about unreachable commands
|
||||
- SC2318: Warn about backreferences in 'declare x=1 y=$x'
|
||||
- SC2319/SC2320: Warn when $? refers to echo/printf/[ ]/[[ ]]/test
|
||||
- SC2321: Suggest removing $((..)) in array[$((idx))]=val
|
||||
- SC2322: Suggest collapsing double parentheses in arithmetic contexts
|
||||
- SC2323: Suggest removing wrapping parentheses in a[(x+1)]=val
|
||||
|
||||
### Fixed
|
||||
- SC2086: Now uses DFA to make more accurate predictions about values
|
||||
- SC2086: No longer warns about values declared as integer with declare -i
|
||||
|
||||
### Changed
|
||||
- ShellCheck now has a Data Flow Analysis engine to make smarter decisions
|
||||
based on control flow rather than just syntax. Existing checks will
|
||||
gradually start using it, which may cause them to trigger differently
|
||||
(but more accurately).
|
||||
- Values in directives/shellcheckrc can now be quoted with '' or ""
|
||||
|
||||
|
||||
## v0.8.0 - 2021-11-06
|
||||
### Added
|
||||
- `disable=all` now conveniently disables all warnings
|
||||
- `external-sources=true` directive can be added to .shellcheckrc to make
|
||||
shellcheck behave as if `-x` was specified.
|
||||
- Optional `check-extra-masked-returns` for pointing out commands with
|
||||
suppressed exit codes (SC2312).
|
||||
- Optional `require-double-brackets` for recommending \[\[ ]] (SC2292).
|
||||
- SC2286-SC2288: Warn when command name ends in a symbol like `/.)'"`
|
||||
- SC2289: Warn when command name contains tabs or linefeeds
|
||||
- SC2291: Warn about repeated unquoted spaces between words in echo
|
||||
- SC2292: Suggest [[ over [ in Bash/Ksh scripts (optional)
|
||||
- SC2293/SC2294: Warn when calling `eval` with arrays
|
||||
- SC2295: Warn about "${x#$y}" treating $y as a pattern when not quoted
|
||||
- SC2296-SC2301: Improved warnings for bad parameter expansions
|
||||
- SC2302/SC2303: Warn about loops over array values when using them as keys
|
||||
- SC2304-SC2306: Warn about unquoted globs in expr arguments
|
||||
- SC2307: Warn about insufficient number of arguments to expr
|
||||
- SC2308: Suggest other approaches for non-standard expr extensions
|
||||
- SC2313: Warn about `read` with unquoted, array indexed variable
|
||||
|
||||
### Fixed
|
||||
- SC2102 about repetitions in ranges no longer triggers on [[ -v arr[xx] ]]
|
||||
- SC2155 now recognizes `typeset` and local read-only `declare` statements
|
||||
- SC2181 now tries to avoid triggering for error handling functions
|
||||
- SC2290: Warn about misused = in declare & co, which were not caught by SC2270+
|
||||
- The flag --color=auto no longer outputs color when TERM is "dumb" or unset
|
||||
|
||||
### Changed
|
||||
- SC2048: Warning about $\* now also applies to ${array[\*]}
|
||||
- SC2181 now only triggers on single condition tests like `[ $? = 0 ]`.
|
||||
- Quote warnings are now emitted for declaration utilities in sh
|
||||
- Leading `_` can now be used to suppress warnings about unused variables
|
||||
- TTY output now includes warning level in text as well as color
|
||||
|
||||
### Removed
|
||||
- SC1004: Literal backslash+linefeed in '' was found to be usually correct
|
||||
|
||||
|
||||
## v0.7.2 - 2021-04-19
|
||||
### Added
|
||||
- `disable` directives can now be a range, e.g. `disable=SC3000-SC4000`
|
||||
- SC1143: Warn about line continuations in comments
|
||||
- SC2259/SC2260: Warn when redirections override pipes
|
||||
- SC2261: Warn about multiple competing redirections
|
||||
- SC2262/SC2263: Warn about aliases declared and used in the same parsing unit
|
||||
- SC2264: Warn about wrapper functions that blatantly recurse
|
||||
- SC2265/SC2266: Warn when using & or | with test statements
|
||||
- SC2267: Warn when using xargs -i instead of -I
|
||||
- SC2268: Warn about unnecessary x-comparisons like `[ x$var = xval ]`
|
||||
|
||||
### Fixed
|
||||
- SC1072/SC1073 now respond to disable annotations, though ignoring parse errors
|
||||
is still purely cosmetic and does not allow ShellCheck to continue.
|
||||
- Improved error reporting for trailing tokens after ]/]] and compound commands
|
||||
- `#!/usr/bin/env -S shell` is now handled correctly
|
||||
- Here docs with \r are now parsed correctly and give better warnings
|
||||
|
||||
### Changed
|
||||
- Assignments are now parsed to spec, without leniency for leading $ or spaces
|
||||
- POSIX/dash unsupported feature warnings now have individual SC3xxx codes
|
||||
- SC1090: A leading `$x/` or `$(x)/` is now treated as `./` when locating files
|
||||
- SC2154: Variables appearing in -z/-n tests are no longer considered unassigned
|
||||
- SC2270-SC2285: Improved warnings about misused `=`, e.g. `${var}=42`
|
||||
|
||||
|
||||
## v0.7.1 - 2020-04-04
|
||||
### Fixed
|
||||
- `-f diff` no longer claims that it found more issues when it didn't
|
||||
- Known empty variables now correctly trigger SC2086
|
||||
- ShellCheck should now be compatible with Cabal 3
|
||||
- SC2154 and all command-specific checks now trigger for builtins
|
||||
called with `builtin`
|
||||
|
||||
### Added
|
||||
- SC1136: Warn about unexpected characters after ]/]]
|
||||
- SC2254: Suggest quoting expansions in case statements
|
||||
- SC2255: Suggest using `$((..))` in `[ 2*3 -eq 6 ]`
|
||||
- SC2256: Warn about translated strings that are known variables
|
||||
- SC2257: Warn about arithmetic mutation in redirections
|
||||
- SC2258: Warn about trailing commas in for loop elements
|
||||
|
||||
### Changed
|
||||
- SC2230: 'command -v' suggestion is now off by default (-i deprecate-which)
|
||||
- SC1081: Keywords are now correctly parsed case sensitively, with a warning
|
||||
|
||||
|
||||
## v0.7.0 - 2019-07-28
|
||||
### Added
|
||||
- Precompiled binaries for macOS and Linux aarch64
|
||||
- Preliminary support for fix suggestions
|
||||
- New `-f diff` unified diff format for auto-fixes
|
||||
- Files containing Bats tests can now be checked
|
||||
- Directory wide directives can now be placed in a `.shellcheckrc`
|
||||
- Optional checks: Use `--list-optional` to show a list of tests,
|
||||
Enable with `-o` flags or `enable=name` directives
|
||||
- Source paths: Use `-P dir1:dir2` or a `source-path=dir1` directive
|
||||
to specify search paths for sourced files.
|
||||
- json1 format like --format=json but treats tabs as single characters
|
||||
- Recognize FLAGS variables created by the shflags library.
|
||||
- Site-specific changes can now be made in Custom.hs for ease of patching
|
||||
- SC2154: Also warn about unassigned uppercase variables (optional)
|
||||
- SC2252: Warn about `[ $a != x ] || [ $a != y ]`, similar to SC2055
|
||||
- SC2251: Inform about ineffectual ! in front of commands
|
||||
- SC2250: Warn about variable references without braces (optional)
|
||||
- SC2249: Warn about `case` with missing default case (optional)
|
||||
- SC2248: Warn about unquoted variables without special chars (optional)
|
||||
- SC2247: Warn about $"(cmd)" and $"{var}"
|
||||
- SC2246: Warn if a shebang's interpreter ends with /
|
||||
- SC2245: Warn that Ksh ignores all but the first glob result in `[`
|
||||
- SC2243/SC2244: Suggest using explicit -n for `[ $foo ]` (optional)
|
||||
- SC1135: Suggest not ending double quotes just to make $ literal
|
||||
|
||||
### Changed
|
||||
- If a directive or shebang is not specified, a `.bash/.bats/.dash/.ksh`
|
||||
extension will be used to infer the shell type when present.
|
||||
- Disabling SC2120 on a function now disables SC2119 on call sites
|
||||
|
||||
### Fixed
|
||||
- SC2183 no longer warns about missing printf args for `%()T`
|
||||
|
||||
## v0.6.0 - 2018-12-02
|
||||
### Added
|
||||
- Command line option --severity/-S for filtering by minimum severity
|
||||
- Command line option --wiki-link-count/-W for showing wiki links
|
||||
- SC2152/SC2151: Warn about bad `exit` values like `1234` and `"foo"`
|
||||
- SC2236/SC2237: Suggest -n/-z instead of ! -z/-n
|
||||
- SC2238: Warn when redirecting to a known command name, e.g. ls > rm
|
||||
- SC2239: Warn if the shebang is not an absolute path, e.g. #!bin/sh
|
||||
- SC2240: Warn when passing additional arguments to dot (.) in sh/dash
|
||||
- SC1133: Better diagnostics when starting a line with |/||/&&
|
||||
|
||||
### Changed
|
||||
- Most warnings now have useful end positions
|
||||
- SC1117 about unknown double-quoted escape sequences has been retired
|
||||
|
||||
### Fixed
|
||||
- SC2021 no longer triggers for equivalence classes like `[=e=]`
|
||||
- SC2221/SC2222 no longer mistriggers on fall-through case branches
|
||||
- SC2081 about glob matches in `[ .. ]` now also triggers for `!=`
|
||||
- SC2086 no longer warns about spaces in `$#`
|
||||
- SC2164 no longer suggests subshells for `cd ..; cmd; cd ..`
|
||||
- `read -a` is now correctly considered an array assignment
|
||||
- SC2039 no longer warns about LINENO now that it's POSIX
|
||||
|
||||
## v0.5.0 - 2018-05-31
|
||||
### Added
|
||||
- SC2233/SC2234/SC2235: Suggest removing or replacing (..) around tests
|
||||
- SC2232: Warn about invalid arguments to sudo
|
||||
- SC2231: Suggest quoting expansions in for loop globs
|
||||
- SC2229: Warn about 'read $var'
|
||||
- SC2227: Warn about redirections in the middle of 'find' commands
|
||||
- SC2224/SC2225/SC2226: Warn when using mv/cp/ln without a destination
|
||||
- SC2223: Quote warning specific to `: ${var=value}`
|
||||
- SC1131: Warn when using `elseif` or `elsif`
|
||||
- SC1128: Warn about blanks/comments before shebang
|
||||
- SC1127: Warn about C-style comments
|
||||
|
||||
### Fixed
|
||||
- Annotations intended for a command's here documents now work
|
||||
- Escaped characters inside groups in =~ regexes now parse
|
||||
- Associative arrays are now respected in arithmetic contexts
|
||||
- SC1087 about `$var[@]` now correctly triggers on any index
|
||||
- Bad expansions in here documents are no longer ignored
|
||||
- FD move operations like {fd}>1- now parse correctly
|
||||
|
||||
### Changed
|
||||
- Here docs are now terminated as per spec, rather than by presumed intent
|
||||
- SC1073: 'else if' is now parsed correctly and not like 'elif'
|
||||
- SC2163: 'export $name' can now be silenced with 'export ${name?}'
|
||||
- SC2183: Now warns when printf arg count is not a multiple of format count
|
||||
|
||||
## v0.4.7 - 2017-12-08
|
||||
### Added
|
||||
- Statically linked binaries for Linux and Windows (see README.md)!
|
||||
- `-a` flag to also include warnings in `source`d files
|
||||
- SC2221/SC2222: Warn about overridden case branches
|
||||
- SC2220: Warn about unhandled error cases in getopt loops
|
||||
- SC2218: Warn when using functions before they're defined
|
||||
- SC2216/SC2217: Warn when piping/redirecting to mv/cp and other non-readers
|
||||
- SC2215: Warn about commands starting with leading dash
|
||||
- SC2214: Warn about superfluous getopt flags
|
||||
- SC2213: Warn about unhandled getopt flags
|
||||
- SC2212: Suggest `false` over `[ ]`
|
||||
- SC2211: Warn when using a glob as a command name
|
||||
- SC2210: Warn when redirecting to an integer, e.g. `foo 1>2`
|
||||
- SC2206/SC2207: Suggest alternatives when using word splitting in arrays
|
||||
- SC1117: Warn about double quoted, undefined backslash sequences
|
||||
- SC1113/SC1114/SC1115: Recognized more malformed shebangs
|
||||
|
||||
### Fixed
|
||||
- `[ -v foo ]` no longer warns if `foo` is undefined
|
||||
- SC2037 is now suppressed by quotes, e.g. `PAGER="cat" man foo`
|
||||
- Ksh nested array declarations now parse correctly
|
||||
- Parameter Expansion without colons are now recognized, e.g. `${foo+bar}`
|
||||
- The `lastpipe` option is now respected with regard to subshell warnings
|
||||
- `\(` is now respected for grouping in `[`
|
||||
- Leading `\` is now ignored for commands, to allow alias suppression
|
||||
- Comments are now allowed after directives to e.g. explain 'disable'
|
||||
|
||||
|
||||
## v0.4.6 - 2017-03-26
|
||||
### Added
|
||||
- SC2204/SC2205: Warn about `( -z foo )` and `( foo -eq bar )`
|
||||
- SC2200/SC2201: Warn about brace expansion in [/[[
|
||||
- SC2198/SC2199: Warn about arrays in [/[[
|
||||
- SC2196/SC2197: Warn about deprecated egrep/fgrep
|
||||
- SC2195: Warn about unmatchable case branches
|
||||
- SC2194: Warn about constant 'case' statements
|
||||
- SC2193: Warn about `[[ file.png == *.mp3 ]]` and other unmatchables
|
||||
- SC2188/SC2189: Warn about redirections without commands
|
||||
- SC2186: Warn about deprecated `tempfile`
|
||||
- SC1109: Warn when finding `&`/`>`/`<` unquoted
|
||||
- SC1108: Warn about missing spaces in `[ var= foo ]`
|
||||
|
||||
### Changed
|
||||
- All files are now read as UTF-8 with lenient latin1 fallback, ignoring locale
|
||||
- Unicode quotes are no longer considered syntactic quotes
|
||||
- `ash` scripts will now be checked as `dash` with a warning
|
||||
|
||||
### Fixed
|
||||
- `-c` no longer suggested when using `grep -o | wc`
|
||||
- Comments and whitespace are now allowed before filewide directives
|
||||
- Here doc delimiters with esoteric quoting like `foo""` are now handled
|
||||
- SC2095 about `ssh` in while read loops is now suppressed when using `-n`
|
||||
- `%(%Y%M%D)T` now recognized as a single formatter in `printf` checks
|
||||
- `grep -F` now suppresses regex related suggestions
|
||||
- Command name checks now recognize busybox applet names
|
||||
|
||||
|
||||
## v0.4.5 - 2016-10-21
|
||||
### Added
|
||||
- A Docker build (thanks, kpankonen!)
|
||||
- SC2185: Suggest explicitly adding path for `find`
|
||||
- SC2184: Warn about unsetting globs (e.g. `unset foo[1]`)
|
||||
- SC2183: Warn about `printf` with more formatters than variables
|
||||
- SC2182: Warn about ignored arguments with `printf`
|
||||
- SC2181: Suggest using command directly instead of `if [ $? -eq 0 ]`
|
||||
- SC1106: Warn when using `test` operators in `(( 1 -eq 2 ))`
|
||||
|
||||
### Changed
|
||||
- Unrecognized directives now causes a warning rather than parse failure.
|
||||
|
||||
### Fixed
|
||||
- Indices in associative arrays are now parsed correctly
|
||||
- Missing shebang warning squashed when specifying with a directive
|
||||
- Ksh multidimensional arrays are now supported
|
||||
- Variables in substring ${a:x:y} expansions now count as referenced
|
||||
- SC1102 now also handles ambiguous `$((`
|
||||
- Using `$(seq ..)` will no longer suggest quoting
|
||||
- SC2148 (missing shebang) is now suppressed when using shell directives
|
||||
- `[ a '>' b ]` is now recognized as being correctly escaped
|
||||
|
||||
|
||||
## v0.4.4 - 2016-05-15
|
||||
### Added
|
||||
- Haskell Stack support (thanks, Arguggi!)
|
||||
- SC2179/SC2178: Warn when assigning/appending strings to arrays
|
||||
- SC1102: Warn about ambiguous `$(((`
|
||||
- SC1101: Warn when \\ linebreaks have trailing spaces
|
||||
|
||||
### Changed
|
||||
- Directives directly after the shebang now apply to the entire file
|
||||
|
||||
### Fixed
|
||||
- `{$i..10}` is now flagged similar to `{1..$i}`
|
||||
|
||||
|
||||
## v0.4.3 - 2016-01-13
|
||||
### Fixed
|
||||
- Build now works on GHC 7.6.3 as found on Debian Stable/Ubuntu LTS
|
||||
|
||||
|
||||
## v0.4.2 - 2016-01-09
|
||||
### Added
|
||||
- First class support for the `dash` shell
|
||||
- The `--color` flag similar to ls/grep's (thanks, haguenau!)
|
||||
- SC2174: Warn about unexpected behavior of `mkdir -pm` (thanks, eatnumber1!)
|
||||
- SC2172: Warn about non-portable use of signal numbers in `trap`
|
||||
- SC2171: Warn about `]]` without leading `[[`
|
||||
- SC2168: Warn about `local` outside functions
|
||||
|
||||
### Fixed
|
||||
- Warnings about unchecked `cd` will no longer trigger with `set -e`
|
||||
- `[ a -nt/-ot/-ef b ]` no longer warns about being constant
|
||||
- Quoted test operators like `[ foo "<" bar ]` now parse
|
||||
- Escaped quotes in backticks now parse correctly
|
||||
|
||||
|
||||
## v0.4.1 - 2015-09-05
|
||||
### Fixed
|
||||
- Added missing files to Cabal, fixing the build
|
||||
|
||||
|
||||
## v0.4.0 - 2015-09-05
|
||||
### Added
|
||||
- Support for following `source`d files
|
||||
- Support for setting default flags in `SHELLCHECK_OPTS`
|
||||
- An `--external-sources` flag for following arbitrary `source`d files
|
||||
- A `source` directive to override the filename to `source`
|
||||
- SC2166: Suggest using `[ p ] && [ q ]` over `[ p -a q ]`
|
||||
- SC2165: Warn when nested `for` loops use the same variable name
|
||||
- SC2164: Warn when using `cd` without checking that it succeeds
|
||||
- SC2163: Warn about `export $var`
|
||||
- SC2162: Warn when using `read` without `-r`
|
||||
- SC2157: Warn about `[ "$var " ]` and similar never-empty string matches
|
||||
|
||||
### Fixed
|
||||
- `cat -vnE file` and similar will no longer flag as UUOC
|
||||
- Nested trinary operators in `(( ))` now parse correctly
|
||||
- Ksh `${ ..; }` command expansions now parse
|
||||
|
||||
|
||||
## v0.3.8 - 2015-06-20
|
||||
### Changed
|
||||
- ShellCheck's license has changed from AGPLv3 to GPLv3.
|
||||
|
||||
### Added
|
||||
- SC2156: Warn about injecting filenames in `find -exec sh -c "{}" \;`
|
||||
|
||||
### Fixed
|
||||
- Variables and command substitutions in brace expansions are now parsed
|
||||
- ANSI colors are now disabled on Windows
|
||||
- Empty scripts now parse
|
||||
|
||||
|
||||
## v0.3.7 - 2015-04-16
|
||||
### Fixed
|
||||
- Build now works on GHC 7.10
|
||||
- Use `regex-tdfa` over `regex-compat` since the latter crashes on OS X.
|
||||
|
||||
## v0.3.6 - 2015-03-28
|
||||
### Added
|
||||
- SC2155: Warn about masked return values in `export foo=$(exit 1)`
|
||||
- SC2154: Warn when a lowercase variable is referenced but not assigned
|
||||
- SC2152/SC2151: Warn about bad `return` values like `1234` and `"foo"`
|
||||
- SC2150: Warn about `find -exec "shell command" \;`
|
||||
|
||||
### Fixed
|
||||
- `coproc` is now supported
|
||||
- Trinary operator now recognized in `((..))`
|
||||
|
||||
### Removed
|
||||
- Zsh support has been removed
|
||||
|
||||
|
||||
## v0.3.5 - 2014-11-09
|
||||
### Added
|
||||
- SC2148: Warn when not including a shebang
|
||||
- SC2147: Warn about literal ~ in PATH
|
||||
- SC1086: Warn about `$` in for loop variables, e.g. `for $i in ..`
|
||||
- SC1084: Warn when the shebang uses `!#` instead of `#!`
|
||||
|
||||
### Fixed
|
||||
- Empty and comment-only backtick expansions now parse
|
||||
- Variables used in PS1/PROMPT\_COMMAND/trap now count as referenced
|
||||
- ShellCheck now skips unreadable files and directories
|
||||
- `-f gcc` on empty files no longer crashes
|
||||
- Variables in $".." are now considered quoted
|
||||
- Warnings about expansions in single quotes now include backticks
|
||||
|
||||
|
||||
## v0.3.4 - 2014-07-08
|
||||
### Added
|
||||
- SC2146: Warn about precedence when combining `find -o` with actions
|
||||
- SC2145: Warn when concatenating arrays and strings
|
||||
|
||||
### Fixed
|
||||
- Case statements now support `;&` and `;;&`
|
||||
- Indices in array declarations now parse correctly
|
||||
- `let` expressions now parsed as arithmetic expressions
|
||||
- Escaping is now respected in here documents
|
||||
|
||||
### Changed
|
||||
- Completely drop Makefile in favor of Cabal (thanks rodrigosetti!)
|
||||
|
||||
|
||||
## v0.3.3 - 2014-05-29
|
||||
### Added
|
||||
- SC2144: Warn when using globs in `[/[[`
|
||||
- SC2143: Suggesting using `grep -q` over `[ "$(.. | grep)" ]`
|
||||
- SC2142: Warn when referencing positional parameters in aliases
|
||||
- SC2141: Warn about suspicious IFS assignments like `IFS="\n"`
|
||||
- SC2140: Warn about bad embedded quotes like `echo "var="value""`
|
||||
- SC2130: Warn when using `-eq` on strings
|
||||
- SC2139: Warn about define time expansions in alias definitions
|
||||
- SC2129: Suggest command grouping over `a >> log; b >> log; c >> log`
|
||||
- SC2128: Warn when expanding arrays without an index
|
||||
- SC2126: Suggest `grep -c` over `grep|wc`
|
||||
- SC2123: Warn about accidentally overriding `$PATH`, e.g. `PATH=/my/dir`
|
||||
- SC1083: Warn about literal `{/}` outside of quotes
|
||||
- SC1082: Warn about UTF-8 BOMs
|
||||
|
||||
### Fixed
|
||||
- SC2051 no longer triggers for `{1,$n}`, only `{1..$n}`
|
||||
- Improved detection of single quoted `sed` variables, e.g. `sed '$s///'`
|
||||
- Stop warning about single quoted variables in `PS1` and similar
|
||||
- Support for Zsh short form loops, `=(..)`
|
||||
|
||||
### Removed
|
||||
- SC1000 about unescaped lonely `$`, e.g. `grep "^foo$"`
|
||||
|
||||
|
||||
## v0.3.2 - 2014-03-22
|
||||
### Added
|
||||
- SC2121: Warn about trying to `set` variables, e.g. `set var = value`
|
||||
- SC2120/SC2119: Warn when a function uses `$1..` if none are ever passed
|
||||
- SC2117: Warn when using `su` in interactive mode, e.g. `su foo; whoami`
|
||||
- SC2116: Detect useless use of echo, e.g. `for i in $(echo $var)`
|
||||
- SC2115/SC2114: Detect some catastrophic `rm -r "$empty/"` mistakes
|
||||
- SC1081: Warn when capitalizing keywords like `While`
|
||||
- SC1077: Warn when using acute accents instead of backticks
|
||||
|
||||
### Fixed
|
||||
- Shells are now properly recognized in shebangs containing flags
|
||||
- Stop warning about math on decimals in ksh/zsh
|
||||
- Stop warning about decimal comparisons with `=`, e.g. `[ $version = 1.2 ]`
|
||||
- Parsing of `|&`
|
||||
- `${a[x]}` not counting as a reference of `x`
|
||||
- `(( x[0] ))` not counting as a reference of `x`
|
||||
|
||||
|
||||
## v0.3.1 - 2014-02-03
|
||||
### Added
|
||||
- The `-s` flag to specify shell dialect
|
||||
- SC2105/SC2104: Warn about `break/continue` outside loops
|
||||
- SC1076: Detect invalid `[/[[` arithmetic like `[ 1 + 2 = 3 ]`
|
||||
- SC1075: Suggest using `elif` over `else if`
|
||||
|
||||
### Fixed
|
||||
- Don't warn when comma separating elements in brace expansions
|
||||
- Improved detection of single quoted `sed` variables, e.g. `sed '$d'`
|
||||
- Parsing of arithmetic for loops using `{..}` instead of `do..done`
|
||||
- Don't treat the last pipeline stage as a subshell in ksh/zsh
|
||||
|
||||
|
||||
## v0.3.0 - 2014-01-19
|
||||
### Added
|
||||
- A man page (thanks Dridi!)
|
||||
- GCC compatible error reporting (`shellcheck -f gcc`)
|
||||
- CheckStyle compatible XML error reporting (`shellcheck -f checkstyle`)
|
||||
- Error codes for each warning, e.g. SC1234
|
||||
- Allow disabling warnings with `# shellcheck disable=SC1234`
|
||||
- Allow disabling warnings with `--exclude`
|
||||
- SC2103: Suggest using subshells over `cd foo; bar; cd ..`
|
||||
- SC2102: Warn about duplicates in char ranges, e.g. `[10-15]`
|
||||
- SC2101: Warn about named classes not inside a char range, e.g. `[:digit:]`
|
||||
- SC2100/SC2099: Warn about bad math expressions like `i=i+5`
|
||||
- SC2098/SC2097: Warn about `foo=bar echo $foo`
|
||||
- SC2095: Warn when using `ssh`/`ffmpeg` in `while read` loops
|
||||
- Better warnings for missing here doc tokens
|
||||
|
||||
### Fixed
|
||||
- Don't warn when single quoting variables with `ssh/perl/eval`
|
||||
- `${!var}` is now counted as a variable reference
|
||||
|
||||
### Removed
|
||||
- Suggestions about using parameter expansion over basename
|
||||
- The `jsoncheck` binary. Use `shellcheck -f json` instead.
|
||||
|
||||
|
||||
## v0.2.0 - 2013-10-27
|
||||
### Added
|
||||
- Suggest `./*` instead of `*` when passing globs to commands
|
||||
- Suggest `pgrep` over `ps | grep`
|
||||
- Warn about unicode quotes
|
||||
- Warn about assigned but unused variables
|
||||
- Inform about client side expansion when using `ssh`
|
||||
|
||||
### Fixed
|
||||
- CLI tool now uses exit codes and stderr canonically
|
||||
- Parsing of extglobs containing empty patterns
|
||||
- Parsing of bash style `eval foo=(bar)`
|
||||
- Parsing of expansions in here documents
|
||||
- Parsing of function names containing :+-
|
||||
- Don't warn about `find|xargs` when using `-print0`
|
||||
|
||||
|
||||
## v0.1.0 - 2013-07-23
|
||||
### Added
|
||||
- First release
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
# Alpine image
|
||||
FROM alpine:latest AS alpine
|
||||
LABEL maintainer="Vidar Holen <vidar@vidarholen.net>"
|
||||
ARG tag
|
||||
|
||||
# Put the right binary for each architecture into place for the
|
||||
# multi-architecture docker image.
|
||||
ARG url_base="https://github.com/koalaman/shellcheck/releases/download/"
|
||||
RUN set -x; \
|
||||
arch="$(uname -m)"; \
|
||||
echo "arch is $arch"; \
|
||||
if [ "${arch}" = 'armv7l' ]; then \
|
||||
arch='armv6hf'; \
|
||||
fi; \
|
||||
tar_file="${tag}/shellcheck-${tag}.linux.${arch}.tar.xz"; \
|
||||
wget "${url_base}${tar_file}" -O - | tar -C /bin --strip-components=1 -xJf - "shellcheck-${tag}/shellcheck" && \
|
||||
ls -laF /bin/shellcheck
|
||||
|
||||
# ShellCheck image
|
||||
FROM scratch
|
||||
LABEL maintainer="Vidar Holen <vidar@vidarholen.net>"
|
||||
WORKDIR /mnt
|
||||
COPY --from=alpine /bin/shellcheck /bin/
|
||||
ENTRYPOINT ["/bin/shellcheck"]
|
||||
674
LICENSE
674
LICENSE
|
|
@ -1,674 +0,0 @@
|
|||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 3, 29 June 2007
|
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
Preamble
|
||||
|
||||
The GNU General Public License is a free, copyleft license for
|
||||
software and other kinds of works.
|
||||
|
||||
The licenses for most software and other practical works are designed
|
||||
to take away your freedom to share and change the works. By contrast,
|
||||
the GNU General Public License is intended to guarantee your freedom to
|
||||
share and change all versions of a program--to make sure it remains free
|
||||
software for all its users. We, the Free Software Foundation, use the
|
||||
GNU General Public License for most of our software; it applies also to
|
||||
any other work released this way by its authors. You can apply it to
|
||||
your programs, too.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
them if you wish), that you receive source code or can get it if you
|
||||
want it, that you can change the software or use pieces of it in new
|
||||
free programs, and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to prevent others from denying you
|
||||
these rights or asking you to surrender the rights. Therefore, you have
|
||||
certain responsibilities if you distribute copies of the software, or if
|
||||
you modify it: responsibilities to respect the freedom of others.
|
||||
|
||||
For example, if you distribute copies of such a program, whether
|
||||
gratis or for a fee, you must pass on to the recipients the same
|
||||
freedoms that you received. You must make sure that they, too, receive
|
||||
or can get the source code. And you must show them these terms so they
|
||||
know their rights.
|
||||
|
||||
Developers that use the GNU GPL protect your rights with two steps:
|
||||
(1) assert copyright on the software, and (2) offer you this License
|
||||
giving you legal permission to copy, distribute and/or modify it.
|
||||
|
||||
For the developers' and authors' protection, the GPL clearly explains
|
||||
that there is no warranty for this free software. For both users' and
|
||||
authors' sake, the GPL requires that modified versions be marked as
|
||||
changed, so that their problems will not be attributed erroneously to
|
||||
authors of previous versions.
|
||||
|
||||
Some devices are designed to deny users access to install or run
|
||||
modified versions of the software inside them, although the manufacturer
|
||||
can do so. This is fundamentally incompatible with the aim of
|
||||
protecting users' freedom to change the software. The systematic
|
||||
pattern of such abuse occurs in the area of products for individuals to
|
||||
use, which is precisely where it is most unacceptable. Therefore, we
|
||||
have designed this version of the GPL to prohibit the practice for those
|
||||
products. If such problems arise substantially in other domains, we
|
||||
stand ready to extend this provision to those domains in future versions
|
||||
of the GPL, as needed to protect the freedom of users.
|
||||
|
||||
Finally, every program is threatened constantly by software patents.
|
||||
States should not allow patents to restrict development and use of
|
||||
software on general-purpose computers, but in those that do, we wish to
|
||||
avoid the special danger that patents applied to a free program could
|
||||
make it effectively proprietary. To prevent this, the GPL assures that
|
||||
patents cannot be used to render the program non-free.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
||||
TERMS AND CONDITIONS
|
||||
|
||||
0. Definitions.
|
||||
|
||||
"This License" refers to version 3 of the GNU General Public License.
|
||||
|
||||
"Copyright" also means copyright-like laws that apply to other kinds of
|
||||
works, such as semiconductor masks.
|
||||
|
||||
"The Program" refers to any copyrightable work licensed under this
|
||||
License. Each licensee is addressed as "you". "Licensees" and
|
||||
"recipients" may be individuals or organizations.
|
||||
|
||||
To "modify" a work means to copy from or adapt all or part of the work
|
||||
in a fashion requiring copyright permission, other than the making of an
|
||||
exact copy. The resulting work is called a "modified version" of the
|
||||
earlier work or a work "based on" the earlier work.
|
||||
|
||||
A "covered work" means either the unmodified Program or a work based
|
||||
on the Program.
|
||||
|
||||
To "propagate" a work means to do anything with it that, without
|
||||
permission, would make you directly or secondarily liable for
|
||||
infringement under applicable copyright law, except executing it on a
|
||||
computer or modifying a private copy. Propagation includes copying,
|
||||
distribution (with or without modification), making available to the
|
||||
public, and in some countries other activities as well.
|
||||
|
||||
To "convey" a work means any kind of propagation that enables other
|
||||
parties to make or receive copies. Mere interaction with a user through
|
||||
a computer network, with no transfer of a copy, is not conveying.
|
||||
|
||||
An interactive user interface displays "Appropriate Legal Notices"
|
||||
to the extent that it includes a convenient and prominently visible
|
||||
feature that (1) displays an appropriate copyright notice, and (2)
|
||||
tells the user that there is no warranty for the work (except to the
|
||||
extent that warranties are provided), that licensees may convey the
|
||||
work under this License, and how to view a copy of this License. If
|
||||
the interface presents a list of user commands or options, such as a
|
||||
menu, a prominent item in the list meets this criterion.
|
||||
|
||||
1. Source Code.
|
||||
|
||||
The "source code" for a work means the preferred form of the work
|
||||
for making modifications to it. "Object code" means any non-source
|
||||
form of a work.
|
||||
|
||||
A "Standard Interface" means an interface that either is an official
|
||||
standard defined by a recognized standards body, or, in the case of
|
||||
interfaces specified for a particular programming language, one that
|
||||
is widely used among developers working in that language.
|
||||
|
||||
The "System Libraries" of an executable work include anything, other
|
||||
than the work as a whole, that (a) is included in the normal form of
|
||||
packaging a Major Component, but which is not part of that Major
|
||||
Component, and (b) serves only to enable use of the work with that
|
||||
Major Component, or to implement a Standard Interface for which an
|
||||
implementation is available to the public in source code form. A
|
||||
"Major Component", in this context, means a major essential component
|
||||
(kernel, window system, and so on) of the specific operating system
|
||||
(if any) on which the executable work runs, or a compiler used to
|
||||
produce the work, or an object code interpreter used to run it.
|
||||
|
||||
The "Corresponding Source" for a work in object code form means all
|
||||
the source code needed to generate, install, and (for an executable
|
||||
work) run the object code and to modify the work, including scripts to
|
||||
control those activities. However, it does not include the work's
|
||||
System Libraries, or general-purpose tools or generally available free
|
||||
programs which are used unmodified in performing those activities but
|
||||
which are not part of the work. For example, Corresponding Source
|
||||
includes interface definition files associated with source files for
|
||||
the work, and the source code for shared libraries and dynamically
|
||||
linked subprograms that the work is specifically designed to require,
|
||||
such as by intimate data communication or control flow between those
|
||||
subprograms and other parts of the work.
|
||||
|
||||
The Corresponding Source need not include anything that users
|
||||
can regenerate automatically from other parts of the Corresponding
|
||||
Source.
|
||||
|
||||
The Corresponding Source for a work in source code form is that
|
||||
same work.
|
||||
|
||||
2. Basic Permissions.
|
||||
|
||||
All rights granted under this License are granted for the term of
|
||||
copyright on the Program, and are irrevocable provided the stated
|
||||
conditions are met. This License explicitly affirms your unlimited
|
||||
permission to run the unmodified Program. The output from running a
|
||||
covered work is covered by this License only if the output, given its
|
||||
content, constitutes a covered work. This License acknowledges your
|
||||
rights of fair use or other equivalent, as provided by copyright law.
|
||||
|
||||
You may make, run and propagate covered works that you do not
|
||||
convey, without conditions so long as your license otherwise remains
|
||||
in force. You may convey covered works to others for the sole purpose
|
||||
of having them make modifications exclusively for you, or provide you
|
||||
with facilities for running those works, provided that you comply with
|
||||
the terms of this License in conveying all material for which you do
|
||||
not control copyright. Those thus making or running the covered works
|
||||
for you must do so exclusively on your behalf, under your direction
|
||||
and control, on terms that prohibit them from making any copies of
|
||||
your copyrighted material outside their relationship with you.
|
||||
|
||||
Conveying under any other circumstances is permitted solely under
|
||||
the conditions stated below. Sublicensing is not allowed; section 10
|
||||
makes it unnecessary.
|
||||
|
||||
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
|
||||
|
||||
No covered work shall be deemed part of an effective technological
|
||||
measure under any applicable law fulfilling obligations under article
|
||||
11 of the WIPO copyright treaty adopted on 20 December 1996, or
|
||||
similar laws prohibiting or restricting circumvention of such
|
||||
measures.
|
||||
|
||||
When you convey a covered work, you waive any legal power to forbid
|
||||
circumvention of technological measures to the extent such circumvention
|
||||
is effected by exercising rights under this License with respect to
|
||||
the covered work, and you disclaim any intention to limit operation or
|
||||
modification of the work as a means of enforcing, against the work's
|
||||
users, your or third parties' legal rights to forbid circumvention of
|
||||
technological measures.
|
||||
|
||||
4. Conveying Verbatim Copies.
|
||||
|
||||
You may convey verbatim copies of the Program's source code as you
|
||||
receive it, in any medium, provided that you conspicuously and
|
||||
appropriately publish on each copy an appropriate copyright notice;
|
||||
keep intact all notices stating that this License and any
|
||||
non-permissive terms added in accord with section 7 apply to the code;
|
||||
keep intact all notices of the absence of any warranty; and give all
|
||||
recipients a copy of this License along with the Program.
|
||||
|
||||
You may charge any price or no price for each copy that you convey,
|
||||
and you may offer support or warranty protection for a fee.
|
||||
|
||||
5. Conveying Modified Source Versions.
|
||||
|
||||
You may convey a work based on the Program, or the modifications to
|
||||
produce it from the Program, in the form of source code under the
|
||||
terms of section 4, provided that you also meet all of these conditions:
|
||||
|
||||
a) The work must carry prominent notices stating that you modified
|
||||
it, and giving a relevant date.
|
||||
|
||||
b) The work must carry prominent notices stating that it is
|
||||
released under this License and any conditions added under section
|
||||
7. This requirement modifies the requirement in section 4 to
|
||||
"keep intact all notices".
|
||||
|
||||
c) You must license the entire work, as a whole, under this
|
||||
License to anyone who comes into possession of a copy. This
|
||||
License will therefore apply, along with any applicable section 7
|
||||
additional terms, to the whole of the work, and all its parts,
|
||||
regardless of how they are packaged. This License gives no
|
||||
permission to license the work in any other way, but it does not
|
||||
invalidate such permission if you have separately received it.
|
||||
|
||||
d) If the work has interactive user interfaces, each must display
|
||||
Appropriate Legal Notices; however, if the Program has interactive
|
||||
interfaces that do not display Appropriate Legal Notices, your
|
||||
work need not make them do so.
|
||||
|
||||
A compilation of a covered work with other separate and independent
|
||||
works, which are not by their nature extensions of the covered work,
|
||||
and which are not combined with it such as to form a larger program,
|
||||
in or on a volume of a storage or distribution medium, is called an
|
||||
"aggregate" if the compilation and its resulting copyright are not
|
||||
used to limit the access or legal rights of the compilation's users
|
||||
beyond what the individual works permit. Inclusion of a covered work
|
||||
in an aggregate does not cause this License to apply to the other
|
||||
parts of the aggregate.
|
||||
|
||||
6. Conveying Non-Source Forms.
|
||||
|
||||
You may convey a covered work in object code form under the terms
|
||||
of sections 4 and 5, provided that you also convey the
|
||||
machine-readable Corresponding Source under the terms of this License,
|
||||
in one of these ways:
|
||||
|
||||
a) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by the
|
||||
Corresponding Source fixed on a durable physical medium
|
||||
customarily used for software interchange.
|
||||
|
||||
b) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by a
|
||||
written offer, valid for at least three years and valid for as
|
||||
long as you offer spare parts or customer support for that product
|
||||
model, to give anyone who possesses the object code either (1) a
|
||||
copy of the Corresponding Source for all the software in the
|
||||
product that is covered by this License, on a durable physical
|
||||
medium customarily used for software interchange, for a price no
|
||||
more than your reasonable cost of physically performing this
|
||||
conveying of source, or (2) access to copy the
|
||||
Corresponding Source from a network server at no charge.
|
||||
|
||||
c) Convey individual copies of the object code with a copy of the
|
||||
written offer to provide the Corresponding Source. This
|
||||
alternative is allowed only occasionally and noncommercially, and
|
||||
only if you received the object code with such an offer, in accord
|
||||
with subsection 6b.
|
||||
|
||||
d) Convey the object code by offering access from a designated
|
||||
place (gratis or for a charge), and offer equivalent access to the
|
||||
Corresponding Source in the same way through the same place at no
|
||||
further charge. You need not require recipients to copy the
|
||||
Corresponding Source along with the object code. If the place to
|
||||
copy the object code is a network server, the Corresponding Source
|
||||
may be on a different server (operated by you or a third party)
|
||||
that supports equivalent copying facilities, provided you maintain
|
||||
clear directions next to the object code saying where to find the
|
||||
Corresponding Source. Regardless of what server hosts the
|
||||
Corresponding Source, you remain obligated to ensure that it is
|
||||
available for as long as needed to satisfy these requirements.
|
||||
|
||||
e) Convey the object code using peer-to-peer transmission, provided
|
||||
you inform other peers where the object code and Corresponding
|
||||
Source of the work are being offered to the general public at no
|
||||
charge under subsection 6d.
|
||||
|
||||
A separable portion of the object code, whose source code is excluded
|
||||
from the Corresponding Source as a System Library, need not be
|
||||
included in conveying the object code work.
|
||||
|
||||
A "User Product" is either (1) a "consumer product", which means any
|
||||
tangible personal property which is normally used for personal, family,
|
||||
or household purposes, or (2) anything designed or sold for incorporation
|
||||
into a dwelling. In determining whether a product is a consumer product,
|
||||
doubtful cases shall be resolved in favor of coverage. For a particular
|
||||
product received by a particular user, "normally used" refers to a
|
||||
typical or common use of that class of product, regardless of the status
|
||||
of the particular user or of the way in which the particular user
|
||||
actually uses, or expects or is expected to use, the product. A product
|
||||
is a consumer product regardless of whether the product has substantial
|
||||
commercial, industrial or non-consumer uses, unless such uses represent
|
||||
the only significant mode of use of the product.
|
||||
|
||||
"Installation Information" for a User Product means any methods,
|
||||
procedures, authorization keys, or other information required to install
|
||||
and execute modified versions of a covered work in that User Product from
|
||||
a modified version of its Corresponding Source. The information must
|
||||
suffice to ensure that the continued functioning of the modified object
|
||||
code is in no case prevented or interfered with solely because
|
||||
modification has been made.
|
||||
|
||||
If you convey an object code work under this section in, or with, or
|
||||
specifically for use in, a User Product, and the conveying occurs as
|
||||
part of a transaction in which the right of possession and use of the
|
||||
User Product is transferred to the recipient in perpetuity or for a
|
||||
fixed term (regardless of how the transaction is characterized), the
|
||||
Corresponding Source conveyed under this section must be accompanied
|
||||
by the Installation Information. But this requirement does not apply
|
||||
if neither you nor any third party retains the ability to install
|
||||
modified object code on the User Product (for example, the work has
|
||||
been installed in ROM).
|
||||
|
||||
The requirement to provide Installation Information does not include a
|
||||
requirement to continue to provide support service, warranty, or updates
|
||||
for a work that has been modified or installed by the recipient, or for
|
||||
the User Product in which it has been modified or installed. Access to a
|
||||
network may be denied when the modification itself materially and
|
||||
adversely affects the operation of the network or violates the rules and
|
||||
protocols for communication across the network.
|
||||
|
||||
Corresponding Source conveyed, and Installation Information provided,
|
||||
in accord with this section must be in a format that is publicly
|
||||
documented (and with an implementation available to the public in
|
||||
source code form), and must require no special password or key for
|
||||
unpacking, reading or copying.
|
||||
|
||||
7. Additional Terms.
|
||||
|
||||
"Additional permissions" are terms that supplement the terms of this
|
||||
License by making exceptions from one or more of its conditions.
|
||||
Additional permissions that are applicable to the entire Program shall
|
||||
be treated as though they were included in this License, to the extent
|
||||
that they are valid under applicable law. If additional permissions
|
||||
apply only to part of the Program, that part may be used separately
|
||||
under those permissions, but the entire Program remains governed by
|
||||
this License without regard to the additional permissions.
|
||||
|
||||
When you convey a copy of a covered work, you may at your option
|
||||
remove any additional permissions from that copy, or from any part of
|
||||
it. (Additional permissions may be written to require their own
|
||||
removal in certain cases when you modify the work.) You may place
|
||||
additional permissions on material, added by you to a covered work,
|
||||
for which you have or can give appropriate copyright permission.
|
||||
|
||||
Notwithstanding any other provision of this License, for material you
|
||||
add to a covered work, you may (if authorized by the copyright holders of
|
||||
that material) supplement the terms of this License with terms:
|
||||
|
||||
a) Disclaiming warranty or limiting liability differently from the
|
||||
terms of sections 15 and 16 of this License; or
|
||||
|
||||
b) Requiring preservation of specified reasonable legal notices or
|
||||
author attributions in that material or in the Appropriate Legal
|
||||
Notices displayed by works containing it; or
|
||||
|
||||
c) Prohibiting misrepresentation of the origin of that material, or
|
||||
requiring that modified versions of such material be marked in
|
||||
reasonable ways as different from the original version; or
|
||||
|
||||
d) Limiting the use for publicity purposes of names of licensors or
|
||||
authors of the material; or
|
||||
|
||||
e) Declining to grant rights under trademark law for use of some
|
||||
trade names, trademarks, or service marks; or
|
||||
|
||||
f) Requiring indemnification of licensors and authors of that
|
||||
material by anyone who conveys the material (or modified versions of
|
||||
it) with contractual assumptions of liability to the recipient, for
|
||||
any liability that these contractual assumptions directly impose on
|
||||
those licensors and authors.
|
||||
|
||||
All other non-permissive additional terms are considered "further
|
||||
restrictions" within the meaning of section 10. If the Program as you
|
||||
received it, or any part of it, contains a notice stating that it is
|
||||
governed by this License along with a term that is a further
|
||||
restriction, you may remove that term. If a license document contains
|
||||
a further restriction but permits relicensing or conveying under this
|
||||
License, you may add to a covered work material governed by the terms
|
||||
of that license document, provided that the further restriction does
|
||||
not survive such relicensing or conveying.
|
||||
|
||||
If you add terms to a covered work in accord with this section, you
|
||||
must place, in the relevant source files, a statement of the
|
||||
additional terms that apply to those files, or a notice indicating
|
||||
where to find the applicable terms.
|
||||
|
||||
Additional terms, permissive or non-permissive, may be stated in the
|
||||
form of a separately written license, or stated as exceptions;
|
||||
the above requirements apply either way.
|
||||
|
||||
8. Termination.
|
||||
|
||||
You may not propagate or modify a covered work except as expressly
|
||||
provided under this License. Any attempt otherwise to propagate or
|
||||
modify it is void, and will automatically terminate your rights under
|
||||
this License (including any patent licenses granted under the third
|
||||
paragraph of section 11).
|
||||
|
||||
However, if you cease all violation of this License, then your
|
||||
license from a particular copyright holder is reinstated (a)
|
||||
provisionally, unless and until the copyright holder explicitly and
|
||||
finally terminates your license, and (b) permanently, if the copyright
|
||||
holder fails to notify you of the violation by some reasonable means
|
||||
prior to 60 days after the cessation.
|
||||
|
||||
Moreover, your license from a particular copyright holder is
|
||||
reinstated permanently if the copyright holder notifies you of the
|
||||
violation by some reasonable means, this is the first time you have
|
||||
received notice of violation of this License (for any work) from that
|
||||
copyright holder, and you cure the violation prior to 30 days after
|
||||
your receipt of the notice.
|
||||
|
||||
Termination of your rights under this section does not terminate the
|
||||
licenses of parties who have received copies or rights from you under
|
||||
this License. If your rights have been terminated and not permanently
|
||||
reinstated, you do not qualify to receive new licenses for the same
|
||||
material under section 10.
|
||||
|
||||
9. Acceptance Not Required for Having Copies.
|
||||
|
||||
You are not required to accept this License in order to receive or
|
||||
run a copy of the Program. Ancillary propagation of a covered work
|
||||
occurring solely as a consequence of using peer-to-peer transmission
|
||||
to receive a copy likewise does not require acceptance. However,
|
||||
nothing other than this License grants you permission to propagate or
|
||||
modify any covered work. These actions infringe copyright if you do
|
||||
not accept this License. Therefore, by modifying or propagating a
|
||||
covered work, you indicate your acceptance of this License to do so.
|
||||
|
||||
10. Automatic Licensing of Downstream Recipients.
|
||||
|
||||
Each time you convey a covered work, the recipient automatically
|
||||
receives a license from the original licensors, to run, modify and
|
||||
propagate that work, subject to this License. You are not responsible
|
||||
for enforcing compliance by third parties with this License.
|
||||
|
||||
An "entity transaction" is a transaction transferring control of an
|
||||
organization, or substantially all assets of one, or subdividing an
|
||||
organization, or merging organizations. If propagation of a covered
|
||||
work results from an entity transaction, each party to that
|
||||
transaction who receives a copy of the work also receives whatever
|
||||
licenses to the work the party's predecessor in interest had or could
|
||||
give under the previous paragraph, plus a right to possession of the
|
||||
Corresponding Source of the work from the predecessor in interest, if
|
||||
the predecessor has it or can get it with reasonable efforts.
|
||||
|
||||
You may not impose any further restrictions on the exercise of the
|
||||
rights granted or affirmed under this License. For example, you may
|
||||
not impose a license fee, royalty, or other charge for exercise of
|
||||
rights granted under this License, and you may not initiate litigation
|
||||
(including a cross-claim or counterclaim in a lawsuit) alleging that
|
||||
any patent claim is infringed by making, using, selling, offering for
|
||||
sale, or importing the Program or any portion of it.
|
||||
|
||||
11. Patents.
|
||||
|
||||
A "contributor" is a copyright holder who authorizes use under this
|
||||
License of the Program or a work on which the Program is based. The
|
||||
work thus licensed is called the contributor's "contributor version".
|
||||
|
||||
A contributor's "essential patent claims" are all patent claims
|
||||
owned or controlled by the contributor, whether already acquired or
|
||||
hereafter acquired, that would be infringed by some manner, permitted
|
||||
by this License, of making, using, or selling its contributor version,
|
||||
but do not include claims that would be infringed only as a
|
||||
consequence of further modification of the contributor version. For
|
||||
purposes of this definition, "control" includes the right to grant
|
||||
patent sublicenses in a manner consistent with the requirements of
|
||||
this License.
|
||||
|
||||
Each contributor grants you a non-exclusive, worldwide, royalty-free
|
||||
patent license under the contributor's essential patent claims, to
|
||||
make, use, sell, offer for sale, import and otherwise run, modify and
|
||||
propagate the contents of its contributor version.
|
||||
|
||||
In the following three paragraphs, a "patent license" is any express
|
||||
agreement or commitment, however denominated, not to enforce a patent
|
||||
(such as an express permission to practice a patent or covenant not to
|
||||
sue for patent infringement). To "grant" such a patent license to a
|
||||
party means to make such an agreement or commitment not to enforce a
|
||||
patent against the party.
|
||||
|
||||
If you convey a covered work, knowingly relying on a patent license,
|
||||
and the Corresponding Source of the work is not available for anyone
|
||||
to copy, free of charge and under the terms of this License, through a
|
||||
publicly available network server or other readily accessible means,
|
||||
then you must either (1) cause the Corresponding Source to be so
|
||||
available, or (2) arrange to deprive yourself of the benefit of the
|
||||
patent license for this particular work, or (3) arrange, in a manner
|
||||
consistent with the requirements of this License, to extend the patent
|
||||
license to downstream recipients. "Knowingly relying" means you have
|
||||
actual knowledge that, but for the patent license, your conveying the
|
||||
covered work in a country, or your recipient's use of the covered work
|
||||
in a country, would infringe one or more identifiable patents in that
|
||||
country that you have reason to believe are valid.
|
||||
|
||||
If, pursuant to or in connection with a single transaction or
|
||||
arrangement, you convey, or propagate by procuring conveyance of, a
|
||||
covered work, and grant a patent license to some of the parties
|
||||
receiving the covered work authorizing them to use, propagate, modify
|
||||
or convey a specific copy of the covered work, then the patent license
|
||||
you grant is automatically extended to all recipients of the covered
|
||||
work and works based on it.
|
||||
|
||||
A patent license is "discriminatory" if it does not include within
|
||||
the scope of its coverage, prohibits the exercise of, or is
|
||||
conditioned on the non-exercise of one or more of the rights that are
|
||||
specifically granted under this License. You may not convey a covered
|
||||
work if you are a party to an arrangement with a third party that is
|
||||
in the business of distributing software, under which you make payment
|
||||
to the third party based on the extent of your activity of conveying
|
||||
the work, and under which the third party grants, to any of the
|
||||
parties who would receive the covered work from you, a discriminatory
|
||||
patent license (a) in connection with copies of the covered work
|
||||
conveyed by you (or copies made from those copies), or (b) primarily
|
||||
for and in connection with specific products or compilations that
|
||||
contain the covered work, unless you entered into that arrangement,
|
||||
or that patent license was granted, prior to 28 March 2007.
|
||||
|
||||
Nothing in this License shall be construed as excluding or limiting
|
||||
any implied license or other defenses to infringement that may
|
||||
otherwise be available to you under applicable patent law.
|
||||
|
||||
12. No Surrender of Others' Freedom.
|
||||
|
||||
If conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot convey a
|
||||
covered work so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you may
|
||||
not convey it at all. For example, if you agree to terms that obligate you
|
||||
to collect a royalty for further conveying from those to whom you convey
|
||||
the Program, the only way you could satisfy both those terms and this
|
||||
License would be to refrain entirely from conveying the Program.
|
||||
|
||||
13. Use with the GNU Affero General Public License.
|
||||
|
||||
Notwithstanding any other provision of this License, you have
|
||||
permission to link or combine any covered work with a work licensed
|
||||
under version 3 of the GNU Affero General Public License into a single
|
||||
combined work, and to convey the resulting work. The terms of this
|
||||
License will continue to apply to the part which is the covered work,
|
||||
but the special requirements of the GNU Affero General Public License,
|
||||
section 13, concerning interaction through a network will apply to the
|
||||
combination as such.
|
||||
|
||||
14. Revised Versions of this License.
|
||||
|
||||
The Free Software Foundation may publish revised and/or new versions of
|
||||
the GNU General Public License from time to time. Such new versions will
|
||||
be similar in spirit to the present version, but may differ in detail to
|
||||
address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the
|
||||
Program specifies that a certain numbered version of the GNU General
|
||||
Public License "or any later version" applies to it, you have the
|
||||
option of following the terms and conditions either of that numbered
|
||||
version or of any later version published by the Free Software
|
||||
Foundation. If the Program does not specify a version number of the
|
||||
GNU General Public License, you may choose any version ever published
|
||||
by the Free Software Foundation.
|
||||
|
||||
If the Program specifies that a proxy can decide which future
|
||||
versions of the GNU General Public License can be used, that proxy's
|
||||
public statement of acceptance of a version permanently authorizes you
|
||||
to choose that version for the Program.
|
||||
|
||||
Later license versions may give you additional or different
|
||||
permissions. However, no additional obligations are imposed on any
|
||||
author or copyright holder as a result of your choosing to follow a
|
||||
later version.
|
||||
|
||||
15. Disclaimer of Warranty.
|
||||
|
||||
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
|
||||
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
|
||||
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
|
||||
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
|
||||
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
|
||||
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
|
||||
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. Limitation of Liability.
|
||||
|
||||
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
|
||||
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
|
||||
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
|
||||
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
|
||||
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
|
||||
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
|
||||
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
|
||||
SUCH DAMAGES.
|
||||
|
||||
17. Interpretation of Sections 15 and 16.
|
||||
|
||||
If the disclaimer of warranty and limitation of liability provided
|
||||
above cannot be given local legal effect according to their terms,
|
||||
reviewing courts shall apply local law that most closely approximates
|
||||
an absolute waiver of all civil liability in connection with the
|
||||
Program, unless a warranty or assumption of liability accompanies a
|
||||
copy of the Program in return for a fee.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Programs
|
||||
|
||||
If you develop a new program, and you want it to be of the greatest
|
||||
possible use to the public, the best way to achieve this is to make it
|
||||
free software which everyone can redistribute and change under these terms.
|
||||
|
||||
To do so, attach the following notices to the program. It is safest
|
||||
to attach them to the start of each source file to most effectively
|
||||
state the exclusion of warranty; and each file should have at least
|
||||
the "copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If the program does terminal interaction, make it output a short
|
||||
notice like this when it starts in an interactive mode:
|
||||
|
||||
<program> Copyright (C) <year> <name of author>
|
||||
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
parts of the General Public License. Of course, your program's commands
|
||||
might be different; for a GUI interface, you would use an "about box".
|
||||
|
||||
You should also get your employer (if you work as a programmer) or school,
|
||||
if any, to sign a "copyright disclaimer" for the program, if necessary.
|
||||
For more information on this, and how to apply and follow the GNU GPL, see
|
||||
<https://www.gnu.org/licenses/>.
|
||||
|
||||
The GNU General Public License does not permit incorporating your program
|
||||
into proprietary programs. If your program is a subroutine library, you
|
||||
may consider it more useful to permit linking proprietary applications with
|
||||
the library. If this is what you want to do, use the GNU Lesser General
|
||||
Public License instead of this License. But first, please read
|
||||
<https://www.gnu.org/licenses/why-not-lgpl.html>.
|
||||
564
README.md
564
README.md
|
|
@ -1,564 +0,0 @@
|
|||
[](https://github.com/koalaman/shellcheck/actions/workflows/build.yml)
|
||||
|
||||
|
||||
# ShellCheck - A shell script static analysis tool
|
||||
|
||||
ShellCheck is a GPLv3 tool that gives warnings and suggestions for bash/sh shell scripts:
|
||||
|
||||
|
||||
|
||||
The goals of ShellCheck are
|
||||
|
||||
* To point out and clarify typical beginner's syntax issues that cause a shell
|
||||
to give cryptic error messages.
|
||||
|
||||
* To point out and clarify typical intermediate level semantic problems that
|
||||
cause a shell to behave strangely and counter-intuitively.
|
||||
|
||||
* To point out subtle caveats, corner cases and pitfalls that may cause an
|
||||
advanced user's otherwise working script to fail under future circumstances.
|
||||
|
||||
See [the gallery of bad code](README.md#user-content-gallery-of-bad-code) for examples of what ShellCheck can help you identify!
|
||||
|
||||
## Table of Contents
|
||||
|
||||
* [How to use](#how-to-use)
|
||||
* [On the web](#on-the-web)
|
||||
* [From your terminal](#from-your-terminal)
|
||||
* [In your editor](#in-your-editor)
|
||||
* [In your build or test suites](#in-your-build-or-test-suites)
|
||||
* [Installing](#installing)
|
||||
* [Compiling from source](#compiling-from-source)
|
||||
* [Installing Cabal](#installing-cabal)
|
||||
* [Compiling ShellCheck](#compiling-shellcheck)
|
||||
* [Running tests](#running-tests)
|
||||
* [Gallery of bad code](#gallery-of-bad-code)
|
||||
* [Quoting](#quoting)
|
||||
* [Conditionals](#conditionals)
|
||||
* [Frequently misused commands](#frequently-misused-commands)
|
||||
* [Common beginner's mistakes](#common-beginners-mistakes)
|
||||
* [Style](#style)
|
||||
* [Data and typing errors](#data-and-typing-errors)
|
||||
* [Robustness](#robustness)
|
||||
* [Portability](#portability)
|
||||
* [Miscellaneous](#miscellaneous)
|
||||
* [Testimonials](#testimonials)
|
||||
* [Ignoring issues](#ignoring-issues)
|
||||
* [Reporting bugs](#reporting-bugs)
|
||||
* [Contributing](#contributing)
|
||||
* [Copyright](#copyright)
|
||||
* [Other Resources](#other-resources)
|
||||
|
||||
## How to use
|
||||
|
||||
There are a number of ways to use ShellCheck!
|
||||
|
||||
### On the web
|
||||
|
||||
Paste a shell script on <https://www.shellcheck.net> for instant feedback.
|
||||
|
||||
[ShellCheck.net](https://www.shellcheck.net) is always synchronized to the latest git commit, and is the easiest way to give ShellCheck a go. Tell your friends!
|
||||
|
||||
### From your terminal
|
||||
|
||||
Run `shellcheck yourscript` in your terminal for instant output, as seen above.
|
||||
|
||||
### In your editor
|
||||
|
||||
You can see ShellCheck suggestions directly in a variety of editors.
|
||||
|
||||
* Vim, through [ALE](https://github.com/w0rp/ale), [Neomake](https://github.com/neomake/neomake), or [Syntastic](https://github.com/scrooloose/syntastic):
|
||||
|
||||
.
|
||||
|
||||
* Emacs, through [Flycheck](https://github.com/flycheck/flycheck) or [Flymake](https://github.com/federicotdn/flymake-shellcheck):
|
||||
|
||||
.
|
||||
|
||||
* Sublime, through [SublimeLinter](https://github.com/SublimeLinter/SublimeLinter-shellcheck).
|
||||
|
||||
* Pulsar Edit (former Atom), through [linter-shellcheck-pulsar](https://github.com/pulsar-cooperative/linter-shellcheck-pulsar).
|
||||
|
||||
* VSCode, through [vscode-shellcheck](https://github.com/timonwong/vscode-shellcheck).
|
||||
|
||||
* Most other editors, through [GCC error compatibility](shellcheck.1.md#user-content-formats).
|
||||
|
||||
### In your build or test suites
|
||||
|
||||
While ShellCheck is mostly intended for interactive use, it can easily be added to builds or test suites.
|
||||
It makes canonical use of exit codes, so you can just add a `shellcheck` command as part of the process.
|
||||
|
||||
For example, in a Makefile:
|
||||
|
||||
```Makefile
|
||||
check-scripts:
|
||||
# Fail if any of these files have warnings
|
||||
shellcheck myscripts/*.sh
|
||||
```
|
||||
|
||||
or in a Travis CI `.travis.yml` file:
|
||||
|
||||
```yaml
|
||||
script:
|
||||
# Fail if any of these files have warnings
|
||||
- shellcheck myscripts/*.sh
|
||||
```
|
||||
|
||||
Services and platforms that have ShellCheck pre-installed and ready to use:
|
||||
|
||||
* [Travis CI](https://travis-ci.org/)
|
||||
* [Codacy](https://www.codacy.com/)
|
||||
* [Code Climate](https://codeclimate.com/)
|
||||
* [Code Factor](https://www.codefactor.io/)
|
||||
* [Codety](https://www.codety.io/) via the [Codety Scanner](https://github.com/codetyio/codety-scanner)
|
||||
* [CircleCI](https://circleci.com) via the [ShellCheck Orb](https://circleci.com/orbs/registry/orb/circleci/shellcheck)
|
||||
* [Github](https://github.com/features/actions) (only Linux)
|
||||
* [Trunk Code Quality](https://trunk.io/code-quality) (universal linter; [allows you to explicitly version your shellcheck install](https://github.com/trunk-io/plugins/blob/bcbb361dcdbe4619af51ea7db474d7fb87540d20/.trunk/trunk.yaml#L32)) via the [shellcheck plugin](https://github.com/trunk-io/plugins/blob/main/linters/shellcheck/plugin.yaml)
|
||||
* [CodeRabbit](https://coderabbit.ai/)
|
||||
|
||||
Most other services, including [GitLab](https://about.gitlab.com/), let you install
|
||||
ShellCheck yourself, either through the system's package manager (see [Installing](#installing)),
|
||||
or by downloading and unpacking a [binary release](#installing-a-pre-compiled-binary).
|
||||
|
||||
It's a good idea to manually install a specific ShellCheck version regardless. This avoids
|
||||
any surprise build breaks when a new version with new warnings is published.
|
||||
|
||||
For customized filtering or reporting, ShellCheck can output simple JSON, CheckStyle compatible XML,
|
||||
GCC compatible warnings as well as human readable text (with or without ANSI colors). See the
|
||||
[Integration](https://github.com/koalaman/shellcheck/wiki/Integration) wiki page for more documentation.
|
||||
|
||||
## Installing
|
||||
|
||||
The easiest way to install ShellCheck locally is through your package manager.
|
||||
|
||||
On systems with Cabal (installs to `~/.cabal/bin`):
|
||||
|
||||
cabal update
|
||||
cabal install ShellCheck
|
||||
|
||||
On systems with Stack (installs to `~/.local/bin`):
|
||||
|
||||
stack update
|
||||
stack install ShellCheck
|
||||
|
||||
On Debian based distros:
|
||||
|
||||
sudo apt install shellcheck
|
||||
|
||||
On Arch Linux based distros:
|
||||
|
||||
pacman -S shellcheck
|
||||
|
||||
or get the dependency free [shellcheck-bin](https://aur.archlinux.org/packages/shellcheck-bin/) from the AUR.
|
||||
|
||||
On Gentoo based distros:
|
||||
|
||||
emerge --ask shellcheck
|
||||
|
||||
On EPEL based distros:
|
||||
|
||||
sudo yum -y install epel-release
|
||||
sudo yum install ShellCheck
|
||||
|
||||
On Fedora based distros:
|
||||
|
||||
dnf install ShellCheck
|
||||
|
||||
On FreeBSD:
|
||||
|
||||
pkg install hs-ShellCheck
|
||||
|
||||
On macOS (OS X) with Homebrew:
|
||||
|
||||
brew install shellcheck
|
||||
|
||||
Or with MacPorts:
|
||||
|
||||
sudo port install shellcheck
|
||||
|
||||
On OpenBSD:
|
||||
|
||||
pkg_add shellcheck
|
||||
|
||||
On openSUSE
|
||||
|
||||
zypper in ShellCheck
|
||||
|
||||
Or use OneClickInstall - <https://software.opensuse.org/package/ShellCheck>
|
||||
|
||||
On Solus:
|
||||
|
||||
eopkg install shellcheck
|
||||
|
||||
On Windows (via [chocolatey](https://chocolatey.org/packages/shellcheck)):
|
||||
|
||||
```cmd
|
||||
C:\> choco install shellcheck
|
||||
```
|
||||
|
||||
Or Windows (via [winget](https://github.com/microsoft/winget-pkgs)):
|
||||
|
||||
```cmd
|
||||
C:\> winget install --id koalaman.shellcheck
|
||||
```
|
||||
|
||||
Or Windows (via [scoop](http://scoop.sh)):
|
||||
|
||||
```cmd
|
||||
C:\> scoop install shellcheck
|
||||
```
|
||||
|
||||
From [conda-forge](https://anaconda.org/conda-forge/shellcheck):
|
||||
|
||||
conda install -c conda-forge shellcheck
|
||||
|
||||
From Snap Store:
|
||||
|
||||
snap install --channel=edge shellcheck
|
||||
|
||||
From Docker Hub:
|
||||
|
||||
```sh
|
||||
docker run --rm -v "$PWD:/mnt" koalaman/shellcheck:stable myscript
|
||||
# Or :v0.4.7 for that version, or :latest for daily builds
|
||||
```
|
||||
|
||||
or use `koalaman/shellcheck-alpine` if you want a larger Alpine Linux based image to extend. It works exactly like a regular Alpine image, but has shellcheck preinstalled.
|
||||
|
||||
Using the [nix package manager](https://nixos.org/nix):
|
||||
```sh
|
||||
nix-env -iA nixpkgs.shellcheck
|
||||
```
|
||||
|
||||
Using the [Flox package manager](https://flox.dev/)
|
||||
```sh
|
||||
flox install shellcheck
|
||||
```
|
||||
|
||||
Alternatively, you can download pre-compiled binaries for the latest release here:
|
||||
|
||||
* [Linux, x86_64](https://github.com/koalaman/shellcheck/releases/download/stable/shellcheck-stable.linux.x86_64.tar.xz) (statically linked)
|
||||
* [Linux, armv6hf](https://github.com/koalaman/shellcheck/releases/download/stable/shellcheck-stable.linux.armv6hf.tar.xz), i.e. Raspberry Pi (statically linked)
|
||||
* [Linux, aarch64](https://github.com/koalaman/shellcheck/releases/download/stable/shellcheck-stable.linux.aarch64.tar.xz) aka ARM64 (statically linked)
|
||||
* [macOS, aarch64](https://github.com/koalaman/shellcheck/releases/download/stable/shellcheck-stable.darwin.aarch64.tar.xz)
|
||||
* [macOS, x86_64](https://github.com/koalaman/shellcheck/releases/download/stable/shellcheck-stable.darwin.x86_64.tar.xz)
|
||||
* [Windows, x86](https://github.com/koalaman/shellcheck/releases/download/stable/shellcheck-stable.zip)
|
||||
|
||||
or see the [GitHub Releases](https://github.com/koalaman/shellcheck/releases) for other releases
|
||||
(including the [latest](https://github.com/koalaman/shellcheck/releases/tag/latest) meta-release for daily git builds).
|
||||
|
||||
There are currently no official binaries for Apple Silicon, but third party builds are available via
|
||||
[ShellCheck for Visual Studio Code](https://github.com/vscode-shellcheck/shellcheck-binaries/releases).
|
||||
|
||||
Distro packages already come with a `man` page. If you are building from source, it can be installed with:
|
||||
|
||||
```console
|
||||
pandoc -s -f markdown-smart -t man shellcheck.1.md -o shellcheck.1
|
||||
sudo mv shellcheck.1 /usr/share/man/man1
|
||||
```
|
||||
|
||||
### pre-commit
|
||||
|
||||
To run ShellCheck via [pre-commit](https://pre-commit.com/), add the hook to your `.pre-commit-config.yaml`:
|
||||
|
||||
```
|
||||
repos:
|
||||
- repo: https://github.com/koalaman/shellcheck-precommit
|
||||
rev: v0.7.2
|
||||
hooks:
|
||||
- id: shellcheck
|
||||
# args: ["--severity=warning"] # Optionally only show errors and warnings
|
||||
```
|
||||
|
||||
### Travis CI
|
||||
|
||||
Travis CI has now integrated ShellCheck by default, so you don't need to manually install it.
|
||||
|
||||
If you still want to do so in order to upgrade at your leisure or ensure you're
|
||||
using the latest release, follow the steps below to install a binary version.
|
||||
|
||||
### Installing a pre-compiled binary
|
||||
|
||||
The pre-compiled binaries come in `tar.xz` files. To decompress them, make sure
|
||||
`xz` is installed.
|
||||
On Debian/Ubuntu/Mint, you can `apt install xz-utils`.
|
||||
On Redhat/Fedora/CentOS, `yum -y install xz`.
|
||||
|
||||
A simple installer may do something like:
|
||||
|
||||
```bash
|
||||
scversion="stable" # or "v0.4.7", or "latest"
|
||||
wget -qO- "https://github.com/koalaman/shellcheck/releases/download/${scversion?}/shellcheck-${scversion?}.linux.x86_64.tar.xz" | tar -xJv
|
||||
cp "shellcheck-${scversion}/shellcheck" /usr/bin/
|
||||
shellcheck --version
|
||||
```
|
||||
|
||||
## Compiling from source
|
||||
|
||||
This section describes how to build ShellCheck from a source directory. ShellCheck is written in Haskell and requires 2GB of RAM to compile.
|
||||
|
||||
### Installing Cabal
|
||||
|
||||
ShellCheck is built and packaged using Cabal. Install the package `cabal-install` from your system's package manager (with e.g. `apt-get`, `brew`, `emerge`, `yum`, or `zypper`).
|
||||
|
||||
On macOS (OS X), you can do a fast install of Cabal using brew, which takes a couple of minutes instead of more than 30 minutes if you try to compile it from source.
|
||||
|
||||
$ brew install cabal-install
|
||||
|
||||
On MacPorts, the package is instead called `hs-cabal-install`, while native Windows users should install the latest version of the Haskell platform from <https://www.haskell.org/platform/>
|
||||
|
||||
Verify that `cabal` is installed and update its dependency list with
|
||||
|
||||
$ cabal update
|
||||
|
||||
### Compiling ShellCheck
|
||||
|
||||
`git clone` this repository, and `cd` to the ShellCheck source directory to build/install:
|
||||
|
||||
$ cabal install
|
||||
|
||||
This will compile ShellCheck and install it to your `~/.cabal/bin` directory.
|
||||
|
||||
Add this directory to your `PATH` (for bash, add this to your `~/.bashrc`):
|
||||
|
||||
```sh
|
||||
export PATH="$HOME/.cabal/bin:$PATH"
|
||||
```
|
||||
|
||||
Log out and in again, and verify that your PATH is set up correctly:
|
||||
|
||||
```sh
|
||||
$ which shellcheck
|
||||
~/.cabal/bin/shellcheck
|
||||
```
|
||||
|
||||
On native Windows, the `PATH` should already be set up, but the system
|
||||
may use a legacy codepage. In `cmd.exe`, `powershell.exe` and Powershell ISE,
|
||||
make sure to use a TrueType font, not a Raster font, and set the active
|
||||
codepage to UTF-8 (65001) with `chcp`:
|
||||
|
||||
```cmd
|
||||
chcp 65001
|
||||
```
|
||||
|
||||
In Powershell ISE, you may need to additionally update the output encoding:
|
||||
|
||||
```powershell
|
||||
[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
|
||||
```
|
||||
|
||||
### Running tests
|
||||
|
||||
To run the unit test suite:
|
||||
|
||||
$ cabal test
|
||||
|
||||
## Gallery of bad code
|
||||
|
||||
So what kind of things does ShellCheck look for? Here is an incomplete list of detected issues.
|
||||
|
||||
### Quoting
|
||||
|
||||
ShellCheck can recognize several types of incorrect quoting:
|
||||
|
||||
```sh
|
||||
echo $1 # Unquoted variables
|
||||
find . -name *.ogg # Unquoted find/grep patterns
|
||||
rm "~/my file.txt" # Quoted tilde expansion
|
||||
v='--verbose="true"'; cmd $v # Literal quotes in variables
|
||||
for f in "*.ogg" # Incorrectly quoted 'for' loops
|
||||
touch $@ # Unquoted $@
|
||||
echo 'Don't forget to restart!' # Singlequote closed by apostrophe
|
||||
echo 'Don\'t try this at home' # Attempting to escape ' in ''
|
||||
echo 'Path is $PATH' # Variables in single quotes
|
||||
trap "echo Took ${SECONDS}s" 0 # Prematurely expanded trap
|
||||
unset var[i] # Array index treated as glob
|
||||
```
|
||||
|
||||
### Conditionals
|
||||
|
||||
ShellCheck can recognize many types of incorrect test statements.
|
||||
|
||||
```sh
|
||||
[[ n != 0 ]] # Constant test expressions
|
||||
[[ -e *.mpg ]] # Existence checks of globs
|
||||
[[ $foo==0 ]] # Always true due to missing spaces
|
||||
[[ -n "$foo " ]] # Always true due to literals
|
||||
[[ $foo =~ "fo+" ]] # Quoted regex in =~
|
||||
[ foo =~ re ] # Unsupported [ ] operators
|
||||
[ $1 -eq "shellcheck" ] # Numerical comparison of strings
|
||||
[ $n && $m ] # && in [ .. ]
|
||||
[ grep -q foo file ] # Command without $(..)
|
||||
[[ "$$file" == *.jpg ]] # Comparisons that can't succeed
|
||||
(( 1 -lt 2 )) # Using test operators in ((..))
|
||||
[ x ] & [ y ] | [ z ] # Accidental backgrounding and piping
|
||||
```
|
||||
|
||||
### Frequently misused commands
|
||||
|
||||
ShellCheck can recognize instances where commands are used incorrectly:
|
||||
|
||||
```sh
|
||||
grep '*foo*' file # Globs in regex contexts
|
||||
find . -exec foo {} && bar {} \; # Prematurely terminated find -exec
|
||||
sudo echo 'Var=42' > /etc/profile # Redirecting sudo
|
||||
time --format=%s sleep 10 # Passing time(1) flags to time builtin
|
||||
while read h; do ssh "$h" uptime # Commands eating while loop input
|
||||
alias archive='mv $1 /backup' # Defining aliases with arguments
|
||||
tr -cd '[a-zA-Z0-9]' # [] around ranges in tr
|
||||
exec foo; echo "Done!" # Misused 'exec'
|
||||
find -name \*.bak -o -name \*~ -delete # Implicit precedence in find
|
||||
# find . -exec foo > bar \; # Redirections in find
|
||||
f() { whoami; }; sudo f # External use of internal functions
|
||||
```
|
||||
|
||||
### Common beginner's mistakes
|
||||
|
||||
ShellCheck recognizes many common beginner's syntax errors:
|
||||
|
||||
```sh
|
||||
var = 42 # Spaces around = in assignments
|
||||
$foo=42 # $ in assignments
|
||||
for $var in *; do ... # $ in for loop variables
|
||||
var$n="Hello" # Wrong indirect assignment
|
||||
echo ${var$n} # Wrong indirect reference
|
||||
var=(1, 2, 3) # Comma separated arrays
|
||||
array=( [index] = value ) # Incorrect index initialization
|
||||
echo $var[14] # Missing {} in array references
|
||||
echo "Argument 10 is $10" # Positional parameter misreference
|
||||
if $(myfunction); then ..; fi # Wrapping commands in $()
|
||||
else if othercondition; then .. # Using 'else if'
|
||||
f; f() { echo "hello world; } # Using function before definition
|
||||
[ false ] # 'false' being true
|
||||
if ( -f file ) # Using (..) instead of test
|
||||
```
|
||||
|
||||
### Style
|
||||
|
||||
ShellCheck can make suggestions to improve style:
|
||||
|
||||
```sh
|
||||
[[ -z $(find /tmp | grep mpg) ]] # Use grep -q instead
|
||||
a >> log; b >> log; c >> log # Use a redirection block instead
|
||||
echo "The time is `date`" # Use $() instead
|
||||
cd dir; process *; cd ..; # Use subshells instead
|
||||
echo $[1+2] # Use standard $((..)) instead of old $[]
|
||||
echo $(($RANDOM % 6)) # Don't use $ on variables in $((..))
|
||||
echo "$(date)" # Useless use of echo
|
||||
cat file | grep foo # Useless use of cat
|
||||
```
|
||||
|
||||
### Data and typing errors
|
||||
|
||||
ShellCheck can recognize issues related to data and typing:
|
||||
|
||||
```sh
|
||||
args="$@" # Assigning arrays to strings
|
||||
files=(foo bar); echo "$files" # Referencing arrays as strings
|
||||
declare -A arr=(foo bar) # Associative arrays without index
|
||||
printf "%s\n" "Arguments: $@." # Concatenating strings and arrays
|
||||
[[ $# > 2 ]] # Comparing numbers as strings
|
||||
var=World; echo "Hello " var # Unused lowercase variables
|
||||
echo "Hello $name" # Unassigned lowercase variables
|
||||
cmd | read bar; echo $bar # Assignments in subshells
|
||||
cat foo | cp bar # Piping to commands that don't read
|
||||
printf '%s: %s\n' foo # Mismatches in printf argument count
|
||||
eval "${array[@]}" # Lost word boundaries in array eval
|
||||
for i in "${x[@]}"; do ${x[$i]} # Using array value as key
|
||||
```
|
||||
|
||||
### Robustness
|
||||
|
||||
ShellCheck can make suggestions for improving the robustness of a script:
|
||||
|
||||
```sh
|
||||
rm -rf "$STEAMROOT/"* # Catastrophic rm
|
||||
touch ./-l; ls * # Globs that could become options
|
||||
find . -exec sh -c 'a && b {}' \; # Find -exec shell injection
|
||||
printf "Hello $name" # Variables in printf format
|
||||
for f in $(ls *.txt); do # Iterating over ls output
|
||||
export MYVAR=$(cmd) # Masked exit codes
|
||||
case $version in 2.*) :;; 2.6.*) # Shadowed case branches
|
||||
```
|
||||
|
||||
### Portability
|
||||
|
||||
ShellCheck will warn when using features not supported by the shebang. For example, if you set the shebang to `#!/bin/sh`, ShellCheck will warn about portability issues similar to `checkbashisms`:
|
||||
|
||||
```sh
|
||||
echo {1..$n} # Works in ksh, but not bash/dash/sh
|
||||
echo {1..10} # Works in ksh and bash, but not dash/sh
|
||||
echo -n 42 # Works in ksh, bash and dash, undefined in sh
|
||||
expr match str regex # Unportable alias for `expr str : regex`
|
||||
trap 'exit 42' sigint # Unportable signal spec
|
||||
cmd &> file # Unportable redirection operator
|
||||
read foo < /dev/tcp/host/22 # Unportable intercepted files
|
||||
foo-bar() { ..; } # Undefined/unsupported function name
|
||||
[ $UID = 0 ] # Variable undefined in dash/sh
|
||||
local var=value # local is undefined in sh
|
||||
time sleep 1 | sleep 5 # Undefined uses of 'time'
|
||||
```
|
||||
|
||||
### Miscellaneous
|
||||
|
||||
ShellCheck recognizes a menagerie of other issues:
|
||||
|
||||
```sh
|
||||
PS1='\e[0;32m\$\e[0m ' # PS1 colors not in \[..\]
|
||||
PATH="$PATH:~/bin" # Literal tilde in $PATH
|
||||
rm “file” # Unicode quotes
|
||||
echo "Hello world" # Carriage return / DOS line endings
|
||||
echo hello \ # Trailing spaces after \
|
||||
var=42 echo $var # Expansion of inlined environment
|
||||
!# bin/bash -x -e # Common shebang errors
|
||||
echo $((n/180*100)) # Unnecessary loss of precision
|
||||
ls *[:digit:].txt # Bad character class globs
|
||||
sed 's/foo/bar/' file > file # Redirecting to input
|
||||
var2=$var2 # Variable assigned to itself
|
||||
[ x$var = xval ] # Antiquated x-comparisons
|
||||
ls() { ls -l "$@"; } # Infinitely recursive wrapper
|
||||
alias ls='ls -l'; ls foo # Alias used before it takes effect
|
||||
for x; do for x; do # Nested loop uses same variable
|
||||
while getopts "a" f; do case $f in "b") # Unhandled getopts flags
|
||||
```
|
||||
|
||||
## Testimonials
|
||||
|
||||
> At first you're like "shellcheck is awesome" but then you're like "wtf are we still using bash"
|
||||
|
||||
Alexander Tarasikov,
|
||||
[via Twitter](https://twitter.com/astarasikov/status/568825996532707330)
|
||||
|
||||
## Ignoring issues
|
||||
|
||||
Issues can be ignored via environmental variable, command line, individually or globally within a file:
|
||||
|
||||
<https://github.com/koalaman/shellcheck/wiki/Ignore>
|
||||
|
||||
## Reporting bugs
|
||||
|
||||
Please use the GitHub issue tracker for any bugs or feature suggestions:
|
||||
|
||||
<https://github.com/koalaman/shellcheck/issues>
|
||||
|
||||
## Contributing
|
||||
|
||||
Please submit patches to code or documentation as GitHub pull requests! Check
|
||||
out the [DevGuide](https://github.com/koalaman/shellcheck/wiki/DevGuide) on the
|
||||
ShellCheck Wiki.
|
||||
|
||||
Contributions must be licensed under the GNU GPLv3.
|
||||
The contributor retains the copyright.
|
||||
|
||||
## Copyright
|
||||
|
||||
ShellCheck is licensed under the GNU General Public License, v3. A copy of this license is included in the file [LICENSE](LICENSE).
|
||||
|
||||
Copyright 2012-2019, [Vidar 'koala_man' Holen](https://github.com/koalaman/) and contributors.
|
||||
|
||||
Happy ShellChecking!
|
||||
|
||||
## Other Resources
|
||||
|
||||
* The wiki has [long form descriptions](https://github.com/koalaman/shellcheck/wiki/Checks) for each warning, e.g. [SC2221](https://github.com/koalaman/shellcheck/wiki/SC2221).
|
||||
* ShellCheck does not attempt to enforce any kind of formatting or indenting style, so also check out [shfmt](https://github.com/mvdan/sh)!
|
||||
146
ShellCheck.cabal
146
ShellCheck.cabal
|
|
@ -1,146 +0,0 @@
|
|||
Name: ShellCheck
|
||||
Version: 0.11.0
|
||||
Synopsis: Shell script analysis tool
|
||||
License: GPL-3
|
||||
License-file: LICENSE
|
||||
Category: Static Analysis
|
||||
Author: Vidar Holen
|
||||
Maintainer: vidar@vidarholen.net
|
||||
Homepage: https://www.shellcheck.net/
|
||||
Build-Type: Simple
|
||||
Cabal-Version: 1.18
|
||||
Bug-reports: https://github.com/koalaman/shellcheck/issues
|
||||
Description:
|
||||
The goals of ShellCheck are:
|
||||
.
|
||||
* To point out and clarify typical beginner's syntax issues,
|
||||
that causes a shell to give cryptic error messages.
|
||||
.
|
||||
* To point out and clarify typical intermediate level semantic problems,
|
||||
that causes a shell to behave strangely and counter-intuitively.
|
||||
.
|
||||
* To point out subtle caveats, corner cases and pitfalls, that may cause an
|
||||
advanced user's otherwise working script to fail under future circumstances.
|
||||
|
||||
Extra-Doc-Files:
|
||||
README.md
|
||||
CHANGELOG.md
|
||||
Extra-Source-Files:
|
||||
-- documentation
|
||||
shellcheck.1.md
|
||||
-- A script to build the man page using pandoc
|
||||
manpage
|
||||
-- convenience script for stripping tests
|
||||
striptests
|
||||
-- tests
|
||||
test/shellcheck.hs
|
||||
|
||||
source-repository head
|
||||
type: git
|
||||
location: git://github.com/koalaman/shellcheck.git
|
||||
|
||||
library
|
||||
hs-source-dirs: src
|
||||
if impl(ghc < 8.0)
|
||||
build-depends:
|
||||
semigroups
|
||||
build-depends:
|
||||
-- The lower bounds are based on GHC 7.10.3
|
||||
-- The upper bounds are based on GHC 9.12.1
|
||||
aeson >= 1.4.0 && < 2.3,
|
||||
array >= 0.5.1 && < 0.6,
|
||||
base >= 4.8.0.0 && < 5,
|
||||
bytestring >= 0.10.6 && < 0.13,
|
||||
containers >= 0.5.6 && < 0.9,
|
||||
deepseq >= 1.4.1 && < 1.6,
|
||||
Diff >= 0.4.0 && < 1.1,
|
||||
fgl (>= 5.7.0 && < 5.8.1.0) || (>= 5.8.1.1 && < 5.9),
|
||||
filepath >= 1.4.0 && < 1.6,
|
||||
mtl >= 2.2.2 && < 2.4,
|
||||
parsec >= 3.1.14 && < 3.2,
|
||||
QuickCheck >= 2.14.2 && < 2.17,
|
||||
regex-tdfa >= 1.2.0 && < 1.4,
|
||||
transformers >= 0.4.2 && < 0.7,
|
||||
|
||||
-- getXdgDirectory from 1.2.3.0
|
||||
directory >= 1.2.3 && < 1.4,
|
||||
|
||||
-- When cabal supports it, move this to setup-depends:
|
||||
process
|
||||
exposed-modules:
|
||||
ShellCheck.AST
|
||||
ShellCheck.ASTLib
|
||||
ShellCheck.Analytics
|
||||
ShellCheck.Analyzer
|
||||
ShellCheck.AnalyzerLib
|
||||
ShellCheck.CFG
|
||||
ShellCheck.CFGAnalysis
|
||||
ShellCheck.Checker
|
||||
ShellCheck.Checks.Commands
|
||||
ShellCheck.Checks.ControlFlow
|
||||
ShellCheck.Checks.Custom
|
||||
ShellCheck.Checks.ShellSupport
|
||||
ShellCheck.Data
|
||||
ShellCheck.Debug
|
||||
ShellCheck.Fixer
|
||||
ShellCheck.Formatter.Format
|
||||
ShellCheck.Formatter.CheckStyle
|
||||
ShellCheck.Formatter.Diff
|
||||
ShellCheck.Formatter.GCC
|
||||
ShellCheck.Formatter.JSON
|
||||
ShellCheck.Formatter.JSON1
|
||||
ShellCheck.Formatter.TTY
|
||||
ShellCheck.Formatter.Quiet
|
||||
ShellCheck.Interface
|
||||
ShellCheck.Parser
|
||||
ShellCheck.Prelude
|
||||
ShellCheck.Regex
|
||||
other-modules:
|
||||
Paths_ShellCheck
|
||||
default-language: Haskell98
|
||||
|
||||
executable shellcheck
|
||||
if impl(ghc < 8.0)
|
||||
build-depends:
|
||||
semigroups
|
||||
build-depends:
|
||||
aeson,
|
||||
array,
|
||||
base,
|
||||
bytestring,
|
||||
containers,
|
||||
deepseq,
|
||||
Diff,
|
||||
directory,
|
||||
fgl,
|
||||
mtl,
|
||||
filepath,
|
||||
parsec,
|
||||
QuickCheck,
|
||||
regex-tdfa,
|
||||
transformers,
|
||||
ShellCheck
|
||||
default-language: Haskell98
|
||||
main-is: shellcheck.hs
|
||||
|
||||
test-suite test-shellcheck
|
||||
type: exitcode-stdio-1.0
|
||||
build-depends:
|
||||
aeson,
|
||||
array,
|
||||
base,
|
||||
bytestring,
|
||||
containers,
|
||||
deepseq,
|
||||
Diff,
|
||||
directory,
|
||||
fgl,
|
||||
filepath,
|
||||
mtl,
|
||||
parsec,
|
||||
QuickCheck,
|
||||
regex-tdfa,
|
||||
transformers,
|
||||
ShellCheck
|
||||
default-language: Haskell98
|
||||
main-is: test/shellcheck.hs
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
This directory contains Dockerfiles for all builds.
|
||||
|
||||
A build image will:
|
||||
|
||||
* Run on Linux x86\_64 with vanilla Docker (no exceptions)
|
||||
* Not contain any software that would restrict easy modification or copying
|
||||
* Take a `cabal sdist` style tar.gz of the ShellCheck directory on stdin
|
||||
* Output a tar.gz of artifacts on stdout, in a directory named for the arch
|
||||
|
||||
This makes it simple to build any release without exotic hardware or software.
|
||||
|
||||
An image can be built and tagged using `build_builder`,
|
||||
and run on a source tarball using `run_builder`.
|
||||
|
||||
Tip: Are you developing an image that relies on QEmu usermode emulation?
|
||||
It's easy to accidentally depend on binfmt\_misc on the host OS.
|
||||
Do a `echo 0 | sudo tee /proc/sys/fs/binfmt_misc/status` before testing.
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
#!/bin/sh
|
||||
if [ $# -eq 0 ]
|
||||
then
|
||||
echo >&2 "No build image directories specified"
|
||||
echo >&2 "Example: $0 build/*/"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
for dir
|
||||
do
|
||||
( cd "$dir" && docker build -t "$(cat tag)" . ) || exit 1
|
||||
done
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
FROM ghcr.io/shepherdjerred/macos-cross-compiler@sha256:7d40c5e179d5d15453cf2a6b1bba3392bb1448b8257ee6b86021fc905c59dad6
|
||||
|
||||
ENV TARGET=aarch64-apple-darwin22
|
||||
ENV TARGETNAME=darwin.aarch64
|
||||
|
||||
# Build dependencies
|
||||
USER root
|
||||
ENV DEBIAN_FRONTEND=noninteractive
|
||||
ENV LC_ALL=C.utf8
|
||||
|
||||
# Install basic deps
|
||||
RUN apt-get update && apt-get install -y automake autoconf build-essential curl xz-utils qemu-user-static
|
||||
|
||||
# Install a more suitable host compiler
|
||||
WORKDIR /host-ghc
|
||||
RUN curl -L "https://downloads.haskell.org/~cabal/cabal-install-3.9.0.0/cabal-install-3.9-x86_64-linux-alpine.tar.xz" | tar xJv -C /usr/local/bin
|
||||
RUN curl -L 'https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-deb10-linux.tar.xz' | tar xJ --strip-components=1
|
||||
RUN ./configure && make install
|
||||
|
||||
# Build GHC. We have to use an old version because cross-compilation across OS has since broken.
|
||||
WORKDIR /ghc
|
||||
RUN curl -L "https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-src.tar.xz" | tar xJ --strip-components=1
|
||||
RUN apt-get install -y llvm-12
|
||||
RUN ./boot && ./configure --host x86_64-linux-gnu --build x86_64-linux-gnu --target "$TARGET"
|
||||
RUN cp mk/flavours/quick-cross.mk mk/build.mk && make -j "$(nproc)"
|
||||
RUN make install
|
||||
|
||||
# Due to an apparent cabal bug, we specify our options directly to cabal
|
||||
# It won't reuse caches if ghc-options are specified in ~/.cabal/config
|
||||
ENV CABALOPTS="--ghc-options;-optc-Os -optc-fPIC;--with-ghc=$TARGET-ghc;--with-hc-pkg=$TARGET-ghc-pkg;--constraint=hashable==1.3.5.0"
|
||||
|
||||
# Prebuild the dependencies
|
||||
RUN cabal update
|
||||
RUN IFS=';' && cabal install --dependencies-only $CABALOPTS ShellCheck
|
||||
|
||||
# Copy the build script
|
||||
COPY build /usr/bin
|
||||
|
||||
WORKDIR /scratch
|
||||
ENTRYPOINT ["/usr/bin/build"]
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
#!/bin/sh
|
||||
set -xe
|
||||
{
|
||||
tar xzv --strip-components=1
|
||||
chmod +x striptests && ./striptests
|
||||
mkdir "$TARGETNAME"
|
||||
( IFS=';'; cabal build $CABALOPTS )
|
||||
find . -name shellcheck -type f -exec mv {} "$TARGETNAME/" \;
|
||||
ls -l "$TARGETNAME"
|
||||
# Stripping invalidates the code signature and the build image does
|
||||
# not appear to have anything similar to the 'codesign' tool.
|
||||
# "$TARGET-strip" "$TARGETNAME/shellcheck"
|
||||
ls -l "$TARGETNAME"
|
||||
file "$TARGETNAME/shellcheck" | grep "Mach-O 64-bit arm64 executable"
|
||||
} >&2
|
||||
tar czv "$TARGETNAME"
|
||||
|
|
@ -1 +0,0 @@
|
|||
koalaman/scbuilder-darwin-aarch64
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
FROM liushuyu/osxcross@sha256:fa32af4677e2860a1c5950bc8c360f309e2a87e2ddfed27b642fddf7a6093b76
|
||||
|
||||
ENV TARGET=x86_64-apple-darwin18
|
||||
ENV TARGETNAME=darwin.x86_64
|
||||
|
||||
# Build dependencies
|
||||
USER root
|
||||
ENV DEBIAN_FRONTEND=noninteractive
|
||||
RUN sed -e 's/focal/kinetic/g' -e 's/archive\|security/old-releases/' -i /etc/apt/sources.list
|
||||
RUN apt-get update
|
||||
RUN apt-get dist-upgrade -y
|
||||
RUN apt-get install -y ghc automake autoconf llvm curl alex happy
|
||||
|
||||
# Build GHC
|
||||
WORKDIR /ghc
|
||||
RUN curl -L "https://downloads.haskell.org/~ghc/9.2.8/ghc-9.2.8-src.tar.xz" | tar xJ --strip-components=1
|
||||
RUN ./configure --host x86_64-linux-gnu --build x86_64-linux-gnu --target "$TARGET"
|
||||
RUN cp mk/flavours/quick-cross.mk mk/build.mk && make -j "$(nproc)"
|
||||
RUN make install
|
||||
RUN curl -L "https://downloads.haskell.org/~cabal/cabal-install-3.9.0.0/cabal-install-3.9-x86_64-linux-alpine.tar.xz" | tar xJv -C /usr/local/bin
|
||||
|
||||
# Due to an apparent cabal bug, we specify our options directly to cabal
|
||||
# It won't reuse caches if ghc-options are specified in ~/.cabal/config
|
||||
ENV CABALOPTS="--with-ghc=$TARGET-ghc;--with-hc-pkg=$TARGET-ghc-pkg"
|
||||
|
||||
# Prebuild the dependencies
|
||||
RUN cabal update && IFS=';' && cabal install --dependencies-only $CABALOPTS ShellCheck
|
||||
|
||||
# Copy the build script
|
||||
COPY build /usr/bin
|
||||
|
||||
WORKDIR /scratch
|
||||
ENTRYPOINT ["/usr/bin/build"]
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
#!/bin/sh
|
||||
set -xe
|
||||
{
|
||||
tar xzv --strip-components=1
|
||||
chmod +x striptests && ./striptests
|
||||
mkdir "$TARGETNAME"
|
||||
( IFS=';'; cabal build $CABALOPTS )
|
||||
find . -name shellcheck -type f -exec mv {} "$TARGETNAME/" \;
|
||||
ls -l "$TARGETNAME"
|
||||
"$TARGET-strip" -Sx "$TARGETNAME/shellcheck"
|
||||
ls -l "$TARGETNAME"
|
||||
} >&2
|
||||
tar czv "$TARGETNAME"
|
||||
|
|
@ -1 +0,0 @@
|
|||
koalaman/scbuilder-darwin-x86_64
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
FROM ubuntu:25.04
|
||||
|
||||
ENV TARGET=aarch64-linux-gnu
|
||||
ENV TARGETNAME=linux.aarch64
|
||||
|
||||
# Build dependencies
|
||||
USER root
|
||||
ENV DEBIAN_FRONTEND=noninteractive
|
||||
RUN apt-get update && apt-get install -y llvm-20 "gcc-$TARGET" "g++-$TARGET" ghc alex happy automake autoconf build-essential curl qemu-user-static
|
||||
RUN curl -L "https://downloads.haskell.org/~cabal/cabal-install-3.16.0.0/cabal-install-3.16.0.0-x86_64-linux-alpine3_20.tar.xz" | tar xJv -C /usr/local/bin && cabal update
|
||||
|
||||
# Build GHC
|
||||
WORKDIR /ghc
|
||||
RUN curl -L "https://downloads.haskell.org/~ghc/9.12.2/ghc-9.12.2-src.tar.xz" | tar xJ --strip-components=1
|
||||
RUN ./boot.source && ./configure --host x86_64-linux-gnu --build x86_64-linux-gnu --target "$TARGET"
|
||||
# GHC fails to build if it can't encode non-ascii
|
||||
ENV LC_CTYPE=C.utf8
|
||||
# We have to do a binary-dist instead of a direct install, otherwise the targest won't have
|
||||
# cross compilation prefixes in /usr/local/lib/aarch64-linux-gnu-ghc-*/lib/settings
|
||||
RUN ./hadrian/build --flavour=quickest --bignum=native -V -j --prefix=/usr/local install
|
||||
# Hadrian just outputs "gcc" as the name of gcc, without accounting for $TARGET. Manually fix up the paths:
|
||||
RUN sed -e 's/"\(gcc\|g++\|ld\)"/"'"$TARGET"'-\1"/g' -i /usr/local/lib/$TARGET-ghc-*/lib/settings
|
||||
|
||||
# Due to an apparent cabal bug, we specify our options directly to cabal
|
||||
# It won't reuse caches if ghc-options are specified in ~/.cabal/config
|
||||
ENV CABALOPTS="--ghc-options;-split-sections -optc-Os -optc-Wl,--gc-sections -optc-fPIC;--with-compiler=$TARGET-ghc;--with-hc-pkg=$TARGET-ghc-pkg;-c;hashable -arch-native"
|
||||
|
||||
# Prebuild the dependencies
|
||||
RUN cabal update && IFS=';' && cabal install --dependencies-only $CABALOPTS ShellCheck
|
||||
|
||||
# Copy the build script
|
||||
COPY build /usr/bin
|
||||
|
||||
WORKDIR /scratch
|
||||
ENTRYPOINT ["/usr/bin/build"]
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
#!/bin/sh
|
||||
set -xe
|
||||
{
|
||||
tar xzv --strip-components=1
|
||||
chmod +x striptests && ./striptests
|
||||
mkdir "$TARGETNAME"
|
||||
( IFS=';'; cabal build $CABALOPTS --enable-executable-static )
|
||||
find . -name shellcheck -type f -exec mv {} "$TARGETNAME/" \;
|
||||
ls -l "$TARGETNAME"
|
||||
"$TARGET-strip" -s "$TARGETNAME/shellcheck"
|
||||
ls -l "$TARGETNAME"
|
||||
"qemu-${TARGET%%-*}-static" "$TARGETNAME/shellcheck" --version
|
||||
} >&2
|
||||
tar czv "$TARGETNAME"
|
||||
|
|
@ -1 +0,0 @@
|
|||
koalaman/scbuilder-linux-aarch64
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
# This Docker file uses a custom QEmu fork with patches to follow execve
|
||||
# to build all of ShellCheck emulated.
|
||||
|
||||
FROM ubuntu:25.04
|
||||
|
||||
ENV TARGETNAME linux.armv6hf
|
||||
|
||||
# Build QEmu with execve follow support
|
||||
USER root
|
||||
ENV DEBIAN_FRONTEND noninteractive
|
||||
RUN apt-get update
|
||||
RUN apt-get install -y --no-install-recommends build-essential git ninja-build python3 pkg-config libglib2.0-dev libpixman-1-dev python3-setuptools ca-certificates debootstrap
|
||||
WORKDIR /qemu
|
||||
RUN git clone --depth 1 https://github.com/koalaman/qemu .
|
||||
RUN ./configure --static --disable-werror && cd build && ninja qemu-arm
|
||||
ENV QEMU_EXECVE 1
|
||||
|
||||
# Convenience utility
|
||||
COPY scutil /bin/scutil
|
||||
COPY scutil /chroot/bin/scutil
|
||||
RUN chmod +x /bin/scutil /chroot/bin/scutil
|
||||
|
||||
# Set up an armv6 userspace
|
||||
WORKDIR /
|
||||
RUN debootstrap --arch armhf --variant=minbase --foreign bookworm /chroot http://mirrordirector.raspbian.org/raspbian
|
||||
RUN cp /qemu/build/qemu-arm /chroot/bin/qemu
|
||||
RUN scutil emu /debootstrap/debootstrap --second-stage
|
||||
|
||||
# Install deps in the chroot
|
||||
RUN scutil emu apt-get update
|
||||
RUN scutil emu apt-get install -y --no-install-recommends ghc cabal-install
|
||||
RUN scutil emu cabal update
|
||||
|
||||
# Finally we can build the current dependencies. This takes hours.
|
||||
ENV CABALOPTS "--ghc-options;-split-sections -optc-Os -optc-Wl,--gc-sections;--gcc-options;-Os -Wl,--gc-sections -ffunction-sections -fdata-sections"
|
||||
# Generated with `cabal freeze --constraint 'hashable -arch-native'`
|
||||
COPY cabal.project.freeze /chroot/etc
|
||||
RUN IFS=";" && scutil install_from_freeze /chroot/etc/cabal.project.freeze emu cabal install $CABALOPTS
|
||||
|
||||
# Copy the build script
|
||||
COPY build /chroot/bin
|
||||
ENTRYPOINT ["/bin/scutil", "emu", "/bin/build"]
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
#!/bin/sh
|
||||
set -xe
|
||||
mkdir /scratch && cd /scratch
|
||||
{
|
||||
tar xzv --strip-components=1
|
||||
cp /etc/cabal.project.freeze .
|
||||
chmod +x striptests && ./striptests
|
||||
mkdir "$TARGETNAME"
|
||||
# This script does not cabal update because compiling anything new is slow
|
||||
( IFS=';'; cabal build $CABALOPTS --enable-executable-static )
|
||||
find . -name shellcheck -type f -exec mv {} "$TARGETNAME/" \;
|
||||
ls -l "$TARGETNAME"
|
||||
strip -s "$TARGETNAME/shellcheck"
|
||||
ls -l "$TARGETNAME"
|
||||
"$TARGETNAME/shellcheck" --version
|
||||
} >&2
|
||||
tar czv "$TARGETNAME"
|
||||
|
|
@ -1,105 +0,0 @@
|
|||
active-repositories: hackage.haskell.org:merge
|
||||
constraints: any.Diff ==1.0.2,
|
||||
any.OneTuple ==0.4.2,
|
||||
any.QuickCheck ==2.16.0.0,
|
||||
QuickCheck -old-random +templatehaskell,
|
||||
any.StateVar ==1.2.2,
|
||||
any.aeson ==2.2.3.0,
|
||||
aeson +ordered-keymap,
|
||||
any.ansi-terminal ==1.1.3,
|
||||
ansi-terminal -example,
|
||||
any.ansi-terminal-types ==1.1.3,
|
||||
any.array ==0.5.4.0,
|
||||
any.assoc ==1.1.1,
|
||||
assoc -tagged,
|
||||
any.base ==4.15.1.0,
|
||||
any.base-orphans ==0.9.3,
|
||||
any.bifunctors ==5.6.2,
|
||||
bifunctors +tagged,
|
||||
any.binary ==0.8.8.0,
|
||||
any.bytestring ==0.10.12.1,
|
||||
any.character-ps ==0.1,
|
||||
any.colour ==2.3.6,
|
||||
any.comonad ==5.0.9,
|
||||
comonad +containers +distributive +indexed-traversable,
|
||||
any.containers ==0.6.4.1,
|
||||
any.contravariant ==1.5.5,
|
||||
contravariant +semigroups +statevar +tagged,
|
||||
any.data-array-byte ==0.1.0.1,
|
||||
any.data-fix ==0.3.4,
|
||||
any.deepseq ==1.4.5.0,
|
||||
any.directory ==1.3.6.2,
|
||||
any.distributive ==0.6.2.1,
|
||||
distributive +semigroups +tagged,
|
||||
any.dlist ==1.0,
|
||||
dlist -werror,
|
||||
any.exceptions ==0.10.4,
|
||||
any.fgl ==5.8.3.0,
|
||||
fgl +containers042,
|
||||
any.filepath ==1.4.2.1,
|
||||
any.foldable1-classes-compat ==0.1.2,
|
||||
foldable1-classes-compat +tagged,
|
||||
any.generically ==0.1.1,
|
||||
any.ghc-bignum ==1.1,
|
||||
any.ghc-boot-th ==9.0.2,
|
||||
any.ghc-prim ==0.7.0,
|
||||
any.hashable ==1.4.7.0,
|
||||
hashable -arch-native +integer-gmp -random-initial-seed,
|
||||
any.indexed-traversable ==0.1.4,
|
||||
any.indexed-traversable-instances ==0.1.2,
|
||||
any.integer-conversion ==0.1.1,
|
||||
any.integer-logarithms ==1.0.4,
|
||||
integer-logarithms -check-bounds +integer-gmp,
|
||||
any.mtl ==2.2.2,
|
||||
any.network-uri ==2.6.4.2,
|
||||
any.optparse-applicative ==0.19.0.0,
|
||||
optparse-applicative +process,
|
||||
any.parsec ==3.1.14.0,
|
||||
any.pretty ==1.1.3.6,
|
||||
any.prettyprinter ==1.7.1,
|
||||
prettyprinter -buildreadme +text,
|
||||
any.prettyprinter-ansi-terminal ==1.1.3,
|
||||
any.primitive ==0.9.1.0,
|
||||
any.process ==1.6.13.2,
|
||||
any.random ==1.3.1,
|
||||
any.regex-base ==0.94.0.3,
|
||||
any.regex-tdfa ==1.3.2.4,
|
||||
regex-tdfa +doctest -force-o2,
|
||||
any.rts ==1.0.2,
|
||||
any.scientific ==0.3.8.0,
|
||||
scientific -integer-simple,
|
||||
any.semialign ==1.3.1,
|
||||
semialign +semigroupoids,
|
||||
any.semigroupoids ==6.0.1,
|
||||
semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
|
||||
any.splitmix ==0.1.3.1,
|
||||
splitmix -optimised-mixer,
|
||||
any.stm ==2.5.0.0,
|
||||
any.strict ==0.5.1,
|
||||
any.tagged ==0.8.9,
|
||||
tagged +deepseq +transformers,
|
||||
any.tasty ==1.5.3,
|
||||
tasty +unix,
|
||||
any.template-haskell ==2.17.0.0,
|
||||
any.text ==1.2.5.0,
|
||||
any.text-iso8601 ==0.1.1,
|
||||
any.text-short ==0.1.6,
|
||||
text-short -asserts,
|
||||
any.th-abstraction ==0.7.1.0,
|
||||
any.th-compat ==0.1.6,
|
||||
any.these ==1.2.1,
|
||||
any.time ==1.9.3,
|
||||
any.time-compat ==1.9.8,
|
||||
any.transformers ==0.5.6.2,
|
||||
any.transformers-compat ==0.7.2,
|
||||
transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
|
||||
any.unbounded-delays ==0.1.1.1,
|
||||
any.unix ==2.7.2.2,
|
||||
any.unordered-containers ==0.2.20,
|
||||
unordered-containers -debug,
|
||||
any.uuid-types ==1.0.6,
|
||||
any.vector ==0.13.2.0,
|
||||
vector +boundschecks -internalchecks -unsafechecks -wall,
|
||||
any.vector-stream ==0.1.0.1,
|
||||
any.witherable ==0.5
|
||||
index-state: hackage.haskell.org 2025-07-22T18:12:16Z
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
#!/bin/dash
|
||||
# Various ShellCheck build utility functions
|
||||
|
||||
# Generally set a ulimit to avoid QEmu using too much memory
|
||||
ulimit -v "$((10*1024*1024))"
|
||||
# If we happen to invoke or run under QEmu, make sure to follow execve.
|
||||
# This requires a patched QEmu.
|
||||
export QEMU_EXECVE=1
|
||||
|
||||
# Retry a command until it succeeds
|
||||
# Usage: scutil retry 3 mycmd
|
||||
retry() {
|
||||
n="$1"
|
||||
ret=1
|
||||
shift
|
||||
while [ "$n" -gt 0 ]
|
||||
do
|
||||
"$@"
|
||||
ret=$?
|
||||
[ "$ret" = 0 ] && break
|
||||
n=$((n-1))
|
||||
done
|
||||
return "$ret"
|
||||
}
|
||||
|
||||
# Install all dependencies from a freeze file
|
||||
# Usage: scutil install_from_freeze /path/cabal.project.freeze cabal install
|
||||
install_from_freeze() {
|
||||
linefeed=$(printf '\nx')
|
||||
linefeed=${linefeed%x}
|
||||
flags=$(
|
||||
sed 's/constraints:/&\n /' "$1" |
|
||||
grep -vw -e rts -e base -e ghc |
|
||||
sed -n -e 's/^ *\([^,]*\).*/\1/p' |
|
||||
sed -e 's/any\.\([^ ]*\) ==\(.*\)/\1-\2/; te; s/.*/--constraint\n&/; :e')
|
||||
shift
|
||||
# shellcheck disable=SC2086
|
||||
( IFS=$linefeed; set -x; "$@" $flags )
|
||||
}
|
||||
|
||||
# Run a command under emulation.
|
||||
# This assumes the correct emulator is named 'qemu' and the chroot is /chroot
|
||||
# Usage: scutil emu echo "Hello World"
|
||||
emu() {
|
||||
chroot /chroot /bin/qemu /usr/bin/env "$@"
|
||||
}
|
||||
|
||||
"$@"
|
||||
|
|
@ -1 +0,0 @@
|
|||
koalaman/scbuilder-linux-armv6hf
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
FROM ubuntu:25.04
|
||||
|
||||
ENV TARGETNAME=linux.riscv64
|
||||
ENV TARGET=riscv64-linux-gnu
|
||||
|
||||
# Build dependencies
|
||||
USER root
|
||||
ENV DEBIAN_FRONTEND=noninteractive
|
||||
RUN apt-get update && apt-get install -y llvm-20 "gcc-$TARGET" "g++-$TARGET" ghc alex happy automake autoconf build-essential curl qemu-user-static
|
||||
RUN curl -L "https://downloads.haskell.org/~cabal/cabal-install-3.16.0.0/cabal-install-3.16.0.0-x86_64-linux-alpine3_20.tar.xz" | tar xJv -C /usr/local/bin && cabal update
|
||||
|
||||
# Build GHC
|
||||
WORKDIR /ghc
|
||||
RUN curl -L "https://downloads.haskell.org/~ghc/9.12.2/ghc-9.12.2-src.tar.xz" | tar xJ --strip-components=1
|
||||
RUN ./boot.source && ./configure --host x86_64-linux-gnu --build x86_64-linux-gnu --target "$TARGET"
|
||||
# GHC fails to build if it can't encode non-ascii
|
||||
ENV LC_CTYPE=C.utf8
|
||||
# We have to do a binary-dist instead of a direct install, otherwise the targest won't have
|
||||
# cross compilation prefixes in /usr/local/lib/aarch64-linux-gnu-ghc-*/lib/settings
|
||||
RUN ./hadrian/build --flavour=quickest --bignum=native -V -j --prefix=/usr/local install
|
||||
# Hadrian just outputs "gcc" as the name of gcc, without accounting for $TARGET. Manually fix up the paths:
|
||||
RUN sed -e 's/"\(gcc\|g++\|ld\)"/"'"$TARGET"'-\1"/g' -i /usr/local/lib/$TARGET-ghc-*/lib/settings
|
||||
|
||||
# Due to an apparent cabal bug, we specify our options directly to cabal
|
||||
# It won't reuse caches if ghc-options are specified in ~/.cabal/config
|
||||
ENV CABALOPTS="--ghc-options;-split-sections -optc-Os -optc-Wl,--gc-sections -optc-fPIC;--with-compiler=$TARGET-ghc;--with-hc-pkg=$TARGET-ghc-pkg;-c;hashable -arch-native"
|
||||
|
||||
# Prebuild the dependencies
|
||||
RUN cabal update && IFS=';' && cabal install --dependencies-only $CABALOPTS ShellCheck
|
||||
|
||||
# Copy the build script
|
||||
COPY build /usr/bin
|
||||
|
||||
WORKDIR /scratch
|
||||
ENTRYPOINT ["/usr/bin/build"]
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
#!/bin/sh
|
||||
set -xe
|
||||
{
|
||||
tar xzv --strip-components=1
|
||||
chmod +x striptests && ./striptests
|
||||
mkdir "$TARGETNAME"
|
||||
( IFS=';'; cabal build $CABALOPTS --enable-executable-static )
|
||||
find . -name shellcheck -type f -exec mv {} "$TARGETNAME/" \;
|
||||
ls -l "$TARGETNAME"
|
||||
"$TARGET-strip" -s "$TARGETNAME/shellcheck"
|
||||
ls -l "$TARGETNAME"
|
||||
"qemu-${TARGET%%-*}-static" "$TARGETNAME/shellcheck" --version
|
||||
} >&2
|
||||
tar czv "$TARGETNAME"
|
||||
|
|
@ -1 +0,0 @@
|
|||
koalaman/scbuilder-linux-riscv64
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
FROM alpine:3.22
|
||||
# alpine:3.16 (GHC 9.0.1): 5.8 megabytes (certs expired)
|
||||
# alpine:3.17 (GHC 9.0.2): 15.0 megabytes (certs expired)
|
||||
# alpine:3.18 (GHC 9.4.4): 29.0 megabytes (certs expired)
|
||||
# alpine:3.19 (GHC 9.4.7): 29.0 megabytes (certs expired)
|
||||
# alpine:3.20 (GHC 9.8.2): 16.0 megabytes
|
||||
# alpine:3.21 (GHC 9.8.2): 16.0 megabytes
|
||||
# alpine:3.22 (GHC 9.8.2): 16.0 megabytes
|
||||
|
||||
ENV TARGETNAME=linux.x86_64
|
||||
|
||||
# Install GHC and cabal
|
||||
USER root
|
||||
RUN apk add ghc cabal g++ libffi-dev curl bash gmp gmp-static
|
||||
|
||||
# Cabal has failed to cache if options are not specified on the command line,
|
||||
# so do that explicitly.
|
||||
ENV CABALOPTS="--ghc-options;-split-sections -optc-Os -optc-Wl,--gc-sections"
|
||||
|
||||
# Verify that we have the certificates in place to successfully update cabal
|
||||
RUN cabal update && rm -rf ~/.cabal
|
||||
|
||||
# Other archs pre-build dependencies here, but this one doesn't to detect ecosystem movement
|
||||
RUN true
|
||||
|
||||
# Copy the build script
|
||||
COPY build /usr/bin
|
||||
|
||||
WORKDIR /scratch
|
||||
ENTRYPOINT ["/usr/bin/build"]
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
#!/bin/sh
|
||||
set -xe
|
||||
{
|
||||
tar xzv --strip-components=1
|
||||
chmod +x striptests && ./striptests
|
||||
mkdir "$TARGETNAME"
|
||||
cabal update
|
||||
( IFS=';'; cabal build $CABALOPTS --enable-executable-static )
|
||||
find . -name shellcheck -type f -exec mv {} "$TARGETNAME/" \;
|
||||
ls -l "$TARGETNAME"
|
||||
strip -s "$TARGETNAME/shellcheck"
|
||||
ls -l "$TARGETNAME"
|
||||
"$TARGETNAME/shellcheck" --version
|
||||
} >&2
|
||||
tar czv "$TARGETNAME"
|
||||
|
|
@ -1 +0,0 @@
|
|||
koalaman/scbuilder-linux-x86_64
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
#!/bin/bash
|
||||
if [ $# -lt 2 ]
|
||||
then
|
||||
echo >&2 "This script builds a source archive (as produced by cabal sdist)"
|
||||
echo >&2 "Usage: $0 sourcefile.tar.gz builddir..."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
file=$(realpath "$1")
|
||||
shift
|
||||
|
||||
if [ ! -e "$file" ]
|
||||
then
|
||||
echo >&2 "$file does not exist"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
set -ex -o pipefail
|
||||
|
||||
for dir
|
||||
do
|
||||
tagfile="$dir/tag"
|
||||
if [ ! -e "$tagfile" ]
|
||||
then
|
||||
echo >&2 "$tagfile does not exist"
|
||||
exit 2
|
||||
fi
|
||||
|
||||
docker run -i "$(< "$tagfile")" < "$file" | tar xz
|
||||
done
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
FROM ubuntu:25.04
|
||||
|
||||
ENV TARGETNAME=windows.x86_64
|
||||
|
||||
# We don't need wine32, even though it complains
|
||||
USER root
|
||||
ENV DEBIAN_FRONTEND=noninteractive
|
||||
RUN apt-get update && apt-get install -y curl busybox wine winbind xz-utils
|
||||
|
||||
# Fetch Windows version, will be available under z:\haskell
|
||||
WORKDIR /haskell
|
||||
# 9.12.2 produces a 37M binary
|
||||
# 9.0.2 produces a 28M binary
|
||||
# 8.10.4 produces a 16M binary
|
||||
# We don't want to be stuck on old versions forever though, so just go with the latest version
|
||||
RUN curl -L "https://downloads.haskell.org/~ghc/9.12.2/ghc-9.12.2-x86_64-unknown-mingw32.tar.xz" | tar xJ --strip-components=1
|
||||
|
||||
# Fetch dependencies
|
||||
WORKDIR /haskell/bin
|
||||
RUN curl -L "https://downloads.haskell.org/~cabal/cabal-install-3.16.0.0/cabal-install-3.16.0.0-x86_64-windows.zip" | busybox unzip -
|
||||
RUN curl -L "https://curl.se/windows/dl-8.15.0_2/curl-8.15.0_2-win64-mingw.zip" | busybox unzip - && mv curl-*-win64-mingw/bin/* .
|
||||
RUN wine /haskell/bin/cabal.exe update
|
||||
ENV WINEPATH=/haskell/bin:/haskell/mingw/bin
|
||||
|
||||
# None of these actually seem to have an effect on GHC on Windows anymore,
|
||||
# but we'll leave them in place anyways.
|
||||
ENV CABALOPTS="--ghc-options;-split-sections -optc-Os -optc-Wl,--gc-sections"
|
||||
|
||||
# Precompile some deps to speed up later builds
|
||||
RUN IFS=';' && wine /haskell/bin/cabal.exe install --lib --dependencies-only $CABALOPTS ShellCheck
|
||||
|
||||
COPY build /usr/bin
|
||||
WORKDIR /scratch
|
||||
ENTRYPOINT ["/usr/bin/build"]
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
#!/bin/sh
|
||||
cabal() {
|
||||
wine /haskell/bin/cabal.exe "$@"
|
||||
}
|
||||
|
||||
set -xe
|
||||
{
|
||||
tar xzv --strip-components=1
|
||||
chmod +x striptests && ./striptests
|
||||
mkdir "$TARGETNAME"
|
||||
( IFS=';'; cabal build $CABALOPTS )
|
||||
find dist*/ -name shellcheck.exe -type f -ls -exec mv {} "$TARGETNAME/" \;
|
||||
ls -l "$TARGETNAME"
|
||||
wine "/haskell/mingw/bin/strip.exe" -s "$TARGETNAME/shellcheck.exe"
|
||||
ls -l "$TARGETNAME"
|
||||
wine "$TARGETNAME/shellcheck.exe" --version
|
||||
} >&2
|
||||
tar czv "$TARGETNAME"
|
||||
|
|
@ -1 +0,0 @@
|
|||
koalaman/scbuilder-windows-x86_64
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 22 KiB |
File diff suppressed because one or more lines are too long
|
Before Width: | Height: | Size: 244 KiB |
BIN
doc/terminal.png
BIN
doc/terminal.png
Binary file not shown.
|
Before Width: | Height: | Size: 4.5 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 2.6 KiB |
4
manpage
4
manpage
|
|
@ -1,4 +0,0 @@
|
|||
#!/bin/sh
|
||||
echo >&2 "Generating man page using pandoc"
|
||||
pandoc -s -f markdown-smart -t man shellcheck.1.md -o shellcheck.1 || exit
|
||||
echo >&2 "Done. You can read it with: man ./shellcheck.1"
|
||||
13
nextnumber
13
nextnumber
|
|
@ -1,13 +0,0 @@
|
|||
#!/usr/bin/env bash
|
||||
# TODO: Find a less trashy way to get the next available error code
|
||||
if ! shopt -s globstar
|
||||
then
|
||||
echo "Error: This script depends on Bash 4." >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
for i in 1 2 3
|
||||
do
|
||||
last=$(grep -hv "^prop" ./**/*.hs | grep -Ewo "${i}[0-9]{3}" | sort -n | tail -n 1)
|
||||
echo "Next ${i}xxx: $((last+1))"
|
||||
done
|
||||
13
quickrun
13
quickrun
|
|
@ -1,13 +0,0 @@
|
|||
#!/usr/bin/env bash
|
||||
# quickrun runs ShellCheck in an interpreted mode.
|
||||
# This allows testing changes without recompiling.
|
||||
|
||||
path=$(find . -type f -path './dist*/Paths_ShellCheck.hs' | sort | head -n 1)
|
||||
if [ -z "$path" ]
|
||||
then
|
||||
echo >&2 "Unable to find Paths_ShellCheck.hs. Please 'cabal build' once."
|
||||
exit 1
|
||||
fi
|
||||
path="${path%/*}"
|
||||
|
||||
exec runghc -isrc -i"$path" shellcheck.hs "$@"
|
||||
24
quicktest
24
quicktest
|
|
@ -1,24 +0,0 @@
|
|||
#!/usr/bin/env bash
|
||||
# quicktest runs the ShellCheck unit tests in an interpreted mode.
|
||||
# This allows running tests without compiling, which can be faster.
|
||||
# 'cabal test' remains the source of truth.
|
||||
|
||||
path=$(find . -type f -path './dist*/Paths_ShellCheck.hs' | sort | head -n 1)
|
||||
if [ -z "$path" ]
|
||||
then
|
||||
echo >&2 "Unable to find Paths_ShellCheck.hs. Please 'cabal build' once."
|
||||
exit 1
|
||||
fi
|
||||
path="${path%/*}"
|
||||
|
||||
|
||||
(
|
||||
var=$(echo 'main' | ghci -isrc -i"$path" test/shellcheck.hs 2>&1 | tee /dev/stderr)
|
||||
if [[ $var == *ExitSuccess* ]]
|
||||
then
|
||||
exit 0
|
||||
else
|
||||
grep -C 3 -e "Fail" -e "Tracing" <<< "$var"
|
||||
exit 1
|
||||
fi
|
||||
) 2>&1
|
||||
|
|
@ -1,11 +0,0 @@
|
|||
#!/bin/sh -xe
|
||||
# This script hardcodes the `git describe` version as ShellCheck's version number.
|
||||
# This is done to allow shellcheck --version to differ from the cabal version when
|
||||
# building git snapshots.
|
||||
|
||||
file="src/ShellCheck/Data.hs"
|
||||
test -e "$file"
|
||||
tmp=$(mktemp)
|
||||
version=$(git describe)
|
||||
sed -e "s/=.*VERSIONSTRING.*/= \"$version\" -- VERSIONSTRING, DO NOT SUBMIT/" "$file" > "$tmp"
|
||||
mv "$tmp" "$file"
|
||||
406
shellcheck.1.md
406
shellcheck.1.md
|
|
@ -1,406 +0,0 @@
|
|||
% SHELLCHECK(1) Shell script analysis tool
|
||||
|
||||
# NAME
|
||||
|
||||
shellcheck - Shell script analysis tool
|
||||
|
||||
# SYNOPSIS
|
||||
|
||||
**shellcheck** [*OPTIONS*...] *FILES*...
|
||||
|
||||
# DESCRIPTION
|
||||
|
||||
ShellCheck is a static analysis and linting tool for sh/bash scripts. It's
|
||||
mainly focused on handling typical beginner and intermediate level syntax
|
||||
errors and pitfalls where the shell just gives a cryptic error message or
|
||||
strange behavior, but it also reports on a few more advanced issues where
|
||||
corner cases can cause delayed failures.
|
||||
|
||||
ShellCheck gives shell specific advice. Consider this line:
|
||||
|
||||
(( area = 3.14*r*r ))
|
||||
|
||||
+ For scripts starting with `#!/bin/sh` (or when using `-s sh`), ShellCheck
|
||||
will warn that `(( .. ))` is not POSIX compliant (similar to checkbashisms).
|
||||
|
||||
+ For scripts starting with `#!/bin/bash` (or using `-s bash`), ShellCheck
|
||||
will warn that decimals are not supported.
|
||||
|
||||
+ For scripts starting with `#!/bin/ksh` (or using `-s ksh`), ShellCheck will
|
||||
not warn at all, as `ksh` supports decimals in arithmetic contexts.
|
||||
|
||||
# OPTIONS
|
||||
|
||||
**-a**,\ **--check-sourced**
|
||||
|
||||
: Emit warnings in sourced files. Normally, `shellcheck` will only warn
|
||||
about issues in the specified files. With this option, any issues in
|
||||
sourced files will also be reported.
|
||||
|
||||
**-C**[*WHEN*],\ **--color**[=*WHEN*]
|
||||
|
||||
: For TTY output, enable colors *always*, *never* or *auto*. The default
|
||||
is *auto*. **--color** without an argument is equivalent to
|
||||
**--color=always**.
|
||||
|
||||
**-i**\ *CODE1*[,*CODE2*...],\ **--include=***CODE1*[,*CODE2*...]
|
||||
|
||||
: Explicitly include only the specified codes in the report. Subsequent **-i**
|
||||
options are cumulative, but all the codes can be specified at once,
|
||||
comma-separated as a single argument. Include options override any provided
|
||||
exclude options.
|
||||
|
||||
**-e**\ *CODE1*[,*CODE2*...],\ **--exclude=***CODE1*[,*CODE2*...]
|
||||
|
||||
: Explicitly exclude the specified codes from the report. Subsequent **-e**
|
||||
options are cumulative, but all the codes can be specified at once,
|
||||
comma-separated as a single argument.
|
||||
|
||||
**--extended-analysis=true/false**
|
||||
|
||||
: Enable/disable Dataflow Analysis to identify more issues (default true). If
|
||||
ShellCheck uses too much CPU/RAM when checking scripts with several
|
||||
thousand lines of code, extended analysis can be disabled with this flag
|
||||
or a directive. This flag overrides directives and rc files.
|
||||
|
||||
**-f** *FORMAT*, **--format=***FORMAT*
|
||||
|
||||
: Specify the output format of shellcheck, which prints its results in the
|
||||
standard output. Subsequent **-f** options are ignored, see **FORMATS**
|
||||
below for more information.
|
||||
|
||||
**--list-optional**
|
||||
|
||||
: Output a list of known optional checks. These can be enabled with **-o**
|
||||
flags or **enable** directives.
|
||||
|
||||
**--norc**
|
||||
|
||||
: Don't try to look for .shellcheckrc configuration files.
|
||||
|
||||
**--rcfile** *RCFILE*
|
||||
|
||||
: Prefer the specified configuration file over searching for one
|
||||
in the default locations.
|
||||
|
||||
**-o**\ *NAME1*[,*NAME2*...],\ **--enable=***NAME1*[,*NAME2*...]
|
||||
|
||||
: Enable optional checks. The special name *all* enables all of them.
|
||||
Subsequent **-o** options accumulate. This is equivalent to specifying
|
||||
**enable** directives.
|
||||
|
||||
**-P**\ *SOURCEPATH*,\ **--source-path=***SOURCEPATH*
|
||||
|
||||
: Specify paths to search for sourced files, separated by `:` on Unix and
|
||||
`;` on Windows. This is equivalent to specifying `search-path`
|
||||
directives.
|
||||
|
||||
**-s**\ *shell*,\ **--shell=***shell*
|
||||
|
||||
: Specify Bourne shell dialect. Valid values are *sh*, *bash*, *dash*, *ksh*,
|
||||
and *busybox*.
|
||||
The default is to deduce the shell from the file's `shell` directive,
|
||||
shebang, or `.bash/.bats/.dash/.ksh` extension, in that order. *sh* refers to
|
||||
POSIX `sh` (not the system's), and will warn of portability issues.
|
||||
|
||||
**-S**\ *SEVERITY*,\ **--severity=***severity*
|
||||
|
||||
: Specify minimum severity of errors to consider. Valid values in order of
|
||||
severity are *error*, *warning*, *info* and *style*.
|
||||
The default is *style*.
|
||||
|
||||
**-V**,\ **--version**
|
||||
|
||||
: Print version information and exit.
|
||||
|
||||
**-W** *NUM*,\ **--wiki-link-count=NUM**
|
||||
|
||||
: For TTY output, show *NUM* wiki links to more information about mentioned
|
||||
warnings. Set to 0 to disable them entirely.
|
||||
|
||||
**-x**,\ **--external-sources**
|
||||
|
||||
: Follow `source` statements even when the file is not specified as input.
|
||||
By default, `shellcheck` will only follow files specified on the command
|
||||
line (plus `/dev/null`). This option allows following any file the script
|
||||
may `source`.
|
||||
|
||||
This option may also be enabled using `external-sources=true` in
|
||||
`.shellcheckrc`. This flag takes precedence.
|
||||
|
||||
**FILES...**
|
||||
|
||||
: One or more script files to check, or "-" for standard input.
|
||||
|
||||
|
||||
# FORMATS
|
||||
|
||||
**tty**
|
||||
|
||||
: Plain text, human readable output. This is the default.
|
||||
|
||||
**gcc**
|
||||
|
||||
: GCC compatible output. Useful for editors that support compiling and
|
||||
showing syntax errors.
|
||||
|
||||
For example, in Vim, `:set makeprg=shellcheck\ -f\ gcc\ %` will allow
|
||||
using `:make` to check the script, and `:cnext` to jump to the next error.
|
||||
|
||||
<file>:<line>:<column>: <type>: <message>
|
||||
|
||||
**checkstyle**
|
||||
|
||||
: Checkstyle compatible XML output. Supported directly or through plugins
|
||||
by many IDEs and build monitoring systems.
|
||||
|
||||
<?xml version='1.0' encoding='UTF-8'?>
|
||||
<checkstyle version='4.3'>
|
||||
<file name='file'>
|
||||
<error
|
||||
line='line'
|
||||
column='column'
|
||||
severity='severity'
|
||||
message='message'
|
||||
source='ShellCheck.SC####' />
|
||||
...
|
||||
</file>
|
||||
...
|
||||
</checkstyle>
|
||||
|
||||
**diff**
|
||||
|
||||
: Auto-fixes in unified diff format. Can be piped to `git apply` or `patch -p1`
|
||||
to automatically apply fixes.
|
||||
|
||||
--- a/test.sh
|
||||
+++ b/test.sh
|
||||
@@ -2,6 +2,6 @@
|
||||
## Example of a broken script.
|
||||
for f in $(ls *.m3u)
|
||||
do
|
||||
- grep -qi hq.*mp3 $f \
|
||||
+ grep -qi hq.*mp3 "$f" \
|
||||
&& echo -e 'Playlist $f contains a HQ file in mp3 format'
|
||||
done
|
||||
|
||||
|
||||
**json1**
|
||||
|
||||
: Json is a popular serialization format that is more suitable for web
|
||||
applications. ShellCheck's json is compact and contains only the bare
|
||||
minimum. Tabs are counted as 1 character.
|
||||
|
||||
{
|
||||
comments: [
|
||||
{
|
||||
"file": "filename",
|
||||
"line": lineNumber,
|
||||
"column": columnNumber,
|
||||
"level": "severitylevel",
|
||||
"code": errorCode,
|
||||
"message": "warning message"
|
||||
},
|
||||
...
|
||||
]
|
||||
}
|
||||
|
||||
**json**
|
||||
|
||||
: This is a legacy version of the **json1** format. It's a raw array of
|
||||
comments, and all offsets have a tab stop of 8.
|
||||
|
||||
**quiet**
|
||||
|
||||
: Suppress all normal output. Exit with zero if no issues are found,
|
||||
otherwise exit with one. Stops processing after the first issue.
|
||||
|
||||
|
||||
# DIRECTIVES
|
||||
|
||||
ShellCheck directives can be specified as comments in the shell script.
|
||||
If they appear before the first command, they are considered file-wide.
|
||||
Otherwise, they apply to the immediately following command or block:
|
||||
|
||||
# shellcheck key=value key=value
|
||||
command-or-structure
|
||||
|
||||
For example, to suppress SC2035 about using `./*.jpg`:
|
||||
|
||||
# shellcheck disable=SC2035
|
||||
echo "Files: " *.jpg
|
||||
|
||||
To tell ShellCheck where to look for an otherwise dynamically determined file:
|
||||
|
||||
# shellcheck source=./lib.sh
|
||||
source "$(find_install_dir)/lib.sh"
|
||||
|
||||
Here a shell brace group is used to suppress a warning on multiple lines:
|
||||
|
||||
# shellcheck disable=SC2016
|
||||
{
|
||||
echo 'Modifying $PATH'
|
||||
echo 'PATH=foo:$PATH' >> ~/.bashrc
|
||||
}
|
||||
|
||||
Valid keys are:
|
||||
|
||||
**disable**
|
||||
: Disables a comma separated list of error codes for the following command.
|
||||
The command can be a simple command like `echo foo`, or a compound command
|
||||
like a function definition, subshell block or loop. A range can be
|
||||
be specified with a dash, e.g. `disable=SC3000-SC4000` to exclude 3xxx.
|
||||
All warnings can be disabled with `disable=all`.
|
||||
|
||||
**enable**
|
||||
: Enable an optional check by name, as listed with **--list-optional**.
|
||||
Only file-wide `enable` directives are considered.
|
||||
|
||||
**extended-analysis**
|
||||
: Set to true/false to enable/disable dataflow analysis. Specifying
|
||||
`# shellcheck extended-analysis=false` in particularly large (2000+ line)
|
||||
auto-generated scripts will reduce ShellCheck's resource usage at the
|
||||
expense of certain checks. Extended analysis is enabled by default.
|
||||
|
||||
**external-sources**
|
||||
: Set to `true` in `.shellcheckrc` to always allow ShellCheck to open
|
||||
arbitrary files from 'source' statements (the way most tools do).
|
||||
|
||||
This option defaults to `false` only due to ShellCheck's origin as a
|
||||
remote service for checking untrusted scripts. It can safely be enabled
|
||||
for normal development.
|
||||
|
||||
**source**
|
||||
: Overrides the filename included by a `source`/`.` statement. This can be
|
||||
used to tell shellcheck where to look for a file whose name is determined
|
||||
at runtime, or to skip a source by telling it to use `/dev/null`.
|
||||
|
||||
**source-path**
|
||||
: Add a directory to the search path for `source`/`.` statements (by default,
|
||||
only ShellCheck's working directory is included). Absolute paths will also
|
||||
be rooted in these paths. The special path `SCRIPTDIR` can be used to
|
||||
specify the currently checked script's directory, as in
|
||||
`source-path=SCRIPTDIR` or `source-path=SCRIPTDIR/../libs`. Multiple
|
||||
paths accumulate, and `-P` takes precedence over them.
|
||||
|
||||
**shell**
|
||||
: Overrides the shell detected from the shebang. This is useful for
|
||||
files meant to be included (and thus lacking a shebang), or possibly
|
||||
as a more targeted alternative to 'disable=SC2039'.
|
||||
|
||||
# RC FILES
|
||||
|
||||
Unless `--norc` is used, ShellCheck will look for a file `.shellcheckrc` or
|
||||
`shellcheckrc` in the script's directory and each parent directory. If found,
|
||||
it will read `key=value` pairs from it and treat them as file-wide directives.
|
||||
|
||||
Here is an example `.shellcheckrc`:
|
||||
|
||||
# Look for 'source'd files relative to the checked script,
|
||||
# and also look for absolute paths in /mnt/chroot
|
||||
source-path=SCRIPTDIR
|
||||
source-path=/mnt/chroot
|
||||
|
||||
# Since 0.9.0, values can be quoted with '' or "" to allow spaces
|
||||
source-path="My Documents/scripts"
|
||||
|
||||
# Allow opening any 'source'd file, even if not specified as input
|
||||
external-sources=true
|
||||
|
||||
# Turn on warnings for unquoted variables with safe values
|
||||
enable=quote-safe-variables
|
||||
|
||||
# Turn on warnings for unassigned uppercase variables
|
||||
enable=check-unassigned-uppercase
|
||||
|
||||
# Allow [ ! -z foo ] instead of suggesting -n
|
||||
disable=SC2236
|
||||
|
||||
If no `.shellcheckrc` is found in any of the parent directories, ShellCheck
|
||||
will look in `~/.shellcheckrc` followed by the `$XDG_CONFIG_HOME`
|
||||
(usually `~/.config/shellcheckrc`) on Unix, or `%APPDATA%/shellcheckrc` on
|
||||
Windows. Only the first file found will be used.
|
||||
|
||||
Note for Snap users: the Snap sandbox disallows access to hidden files.
|
||||
Use `shellcheckrc` without the dot instead.
|
||||
|
||||
Note for Docker users: ShellCheck will only be able to look for files that
|
||||
are mounted in the container, so `~/.shellcheckrc` will not be read.
|
||||
|
||||
|
||||
# ENVIRONMENT VARIABLES
|
||||
|
||||
The environment variable `SHELLCHECK_OPTS` can be set with default flags:
|
||||
|
||||
export SHELLCHECK_OPTS='--shell=bash --exclude=SC2016'
|
||||
|
||||
Its value will be split on spaces and prepended to the command line on each
|
||||
invocation.
|
||||
|
||||
# RETURN VALUES
|
||||
|
||||
ShellCheck uses the following exit codes:
|
||||
|
||||
+ 0: All files successfully scanned with no issues.
|
||||
+ 1: All files successfully scanned with some issues.
|
||||
+ 2: Some files could not be processed (e.g. file not found).
|
||||
+ 3: ShellCheck was invoked with bad syntax (e.g. unknown flag).
|
||||
+ 4: ShellCheck was invoked with bad options (e.g. unknown formatter).
|
||||
|
||||
# LOCALE
|
||||
|
||||
This version of ShellCheck is only available in English. All files are
|
||||
leniently decoded as UTF-8, with a fallback of ISO-8859-1 for invalid
|
||||
sequences. `LC_CTYPE` is respected for output, and defaults to UTF-8 for
|
||||
locales where encoding is unspecified (such as the `C` locale).
|
||||
|
||||
Windows users seeing `commitBuffer: invalid argument (invalid character)`
|
||||
should set their terminal to use UTF-8 with `chcp 65001`.
|
||||
|
||||
# KNOWN INCOMPATIBILITIES
|
||||
|
||||
(If nothing in this section makes sense, you are unlikely to be affected by it)
|
||||
|
||||
To avoid confusing and misguided suggestions, ShellCheck requires function
|
||||
bodies to be either `{ brace groups; }` or `( subshells )`, and function names
|
||||
containing `[]*=!` are only recognized after a `function` keyword.
|
||||
|
||||
The following unconventional function definitions are identical in Bash,
|
||||
but ShellCheck only recognizes the latter.
|
||||
|
||||
[x!=y] () [[ $1 ]]
|
||||
function [x!=y] () { [[ $1 ]]; }
|
||||
|
||||
Shells without the `function` keyword do not allow these characters in function
|
||||
names to begin with. Function names containing `{}` are not supported at all.
|
||||
|
||||
Further, if ShellCheck sees `[x!=y]` it will assume this is an invalid
|
||||
comparison. To invoke the above function, quote the command as in `'[x!=y]'`,
|
||||
or to retain the same globbing behavior, use `command [x!=y]`.
|
||||
|
||||
ShellCheck imposes additional restrictions on the `[` command to help diagnose
|
||||
common invalid uses. While `[ $x= 1 ]` is defined in POSIX, ShellCheck will
|
||||
assume it was intended as the much more likely comparison `[ "$x" = 1 ]` and
|
||||
fail accordingly. For unconventional or dynamic uses of the `[` command, use
|
||||
`test` or `\[` instead.
|
||||
|
||||
# REPORTING BUGS
|
||||
|
||||
Bugs and issues can be reported on GitHub:
|
||||
|
||||
https://github.com/koalaman/shellcheck/issues
|
||||
|
||||
# AUTHORS
|
||||
|
||||
ShellCheck is developed and maintained by Vidar Holen, with assistance from a
|
||||
long list of wonderful contributors.
|
||||
|
||||
# COPYRIGHT
|
||||
|
||||
Copyright 2012-2025, Vidar Holen and contributors.
|
||||
Licensed under the GNU General Public License version 3 or later,
|
||||
see https://gnu.org/licenses/gpl.html
|
||||
|
||||
# SEE ALSO
|
||||
|
||||
sh(1), bash(1), dash(1), ksh(1)
|
||||
635
shellcheck.hs
635
shellcheck.hs
|
|
@ -1,635 +0,0 @@
|
|||
{-
|
||||
Copyright 2012-2019 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
import qualified ShellCheck.Analyzer
|
||||
import ShellCheck.Checker
|
||||
import ShellCheck.Data
|
||||
import ShellCheck.Interface
|
||||
import ShellCheck.Regex
|
||||
|
||||
import qualified ShellCheck.Formatter.CheckStyle
|
||||
import ShellCheck.Formatter.Format
|
||||
import qualified ShellCheck.Formatter.Diff
|
||||
import qualified ShellCheck.Formatter.GCC
|
||||
import qualified ShellCheck.Formatter.JSON
|
||||
import qualified ShellCheck.Formatter.JSON1
|
||||
import qualified ShellCheck.Formatter.TTY
|
||||
import qualified ShellCheck.Formatter.Quiet
|
||||
|
||||
import Control.Exception
|
||||
import Control.Monad
|
||||
import Control.Monad.IO.Class
|
||||
import Control.Monad.Trans.Class
|
||||
import Control.Monad.Except
|
||||
import Data.Bits
|
||||
import Data.Char
|
||||
import Data.Either
|
||||
import Data.Functor
|
||||
import Data.IORef
|
||||
import Data.List
|
||||
import qualified Data.Map as Map
|
||||
import Data.Maybe
|
||||
import Data.Monoid
|
||||
import Data.Semigroup (Semigroup (..))
|
||||
import Prelude hiding (catch)
|
||||
import System.Console.GetOpt
|
||||
import System.Directory
|
||||
import System.Environment
|
||||
import System.Exit
|
||||
import System.FilePath
|
||||
import System.IO
|
||||
|
||||
data Flag = Flag String String
|
||||
data Status =
|
||||
NoProblems
|
||||
| SomeProblems
|
||||
| SupportFailure
|
||||
| SyntaxFailure
|
||||
| RuntimeException
|
||||
deriving (Ord, Eq, Show)
|
||||
|
||||
instance Semigroup Status where
|
||||
(<>) = max
|
||||
|
||||
instance Monoid Status where
|
||||
mempty = NoProblems
|
||||
mappend = (Data.Semigroup.<>)
|
||||
|
||||
data Options = Options {
|
||||
checkSpec :: CheckSpec,
|
||||
externalSources :: Bool,
|
||||
sourcePaths :: [FilePath],
|
||||
formatterOptions :: FormatterOptions,
|
||||
minSeverity :: Severity,
|
||||
rcfile :: Maybe FilePath
|
||||
}
|
||||
|
||||
defaultOptions = Options {
|
||||
checkSpec = emptyCheckSpec,
|
||||
externalSources = False,
|
||||
sourcePaths = [],
|
||||
formatterOptions = newFormatterOptions {
|
||||
foColorOption = ColorAuto
|
||||
},
|
||||
minSeverity = StyleC,
|
||||
rcfile = Nothing
|
||||
}
|
||||
|
||||
usageHeader = "Usage: shellcheck [OPTIONS...] FILES..."
|
||||
options = [
|
||||
Option "a" ["check-sourced"]
|
||||
(NoArg $ Flag "sourced" "false") "Include warnings from sourced files",
|
||||
Option "C" ["color"]
|
||||
(OptArg (maybe (Flag "color" "always") (Flag "color")) "WHEN")
|
||||
"Use color (auto, always, never)",
|
||||
Option "i" ["include"]
|
||||
(ReqArg (Flag "include") "CODE1,CODE2..") "Consider only given types of warnings",
|
||||
Option "e" ["exclude"]
|
||||
(ReqArg (Flag "exclude") "CODE1,CODE2..") "Exclude types of warnings",
|
||||
Option "" ["extended-analysis"]
|
||||
(ReqArg (Flag "extended-analysis") "bool") "Perform dataflow analysis (default true)",
|
||||
Option "f" ["format"]
|
||||
(ReqArg (Flag "format") "FORMAT") $
|
||||
"Output format (" ++ formatList ++ ")",
|
||||
Option "" ["list-optional"]
|
||||
(NoArg $ Flag "list-optional" "true") "List checks disabled by default",
|
||||
Option "" ["norc"]
|
||||
(NoArg $ Flag "norc" "true") "Don't look for .shellcheckrc files",
|
||||
Option "" ["rcfile"]
|
||||
(ReqArg (Flag "rcfile") "RCFILE")
|
||||
"Prefer the specified configuration file over searching for one",
|
||||
Option "o" ["enable"]
|
||||
(ReqArg (Flag "enable") "check1,check2..")
|
||||
"List of optional checks to enable (or 'all')",
|
||||
Option "P" ["source-path"]
|
||||
(ReqArg (Flag "source-path") "SOURCEPATHS")
|
||||
"Specify path when looking for sourced files (\"SCRIPTDIR\" for script's dir)",
|
||||
Option "s" ["shell"]
|
||||
(ReqArg (Flag "shell") "SHELLNAME")
|
||||
"Specify dialect (sh, bash, dash, ksh, busybox)",
|
||||
Option "S" ["severity"]
|
||||
(ReqArg (Flag "severity") "SEVERITY")
|
||||
"Minimum severity of errors to consider (error, warning, info, style)",
|
||||
Option "V" ["version"]
|
||||
(NoArg $ Flag "version" "true") "Print version information",
|
||||
Option "W" ["wiki-link-count"]
|
||||
(ReqArg (Flag "wiki-link-count") "NUM")
|
||||
"The number of wiki links to show, when applicable",
|
||||
Option "x" ["external-sources"]
|
||||
(NoArg $ Flag "externals" "true") "Allow 'source' outside of FILES",
|
||||
Option "" ["help"]
|
||||
(NoArg $ Flag "help" "true") "Show this usage summary and exit"
|
||||
]
|
||||
getUsageInfo = usageInfo usageHeader options
|
||||
|
||||
printErr = lift . hPutStrLn stderr
|
||||
|
||||
parseArguments :: [String] -> ExceptT Status IO ([Flag], [FilePath])
|
||||
parseArguments argv =
|
||||
case getOpt Permute options argv of
|
||||
(opts, files, []) -> return (opts, files)
|
||||
(_, _, errors) -> do
|
||||
printErr $ concat errors ++ "\n" ++ getUsageInfo
|
||||
throwError SyntaxFailure
|
||||
|
||||
formats :: FormatterOptions -> Map.Map String (IO Formatter)
|
||||
formats options = Map.fromList [
|
||||
("checkstyle", ShellCheck.Formatter.CheckStyle.format),
|
||||
("diff", ShellCheck.Formatter.Diff.format options),
|
||||
("gcc", ShellCheck.Formatter.GCC.format),
|
||||
("json", ShellCheck.Formatter.JSON.format),
|
||||
("json1", ShellCheck.Formatter.JSON1.format),
|
||||
("tty", ShellCheck.Formatter.TTY.format options),
|
||||
("quiet", ShellCheck.Formatter.Quiet.format options)
|
||||
]
|
||||
|
||||
formatList = intercalate ", " names
|
||||
where
|
||||
names = Map.keys $ formats (formatterOptions defaultOptions)
|
||||
|
||||
getOption [] _ = Nothing
|
||||
getOption (Flag var val:_) name | name == var = return val
|
||||
getOption (_:rest) flag = getOption rest flag
|
||||
|
||||
getOptions options name =
|
||||
map (\(Flag _ val) -> val) . filter (\(Flag var _) -> var == name) $ options
|
||||
|
||||
split char str =
|
||||
split' str []
|
||||
where
|
||||
split' (a:rest) element =
|
||||
if a == char
|
||||
then reverse element : split' rest []
|
||||
else split' rest (a:element)
|
||||
split' [] element = [reverse element]
|
||||
|
||||
toStatus = fmap (either id id) . runExceptT
|
||||
|
||||
getEnvArgs = do
|
||||
opts <- getEnv "SHELLCHECK_OPTS" `catch` cantWaitForLookupEnv
|
||||
return . filter (not . null) $ opts `splitOn` mkRegex " +"
|
||||
where
|
||||
cantWaitForLookupEnv :: IOException -> IO String
|
||||
cantWaitForLookupEnv = const $ return ""
|
||||
|
||||
main = do
|
||||
params <- getArgs
|
||||
envOpts <- getEnvArgs
|
||||
let args = envOpts ++ params
|
||||
status <- toStatus $ do
|
||||
(flags, files) <- parseArguments args
|
||||
process flags files
|
||||
exitWith $ statusToCode status
|
||||
|
||||
statusToCode status =
|
||||
case status of
|
||||
NoProblems -> ExitSuccess
|
||||
SomeProblems -> ExitFailure 1
|
||||
SyntaxFailure -> ExitFailure 3
|
||||
SupportFailure -> ExitFailure 4
|
||||
RuntimeException -> ExitFailure 2
|
||||
|
||||
process :: [Flag] -> [FilePath] -> ExceptT Status IO Status
|
||||
process flags files = do
|
||||
options <- foldM (flip parseOption) defaultOptions flags
|
||||
verifyFiles files
|
||||
let format = fromMaybe "tty" $ getOption flags "format"
|
||||
let formatters = formats $ formatterOptions options
|
||||
formatter <-
|
||||
case Map.lookup format formatters of
|
||||
Nothing -> do
|
||||
printErr $ "Unknown format " ++ format
|
||||
printErr "Supported formats:"
|
||||
mapM_ (printErr . write) $ Map.keys formatters
|
||||
throwError SupportFailure
|
||||
where write s = " " ++ s
|
||||
Just f -> ExceptT $ fmap Right f
|
||||
sys <- lift $ ioInterface options files
|
||||
lift $ runFormatter sys formatter options files
|
||||
|
||||
runFormatter :: SystemInterface IO -> Formatter -> Options -> [FilePath]
|
||||
-> IO Status
|
||||
runFormatter sys format options files = do
|
||||
header format
|
||||
result <- foldM f NoProblems files
|
||||
footer format
|
||||
return result
|
||||
where
|
||||
f :: Status -> FilePath -> IO Status
|
||||
f status file = do
|
||||
newStatus <- process file `catch` handler file
|
||||
return $! status `mappend` newStatus
|
||||
handler :: FilePath -> IOException -> IO Status
|
||||
handler file e = reportFailure file (show e)
|
||||
reportFailure file str = do
|
||||
onFailure format file str
|
||||
return RuntimeException
|
||||
|
||||
process :: FilePath -> IO Status
|
||||
process filename = do
|
||||
input <- siReadFile sys Nothing filename
|
||||
either (reportFailure filename) check input
|
||||
where
|
||||
check contents = do
|
||||
let checkspec = (checkSpec options) {
|
||||
csFilename = filename,
|
||||
csScript = contents
|
||||
}
|
||||
result <- checkScript sys checkspec
|
||||
onResult format result sys
|
||||
return $
|
||||
if null (crComments result)
|
||||
then NoProblems
|
||||
else SomeProblems
|
||||
|
||||
parseEnum name value list =
|
||||
case lookup value list of
|
||||
Just value -> return value
|
||||
Nothing -> do
|
||||
printErr $ "Unknown value for --" ++ name ++ ". " ++
|
||||
"Valid options are: " ++ (intercalate ", " $ map fst list)
|
||||
throwError SupportFailure
|
||||
|
||||
parseColorOption value =
|
||||
parseEnum "color" value [
|
||||
("auto", ColorAuto),
|
||||
("always", ColorAlways),
|
||||
("never", ColorNever)
|
||||
]
|
||||
|
||||
parseSeverityOption value =
|
||||
parseEnum "severity" value [
|
||||
("error", ErrorC),
|
||||
("warning", WarningC),
|
||||
("info", InfoC),
|
||||
("style", StyleC)
|
||||
]
|
||||
|
||||
parseOption flag options =
|
||||
case flag of
|
||||
Flag "shell" str ->
|
||||
fromMaybe (die $ "Unknown shell: " ++ str) $ do
|
||||
shell <- shellForExecutable str
|
||||
return $ return options {
|
||||
checkSpec = (checkSpec options) {
|
||||
csShellTypeOverride = Just shell
|
||||
}
|
||||
}
|
||||
|
||||
Flag "exclude" str -> do
|
||||
new <- mapM parseNum $ filter (not . null) $ split ',' str
|
||||
let old = csExcludedWarnings . checkSpec $ options
|
||||
return options {
|
||||
checkSpec = (checkSpec options) {
|
||||
csExcludedWarnings = new ++ old
|
||||
}
|
||||
}
|
||||
|
||||
Flag "include" str -> do
|
||||
new <- mapM parseNum $ filter (not . null) $ split ',' str
|
||||
let old = csIncludedWarnings . checkSpec $ options
|
||||
return options {
|
||||
checkSpec = (checkSpec options) {
|
||||
csIncludedWarnings =
|
||||
if null new
|
||||
then old
|
||||
else Just new `mappend` old
|
||||
}
|
||||
}
|
||||
|
||||
Flag "version" _ -> do
|
||||
liftIO printVersion
|
||||
throwError NoProblems
|
||||
|
||||
Flag "list-optional" _ -> do
|
||||
liftIO printOptional
|
||||
throwError NoProblems
|
||||
|
||||
Flag "help" _ -> do
|
||||
liftIO $ putStrLn getUsageInfo
|
||||
throwError NoProblems
|
||||
|
||||
Flag "externals" _ ->
|
||||
return options {
|
||||
externalSources = True
|
||||
}
|
||||
|
||||
Flag "color" color -> do
|
||||
option <- parseColorOption color
|
||||
return options {
|
||||
formatterOptions = (formatterOptions options) {
|
||||
foColorOption = option
|
||||
}
|
||||
}
|
||||
|
||||
Flag "source-path" str -> do
|
||||
let paths = splitSearchPath str
|
||||
return options {
|
||||
sourcePaths = (sourcePaths options) ++ paths
|
||||
}
|
||||
|
||||
Flag "sourced" _ ->
|
||||
return options {
|
||||
checkSpec = (checkSpec options) {
|
||||
csCheckSourced = True
|
||||
}
|
||||
}
|
||||
|
||||
Flag "severity" severity -> do
|
||||
option <- parseSeverityOption severity
|
||||
return options {
|
||||
checkSpec = (checkSpec options) {
|
||||
csMinSeverity = option
|
||||
}
|
||||
}
|
||||
|
||||
Flag "wiki-link-count" countString -> do
|
||||
count <- parseNum countString
|
||||
return options {
|
||||
formatterOptions = (formatterOptions options) {
|
||||
foWikiLinkCount = count
|
||||
}
|
||||
}
|
||||
|
||||
Flag "norc" _ ->
|
||||
return options {
|
||||
checkSpec = (checkSpec options) {
|
||||
csIgnoreRC = True
|
||||
}
|
||||
}
|
||||
|
||||
Flag "rcfile" str -> do
|
||||
return options {
|
||||
rcfile = Just str
|
||||
}
|
||||
|
||||
Flag "enable" value ->
|
||||
let cs = checkSpec options in return options {
|
||||
checkSpec = cs {
|
||||
csOptionalChecks = (csOptionalChecks cs) ++ split ',' value
|
||||
}
|
||||
}
|
||||
|
||||
Flag "extended-analysis" str -> do
|
||||
value <- parseBool str
|
||||
return options {
|
||||
checkSpec = (checkSpec options) {
|
||||
csExtendedAnalysis = Just value
|
||||
}
|
||||
}
|
||||
|
||||
-- This flag is handled specially in 'process'
|
||||
Flag "format" _ -> return options
|
||||
|
||||
Flag str _ -> do
|
||||
printErr $ "Internal error for --" ++ str ++ ". Please file a bug :("
|
||||
return options
|
||||
where
|
||||
die s = do
|
||||
printErr s
|
||||
throwError SupportFailure
|
||||
parseNum ('S':'C':str) = parseNum str
|
||||
parseNum num = do
|
||||
unless (all isDigit num) $ do
|
||||
printErr $ "Invalid number: " ++ num
|
||||
throwError SyntaxFailure
|
||||
return (Prelude.read num :: Integer)
|
||||
|
||||
parseBool str = do
|
||||
case str of
|
||||
"true" -> return True
|
||||
"false" -> return False
|
||||
_ -> do
|
||||
printErr $ "Invalid boolean, expected true/false: " ++ str
|
||||
throwError SyntaxFailure
|
||||
|
||||
ioInterface :: Options -> [FilePath] -> IO (SystemInterface IO)
|
||||
ioInterface options files = do
|
||||
inputs <- mapM normalize files
|
||||
cache <- newIORef emptyCache
|
||||
configCache <- newIORef ("", Nothing)
|
||||
return (newSystemInterface :: SystemInterface IO) {
|
||||
siReadFile = get cache inputs,
|
||||
siFindSource = findSourceFile inputs (sourcePaths options),
|
||||
siGetConfig = getConfig configCache
|
||||
}
|
||||
where
|
||||
emptyCache :: Map.Map FilePath String
|
||||
emptyCache = Map.empty
|
||||
|
||||
get cache inputs rcSuggestsExternal file = do
|
||||
map <- readIORef cache
|
||||
case Map.lookup file map of
|
||||
Just x -> return $ Right x
|
||||
Nothing -> fetch cache inputs rcSuggestsExternal file
|
||||
|
||||
fetch cache inputs rcSuggestsExternal file = do
|
||||
ok <- allowable rcSuggestsExternal inputs file
|
||||
if ok
|
||||
then (do
|
||||
(contents, shouldCache) <- inputFile file
|
||||
when shouldCache $
|
||||
modifyIORef cache $ Map.insert file contents
|
||||
return $ Right contents
|
||||
) `catch` handler
|
||||
else
|
||||
if rcSuggestsExternal == Just False
|
||||
then return $ Left (file ++ " was not specified as input, and external files were disabled via directive.")
|
||||
else return $ Left (file ++ " was not specified as input (see shellcheck -x).")
|
||||
where
|
||||
handler :: IOException -> IO (Either ErrorMessage String)
|
||||
handler ex = return . Left $ show ex
|
||||
|
||||
allowable rcSuggestsExternal inputs x =
|
||||
if fromMaybe (externalSources options) rcSuggestsExternal
|
||||
then return True
|
||||
else do
|
||||
path <- normalize x
|
||||
return $ path `elem` inputs
|
||||
|
||||
normalize x =
|
||||
canonicalizePath x `catch` fallback x
|
||||
where
|
||||
fallback :: FilePath -> IOException -> IO FilePath
|
||||
fallback path _ = return path
|
||||
|
||||
|
||||
-- Returns the name and contents of .shellcheckrc for the given file
|
||||
getConfig cache filename =
|
||||
case rcfile options of
|
||||
Just file -> do
|
||||
-- We have a specified rcfile. Ignore normal rcfile resolution.
|
||||
(path, result) <- readIORef cache
|
||||
if path == "/"
|
||||
then return result
|
||||
else do
|
||||
result <- readConfig file
|
||||
when (isNothing result) $
|
||||
hPutStrLn stderr $ "Warning: unable to read --rcfile " ++ file
|
||||
writeIORef cache ("/", result)
|
||||
return result
|
||||
|
||||
Nothing -> do
|
||||
path <- normalize filename
|
||||
let dir = takeDirectory path
|
||||
(previousPath, result) <- readIORef cache
|
||||
if dir == previousPath
|
||||
then return result
|
||||
else do
|
||||
paths <- getConfigPaths dir
|
||||
result <- findConfig paths
|
||||
writeIORef cache (dir, result)
|
||||
return result
|
||||
|
||||
findConfig paths =
|
||||
case paths of
|
||||
(file:rest) -> do
|
||||
contents <- readConfig file
|
||||
if isJust contents
|
||||
then return contents
|
||||
else findConfig rest
|
||||
[] -> return Nothing
|
||||
|
||||
-- Get a list of candidate filenames. This includes .shellcheckrc
|
||||
-- in all parent directories, plus the user's home dir and xdg dir.
|
||||
-- The dot is optional for Windows and Snap users.
|
||||
getConfigPaths dir = do
|
||||
let next = takeDirectory dir
|
||||
rest <- if next /= dir
|
||||
then getConfigPaths next
|
||||
else defaultPaths `catch`
|
||||
((const $ return []) :: IOException -> IO [FilePath])
|
||||
return $ (dir </> ".shellcheckrc") : (dir </> "shellcheckrc") : rest
|
||||
|
||||
defaultPaths = do
|
||||
home <- getAppUserDataDirectory "shellcheckrc"
|
||||
xdg <- getXdgDirectory XdgConfig "shellcheckrc"
|
||||
return [home, xdg]
|
||||
|
||||
readConfig file = do
|
||||
exists <- doesFileExist file
|
||||
if exists
|
||||
then do
|
||||
(contents, _) <- inputFile file `catch` handler file
|
||||
return $ Just (file, contents)
|
||||
else
|
||||
return Nothing
|
||||
where
|
||||
handler :: FilePath -> IOException -> IO (String, Bool)
|
||||
handler file err = do
|
||||
hPutStrLn stderr $ file ++ ": " ++ show err
|
||||
return ("", True)
|
||||
|
||||
andM a b arg = do
|
||||
first <- a arg
|
||||
if not first then return False else b arg
|
||||
|
||||
findM p = foldr go (pure Nothing)
|
||||
where
|
||||
go x acc = do
|
||||
b <- p x
|
||||
if b then pure (Just x) else acc
|
||||
|
||||
findSourceFile inputs sourcePathFlag currentScript rcSuggestsExternal sourcePathAnnotation original =
|
||||
if isAbsolute original
|
||||
then
|
||||
let (_, relative) = splitDrive original
|
||||
in find relative original
|
||||
else
|
||||
find original original
|
||||
where
|
||||
find filename deflt = do
|
||||
sources <- findM ((allowable rcSuggestsExternal inputs) `andM` doesFileExist) $
|
||||
(adjustPath filename):(map ((</> filename) . adjustPath) $ sourcePathFlag ++ sourcePathAnnotation)
|
||||
case sources of
|
||||
Nothing -> return deflt
|
||||
Just first -> return first
|
||||
scriptdir = dropFileName currentScript
|
||||
adjustPath str =
|
||||
case (splitDirectories str) of
|
||||
("SCRIPTDIR":rest) -> joinPath (scriptdir:rest)
|
||||
_ -> str
|
||||
|
||||
inputFile file = do
|
||||
(handle, shouldCache) <-
|
||||
if file == "-"
|
||||
then return (stdin, True)
|
||||
else do
|
||||
h <- openBinaryFile file ReadMode
|
||||
reopenable <- hIsSeekable h
|
||||
return (h, not reopenable)
|
||||
|
||||
hSetBinaryMode handle True
|
||||
contents <- decodeString <$> hGetContents handle -- closes handle
|
||||
|
||||
seq (length contents) $
|
||||
return (contents, shouldCache)
|
||||
|
||||
-- Decode a char8 string into a utf8 string, with fallback on
|
||||
-- ISO-8859-1. This avoids depending on additional libraries.
|
||||
decodeString = decode
|
||||
where
|
||||
decode [] = []
|
||||
decode (c:rest) | isAscii c = c : decode rest
|
||||
decode (c:rest) =
|
||||
let num = (fromIntegral $ ord c) :: Int
|
||||
next = case num of
|
||||
_ | num >= 0xF8 -> Nothing
|
||||
| num >= 0xF0 -> construct (num .&. 0x07) 3 rest
|
||||
| num >= 0xE0 -> construct (num .&. 0x0F) 2 rest
|
||||
| num >= 0xC0 -> construct (num .&. 0x1F) 1 rest
|
||||
| True -> Nothing
|
||||
in
|
||||
case next of
|
||||
Just (n, remainder) -> chr n : decode remainder
|
||||
Nothing -> c : decode rest
|
||||
|
||||
construct x 0 rest = do
|
||||
guard $ x <= 0x10FFFF
|
||||
return (x, rest)
|
||||
construct x n (c:rest) =
|
||||
let num = (fromIntegral $ ord c) :: Int in
|
||||
if num >= 0x80 && num <= 0xBF
|
||||
then construct ((x `shiftL` 6) .|. (num .&. 0x3f)) (n-1) rest
|
||||
else Nothing
|
||||
construct _ _ _ = Nothing
|
||||
|
||||
|
||||
verifyFiles files =
|
||||
when (null files) $ do
|
||||
printErr "No files specified.\n"
|
||||
printErr $ usageInfo usageHeader options
|
||||
throwError SyntaxFailure
|
||||
|
||||
printVersion = do
|
||||
putStrLn "ShellCheck - shell script analysis tool"
|
||||
putStrLn $ "version: " ++ shellcheckVersion
|
||||
putStrLn "license: GNU General Public License, version 3"
|
||||
putStrLn "website: https://www.shellcheck.net"
|
||||
|
||||
printOptional = do
|
||||
mapM f list
|
||||
where
|
||||
list = sortOn cdName ShellCheck.Analyzer.optionalChecks
|
||||
f item = do
|
||||
putStrLn $ "name: " ++ cdName item
|
||||
putStrLn $ "desc: " ++ cdDescription item
|
||||
putStrLn $ "example: " ++ cdPositive item
|
||||
putStrLn $ "fix: " ++ cdNegative item
|
||||
putStrLn ""
|
||||
934
shpell.hs
Normal file
934
shpell.hs
Normal file
|
|
@ -0,0 +1,934 @@
|
|||
{-# LANGUAGE NoMonomorphismRestriction #-}
|
||||
|
||||
-- Shpell Check, by Vidar 'koala_man' Holen
|
||||
-- Sorry about the code. It was a week's worth of hacking.
|
||||
|
||||
import Text.Parsec
|
||||
import Text.Parsec.Pos (initialPos)
|
||||
import Debug.Trace
|
||||
import Control.Monad
|
||||
import Data.Char
|
||||
import Data.List (isInfixOf, partition, sortBy, intercalate)
|
||||
import qualified Control.Monad.State as Ms
|
||||
import Data.Maybe
|
||||
import Prelude hiding (readList)
|
||||
import System.IO
|
||||
|
||||
|
||||
|
||||
backslash = char '\\'
|
||||
linefeed = char '\n'
|
||||
singleQuote = char '\''
|
||||
doubleQuote = char '"'
|
||||
variableStart = upper <|> lower <|> oneOf "_"
|
||||
variableChars = upper <|> lower <|> digit <|> oneOf "_"
|
||||
specialVariable = oneOf "@*#?-$!"
|
||||
tokenDelimiter = oneOf "&|;<> \t\n"
|
||||
quotable = oneOf "#|&;<>()$`\\ \"'\t\n"
|
||||
doubleQuotable = oneOf "\"$`"
|
||||
whitespace = oneOf " \t\n"
|
||||
linewhitespace = oneOf " \t"
|
||||
|
||||
spacing = do
|
||||
x <- many (many1 linewhitespace <|> (try $ string "\\\n"))
|
||||
optional readComment
|
||||
return $ concat x
|
||||
|
||||
allspacing = do
|
||||
spacing
|
||||
x <- option False ((linefeed <|> carriageReturn) >> return True)
|
||||
when x allspacing
|
||||
|
||||
carriageReturn = do
|
||||
parseNote ErrorC "Literal carriage return. Run script through tr -d '\\r' "
|
||||
char '\r'
|
||||
|
||||
|
||||
--------- Message/position annotation on top of user state
|
||||
data Annotated a = Annotated SourcePos [Note] a deriving (Show, Eq)
|
||||
data Note = ParseNote SourcePos Severity String | Note Severity String deriving (Show, Eq)
|
||||
data MessageStack = StackNode Note MessageStack | StackMark String SourcePos MessageStack | StackEmpty
|
||||
data ParseProblem = ParseProblem SourcePos Severity String deriving (Show, Eq)
|
||||
data OutputNote = OutputNote SourcePos Severity String deriving (Show, Eq)
|
||||
data Severity = ErrorC | WarningC | InfoC | StyleC deriving (Show, Eq, Ord)
|
||||
|
||||
instance Functor Annotated where
|
||||
fmap f (Annotated p n a) = Annotated p n (f a)
|
||||
|
||||
markStack msg = do
|
||||
pos <- getPosition
|
||||
modifyState (StackMark msg pos)
|
||||
|
||||
getMessages r (StackMark _ _ s) = (r, s)
|
||||
getMessages r (StackNode n s) = getMessages (n:r) s
|
||||
popStack = do
|
||||
f <- getState
|
||||
let (notes, stack) = getMessages [] f
|
||||
putState stack
|
||||
return notes
|
||||
|
||||
-- Store potential parse problems outside of parsec
|
||||
parseProblem level msg = do
|
||||
pos <- getPosition
|
||||
parseProblemAt pos level msg
|
||||
|
||||
parseProblemAt pos level msg = do
|
||||
Ms.modify ((ParseProblem pos level msg):)
|
||||
|
||||
pushNote n = modifyState (StackNode n)
|
||||
|
||||
parseNote l a = do
|
||||
pos <- getPosition
|
||||
parseNoteAt pos l a
|
||||
|
||||
parseNoteAt pos l a = pushNote $ ParseNote pos l a
|
||||
|
||||
|
||||
annotated msg parser = do
|
||||
pos <- getPosition
|
||||
markStack msg
|
||||
result <- parser
|
||||
messages <- popStack
|
||||
return $ Annotated pos messages result
|
||||
|
||||
dropAnnotation (Annotated _ _ s) = s
|
||||
blankAnnotation pos t = Annotated pos [] t
|
||||
|
||||
merge (Annotated pos messages result) = do
|
||||
mapM pushNote messages
|
||||
return result
|
||||
|
||||
merging p = p >>= merge
|
||||
|
||||
getOutputNotes (Annotated p notes _) = map (makeOutputNote p) notes
|
||||
|
||||
makeOutputNote _ (ParseNote p l s) = OutputNote p l s
|
||||
makeOutputNote p (Note l s) = OutputNote p l s
|
||||
|
||||
--------- Convenient combinators
|
||||
|
||||
thenSkip main follow = do
|
||||
r <- main
|
||||
optional follow
|
||||
return r
|
||||
|
||||
disregard x = x >> return ()
|
||||
|
||||
reluctantlyTill p end = do -- parse p until end <|> eof matches ahead
|
||||
(lookAhead ((disregard $ try end) <|> eof) >> return []) <|> do
|
||||
x <- p
|
||||
more <- reluctantlyTill p end
|
||||
return $ x:more
|
||||
<|> return []
|
||||
|
||||
reluctantlyTill1 p end = do
|
||||
notFollowedBy end
|
||||
x <- p
|
||||
more <- reluctantlyTill p end
|
||||
return $ x:more
|
||||
|
||||
attempting rest branch = do
|
||||
((try branch) >> rest) <|> rest
|
||||
|
||||
wasIncluded p = option False (p >> return True)
|
||||
|
||||
-- Horrifying AST
|
||||
data Token = T_AND_IF | T_OR_IF | T_DSEMI | T_Semi | T_DLESS | T_DGREAT | T_LESSAND | T_GREATAND | T_LESSGREAT | T_DLESSDASH | T_CLOBBER | T_If | T_Then | T_Else | T_Elif | T_Fi | T_Do | T_Done | T_Case | T_Esac | T_While | T_Until | T_For | T_Lbrace | T_Rbrace | T_Lparen | T_Rparen | T_Bang | T_In | T_NEWLINE | T_EOF | T_Less | T_Greater | T_SingleQuoted String | T_Literal String | T_NormalWord [Annotated Token] | T_DoubleQuoted [Annotated Token] | T_DollarExpansion [Token] | T_DollarBraced String | T_DollarVariable String | T_DollarArithmetic String | T_BraceExpansion String | T_IoFile Token Token | T_HereDoc Bool Bool String | T_HereString Token | T_FdRedirect String Token | T_Assignment String Token | T_Redirecting [Annotated Token] Token | T_SimpleCommand [Annotated Token] [Annotated Token] | T_Pipeline [Annotated Token] | T_Banged Token | T_AndIf (Annotated Token) (Annotated Token) | T_OrIf (Annotated Token) (Annotated Token) | T_Backgrounded Token | T_IfExpression [([Token],[Token])] [Token] | T_Subshell [Token] | T_BraceGroup [Token] | T_WhileExpression [Token] [Token] | T_UntilExpression [Token] [Token] | T_ForIn String [Token] [Token] | T_CaseExpression Token [([Token],[Token])] |T_Function String Token | T_Command (Annotated Token) | T_Script [Token]
|
||||
deriving (Show)
|
||||
|
||||
extractNotes' list = modifyFlag ((++) $ concatMap getOutputNotes list) >> return ()
|
||||
extractNotes (T_NormalWord list) = extractNotes' list
|
||||
extractNotes (T_DoubleQuoted list) = extractNotes' list
|
||||
extractNotes (T_Redirecting list f) = extractNotes' list
|
||||
extractNotes (T_Pipeline list) = extractNotes' list
|
||||
extractNotes (T_Command list) = extractNotes' [list]
|
||||
extractNotes (T_SimpleCommand list1 list2) = do
|
||||
extractNotes' list1
|
||||
extractNotes' list2
|
||||
extractNotes t = return ()
|
||||
|
||||
|
||||
postMessage level s = Ms.modify $ \(x, l) -> (x, Note level s : l)
|
||||
warn s = postMessage WarningC s
|
||||
inform s = postMessage InfoC s
|
||||
style s = postMessage StyleC s
|
||||
|
||||
|
||||
putFlag v = modifyFlag (const v) >> return ()
|
||||
getFlag = modifyFlag id
|
||||
modifyFlag f = do
|
||||
Ms.modify $ \(x, l) -> (f x, l)
|
||||
v <- Ms.get
|
||||
return $ fst v
|
||||
|
||||
|
||||
analyzeScopes f i = mapM (analyzeScope f i)
|
||||
analyzeScope f i (Annotated pos notes t) = do
|
||||
v <- getFlag
|
||||
let (ret, (flag, list)) = Ms.runState (analyze f i t) (v, [])
|
||||
putFlag flag
|
||||
return $ Annotated pos (notes++list) ret
|
||||
|
||||
analyze f i s@(T_NormalWord list) = do
|
||||
f s
|
||||
a <- analyzeScopes f i list
|
||||
return . i $ T_NormalWord a
|
||||
|
||||
analyze f i s@(T_DoubleQuoted list) = do
|
||||
f s
|
||||
a <- analyzeScopes f i list
|
||||
return . i $ T_DoubleQuoted a
|
||||
|
||||
analyze f i s@(T_DollarExpansion l) = do
|
||||
f s
|
||||
nl <- mapM (analyze f i) l
|
||||
return . i $ T_DollarExpansion nl
|
||||
|
||||
analyze f i s@(T_IoFile op file) = do
|
||||
f s
|
||||
a <- analyze f i op
|
||||
b <- analyze f i file
|
||||
return . i $ T_IoFile a b
|
||||
|
||||
analyze f i s@(T_HereString word) = do
|
||||
f s
|
||||
a <- analyze f i word
|
||||
return . i $ T_HereString a
|
||||
|
||||
analyze f i s@(T_FdRedirect v t) = do
|
||||
f s
|
||||
a <- analyze f i t
|
||||
return . i $ T_FdRedirect v a
|
||||
|
||||
analyze f i s@(T_Assignment v t) = do
|
||||
f s
|
||||
a <- analyze f i t
|
||||
return . i $ T_Assignment v a
|
||||
|
||||
analyze f i s@(T_Redirecting redirs cmd) = do
|
||||
f s
|
||||
newRedirs <- analyzeScopes f i redirs
|
||||
newCmd <- analyze f i $ cmd
|
||||
return . i $ (T_Redirecting newRedirs newCmd)
|
||||
|
||||
analyze f i s@(T_SimpleCommand vars cmds) = do
|
||||
f s
|
||||
a <- analyzeScopes f i vars
|
||||
b <- analyzeScopes f i cmds
|
||||
return . i $ T_SimpleCommand a b
|
||||
|
||||
analyze f i s@(T_Pipeline l) = do
|
||||
f s
|
||||
a <- analyzeScopes f i l
|
||||
return . i $ T_Pipeline a
|
||||
|
||||
analyze f i s@(T_Banged l) = do
|
||||
f s
|
||||
a <- analyze f i l
|
||||
return . i $ T_Banged a
|
||||
|
||||
analyze f i s@(T_AndIf t u) = do
|
||||
f s
|
||||
a <- analyzeScope f i t
|
||||
b <- analyzeScope f i u
|
||||
return . i $ T_AndIf a b
|
||||
|
||||
analyze f i s@(T_OrIf t u) = do
|
||||
f s
|
||||
a <- analyzeScope f i t
|
||||
b <- analyzeScope f i u
|
||||
return . i $ T_OrIf a b
|
||||
|
||||
analyze f i s@(T_Backgrounded l) = do
|
||||
f s
|
||||
a <- analyze f i l
|
||||
return . i $ T_Backgrounded a
|
||||
|
||||
analyze f i s@(T_IfExpression conditions elses) = do
|
||||
f s
|
||||
newConds <- mapM (\(c, t) -> do
|
||||
x <- mapM (analyze f i) c
|
||||
y <- mapM (analyze f i) t
|
||||
return (x, y)
|
||||
) conditions
|
||||
newElses <- mapM (analyze f i) elses
|
||||
return . i $ T_IfExpression newConds newElses
|
||||
|
||||
analyze f i s@(T_Subshell l) = do
|
||||
f s
|
||||
a <- mapM (analyze f i) l
|
||||
return . i $ T_Subshell a
|
||||
|
||||
analyze f i s@(T_BraceGroup l) = do
|
||||
f s
|
||||
a <- mapM (analyze f i) l
|
||||
return . i $ T_BraceGroup a
|
||||
|
||||
analyze f i s@(T_WhileExpression c l) = do
|
||||
f s
|
||||
a <- mapM (analyze f i) c
|
||||
b <- mapM (analyze f i) l
|
||||
return . i $ T_WhileExpression a b
|
||||
|
||||
analyze f i s@(T_UntilExpression c l) = do
|
||||
f s
|
||||
a <- mapM (analyze f i) c
|
||||
b <- mapM (analyze f i) l
|
||||
return . i $ T_UntilExpression a b
|
||||
|
||||
analyze f i s@(T_ForIn v w l) = do
|
||||
f s
|
||||
a <- mapM (analyze f i) w
|
||||
b <- mapM (analyze f i) l
|
||||
return . i $ T_ForIn v a b
|
||||
|
||||
analyze f i s@(T_CaseExpression word cases) = do
|
||||
f s
|
||||
newWord <- analyze f i word
|
||||
newCases <- mapM (\(c, t) -> do
|
||||
x <- mapM (analyze f i) c
|
||||
y <- mapM (analyze f i) t
|
||||
return (x, y)
|
||||
) cases
|
||||
return . i $ T_CaseExpression newWord newCases
|
||||
|
||||
analyze f i s@(T_Script l) = do
|
||||
f s
|
||||
a <- mapM (analyze f i) l
|
||||
return . i $ T_Script a
|
||||
|
||||
analyze f i s@(T_Function name body) = do
|
||||
f s
|
||||
a <- analyze f i body
|
||||
return . i $ T_Function name a
|
||||
|
||||
analyze f i s@(T_Command c) = do
|
||||
f s
|
||||
a <- analyzeScope f i c
|
||||
return . i $ T_Command a
|
||||
|
||||
analyze f i t = do
|
||||
f t
|
||||
return . i $ t
|
||||
|
||||
doAnalysis f t = fst $ Ms.runState (analyze f id t) ((), [])
|
||||
explore f d t = fst . snd $ Ms.runState (analyze f id t) (d, [])
|
||||
transform i t = fst $ Ms.runState (analyze (const $ return ()) i t) ((), [])
|
||||
|
||||
findNotes t = explore extractNotes [] t
|
||||
sortNotes l = sortBy compareNotes l
|
||||
compareNotes (OutputNote pos1 level1 _) (OutputNote pos2 level2 _) = compare (pos1, level1) (pos2, level2)
|
||||
findParseNotes l = map (\(ParseProblem p level s) -> OutputNote p level s) l
|
||||
-- T_UntilExpression [Token] [Token] | T_ForIn String [Token] [Token]
|
||||
|
||||
getNotes s =
|
||||
case rp readScript s of
|
||||
(Right x, p) -> sortNotes $ (findNotes $ doAllAnalysis x) ++ (findParseNotes p)
|
||||
(Left _, p) -> sortNotes $ (OutputNote (initialPos "-") ErrorC "Parsing failed"):(findParseNotes p)
|
||||
|
||||
readComment = do
|
||||
char '#'
|
||||
anyChar `reluctantlyTill` linefeed
|
||||
|
||||
readNormalWord = do
|
||||
x <- many1 readNormalWordPart
|
||||
return $ T_NormalWord x
|
||||
|
||||
readNormalWordPart = readSingleQuoted <|> readDoubleQuoted <|> readDollar <|> readBraced <|> readBackTicked <|> (annotated "normal literal" $ readNormalLiteral)
|
||||
|
||||
readSingleQuoted = annotated "single quoted string" $ do
|
||||
singleQuote
|
||||
s <- readSingleQuotedPart `reluctantlyTill` singleQuote
|
||||
singleQuote <?> "End single quoted string"
|
||||
|
||||
let string = concat s
|
||||
return (T_SingleQuoted string) `attempting` do
|
||||
x <- lookAhead anyChar
|
||||
when (isAlpha x && isAlpha (last string)) $ parseProblem WarningC "This apostrophe terminated the single quoted string."
|
||||
|
||||
readSingleQuotedLiteral = do
|
||||
singleQuote
|
||||
strs <- many1 readSingleQuotedPart
|
||||
singleQuote
|
||||
return $ concat strs
|
||||
|
||||
readSingleQuotedPart =
|
||||
readSingleEscaped
|
||||
<|> anyChar `reluctantlyTill1` (singleQuote <|> backslash)
|
||||
|
||||
readBackTicked = annotated "backtick expansion" $ do
|
||||
parseNote StyleC "`..` style expansion is deprecated, use $(..) instead if you want my help"
|
||||
pos <- getPosition
|
||||
char '`'
|
||||
f <- readGenericLiteral (char '`')
|
||||
char '`' `attempting` (eof >> parseProblemAt pos ErrorC "Can't find terminating backtick for this one")
|
||||
return $ T_Literal f
|
||||
|
||||
|
||||
readDoubleQuoted = annotated "double quoted string" $ do
|
||||
doubleQuote
|
||||
x <- many doubleQuotedPart
|
||||
doubleQuote <?> "End double quoted"
|
||||
return $ T_DoubleQuoted x
|
||||
|
||||
doubleQuotedPart = readDoubleLiteral <|> readDollar <|> readBackTicked
|
||||
|
||||
readDoubleQuotedLiteral = do
|
||||
doubleQuote
|
||||
x <- readDoubleLiteral
|
||||
doubleQuote
|
||||
return $ dropAnnotation x
|
||||
|
||||
readDoubleLiteral = annotated "double literal" $ do
|
||||
s <- many1 readDoubleLiteralPart
|
||||
return $ T_Literal (concat s)
|
||||
|
||||
readDoubleLiteralPart = do
|
||||
x <- (readDoubleEscaped <|> (anyChar >>= \x -> return [x])) `reluctantlyTill1` doubleQuotable
|
||||
return $ concat x
|
||||
|
||||
readNormalLiteral = do
|
||||
s <- many1 readNormalLiteralPart
|
||||
return $ T_Literal (concat s)
|
||||
|
||||
readNormalLiteralPart = do
|
||||
readNormalEscaped <|> (anyChar `reluctantlyTill1` quotable)
|
||||
|
||||
readNormalEscaped = do
|
||||
backslash
|
||||
pos <- getPosition
|
||||
do
|
||||
next <- (quotable <|> oneOf "?*[]")
|
||||
return $ if next == '\n' then "" else [next]
|
||||
<|>
|
||||
do
|
||||
next <- anyChar <?> "No character after \\"
|
||||
parseNoteAt pos WarningC $ "This character doesn't need escaping here, the \\ is ignored"
|
||||
return [next]
|
||||
|
||||
readSingleEscaped = do
|
||||
s <- backslash
|
||||
let attempt level p msg = do { try $ parseNote level msg; x <- p; return [s,x]; }
|
||||
|
||||
do {
|
||||
x <- singleQuote;
|
||||
parseProblem InfoC "Are you trying to escape a single quote? echo 'You'\\''re doing it wrong'.";
|
||||
return [s,x];
|
||||
}
|
||||
<|> attempt InfoC linefeed "You don't break lines with \\ in single quotes, it results in literal backslash-linefeed."
|
||||
<|> do
|
||||
x <- anyChar
|
||||
return [s,x]
|
||||
|
||||
|
||||
readDoubleEscaped = do
|
||||
bs <- backslash
|
||||
(linefeed >> return "")
|
||||
<|> (doubleQuotable >>= return . return)
|
||||
<|> (anyChar >>= (return . \x -> [bs, x]))
|
||||
|
||||
|
||||
readGenericLiteral endExp = do
|
||||
strings <- many (readGenericEscaped <|> anyChar `reluctantlyTill1` endExp)
|
||||
return $ concat strings
|
||||
|
||||
readGenericLiteral1 endExp = do
|
||||
strings <- many1 (readGenericEscaped <|> anyChar `reluctantlyTill1` endExp)
|
||||
return $ concat strings
|
||||
|
||||
readGenericEscaped = do
|
||||
backslash
|
||||
x <- anyChar
|
||||
return $ if x == '\n' then [] else [x]
|
||||
|
||||
readBraced = annotated "{1,2..3} expression" $ try $ do
|
||||
let strip (T_Literal s) = return ("\"" ++ s ++ "\"")
|
||||
char '{'
|
||||
str <- many1 ((readDoubleQuotedLiteral >>= (strip )) <|> readGenericLiteral1 (oneOf "}" <|> whitespace))
|
||||
char '}'
|
||||
return $ T_BraceExpansion $ concat str
|
||||
|
||||
readDollar = readDollarArithmetic <|> readDollarBraced <|> readDollarExpansion <|> readDollarVariable <|> readDollarLonely
|
||||
|
||||
|
||||
readParenLiteralHack = do
|
||||
strs <- ((anyChar >>= \x -> return [x]) <|> readParenHack) `reluctantlyTill1` (string "))")
|
||||
return $ concat strs
|
||||
|
||||
readParenHack = do
|
||||
char '('
|
||||
x <- many anyChar
|
||||
char ')'
|
||||
return $ "(" ++ x ++ ")"
|
||||
|
||||
readDollarArithmetic = annotated "$(( )) expression" $ do
|
||||
try (string "$((")
|
||||
-- TODO
|
||||
str <- readParenLiteralHack
|
||||
string "))"
|
||||
return (T_DollarArithmetic str)
|
||||
|
||||
readDollarBraced = annotated "${ } expression" $ do
|
||||
try (string "${")
|
||||
-- TODO
|
||||
str <- readGenericLiteral (char '}')
|
||||
char '}' <?> "matching }"
|
||||
return $ (T_DollarBraced str)
|
||||
|
||||
readDollarExpansion = annotated "$( )" $ do
|
||||
try (string "$(")
|
||||
cmds <- readCompoundList
|
||||
char ')'
|
||||
return $ (T_DollarExpansion cmds)
|
||||
|
||||
readDollarVariable = annotated "$variable" $ do
|
||||
let singleCharred p = do
|
||||
n <- p
|
||||
return (T_DollarVariable [n]) `attempting` do
|
||||
pos <- getPosition
|
||||
num <- lookAhead $ many1 p
|
||||
parseNoteAt pos ErrorC $ "$" ++ (n:num) ++ " is equivalent to ${" ++ [n] ++ "}"++ num
|
||||
|
||||
let positional = singleCharred digit
|
||||
let special = singleCharred specialVariable
|
||||
|
||||
let regular = do
|
||||
name <- readVariableName
|
||||
return $ T_DollarVariable (name)
|
||||
|
||||
char '$'
|
||||
positional <|> special <|> regular
|
||||
|
||||
readVariableName = do
|
||||
f <- variableStart
|
||||
rest <- many variableChars
|
||||
return (f:rest)
|
||||
|
||||
readDollarLonely = annotated "lonely $" $ do
|
||||
parseNote ErrorC "$ is not used specially and should therefore be escaped"
|
||||
char '$'
|
||||
return $ T_Literal "$"
|
||||
|
||||
readHereDoc = annotated "here document" $ do
|
||||
let stripLiteral (T_Literal x) = x
|
||||
stripLiteral (T_SingleQuoted x) = x
|
||||
try $ string "<<"
|
||||
dashed <- (char '-' >> return True) <|> return False
|
||||
tokenPosition <- getPosition
|
||||
spacing
|
||||
(quoted, endToken) <- (readNormalLiteral >>= (\x -> return (False, stripLiteral x)) )
|
||||
<|> (readDoubleQuotedLiteral >>= return . (\x -> (True, stripLiteral x)))
|
||||
<|> (readSingleQuotedLiteral >>= return . (\x -> (True, x)))
|
||||
spacing
|
||||
|
||||
hereInfo <- anyChar `reluctantlyTill` (linefeed >> spacing >> (string endToken) >> (disregard whitespace <|> eof))
|
||||
|
||||
do
|
||||
linefeed
|
||||
spaces <- spacing
|
||||
verifyHereDoc dashed quoted spaces hereInfo
|
||||
token <- string endToken
|
||||
return $ T_FdRedirect "" $ T_HereDoc dashed quoted hereInfo
|
||||
`attempting` (eof >> debugHereDoc tokenPosition endToken hereInfo)
|
||||
|
||||
verifyHereDoc dashed quoted spacing hereInfo = do
|
||||
when (not dashed && spacing /= "") $ parseNote ErrorC "When using << instead of <<-, the end tokens can't be indented"
|
||||
when (dashed && filter (/= '\t') spacing /= "" ) $ parseNote ErrorC "When using <<-, you can only indent with tabs"
|
||||
return ()
|
||||
|
||||
debugHereDoc pos endToken doc =
|
||||
if endToken `isInfixOf` doc
|
||||
then parseProblemAt pos ErrorC (endToken ++ " was part of the here document, but not by itself at the start of the line")
|
||||
else if (map toLower endToken) `isInfixOf` (map toLower doc)
|
||||
then parseProblemAt pos ErrorC (endToken ++ " appears in the here document, but with different case")
|
||||
else parseProblemAt pos ErrorC ("Couldn't find end token `" ++ endToken ++ "' in the here document ")
|
||||
|
||||
|
||||
readFilename = readNormalWord
|
||||
readIoFileOp = choice [g_LESSAND, g_GREATAND, g_DGREAT, g_LESSGREAT, g_CLOBBER, string "<" >> return T_Less, string ">" >> return T_Greater ]
|
||||
readIoFile = do
|
||||
op <- readIoFileOp
|
||||
spacing
|
||||
file <- readFilename
|
||||
return $ T_FdRedirect "" $ T_IoFile op file
|
||||
readIoNumber = try $ do
|
||||
x <- many1 digit
|
||||
lookAhead readIoFileOp
|
||||
return x
|
||||
readIoNumberRedirect = annotated "fd io redirect" $ do
|
||||
n <- readIoNumber
|
||||
op <- merging readHereString <|> merging readHereDoc <|> readIoFile
|
||||
let actualOp = case op of T_FdRedirect "" x -> x
|
||||
spacing
|
||||
return $ T_FdRedirect n actualOp
|
||||
|
||||
readIoRedirect = annotated "io redirect" $ choice [ merging readIoNumberRedirect, merging readHereString, merging readHereDoc, readIoFile ] `thenSkip` spacing
|
||||
|
||||
readRedirectList = many1 readIoRedirect
|
||||
|
||||
readHereString = annotated "here string" $ do
|
||||
try $ string "<<<"
|
||||
spacing
|
||||
word <- readNormalWord
|
||||
return $ T_FdRedirect "" $ T_HereString word
|
||||
|
||||
readNewlineList = many1 ((newline <|> carriageReturn) `thenSkip` spacing)
|
||||
readLineBreak = optional readNewlineList
|
||||
|
||||
readSeparatorOp = do
|
||||
notFollowedBy (g_AND_IF <|> g_DSEMI)
|
||||
f <- char ';' <|> char '&'
|
||||
spacing
|
||||
return f
|
||||
|
||||
readSequentialSep = (disregard $ g_Semi >> readLineBreak) <|> (disregard readNewlineList)
|
||||
readSeparator =
|
||||
do
|
||||
separator <- readSeparatorOp
|
||||
readLineBreak
|
||||
return separator
|
||||
<|>
|
||||
do
|
||||
readNewlineList
|
||||
return '\n'
|
||||
|
||||
makeSimpleCommand tokens =
|
||||
let (assignment, rest) = partition (\x -> case dropAnnotation x of T_Assignment _ _ -> True; _ -> False) tokens
|
||||
in let (redirections, rest2) = partition (\x -> case dropAnnotation x of T_FdRedirect _ _ -> True; _ -> False) rest
|
||||
in T_Redirecting redirections $ T_SimpleCommand assignment rest2
|
||||
|
||||
readSimpleCommand = annotated "simple command" $ do
|
||||
prefix <- option [] readCmdPrefix
|
||||
cmd <- option [] $ do { f <- annotated "command name" readCmdName; return [f]; }
|
||||
when (null prefix && null cmd) $ fail "No command"
|
||||
if null cmd
|
||||
then return $ makeSimpleCommand prefix
|
||||
else do
|
||||
suffix <- option [] readCmdSuffix
|
||||
return $ makeSimpleCommand (prefix ++ cmd ++ suffix)
|
||||
|
||||
readPipeline = annotated "Pipeline" $ do
|
||||
notFollowedBy $ try readKeyword
|
||||
do
|
||||
g_Bang `thenSkip` spacing
|
||||
pipe <- readPipeSequence
|
||||
return $ T_Banged pipe
|
||||
<|> do
|
||||
readPipeSequence
|
||||
|
||||
readAndOr = (flip (>>=)) (return . T_Command) $ chainr1 readPipeline $ do
|
||||
pos <- getPosition
|
||||
op <- g_AND_IF <|> g_OR_IF
|
||||
readLineBreak
|
||||
return $ \a b ->
|
||||
blankAnnotation pos $
|
||||
case op of T_AND_IF -> T_AndIf a b
|
||||
T_OR_IF -> T_OrIf a b
|
||||
|
||||
readTerm = do
|
||||
m <- readAndOr
|
||||
readTerm' m
|
||||
|
||||
readTerm' current =
|
||||
do
|
||||
sep <- readSeparator
|
||||
more <- (option T_EOF $ readAndOr)
|
||||
case more of T_EOF -> return [transformWithSeparator sep current]
|
||||
_ -> do
|
||||
list <- readTerm' more
|
||||
return $ (transformWithSeparator sep current : list)
|
||||
<|>
|
||||
return [current]
|
||||
|
||||
transformWithSeparator '&' = T_Backgrounded
|
||||
transformWithSeparator _ = id
|
||||
|
||||
|
||||
readPipeSequence = do
|
||||
list <- readCommand `sepBy1` (readPipe `thenSkip` (spacing >> readLineBreak))
|
||||
spacing
|
||||
return $ T_Pipeline list
|
||||
|
||||
readPipe = do
|
||||
notFollowedBy g_OR_IF
|
||||
char '|' `thenSkip` spacing
|
||||
|
||||
readCommand = (readCompoundCommand <|> readSimpleCommand)
|
||||
|
||||
readCmdName = do
|
||||
f <- readNormalWord
|
||||
spacing
|
||||
return f
|
||||
|
||||
readCmdWord = do
|
||||
f <- readNormalWord
|
||||
spacing
|
||||
return f
|
||||
|
||||
readIfClause = annotated "if statement" $ do
|
||||
(condition, action) <- readIfPart
|
||||
elifs <- many readElifPart
|
||||
elses <- option [] readElsePart
|
||||
g_Fi
|
||||
return $ T_IfExpression ((condition, action):elifs) elses
|
||||
|
||||
readIfPart = do
|
||||
g_If
|
||||
allspacing
|
||||
condition <- readTerm
|
||||
g_Then
|
||||
allspacing
|
||||
action <- readTerm
|
||||
return (condition, action)
|
||||
|
||||
readElifPart = do
|
||||
g_Elif
|
||||
allspacing
|
||||
condition <- readTerm
|
||||
g_Then
|
||||
allspacing
|
||||
action <- readTerm
|
||||
return (condition, action)
|
||||
|
||||
readElsePart = do
|
||||
g_Else
|
||||
allspacing
|
||||
readTerm
|
||||
|
||||
readSubshell = annotated "subshell group" $ do
|
||||
char '('
|
||||
allspacing
|
||||
list <- readCompoundList
|
||||
allspacing
|
||||
char ')'
|
||||
return $ T_Subshell list
|
||||
|
||||
readBraceGroup = annotated "brace group" $ do
|
||||
char '{'
|
||||
allspacing
|
||||
list <- readTerm
|
||||
allspacing
|
||||
char '}'
|
||||
return $ T_BraceGroup list
|
||||
|
||||
readWhileClause = annotated "while loop" $ do
|
||||
g_While
|
||||
condition <- readTerm
|
||||
statements <- readDoGroup
|
||||
return $ T_WhileExpression condition statements
|
||||
|
||||
readUntilClause = annotated "until loop" $ do
|
||||
g_Until
|
||||
condition <- readTerm
|
||||
statements <- readDoGroup
|
||||
return $ T_UntilExpression condition statements
|
||||
|
||||
readDoGroup = do
|
||||
pos <- getPosition
|
||||
g_Do
|
||||
allspacing
|
||||
(eof >> return []) <|>
|
||||
do
|
||||
commands <- readCompoundList
|
||||
disregard g_Done <|> eof -- stunted support
|
||||
return commands
|
||||
<|> do
|
||||
parseProblemAt pos ErrorC "Can't find the 'done' for this 'do'"
|
||||
fail "No done"
|
||||
|
||||
readForClause = annotated "for loop" $ do
|
||||
g_For
|
||||
spacing
|
||||
name <- readVariableName
|
||||
allspacing
|
||||
values <- readInClause <|> (readSequentialSep >> return [])
|
||||
group <- readDoGroup <|> (allspacing >> eof >> return []) -- stunted support
|
||||
return $ T_ForIn name values group
|
||||
|
||||
readInClause = do
|
||||
g_In
|
||||
things <- (readCmdWord) `reluctantlyTill`
|
||||
(disregard (g_Semi) <|> disregard linefeed <|> disregard g_Do)
|
||||
|
||||
do {
|
||||
lookAhead (g_Do);
|
||||
parseNote ErrorC "You need a line feed or semicolon before the 'do' (in Bash)";
|
||||
} <|> do {
|
||||
optional $ g_Semi;
|
||||
disregard allspacing;
|
||||
}
|
||||
|
||||
return things
|
||||
|
||||
readCaseClause = annotated "case statement" $ do
|
||||
g_Case
|
||||
word <- readNormalWord
|
||||
spacing
|
||||
g_In
|
||||
readLineBreak
|
||||
list <- readCaseList
|
||||
g_Esac
|
||||
return $ T_CaseExpression word list
|
||||
|
||||
readCaseList = many readCaseItem
|
||||
|
||||
readCaseItem = do
|
||||
notFollowedBy g_Esac
|
||||
optional g_Lparen
|
||||
spacing
|
||||
pattern <- readPattern
|
||||
g_Rparen
|
||||
readLineBreak
|
||||
list <- ((lookAhead g_DSEMI >> return []) <|> readCompoundList)
|
||||
(g_DSEMI <|> lookAhead (readLineBreak >> g_Esac))
|
||||
readLineBreak
|
||||
return (pattern, list)
|
||||
|
||||
readFunctionDefinition = annotated "function definition" $ do
|
||||
name <- try readFunctionSignature
|
||||
allspacing
|
||||
(disregard (lookAhead g_Lbrace) <|> parseProblem ErrorC "Expected a { to open the function definition")
|
||||
group <- merging readBraceGroup
|
||||
return $ T_Function name group
|
||||
|
||||
|
||||
readFunctionSignature = do
|
||||
(optional $ try (string "function " >> parseNote StyleC "Don't use 'function' in front of function definitions"))
|
||||
name <- readVariableName
|
||||
spacing
|
||||
g_Lparen
|
||||
g_Rparen
|
||||
return name
|
||||
|
||||
|
||||
readPattern = (readNormalWord `thenSkip` spacing) `sepBy1` (char '|' `thenSkip` spacing)
|
||||
|
||||
|
||||
readCompoundCommand = annotated "compound command" $ do
|
||||
cmd <- merging $ choice [ readBraceGroup, readSubshell, readWhileClause, readUntilClause, readIfClause, readForClause, readCaseClause, readFunctionDefinition]
|
||||
spacing
|
||||
redirs <- many readIoRedirect
|
||||
return $ T_Redirecting redirs $ cmd
|
||||
|
||||
|
||||
readCompoundList = readTerm
|
||||
|
||||
readCmdPrefix = many1 (readIoRedirect <|> readAssignmentWord)
|
||||
readCmdSuffix = many1 (readIoRedirect <|> annotated "normal word" readCmdWord)
|
||||
|
||||
readAssignmentWord = annotated "assignment" $ try $ do
|
||||
optional (char '$' >> parseNote ErrorC "Don't use $ on the left side of assignments")
|
||||
variable <- readVariableName
|
||||
space <- spacing
|
||||
pos <- getPosition
|
||||
char '='
|
||||
space2 <- spacing
|
||||
value <- readNormalWord
|
||||
spacing
|
||||
when (space ++ space2 /= "") $ parseNoteAt pos ErrorC "Don't put spaces around the = in assignments"
|
||||
return $ T_Assignment variable value
|
||||
|
||||
|
||||
tryToken s t = try (string s >> spacing >> return t)
|
||||
tryWordToken s t = tryParseWordToken (string s) t `thenSkip` spacing
|
||||
tryParseWordToken parser t = try (parser >> (lookAhead (eof <|> disregard whitespace))) >> return t
|
||||
|
||||
g_AND_IF = tryToken "&&" T_AND_IF
|
||||
g_OR_IF = tryToken "||" T_OR_IF
|
||||
g_DSEMI = tryToken ";;" T_DSEMI
|
||||
g_DLESS = tryToken "<<" T_DLESS
|
||||
g_DGREAT = tryToken ">>" T_DGREAT
|
||||
g_LESSAND = tryToken "<&" T_LESSAND
|
||||
g_GREATAND = tryToken ">&" T_GREATAND
|
||||
g_LESSGREAT = tryToken "<>" T_LESSGREAT
|
||||
g_DLESSDASH = tryToken "<<-" T_DLESSDASH
|
||||
g_CLOBBER = tryToken ">|" T_CLOBBER
|
||||
g_OPERATOR = g_AND_IF <|> g_OR_IF <|> g_DSEMI <|> g_DLESSDASH <|> g_DLESS <|> g_DGREAT <|> g_LESSAND <|> g_GREATAND <|> g_LESSGREAT
|
||||
|
||||
g_If = tryWordToken "if" T_If
|
||||
g_Then = tryWordToken "then" T_Then
|
||||
g_Else = tryWordToken "else" T_Else
|
||||
g_Elif = tryWordToken "elif" T_Elif
|
||||
g_Fi = tryWordToken "fi" T_Fi
|
||||
g_Do = tryWordToken "do" T_Do
|
||||
g_Done = tryWordToken "done" T_Done
|
||||
g_Case = tryWordToken "case" T_Case
|
||||
g_Esac = tryWordToken "esac" T_Esac
|
||||
g_While = tryWordToken "while" T_While
|
||||
g_Until = tryWordToken "until" T_Until
|
||||
g_For = tryWordToken "for" T_For
|
||||
g_In = tryWordToken "in" T_In
|
||||
g_Lbrace = tryWordToken "{" T_Lbrace
|
||||
g_Rbrace = tryWordToken "}" T_Rbrace
|
||||
|
||||
g_Lparen = tryToken "(" T_Lparen
|
||||
g_Rparen = tryToken ")" T_Rparen
|
||||
g_Bang = tryToken "!" T_Bang
|
||||
|
||||
g_Semi = do
|
||||
notFollowedBy g_DSEMI
|
||||
tryToken ";" T_Semi
|
||||
|
||||
readKeyword = choice [ g_Then, g_Else, g_Elif, g_Fi, g_Do, g_Done, g_Esac, g_Rbrace, g_Rparen, g_DSEMI ]
|
||||
|
||||
ifParse p t f = do
|
||||
(lookAhead (try p) >> t) <|> f
|
||||
|
||||
wtf = do
|
||||
x <- many anyChar
|
||||
parseProblem ErrorC x
|
||||
|
||||
readScript = do
|
||||
do {
|
||||
allspacing;
|
||||
commands <- readTerm;
|
||||
eof <|> (parseProblem WarningC "Stopping here, because I can't parse this command");
|
||||
return $ T_Script commands;
|
||||
} <|> do {
|
||||
parseProblem WarningC "Couldn't read any commands";
|
||||
wtf;
|
||||
return T_EOF;
|
||||
}
|
||||
|
||||
shpell s = rp readScript s
|
||||
rp p s = Ms.runState (runParserT p StackEmpty "-" s) []
|
||||
|
||||
-------- Destructively simplify AST
|
||||
|
||||
simplify (T_Redirecting [] t) = t
|
||||
simplify (T_Pipeline [x]) = dropAnnotation x
|
||||
simplify (T_NormalWord [x]) = dropAnnotation x
|
||||
simplify t = t
|
||||
|
||||
-------- Analytics
|
||||
doAllAnalysis t = foldl (\v f -> doAnalysis f v) t checks
|
||||
|
||||
getAst s = case rp readScript s of (Right parsed, _) -> parsed
|
||||
getAst2 s = case rp readScript s of (Right parsed, _) -> transform simplify parsed
|
||||
lol (Right x, _) = x
|
||||
|
||||
deadSimple (T_NormalWord l) = [concat (concatMap (deadSimple . dropAnnotation) l)]
|
||||
deadSimple (T_DoubleQuoted l) = ["\"" ++(concat (concatMap (deadSimple . dropAnnotation) l)) ++ "\""]
|
||||
deadSimple (T_SingleQuoted s) = [s]
|
||||
deadSimple (T_DollarVariable _) = ["${VAR}"]
|
||||
deadSimple (T_DollarBraced _) = ["${VAR}"]
|
||||
deadSimple (T_DollarArithmetic _) = ["${VAR}"]
|
||||
deadSimple (T_DollarExpansion _) = ["${VAR}"]
|
||||
deadSimple (T_Literal x) = [x]
|
||||
deadSimple (T_SimpleCommand vars words) = concatMap (deadSimple . dropAnnotation) words
|
||||
deadSimple (T_Redirecting _ foo) = deadSimple foo
|
||||
deadSimple _ = []
|
||||
|
||||
|
||||
checks = [checkUuoc]
|
||||
checkUuoc (T_Pipeline ((Annotated _ _ x):_:_)) = case (deadSimple x) of ["cat", _] -> style "UUOC: Instead of 'cat a | b', use 'b < a'"
|
||||
_ -> return ()
|
||||
checkUuoc _ = return ()
|
||||
|
||||
|
||||
main = do
|
||||
s <- getContents
|
||||
-- case rp readScript s of (Right parsed, _) -> putStrLn . show $ transform simplify parsed
|
||||
-- (Left x, y) -> putStrLn $ "Can't parse: " ++ (show (x,y))
|
||||
|
||||
mapM (putStrLn . show) $ getNotes s
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
name: shellcheck
|
||||
summary: A shell script static analysis tool
|
||||
description: |
|
||||
ShellCheck is a GPLv3 tool that gives warnings and suggestions for bash/sh
|
||||
shell scripts.
|
||||
|
||||
The goals of ShellCheck are
|
||||
|
||||
- To point out and clarify typical beginner's syntax issues that cause a
|
||||
shell to give cryptic error messages.
|
||||
|
||||
- To point out and clarify typical intermediate level semantic problems that
|
||||
cause a shell to behave strangely and counter-intuitively.
|
||||
|
||||
- To point out subtle caveats, corner cases and pitfalls that may cause an
|
||||
advanced user's otherwise working script to fail under future
|
||||
circumstances.
|
||||
|
||||
By default ShellCheck can only check non-hidden files under /home, to make
|
||||
ShellCheck be able to check files under /media and /run/media you must
|
||||
connect it to the `removable-media` interface manually:
|
||||
|
||||
# snap connect shellcheck:removable-media
|
||||
|
||||
version: git
|
||||
base: core24
|
||||
grade: stable
|
||||
confinement: strict
|
||||
|
||||
apps:
|
||||
shellcheck:
|
||||
command: usr/bin/shellcheck
|
||||
plugs: [home, removable-media]
|
||||
environment:
|
||||
LANG: C.UTF-8
|
||||
|
||||
parts:
|
||||
shellcheck:
|
||||
plugin: dump
|
||||
source: .
|
||||
build-packages:
|
||||
- cabal-install
|
||||
override-build: |
|
||||
# Give ourselves enough memory to build
|
||||
fallocate -l 2G /tmp/swap
|
||||
chmod 0600 /tmp/swap
|
||||
mkswap /tmp/swap
|
||||
if ! swapon /tmp/swap; then
|
||||
echo "Could not enable swap file, continuing anyway"
|
||||
rm /tmp/swap
|
||||
fi
|
||||
|
||||
cabal update
|
||||
cabal install -j
|
||||
|
||||
install -d "${CRAFT_PART_INSTALL}/usr/bin"
|
||||
install --strip ~/.cabal/bin/shellcheck "${CRAFT_PART_INSTALL}/usr/bin"
|
||||
|
|
@ -1,289 +0,0 @@
|
|||
{-
|
||||
Copyright 2012-2019 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
{-# LANGUAGE DeriveGeneric, DeriveAnyClass, DeriveTraversable, PatternSynonyms #-}
|
||||
module ShellCheck.AST where
|
||||
|
||||
import GHC.Generics (Generic)
|
||||
import Control.Monad.Identity
|
||||
import Control.DeepSeq
|
||||
import Text.Parsec
|
||||
import qualified ShellCheck.Regex as Re
|
||||
import Prelude hiding (id)
|
||||
|
||||
newtype Id = Id Int deriving (Show, Eq, Ord, Generic, NFData)
|
||||
|
||||
data Quoted = Quoted | Unquoted deriving (Show, Eq)
|
||||
data Dashed = Dashed | Undashed deriving (Show, Eq)
|
||||
data Piped = Piped | Unpiped deriving (Show, Eq)
|
||||
data AssignmentMode = Assign | Append deriving (Show, Eq)
|
||||
newtype FunctionKeyword = FunctionKeyword Bool deriving (Show, Eq)
|
||||
newtype FunctionParentheses = FunctionParentheses Bool deriving (Show, Eq)
|
||||
data CaseType = CaseBreak | CaseFallThrough | CaseContinue deriving (Show, Eq)
|
||||
|
||||
newtype Root = Root Token
|
||||
data Token = OuterToken Id (InnerToken Token) deriving (Show)
|
||||
|
||||
data InnerToken t =
|
||||
Inner_TA_Binary String t t
|
||||
| Inner_TA_Assignment String t t
|
||||
| Inner_TA_Variable String [t]
|
||||
| Inner_TA_Expansion [t]
|
||||
| Inner_TA_Sequence [t]
|
||||
| Inner_TA_Parenthesis t
|
||||
| Inner_TA_Trinary t t t
|
||||
| Inner_TA_Unary String t
|
||||
| Inner_TC_And ConditionType String t t
|
||||
| Inner_TC_Binary ConditionType String t t
|
||||
| Inner_TC_Group ConditionType t
|
||||
| Inner_TC_Nullary ConditionType t
|
||||
| Inner_TC_Or ConditionType String t t
|
||||
| Inner_TC_Unary ConditionType String t
|
||||
| Inner_TC_Empty ConditionType
|
||||
| Inner_T_AND_IF
|
||||
| Inner_T_AndIf t t
|
||||
| Inner_T_Arithmetic t
|
||||
| Inner_T_Array [t]
|
||||
| Inner_T_IndexedElement [t] t
|
||||
-- Store the index as string, and parse as arithmetic or string later
|
||||
| Inner_T_UnparsedIndex SourcePos String
|
||||
| Inner_T_Assignment AssignmentMode String [t] t
|
||||
| Inner_T_Backgrounded t
|
||||
| Inner_T_Backticked [t]
|
||||
| Inner_T_Bang
|
||||
| Inner_T_Banged t
|
||||
| Inner_T_BraceExpansion [t]
|
||||
| Inner_T_BraceGroup [t]
|
||||
| Inner_T_CLOBBER
|
||||
| Inner_T_Case
|
||||
| Inner_T_CaseExpression t [(CaseType, [t], [t])]
|
||||
| Inner_T_Condition ConditionType t
|
||||
| Inner_T_DGREAT
|
||||
| Inner_T_DLESS
|
||||
| Inner_T_DLESSDASH
|
||||
| Inner_T_DSEMI
|
||||
| Inner_T_Do
|
||||
| Inner_T_DollarArithmetic t
|
||||
| Inner_T_DollarBraced Bool t
|
||||
| Inner_T_DollarBracket t
|
||||
| Inner_T_DollarDoubleQuoted [t]
|
||||
| Inner_T_DollarExpansion [t]
|
||||
| Inner_T_DollarSingleQuoted String
|
||||
| Inner_T_DollarBraceCommandExpansion Piped [t]
|
||||
| Inner_T_Done
|
||||
| Inner_T_DoubleQuoted [t]
|
||||
| Inner_T_EOF
|
||||
| Inner_T_Elif
|
||||
| Inner_T_Else
|
||||
| Inner_T_Esac
|
||||
| Inner_T_Extglob String [t]
|
||||
| Inner_T_FdRedirect String t
|
||||
| Inner_T_Fi
|
||||
| Inner_T_For
|
||||
| Inner_T_ForArithmetic t t t [t]
|
||||
| Inner_T_ForIn String [t] [t]
|
||||
| Inner_T_Function FunctionKeyword FunctionParentheses String t
|
||||
| Inner_T_GREATAND
|
||||
| Inner_T_Glob String
|
||||
| Inner_T_Greater
|
||||
| Inner_T_HereDoc Dashed Quoted String [t]
|
||||
| Inner_T_HereString t
|
||||
| Inner_T_If
|
||||
| Inner_T_IfExpression [([t],[t])] [t]
|
||||
| Inner_T_In
|
||||
| Inner_T_IoFile t t
|
||||
| Inner_T_IoDuplicate t String
|
||||
| Inner_T_LESSAND
|
||||
| Inner_T_LESSGREAT
|
||||
| Inner_T_Lbrace
|
||||
| Inner_T_Less
|
||||
| Inner_T_Literal String
|
||||
| Inner_T_Lparen
|
||||
| Inner_T_NEWLINE
|
||||
| Inner_T_NormalWord [t]
|
||||
| Inner_T_OR_IF
|
||||
| Inner_T_OrIf t t
|
||||
| Inner_T_ParamSubSpecialChar String -- e.g. '%' in ${foo%bar} or '/' in ${foo/bar/baz}
|
||||
| Inner_T_Pipeline [t] [t] -- [Pipe separators] [Commands]
|
||||
| Inner_T_ProcSub String [t]
|
||||
| Inner_T_Rbrace
|
||||
| Inner_T_Redirecting [t] t
|
||||
| Inner_T_Rparen
|
||||
| Inner_T_Script t [t] -- Shebang T_Literal, followed by script.
|
||||
| Inner_T_Select
|
||||
| Inner_T_SelectIn String [t] [t]
|
||||
| Inner_T_Semi
|
||||
| Inner_T_SimpleCommand [t] [t]
|
||||
| Inner_T_SingleQuoted String
|
||||
| Inner_T_Subshell [t]
|
||||
| Inner_T_Then
|
||||
| Inner_T_Until
|
||||
| Inner_T_UntilExpression [t] [t]
|
||||
| Inner_T_While
|
||||
| Inner_T_WhileExpression [t] [t]
|
||||
| Inner_T_Annotation [Annotation] t
|
||||
| Inner_T_Pipe String
|
||||
| Inner_T_CoProc (Maybe Token) t
|
||||
| Inner_T_CoProcBody t
|
||||
| Inner_T_Include t
|
||||
| Inner_T_SourceCommand t t
|
||||
| Inner_T_BatsTest String t
|
||||
deriving (Show, Eq, Functor, Foldable, Traversable)
|
||||
|
||||
data Annotation =
|
||||
DisableComment Integer Integer -- [from, to)
|
||||
| EnableComment String
|
||||
| SourceOverride String
|
||||
| ShellOverride String
|
||||
| SourcePath String
|
||||
| ExternalSources Bool
|
||||
| ExtendedAnalysis Bool
|
||||
deriving (Show, Eq)
|
||||
data ConditionType = DoubleBracket | SingleBracket deriving (Show, Eq)
|
||||
|
||||
pattern T_AND_IF id = OuterToken id Inner_T_AND_IF
|
||||
pattern T_Bang id = OuterToken id Inner_T_Bang
|
||||
pattern T_Case id = OuterToken id Inner_T_Case
|
||||
pattern TC_Empty id typ = OuterToken id (Inner_TC_Empty typ)
|
||||
pattern T_CLOBBER id = OuterToken id Inner_T_CLOBBER
|
||||
pattern T_DGREAT id = OuterToken id Inner_T_DGREAT
|
||||
pattern T_DLESS id = OuterToken id Inner_T_DLESS
|
||||
pattern T_DLESSDASH id = OuterToken id Inner_T_DLESSDASH
|
||||
pattern T_Do id = OuterToken id Inner_T_Do
|
||||
pattern T_DollarSingleQuoted id str = OuterToken id (Inner_T_DollarSingleQuoted str)
|
||||
pattern T_Done id = OuterToken id Inner_T_Done
|
||||
pattern T_DSEMI id = OuterToken id Inner_T_DSEMI
|
||||
pattern T_Elif id = OuterToken id Inner_T_Elif
|
||||
pattern T_Else id = OuterToken id Inner_T_Else
|
||||
pattern T_EOF id = OuterToken id Inner_T_EOF
|
||||
pattern T_Esac id = OuterToken id Inner_T_Esac
|
||||
pattern T_Fi id = OuterToken id Inner_T_Fi
|
||||
pattern T_For id = OuterToken id Inner_T_For
|
||||
pattern T_Glob id str = OuterToken id (Inner_T_Glob str)
|
||||
pattern T_GREATAND id = OuterToken id Inner_T_GREATAND
|
||||
pattern T_Greater id = OuterToken id Inner_T_Greater
|
||||
pattern T_If id = OuterToken id Inner_T_If
|
||||
pattern T_In id = OuterToken id Inner_T_In
|
||||
pattern T_Lbrace id = OuterToken id Inner_T_Lbrace
|
||||
pattern T_Less id = OuterToken id Inner_T_Less
|
||||
pattern T_LESSAND id = OuterToken id Inner_T_LESSAND
|
||||
pattern T_LESSGREAT id = OuterToken id Inner_T_LESSGREAT
|
||||
pattern T_Literal id str = OuterToken id (Inner_T_Literal str)
|
||||
pattern T_Lparen id = OuterToken id Inner_T_Lparen
|
||||
pattern T_NEWLINE id = OuterToken id Inner_T_NEWLINE
|
||||
pattern T_OR_IF id = OuterToken id Inner_T_OR_IF
|
||||
pattern T_ParamSubSpecialChar id str = OuterToken id (Inner_T_ParamSubSpecialChar str)
|
||||
pattern T_Pipe id str = OuterToken id (Inner_T_Pipe str)
|
||||
pattern T_Rbrace id = OuterToken id Inner_T_Rbrace
|
||||
pattern T_Rparen id = OuterToken id Inner_T_Rparen
|
||||
pattern T_Select id = OuterToken id Inner_T_Select
|
||||
pattern T_Semi id = OuterToken id Inner_T_Semi
|
||||
pattern T_SingleQuoted id str = OuterToken id (Inner_T_SingleQuoted str)
|
||||
pattern T_Then id = OuterToken id Inner_T_Then
|
||||
pattern T_UnparsedIndex id pos str = OuterToken id (Inner_T_UnparsedIndex pos str)
|
||||
pattern T_Until id = OuterToken id Inner_T_Until
|
||||
pattern T_While id = OuterToken id Inner_T_While
|
||||
pattern TA_Assignment id op t1 t2 = OuterToken id (Inner_TA_Assignment op t1 t2)
|
||||
pattern TA_Binary id op t1 t2 = OuterToken id (Inner_TA_Binary op t1 t2)
|
||||
pattern TA_Expansion id t = OuterToken id (Inner_TA_Expansion t)
|
||||
pattern T_AndIf id t u = OuterToken id (Inner_T_AndIf t u)
|
||||
pattern T_Annotation id anns t = OuterToken id (Inner_T_Annotation anns t)
|
||||
pattern T_Arithmetic id c = OuterToken id (Inner_T_Arithmetic c)
|
||||
pattern T_Array id t = OuterToken id (Inner_T_Array t)
|
||||
pattern TA_Sequence id l = OuterToken id (Inner_TA_Sequence l)
|
||||
pattern TA_Parenthesis id t = OuterToken id (Inner_TA_Parenthesis t)
|
||||
pattern T_Assignment id mode var indices value = OuterToken id (Inner_T_Assignment mode var indices value)
|
||||
pattern TA_Trinary id t1 t2 t3 = OuterToken id (Inner_TA_Trinary t1 t2 t3)
|
||||
pattern TA_Unary id op t1 = OuterToken id (Inner_TA_Unary op t1)
|
||||
pattern TA_Variable id str t = OuterToken id (Inner_TA_Variable str t)
|
||||
pattern T_Backgrounded id l = OuterToken id (Inner_T_Backgrounded l)
|
||||
pattern T_Backticked id list = OuterToken id (Inner_T_Backticked list)
|
||||
pattern T_Banged id l = OuterToken id (Inner_T_Banged l)
|
||||
pattern T_BatsTest id name t = OuterToken id (Inner_T_BatsTest name t)
|
||||
pattern T_BraceExpansion id list = OuterToken id (Inner_T_BraceExpansion list)
|
||||
pattern T_BraceGroup id l = OuterToken id (Inner_T_BraceGroup l)
|
||||
pattern TC_And id typ str t1 t2 = OuterToken id (Inner_TC_And typ str t1 t2)
|
||||
pattern T_CaseExpression id word cases = OuterToken id (Inner_T_CaseExpression word cases)
|
||||
pattern TC_Binary id typ op lhs rhs = OuterToken id (Inner_TC_Binary typ op lhs rhs)
|
||||
pattern TC_Group id typ token = OuterToken id (Inner_TC_Group typ token)
|
||||
pattern TC_Nullary id typ token = OuterToken id (Inner_TC_Nullary typ token)
|
||||
pattern T_Condition id typ token = OuterToken id (Inner_T_Condition typ token)
|
||||
pattern T_CoProcBody id t = OuterToken id (Inner_T_CoProcBody t)
|
||||
pattern T_CoProc id var body = OuterToken id (Inner_T_CoProc var body)
|
||||
pattern TC_Or id typ str t1 t2 = OuterToken id (Inner_TC_Or typ str t1 t2)
|
||||
pattern TC_Unary id typ op token = OuterToken id (Inner_TC_Unary typ op token)
|
||||
pattern T_DollarArithmetic id c = OuterToken id (Inner_T_DollarArithmetic c)
|
||||
pattern T_DollarBraceCommandExpansion id pipe list = OuterToken id (Inner_T_DollarBraceCommandExpansion pipe list)
|
||||
pattern T_DollarBraced id braced op = OuterToken id (Inner_T_DollarBraced braced op)
|
||||
pattern T_DollarBracket id c = OuterToken id (Inner_T_DollarBracket c)
|
||||
pattern T_DollarDoubleQuoted id list = OuterToken id (Inner_T_DollarDoubleQuoted list)
|
||||
pattern T_DollarExpansion id list = OuterToken id (Inner_T_DollarExpansion list)
|
||||
pattern T_DoubleQuoted id list = OuterToken id (Inner_T_DoubleQuoted list)
|
||||
pattern T_Extglob id str l = OuterToken id (Inner_T_Extglob str l)
|
||||
pattern T_FdRedirect id v t = OuterToken id (Inner_T_FdRedirect v t)
|
||||
pattern T_ForArithmetic id a b c group = OuterToken id (Inner_T_ForArithmetic a b c group)
|
||||
pattern T_ForIn id v w l = OuterToken id (Inner_T_ForIn v w l)
|
||||
pattern T_Function id a b name body = OuterToken id (Inner_T_Function a b name body)
|
||||
pattern T_HereDoc id d q str l = OuterToken id (Inner_T_HereDoc d q str l)
|
||||
pattern T_HereString id word = OuterToken id (Inner_T_HereString word)
|
||||
pattern T_IfExpression id conditions elses = OuterToken id (Inner_T_IfExpression conditions elses)
|
||||
pattern T_Include id script = OuterToken id (Inner_T_Include script)
|
||||
pattern T_IndexedElement id indices t = OuterToken id (Inner_T_IndexedElement indices t)
|
||||
pattern T_IoDuplicate id op num = OuterToken id (Inner_T_IoDuplicate op num)
|
||||
pattern T_IoFile id op file = OuterToken id (Inner_T_IoFile op file)
|
||||
pattern T_NormalWord id list = OuterToken id (Inner_T_NormalWord list)
|
||||
pattern T_OrIf id t u = OuterToken id (Inner_T_OrIf t u)
|
||||
pattern T_Pipeline id l1 l2 = OuterToken id (Inner_T_Pipeline l1 l2)
|
||||
pattern T_ProcSub id typ l = OuterToken id (Inner_T_ProcSub typ l)
|
||||
pattern T_Redirecting id redirs cmd = OuterToken id (Inner_T_Redirecting redirs cmd)
|
||||
pattern T_Script id shebang list = OuterToken id (Inner_T_Script shebang list)
|
||||
pattern T_SelectIn id v w l = OuterToken id (Inner_T_SelectIn v w l)
|
||||
pattern T_SimpleCommand id vars cmds = OuterToken id (Inner_T_SimpleCommand vars cmds)
|
||||
pattern T_SourceCommand id includer t_include = OuterToken id (Inner_T_SourceCommand includer t_include)
|
||||
pattern T_Subshell id l = OuterToken id (Inner_T_Subshell l)
|
||||
pattern T_UntilExpression id c l = OuterToken id (Inner_T_UntilExpression c l)
|
||||
pattern T_WhileExpression id c l = OuterToken id (Inner_T_WhileExpression c l)
|
||||
|
||||
{-# COMPLETE T_AND_IF, T_Bang, T_Case, TC_Empty, T_CLOBBER, T_DGREAT, T_DLESS, T_DLESSDASH, T_Do, T_DollarSingleQuoted, T_Done, T_DSEMI, T_Elif, T_Else, T_EOF, T_Esac, T_Fi, T_For, T_Glob, T_GREATAND, T_Greater, T_If, T_In, T_Lbrace, T_Less, T_LESSAND, T_LESSGREAT, T_Literal, T_Lparen, T_NEWLINE, T_OR_IF, T_ParamSubSpecialChar, T_Pipe, T_Rbrace, T_Rparen, T_Select, T_Semi, T_SingleQuoted, T_Then, T_UnparsedIndex, T_Until, T_While, TA_Assignment, TA_Binary, TA_Expansion, T_AndIf, T_Annotation, T_Arithmetic, T_Array, TA_Sequence, TA_Parenthesis, T_Assignment, TA_Trinary, TA_Unary, TA_Variable, T_Backgrounded, T_Backticked, T_Banged, T_BatsTest, T_BraceExpansion, T_BraceGroup, TC_And, T_CaseExpression, TC_Binary, TC_Group, TC_Nullary, T_Condition, T_CoProcBody, T_CoProc, TC_Or, TC_Unary, T_DollarArithmetic, T_DollarBraceCommandExpansion, T_DollarBraced, T_DollarBracket, T_DollarDoubleQuoted, T_DollarExpansion, T_DoubleQuoted, T_Extglob, T_FdRedirect, T_ForArithmetic, T_ForIn, T_Function, T_HereDoc, T_HereString, T_IfExpression, T_Include, T_IndexedElement, T_IoDuplicate, T_IoFile, T_NormalWord, T_OrIf, T_Pipeline, T_ProcSub, T_Redirecting, T_Script, T_SelectIn, T_SimpleCommand, T_SourceCommand, T_Subshell, T_UntilExpression, T_WhileExpression #-}
|
||||
|
||||
instance Eq Token where
|
||||
OuterToken _ a == OuterToken _ b = a == b
|
||||
|
||||
analyze :: Monad m => (Token -> m ()) -> (Token -> m ()) -> (Token -> m Token) -> Token -> m Token
|
||||
analyze f g i =
|
||||
round
|
||||
where
|
||||
round t@(OuterToken id it) = do
|
||||
f t
|
||||
newIt <- traverse round it
|
||||
g t
|
||||
i (OuterToken id newIt)
|
||||
|
||||
getId :: Token -> Id
|
||||
getId (OuterToken id _) = id
|
||||
|
||||
blank :: Monad m => Token -> m ()
|
||||
blank = const $ return ()
|
||||
doAnalysis :: Monad m => (Token -> m ()) -> Token -> m Token
|
||||
doAnalysis f = analyze f blank return
|
||||
doStackAnalysis :: Monad m => (Token -> m ()) -> (Token -> m ()) -> Token -> m Token
|
||||
doStackAnalysis startToken endToken = analyze startToken endToken return
|
||||
doTransform :: (Token -> Token) -> Token -> Token
|
||||
doTransform i = runIdentity . analyze blank blank (return . i)
|
||||
|
||||
|
|
@ -1,926 +0,0 @@
|
|||
{-
|
||||
Copyright 2012-2021 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
{-# LANGUAGE TemplateHaskell #-}
|
||||
module ShellCheck.ASTLib where
|
||||
|
||||
import ShellCheck.AST
|
||||
import ShellCheck.Prelude
|
||||
import ShellCheck.Regex
|
||||
|
||||
import Control.Monad.Writer
|
||||
import Control.Monad
|
||||
import Data.Char
|
||||
import Data.Functor
|
||||
import Data.Functor.Identity
|
||||
import Data.List
|
||||
import Data.Maybe
|
||||
import qualified Data.List.NonEmpty as NE
|
||||
import qualified Data.Map as Map
|
||||
import Numeric (showHex)
|
||||
|
||||
import Test.QuickCheck
|
||||
|
||||
arguments (T_SimpleCommand _ _ (cmd:args)) = args
|
||||
|
||||
-- Is this a type of loop?
|
||||
isLoop t = case t of
|
||||
T_WhileExpression {} -> True
|
||||
T_UntilExpression {} -> True
|
||||
T_ForIn {} -> True
|
||||
T_ForArithmetic {} -> True
|
||||
T_SelectIn {} -> True
|
||||
_ -> False
|
||||
|
||||
-- Will this split into multiple words when used as an argument?
|
||||
willSplit x =
|
||||
case x of
|
||||
T_DollarBraced {} -> True
|
||||
T_DollarExpansion {} -> True
|
||||
T_Backticked {} -> True
|
||||
T_BraceExpansion {} -> True
|
||||
T_Glob {} -> True
|
||||
T_Extglob {} -> True
|
||||
T_DoubleQuoted _ l -> any willBecomeMultipleArgs l
|
||||
T_NormalWord _ l -> any willSplit l
|
||||
_ -> False
|
||||
|
||||
isGlob t = case t of
|
||||
T_Extglob {} -> True
|
||||
T_Glob {} -> True
|
||||
T_NormalWord _ l -> any isGlob l || hasSplitRange l
|
||||
_ -> False
|
||||
where
|
||||
-- foo[x${var}y] gets parsed as foo,[,x,$var,y],
|
||||
-- so check if there's such an interval
|
||||
hasSplitRange l =
|
||||
let afterBracket = dropWhile (not . isHalfOpenRange) l
|
||||
in any isClosingRange afterBracket
|
||||
|
||||
isHalfOpenRange t =
|
||||
case t of
|
||||
T_Literal _ "[" -> True
|
||||
_ -> False
|
||||
|
||||
isClosingRange t =
|
||||
case t of
|
||||
T_Literal _ str -> ']' `elem` str
|
||||
_ -> False
|
||||
|
||||
|
||||
-- Is this shell word a constant?
|
||||
isConstant token =
|
||||
case token of
|
||||
-- This ignores some cases like ~"foo":
|
||||
T_NormalWord _ (T_Literal _ ('~':_) : _) -> False
|
||||
T_NormalWord _ l -> all isConstant l
|
||||
T_DoubleQuoted _ l -> all isConstant l
|
||||
T_SingleQuoted _ _ -> True
|
||||
T_Literal _ _ -> True
|
||||
_ -> False
|
||||
|
||||
-- Is this an empty literal?
|
||||
isEmpty token =
|
||||
case token of
|
||||
T_NormalWord _ l -> all isEmpty l
|
||||
T_DoubleQuoted _ l -> all isEmpty l
|
||||
T_SingleQuoted _ "" -> True
|
||||
T_Literal _ "" -> True
|
||||
_ -> False
|
||||
|
||||
-- Quick&lazy oversimplification of commands, throwing away details
|
||||
-- and returning a list like ["find", ".", "-name", "${VAR}*" ].
|
||||
oversimplify token =
|
||||
case token of
|
||||
(T_NormalWord _ l) -> [concat (concatMap oversimplify l)]
|
||||
(T_DoubleQuoted _ l) -> [concat (concatMap oversimplify l)]
|
||||
(T_SingleQuoted _ s) -> [s]
|
||||
(T_DollarBraced _ _ _) -> ["${VAR}"]
|
||||
(T_DollarArithmetic _ _) -> ["${VAR}"]
|
||||
(T_DollarExpansion _ _) -> ["${VAR}"]
|
||||
(T_Backticked _ _) -> ["${VAR}"]
|
||||
(T_Glob _ s) -> [s]
|
||||
(T_Pipeline _ _ [x]) -> oversimplify x
|
||||
(T_Literal _ x) -> [x]
|
||||
(T_ParamSubSpecialChar _ x) -> [x]
|
||||
(T_SimpleCommand _ vars words) -> concatMap oversimplify words
|
||||
(T_Redirecting _ _ foo) -> oversimplify foo
|
||||
(T_DollarSingleQuoted _ s) -> [s]
|
||||
(T_Annotation _ _ s) -> oversimplify s
|
||||
-- Workaround for let "foo = bar" parsing
|
||||
(TA_Sequence _ [TA_Expansion _ v]) -> concatMap oversimplify v
|
||||
_ -> []
|
||||
|
||||
|
||||
-- Turn a SimpleCommand foo -avz --bar=baz into args "a", "v", "z", "bar",
|
||||
-- each in a tuple of (token, stringFlag). Non-flag arguments are added with
|
||||
-- stringFlag == "".
|
||||
getFlagsUntil stopCondition (T_SimpleCommand _ _ (_:args)) =
|
||||
let tokenAndText = map (\x -> (x, concat $ oversimplify x)) args
|
||||
(flagArgs, rest) = break (stopCondition . snd) tokenAndText
|
||||
in
|
||||
concatMap flag flagArgs ++ map (\(t, _) -> (t, "")) rest
|
||||
where
|
||||
flag (x, '-':'-':arg) = [ (x, takeWhile (/= '=') arg) ]
|
||||
flag (x, '-':args) = map (\v -> (x, [v])) args
|
||||
flag (x, _) = [ (x, "") ]
|
||||
getFlagsUntil _ _ = error $ pleaseReport "getFlags on non-command"
|
||||
|
||||
-- Get all flags in a GNU way, up until --
|
||||
getAllFlags :: Token -> [(Token, String)]
|
||||
getAllFlags = getFlagsUntil (== "--")
|
||||
-- Get all flags in a BSD way, up until first non-flag argument or --
|
||||
getLeadingFlags = getFlagsUntil (\x -> x == "--" || (not $ "-" `isPrefixOf` x))
|
||||
|
||||
-- Check if a command has a flag.
|
||||
hasFlag cmd str = str `elem` (map snd $ getAllFlags cmd)
|
||||
|
||||
-- Is this token a word that starts with a dash?
|
||||
isFlag token =
|
||||
case getWordParts token of
|
||||
T_Literal _ ('-':_) : _ -> True
|
||||
_ -> False
|
||||
|
||||
-- Is this token a flag where the - is unquoted?
|
||||
isUnquotedFlag token =
|
||||
case getLeadingUnquotedString token of
|
||||
Just ('-':_) -> True
|
||||
_ -> False
|
||||
|
||||
-- getGnuOpts "erd:u:" will parse a list of arguments tokens like `read`
|
||||
-- -re -d : -u 3 bar
|
||||
-- into
|
||||
-- Just [("r", (-re, -re)), ("e", (-re, -re)), ("d", (-d,:)), ("u", (-u,3)), ("", (bar,bar))]
|
||||
--
|
||||
-- Each string flag maps to a tuple of (flag, argument), where argument=flag if it
|
||||
-- doesn't take a specific one.
|
||||
--
|
||||
-- Any unrecognized flag will result in Nothing. The exception is if arbitraryLongOpts
|
||||
-- is set, in which case --anything will map to "anything".
|
||||
getGnuOpts :: String -> [Token] -> Maybe [(String, (Token, Token))]
|
||||
getGnuOpts str args = getOpts (True, False) str [] args
|
||||
|
||||
-- As above, except the first non-arg string will treat the rest as arguments
|
||||
getBsdOpts :: String -> [Token] -> Maybe [(String, (Token, Token))]
|
||||
getBsdOpts str args = getOpts (False, False) str [] args
|
||||
|
||||
-- Tests for this are in Commands.hs where it's more frequently used
|
||||
getOpts ::
|
||||
-- Behavioral config: gnu style, allow arbitrary long options
|
||||
(Bool, Bool)
|
||||
-- A getopts style string
|
||||
-> String
|
||||
-- List of long options and whether they take arguments
|
||||
-> [(String, Bool)]
|
||||
-- List of arguments (excluding command)
|
||||
-> [Token]
|
||||
-- List of flags to tuple of (optionToken, valueToken)
|
||||
-> Maybe [(String, (Token, Token))]
|
||||
|
||||
getOpts (gnu, arbitraryLongOpts) string longopts args = process args
|
||||
where
|
||||
flagList (c:':':rest) = ([c], True) : flagList rest
|
||||
flagList (c:rest) = ([c], False) : flagList rest
|
||||
flagList [] = longopts
|
||||
flagMap = Map.fromList $ ("", False) : flagList string
|
||||
|
||||
process [] = return []
|
||||
process (token:rest) = do
|
||||
case getLiteralStringDef "\0" token of
|
||||
"--" -> return $ listToArgs rest
|
||||
'-':'-':word -> do
|
||||
let (name, arg) = span (/= '=') word
|
||||
needsArg <-
|
||||
if arbitraryLongOpts
|
||||
then return $ Map.findWithDefault False name flagMap
|
||||
else Map.lookup name flagMap
|
||||
|
||||
if needsArg && null arg
|
||||
then
|
||||
case rest of
|
||||
(arg:rest2) -> do
|
||||
more <- process rest2
|
||||
return $ (name, (token, arg)) : more
|
||||
_ -> fail "Missing arg"
|
||||
else do
|
||||
more <- process rest
|
||||
-- Consider splitting up token to get arg
|
||||
return $ (name, (token, token)) : more
|
||||
'-':opts -> shortToOpts opts token rest
|
||||
arg ->
|
||||
if gnu
|
||||
then do
|
||||
more <- process rest
|
||||
return $ ("", (token, token)):more
|
||||
else return $ listToArgs (token:rest)
|
||||
|
||||
shortToOpts opts token args =
|
||||
case opts of
|
||||
c:rest -> do
|
||||
needsArg <- Map.lookup [c] flagMap
|
||||
case () of
|
||||
_ | needsArg && null rest -> do
|
||||
(next:restArgs) <- return args
|
||||
more <- process restArgs
|
||||
return $ ([c], (token, next)):more
|
||||
_ | needsArg -> do
|
||||
more <- process args
|
||||
return $ ([c], (token, token)):more
|
||||
_ -> do
|
||||
more <- shortToOpts rest token args
|
||||
return $ ([c], (token, token)):more
|
||||
[] -> process args
|
||||
|
||||
listToArgs = map (\x -> ("", (x, x)))
|
||||
|
||||
|
||||
-- Generic getOpts that doesn't rely on a format string, but may also be inaccurate.
|
||||
-- This provides a best guess interpretation instead of failing when new options are added.
|
||||
--
|
||||
-- "--" is treated as end of arguments
|
||||
-- "--anything[=foo]" is treated as a long option without argument
|
||||
-- "-any" is treated as -a -n -y, with the next arg as an option to -y unless it starts with -
|
||||
-- anything else is an argument
|
||||
getGenericOpts :: [Token] -> [(String, (Token, Token))]
|
||||
getGenericOpts = process
|
||||
where
|
||||
process (token:rest) =
|
||||
case getLiteralStringDef "\0" token of
|
||||
"--" -> map (\c -> ("", (c,c))) rest
|
||||
'-':'-':word -> (takeWhile (`notElem` "\0=") word, (token, token)) : process rest
|
||||
'-':optString ->
|
||||
let opts = takeWhile (/= '\0') optString
|
||||
in
|
||||
case rest of
|
||||
next:_ | "-" `isPrefixOf` getLiteralStringDef "\0" next ->
|
||||
map (\c -> ([c], (token, token))) opts ++ process rest
|
||||
next:remainder ->
|
||||
case reverse opts of
|
||||
last:initial ->
|
||||
map (\c -> ([c], (token, token))) (reverse initial)
|
||||
++ [([last], (token, next))]
|
||||
++ process remainder
|
||||
[] -> process remainder
|
||||
[] -> map (\c -> ([c], (token, token))) opts
|
||||
_ -> ("", (token, token)) : process rest
|
||||
process [] = []
|
||||
|
||||
|
||||
-- Is this an expansion of multiple items of an array?
|
||||
isArrayExpansion (T_DollarBraced _ _ l) =
|
||||
let string = concat $ oversimplify l in
|
||||
"@" `isPrefixOf` string ||
|
||||
not ("#" `isPrefixOf` string) && "[@]" `isInfixOf` string
|
||||
isArrayExpansion _ = False
|
||||
|
||||
-- Is it possible that this arg becomes multiple args?
|
||||
mayBecomeMultipleArgs t = willBecomeMultipleArgs t || f False t
|
||||
where
|
||||
f quoted (T_DollarBraced _ _ l) =
|
||||
let string = concat $ oversimplify l in
|
||||
not quoted || "!" `isPrefixOf` string
|
||||
f quoted (T_DoubleQuoted _ parts) = any (f True) parts
|
||||
f quoted (T_NormalWord _ parts) = any (f quoted) parts
|
||||
f _ _ = False
|
||||
|
||||
-- Is it certain that this word will becomes multiple words?
|
||||
willBecomeMultipleArgs t = willConcatInAssignment t || f t
|
||||
where
|
||||
f T_Extglob {} = True
|
||||
f T_Glob {} = True
|
||||
f T_BraceExpansion {} = True
|
||||
f (T_NormalWord _ parts) = any f parts
|
||||
f _ = False
|
||||
|
||||
-- This does token cause implicit concatenation in assignments?
|
||||
willConcatInAssignment token =
|
||||
case token of
|
||||
t@T_DollarBraced {} -> isArrayExpansion t
|
||||
(T_DoubleQuoted _ parts) -> any willConcatInAssignment parts
|
||||
(T_NormalWord _ parts) -> any willConcatInAssignment parts
|
||||
_ -> False
|
||||
|
||||
-- Maybe get the literal string corresponding to this token
|
||||
getLiteralString :: Token -> Maybe String
|
||||
getLiteralString = getLiteralStringExt (const Nothing)
|
||||
|
||||
-- Definitely get a literal string, with a given default for all non-literals
|
||||
getLiteralStringDef :: String -> Token -> String
|
||||
getLiteralStringDef x = runIdentity . getLiteralStringExt (const $ return x)
|
||||
|
||||
-- Definitely get a literal string, skipping over all non-literals
|
||||
onlyLiteralString :: Token -> String
|
||||
onlyLiteralString = getLiteralStringDef ""
|
||||
|
||||
-- Maybe get a literal string, but only if it's an unquoted argument.
|
||||
getUnquotedLiteral (T_NormalWord _ list) =
|
||||
concat <$> mapM str list
|
||||
where
|
||||
str (T_Literal _ s) = return s
|
||||
str _ = Nothing
|
||||
getUnquotedLiteral _ = Nothing
|
||||
|
||||
isQuotes t =
|
||||
case t of
|
||||
T_DoubleQuoted {} -> True
|
||||
T_SingleQuoted {} -> True
|
||||
_ -> False
|
||||
|
||||
-- Get the last unquoted T_Literal in a word like "${var}foo"THIS
|
||||
-- or nothing if the word does not end in an unquoted literal.
|
||||
getTrailingUnquotedLiteral :: Token -> Maybe Token
|
||||
getTrailingUnquotedLiteral t =
|
||||
case t of
|
||||
(T_NormalWord _ list@(_:_)) ->
|
||||
from (last list)
|
||||
_ -> Nothing
|
||||
where
|
||||
from t =
|
||||
case t of
|
||||
T_Literal {} -> return t
|
||||
_ -> Nothing
|
||||
|
||||
-- Get the leading, unquoted, literal string of a token (if any).
|
||||
getLeadingUnquotedString :: Token -> Maybe String
|
||||
getLeadingUnquotedString t =
|
||||
case t of
|
||||
T_NormalWord _ ((T_Literal _ s) : rest) -> return $ s ++ from rest
|
||||
_ -> Nothing
|
||||
where
|
||||
from ((T_Literal _ s):rest) = s ++ from rest
|
||||
from _ = ""
|
||||
|
||||
-- Maybe get the literal string of this token and any globs in it.
|
||||
getGlobOrLiteralString = getLiteralStringExt f
|
||||
where
|
||||
f (T_Glob _ str) = return str
|
||||
f _ = Nothing
|
||||
|
||||
|
||||
prop_getLiteralString1 = getLiteralString (T_DollarSingleQuoted (Id 0) "\\x01") == Just "\1"
|
||||
prop_getLiteralString2 = getLiteralString (T_DollarSingleQuoted (Id 0) "\\xyz") == Just "\\xyz"
|
||||
prop_getLiteralString3 = getLiteralString (T_DollarSingleQuoted (Id 0) "\\x1") == Just "\x1"
|
||||
prop_getLiteralString4 = getLiteralString (T_DollarSingleQuoted (Id 0) "\\x1y") == Just "\x1y"
|
||||
prop_getLiteralString5 = getLiteralString (T_DollarSingleQuoted (Id 0) "\\xy") == Just "\\xy"
|
||||
prop_getLiteralString6 = getLiteralString (T_DollarSingleQuoted (Id 0) "\\x") == Just "\\x"
|
||||
prop_getLiteralString7 = getLiteralString (T_DollarSingleQuoted (Id 0) "\\1x") == Just "\1x"
|
||||
prop_getLiteralString8 = getLiteralString (T_DollarSingleQuoted (Id 0) "\\12x") == Just "\o12x"
|
||||
prop_getLiteralString9 = getLiteralString (T_DollarSingleQuoted (Id 0) "\\123x") == Just "\o123x"
|
||||
prop_getLiteralString10 = getLiteralString (T_DollarSingleQuoted (Id 0) "\\1234") == Just "\o123\&4"
|
||||
prop_getLiteralString11 = getLiteralString (T_DollarSingleQuoted (Id 0) "\\1") == Just "\1"
|
||||
prop_getLiteralString12 = getLiteralString (T_DollarSingleQuoted (Id 0) "\\12") == Just "\o12"
|
||||
prop_getLiteralString13 = getLiteralString (T_DollarSingleQuoted (Id 0) "\\123") == Just "\o123"
|
||||
|
||||
-- Maybe get the literal value of a token, using a custom function
|
||||
-- to map unrecognized Tokens into strings.
|
||||
getLiteralStringExt :: Monad m => (Token -> m String) -> Token -> m String
|
||||
getLiteralStringExt more = g
|
||||
where
|
||||
allInList = fmap concat . mapM g
|
||||
g (T_DoubleQuoted _ l) = allInList l
|
||||
g (T_DollarDoubleQuoted _ l) = allInList l
|
||||
g (T_NormalWord _ l) = allInList l
|
||||
g (TA_Expansion _ l) = allInList l
|
||||
g (T_SingleQuoted _ s) = return s
|
||||
g (T_Literal _ s) = return s
|
||||
g (T_ParamSubSpecialChar _ s) = return s
|
||||
g (T_DollarSingleQuoted _ s) = return $ decodeEscapes s
|
||||
g x = more x
|
||||
|
||||
-- Bash style $'..' decoding
|
||||
decodeEscapes ('\\':c:cs) =
|
||||
case c of
|
||||
'a' -> '\a' : rest
|
||||
'b' -> '\b' : rest
|
||||
'e' -> '\x1B' : rest
|
||||
'f' -> '\f' : rest
|
||||
'n' -> '\n' : rest
|
||||
'r' -> '\r' : rest
|
||||
't' -> '\t' : rest
|
||||
'v' -> '\v' : rest
|
||||
'\'' -> '\'' : rest
|
||||
'"' -> '"' : rest
|
||||
'\\' -> '\\' : rest
|
||||
'x' ->
|
||||
case cs of
|
||||
(x:y:more) | isHexDigit x && isHexDigit y ->
|
||||
chr (16*(digitToInt x) + (digitToInt y)) : decodeEscapes more
|
||||
(x:more) | isHexDigit x ->
|
||||
chr (digitToInt x) : decodeEscapes more
|
||||
more -> '\\' : 'x' : decodeEscapes more
|
||||
_ | isOctDigit c ->
|
||||
let (digits, more) = spanMax isOctDigit 3 (c:cs)
|
||||
num = (parseOct digits) `mod` 256
|
||||
in (chr num) : decodeEscapes more
|
||||
_ -> '\\' : c : rest
|
||||
where
|
||||
rest = decodeEscapes cs
|
||||
parseOct = f 0
|
||||
where
|
||||
f n "" = n
|
||||
f n (c:rest) = f (n * 8 + digitToInt c) rest
|
||||
spanMax f n list =
|
||||
let (first, second) = span f list
|
||||
(prefix, suffix) = splitAt n first
|
||||
in
|
||||
(prefix, suffix ++ second)
|
||||
decodeEscapes (c:cs) = c : decodeEscapes cs
|
||||
decodeEscapes [] = []
|
||||
|
||||
-- Is this token a string literal?
|
||||
isLiteral t = isJust $ getLiteralString t
|
||||
|
||||
-- Is this token a string literal number?
|
||||
isLiteralNumber t = fromMaybe False $ do
|
||||
s <- getLiteralString t
|
||||
guard $ all isDigit s
|
||||
return True
|
||||
|
||||
-- Escape user data for messages.
|
||||
-- Messages generally avoid repeating user data, but sometimes it's helpful.
|
||||
e4m = escapeForMessage
|
||||
escapeForMessage :: String -> String
|
||||
escapeForMessage str = concatMap f str
|
||||
where
|
||||
f '\\' = "\\\\"
|
||||
f '\n' = "\\n"
|
||||
f '\r' = "\\r"
|
||||
f '\t' = "\\t"
|
||||
f '\x1B' = "\\e"
|
||||
f c =
|
||||
if shouldEscape c
|
||||
then
|
||||
if ord c < 256
|
||||
then "\\x" ++ (pad0 2 $ toHex c)
|
||||
else "\\U" ++ (pad0 4 $ toHex c)
|
||||
else [c]
|
||||
|
||||
shouldEscape c =
|
||||
(not $ isPrint c)
|
||||
|| (not (isAscii c) && not (isLetter c))
|
||||
|
||||
pad0 :: Int -> String -> String
|
||||
pad0 n s =
|
||||
let l = length s in
|
||||
if l < n
|
||||
then (replicate (n-l) '0') ++ s
|
||||
else s
|
||||
toHex :: Char -> String
|
||||
toHex c = map toUpper $ showHex (ord c) ""
|
||||
|
||||
-- Turn a NormalWord like foo="bar $baz" into a series of constituent elements like [foo=,bar ,$baz]
|
||||
getWordParts (T_NormalWord _ l) = concatMap getWordParts l
|
||||
getWordParts (T_DoubleQuoted _ l) = l
|
||||
-- TA_Expansion is basically T_NormalWord for arithmetic expressions
|
||||
getWordParts (TA_Expansion _ l) = concatMap getWordParts l
|
||||
getWordParts other = [other]
|
||||
|
||||
-- Return a list of NormalWords that would result from brace expansion
|
||||
braceExpand (T_NormalWord id list) = take 1000 $ do
|
||||
items <- mapM part list
|
||||
return $ T_NormalWord id items
|
||||
where
|
||||
part (T_BraceExpansion id items) = do
|
||||
item <- items
|
||||
braceExpand item
|
||||
part x = return x
|
||||
|
||||
-- Maybe get a SimpleCommand from immediate wrappers like T_Redirections
|
||||
getCommand t =
|
||||
case t of
|
||||
T_Redirecting _ _ w -> getCommand w
|
||||
T_SimpleCommand _ _ (w:_) -> return t
|
||||
T_Annotation _ _ t -> getCommand t
|
||||
_ -> Nothing
|
||||
|
||||
-- Maybe get the command name string of a token representing a command
|
||||
getCommandName :: Token -> Maybe String
|
||||
getCommandName = fst . getCommandNameAndToken False
|
||||
|
||||
-- Maybe get the name+arguments of a command.
|
||||
getCommandArgv t = do
|
||||
(T_SimpleCommand _ _ args@(_:_)) <- getCommand t
|
||||
return args
|
||||
|
||||
-- Get the command name token from a command, i.e.
|
||||
-- the token representing 'ls' in 'ls -la 2> foo'.
|
||||
-- If it can't be determined, return the original token.
|
||||
getCommandTokenOrThis = snd . getCommandNameAndToken False
|
||||
|
||||
-- Given a command, get the string and token that represents the command name.
|
||||
-- If direct, return the actual command (e.g. exec in 'exec ls')
|
||||
-- If not, return the logical command (e.g. 'ls' in 'exec ls')
|
||||
|
||||
getCommandNameAndToken :: Bool -> Token -> (Maybe String, Token)
|
||||
getCommandNameAndToken direct t = fromMaybe (Nothing, t) $ do
|
||||
cmd@(T_SimpleCommand _ _ (w:rest)) <- getCommand t
|
||||
s <- getLiteralString w
|
||||
return $ fromMaybe (Just s, w) $ do
|
||||
guard $ not direct
|
||||
actual <- getEffectiveCommandToken s cmd rest
|
||||
return (getLiteralString actual, actual)
|
||||
where
|
||||
getEffectiveCommandToken str cmd args =
|
||||
let
|
||||
firstArg = do
|
||||
arg <- listToMaybe args
|
||||
guard . not $ isFlag arg
|
||||
return arg
|
||||
in
|
||||
case str of
|
||||
"busybox" -> firstArg
|
||||
"builtin" -> firstArg
|
||||
"command" -> firstArg
|
||||
"run" -> firstArg -- Used by bats
|
||||
"exec" -> do
|
||||
opts <- getBsdOpts "cla:" args
|
||||
(_, (t, _)) <- find (null . fst) opts
|
||||
return t
|
||||
_ -> fail ""
|
||||
|
||||
-- If a command substitution is a single command, get its name.
|
||||
-- $(date +%s) = Just "date"
|
||||
getCommandNameFromExpansion :: Token -> Maybe String
|
||||
getCommandNameFromExpansion t =
|
||||
case t of
|
||||
T_DollarExpansion _ [c] -> extract c
|
||||
T_Backticked _ [c] -> extract c
|
||||
T_DollarBraceCommandExpansion _ _ [c] -> extract c
|
||||
_ -> Nothing
|
||||
where
|
||||
extract (T_Pipeline _ _ [cmd]) = getCommandName cmd
|
||||
extract _ = Nothing
|
||||
|
||||
-- Get the basename of a token representing a command
|
||||
getCommandBasename = fmap basename . getCommandName
|
||||
|
||||
basename = reverse . takeWhile (/= '/') . reverse
|
||||
|
||||
isAssignment t =
|
||||
case t of
|
||||
T_Redirecting _ _ w -> isAssignment w
|
||||
T_SimpleCommand _ (w:_) [] -> True
|
||||
T_Assignment {} -> True
|
||||
T_Annotation _ _ w -> isAssignment w
|
||||
_ -> False
|
||||
|
||||
isOnlyRedirection t =
|
||||
case t of
|
||||
T_Pipeline _ _ [x] -> isOnlyRedirection x
|
||||
T_Annotation _ _ w -> isOnlyRedirection w
|
||||
T_Redirecting _ (_:_) c -> isOnlyRedirection c
|
||||
T_SimpleCommand _ [] [] -> True
|
||||
_ -> False
|
||||
|
||||
isFunction t = case t of T_Function {} -> True; _ -> False
|
||||
|
||||
-- Bats tests are functions for the purpose of 'local' and such
|
||||
isFunctionLike t =
|
||||
case t of
|
||||
T_Function {} -> True
|
||||
T_BatsTest {} -> True
|
||||
_ -> False
|
||||
|
||||
|
||||
isBraceExpansion t = case t of T_BraceExpansion {} -> True; _ -> False
|
||||
|
||||
-- Get the lists of commands from tokens that contain them, such as
|
||||
-- the conditions and bodies of while loops or branches of if statements.
|
||||
getCommandSequences :: Token -> [[Token]]
|
||||
getCommandSequences t =
|
||||
case t of
|
||||
T_Script _ _ cmds -> [cmds]
|
||||
T_BraceGroup _ cmds -> [cmds]
|
||||
T_Subshell _ cmds -> [cmds]
|
||||
T_WhileExpression _ cond cmds -> [cond, cmds]
|
||||
T_UntilExpression _ cond cmds -> [cond, cmds]
|
||||
T_ForIn _ _ _ cmds -> [cmds]
|
||||
T_ForArithmetic _ _ _ _ cmds -> [cmds]
|
||||
T_IfExpression _ thens elses -> (concatMap (\(a,b) -> [a,b]) thens) ++ [elses]
|
||||
T_Annotation _ _ t -> getCommandSequences t
|
||||
|
||||
T_DollarExpansion _ cmds -> [cmds]
|
||||
T_DollarBraceCommandExpansion _ _ cmds -> [cmds]
|
||||
T_Backticked _ cmds -> [cmds]
|
||||
_ -> []
|
||||
|
||||
-- Get a list of names of associative arrays
|
||||
getAssociativeArrays t =
|
||||
nub . execWriter $ doAnalysis f t
|
||||
where
|
||||
f :: Token -> Writer [String] ()
|
||||
f t@T_SimpleCommand {} = sequence_ $ do
|
||||
name <- getCommandName t
|
||||
let assocNames = ["declare","local","typeset"]
|
||||
guard $ name `elem` assocNames
|
||||
let flags = getAllFlags t
|
||||
guard $ "A" `elem` map snd flags
|
||||
let args = [arg | (arg, "") <- flags]
|
||||
let names = mapMaybe (getLiteralStringExt nameAssignments) args
|
||||
return $ tell names
|
||||
f _ = return ()
|
||||
|
||||
nameAssignments t =
|
||||
case t of
|
||||
T_Assignment _ _ name _ _ -> return name
|
||||
_ -> Nothing
|
||||
|
||||
-- A Pseudoglob is a wildcard pattern used for checking if a match can succeed.
|
||||
-- For example, [[ $(cmd).jpg == [a-z] ]] will give the patterns *.jpg and ?, which
|
||||
-- can be proven never to match.
|
||||
data PseudoGlob = PGAny | PGMany | PGChar Char
|
||||
deriving (Eq, Show)
|
||||
|
||||
-- Turn a word into a PG pattern, replacing all unknown/runtime values with
|
||||
-- PGMany.
|
||||
wordToPseudoGlob :: Token -> [PseudoGlob]
|
||||
wordToPseudoGlob = fromMaybe [PGMany] . wordToPseudoGlob' False
|
||||
|
||||
-- Turn a word into a PG pattern, but only if we can preserve
|
||||
-- exact semantics.
|
||||
wordToExactPseudoGlob :: Token -> Maybe [PseudoGlob]
|
||||
wordToExactPseudoGlob = wordToPseudoGlob' True
|
||||
|
||||
wordToPseudoGlob' :: Bool -> Token -> Maybe [PseudoGlob]
|
||||
wordToPseudoGlob' exact word =
|
||||
simplifyPseudoGlob <$> toGlob word
|
||||
where
|
||||
toGlob :: Token -> Maybe [PseudoGlob]
|
||||
toGlob word =
|
||||
case word of
|
||||
T_NormalWord _ (T_Literal _ ('~':str):rest) -> do
|
||||
guard $ not exact
|
||||
let this = (PGMany : (map PGChar $ dropWhile (/= '/') str))
|
||||
tail <- concat <$> (mapM f $ concatMap getWordParts rest)
|
||||
return $ this ++ tail
|
||||
_ -> concat <$> (mapM f $ getWordParts word)
|
||||
|
||||
f x = case x of
|
||||
T_Literal _ s -> return $ map PGChar s
|
||||
T_SingleQuoted _ s -> return $ map PGChar s
|
||||
T_Glob _ "?" -> return [PGAny]
|
||||
T_Glob _ "*" -> return [PGMany]
|
||||
T_Glob _ ('[':_) | not exact -> return [PGAny]
|
||||
_ -> if exact then fail "" else return [PGMany]
|
||||
|
||||
|
||||
-- Reorder a PseudoGlob for more efficient matching, e.g.
|
||||
-- f?*?**g -> f??*g
|
||||
simplifyPseudoGlob :: [PseudoGlob] -> [PseudoGlob]
|
||||
simplifyPseudoGlob = f
|
||||
where
|
||||
f [] = []
|
||||
f (x@(PGChar _) : rest ) = x : f rest
|
||||
f list =
|
||||
let (anys, rest) = span (\x -> x == PGMany || x == PGAny) list in
|
||||
order anys ++ f rest
|
||||
|
||||
order s = let (any, many) = partition (== PGAny) s in
|
||||
any ++ take 1 many
|
||||
|
||||
-- Check whether the two patterns can ever overlap.
|
||||
pseudoGlobsCanOverlap :: [PseudoGlob] -> [PseudoGlob] -> Bool
|
||||
pseudoGlobsCanOverlap = matchable
|
||||
where
|
||||
matchable x@(xf:xs) y@(yf:ys) =
|
||||
case (xf, yf) of
|
||||
(PGMany, _) -> matchable x ys || matchable xs y
|
||||
(_, PGMany) -> matchable x ys || matchable xs y
|
||||
(PGAny, _) -> matchable xs ys
|
||||
(_, PGAny) -> matchable xs ys
|
||||
(_, _) -> xf == yf && matchable xs ys
|
||||
|
||||
matchable [] [] = True
|
||||
matchable (PGMany : rest) [] = matchable rest []
|
||||
matchable (_:_) [] = False
|
||||
matchable [] r = matchable r []
|
||||
|
||||
-- Check whether the first pattern always overlaps the second.
|
||||
pseudoGlobIsSuperSetof :: [PseudoGlob] -> [PseudoGlob] -> Bool
|
||||
pseudoGlobIsSuperSetof = matchable
|
||||
where
|
||||
matchable x@(xf:xs) y@(yf:ys) =
|
||||
case (xf, yf) of
|
||||
(PGMany, PGMany) -> matchable x ys
|
||||
(PGMany, _) -> matchable x ys || matchable xs y
|
||||
(_, PGMany) -> False
|
||||
(PGAny, _) -> matchable xs ys
|
||||
(_, PGAny) -> False
|
||||
(_, _) -> xf == yf && matchable xs ys
|
||||
|
||||
matchable [] [] = True
|
||||
matchable (PGMany : rest) [] = matchable rest []
|
||||
matchable _ _ = False
|
||||
|
||||
wordsCanBeEqual x y = pseudoGlobsCanOverlap (wordToPseudoGlob x) (wordToPseudoGlob y)
|
||||
|
||||
-- Is this an expansion that can be quoted,
|
||||
-- e.g. $(foo) `foo` $foo (but not {foo,})?
|
||||
isQuoteableExpansion t = case t of
|
||||
T_DollarBraced {} -> True
|
||||
_ -> isCommandSubstitution t
|
||||
|
||||
isCommandSubstitution t = case t of
|
||||
T_DollarExpansion {} -> True
|
||||
T_DollarBraceCommandExpansion {} -> True
|
||||
T_Backticked {} -> True
|
||||
_ -> False
|
||||
|
||||
-- Is this an expansion that results in a simple string?
|
||||
isStringExpansion t = isCommandSubstitution t || case t of
|
||||
T_DollarArithmetic {} -> True
|
||||
T_DollarBraced {} -> not (isArrayExpansion t)
|
||||
_ -> False
|
||||
|
||||
-- Is this a T_Annotation that ignores a specific code?
|
||||
isAnnotationIgnoringCode code t =
|
||||
case t of
|
||||
T_Annotation _ anns _ -> any hasNum anns
|
||||
_ -> False
|
||||
where
|
||||
hasNum (DisableComment from to) = code >= from && code < to
|
||||
hasNum _ = False
|
||||
|
||||
prop_executableFromShebang1 = executableFromShebang "/bin/sh" == "sh"
|
||||
prop_executableFromShebang2 = executableFromShebang "/bin/bash" == "bash"
|
||||
prop_executableFromShebang3 = executableFromShebang "/usr/bin/env ksh" == "ksh"
|
||||
prop_executableFromShebang4 = executableFromShebang "/usr/bin/env -S foo=bar bash -x" == "bash"
|
||||
prop_executableFromShebang5 = executableFromShebang "/usr/bin/env --split-string=bash -x" == "bash"
|
||||
prop_executableFromShebang6 = executableFromShebang "/usr/bin/env --split-string=foo=bar bash -x" == "bash"
|
||||
prop_executableFromShebang7 = executableFromShebang "/usr/bin/env --split-string bash -x" == "bash"
|
||||
prop_executableFromShebang8 = executableFromShebang "/usr/bin/env --split-string foo=bar bash -x" == "bash"
|
||||
prop_executableFromShebang9 = executableFromShebang "/usr/bin/env foo=bar dash" == "dash"
|
||||
prop_executableFromShebang10 = executableFromShebang "/bin/busybox sh" == "busybox sh"
|
||||
prop_executableFromShebang11 = executableFromShebang "/bin/busybox ash" == "busybox ash"
|
||||
|
||||
-- Get the shell executable from a string like '/usr/bin/env bash'
|
||||
executableFromShebang :: String -> String
|
||||
executableFromShebang = shellFor
|
||||
where
|
||||
re = mkRegex "/env +(-S|--split-string=?)? *(.*)"
|
||||
shellFor s | s `matches` re =
|
||||
case matchRegex re s of
|
||||
Just [flag, shell] -> fromEnvArgs (words shell)
|
||||
_ -> ""
|
||||
shellFor sb =
|
||||
case words sb of
|
||||
[] -> ""
|
||||
[x] -> basename x
|
||||
(first:second:args) | basename first == "busybox" ->
|
||||
case basename second of
|
||||
"sh" -> "busybox sh"
|
||||
"ash" -> "busybox ash"
|
||||
x -> x
|
||||
(first:args) | basename first == "env" ->
|
||||
fromEnvArgs args
|
||||
(first:_) -> basename first
|
||||
|
||||
fromEnvArgs args = fromMaybe "" $ find (notElem '=') $ skipFlags args
|
||||
basename s = reverse . takeWhile (/= '/') . reverse $ s
|
||||
skipFlags = dropWhile ("-" `isPrefixOf`)
|
||||
|
||||
|
||||
-- Determining if a name is a variable
|
||||
isVariableStartChar x = x == '_' || isAsciiLower x || isAsciiUpper x
|
||||
isVariableChar x = isVariableStartChar x || isDigit x
|
||||
isSpecialVariableChar = (`elem` "*@#?-$!")
|
||||
variableNameRegex = mkRegex "[_a-zA-Z][_a-zA-Z0-9]*"
|
||||
|
||||
prop_isVariableName1 = isVariableName "_fo123"
|
||||
prop_isVariableName2 = not $ isVariableName "4"
|
||||
prop_isVariableName3 = not $ isVariableName "test: "
|
||||
isVariableName (x:r) = isVariableStartChar x && all isVariableChar r
|
||||
isVariableName _ = False
|
||||
|
||||
|
||||
-- Get the variable name from an expansion like ${var:-foo}
|
||||
prop_getBracedReference1 = getBracedReference "foo" == "foo"
|
||||
prop_getBracedReference2 = getBracedReference "#foo" == "foo"
|
||||
prop_getBracedReference3 = getBracedReference "#" == "#"
|
||||
prop_getBracedReference4 = getBracedReference "##" == "#"
|
||||
prop_getBracedReference5 = getBracedReference "#!" == "!"
|
||||
prop_getBracedReference6 = getBracedReference "!#" == "#"
|
||||
prop_getBracedReference7 = getBracedReference "!foo#?" == "foo"
|
||||
prop_getBracedReference8 = getBracedReference "foo-bar" == "foo"
|
||||
prop_getBracedReference9 = getBracedReference "foo:-bar" == "foo"
|
||||
prop_getBracedReference10 = getBracedReference "foo: -1" == "foo"
|
||||
prop_getBracedReference11 = getBracedReference "!os*" == ""
|
||||
prop_getBracedReference11b = getBracedReference "!os@" == ""
|
||||
prop_getBracedReference12 = getBracedReference "!os?bar**" == ""
|
||||
prop_getBracedReference13 = getBracedReference "foo[bar]" == "foo"
|
||||
getBracedReference s = fromMaybe s $
|
||||
nameExpansion s `mplus` takeName noPrefix `mplus` getSpecial noPrefix `mplus` getSpecial s
|
||||
where
|
||||
noPrefix = dropPrefix s
|
||||
dropPrefix (c:rest) | c `elem` "!#" = rest
|
||||
dropPrefix cs = cs
|
||||
takeName s = do
|
||||
let name = takeWhile isVariableChar s
|
||||
guard . not $ null name
|
||||
return name
|
||||
getSpecial (c:_) | isSpecialVariableChar c = return [c]
|
||||
getSpecial _ = fail "empty or not special"
|
||||
|
||||
nameExpansion ('!':next:rest) = do -- e.g. ${!foo*bar*}
|
||||
guard $ isVariableChar next -- e.g. ${!@}
|
||||
first <- find (not . isVariableChar) rest
|
||||
guard $ first `elem` "*?@"
|
||||
return ""
|
||||
nameExpansion _ = Nothing
|
||||
|
||||
-- Get the variable modifier like /a/b in ${var/a/b}
|
||||
prop_getBracedModifier1 = getBracedModifier "foo:bar:baz" == ":bar:baz"
|
||||
prop_getBracedModifier2 = getBracedModifier "!var:-foo" == ":-foo"
|
||||
prop_getBracedModifier3 = getBracedModifier "foo[bar]" == "[bar]"
|
||||
prop_getBracedModifier4 = getBracedModifier "foo[@]@Q" == "[@]@Q"
|
||||
prop_getBracedModifier5 = getBracedModifier "@@Q" == "@Q"
|
||||
getBracedModifier s = headOrDefault "" $ do
|
||||
let var = getBracedReference s
|
||||
a <- dropModifier s
|
||||
dropPrefix var a
|
||||
where
|
||||
dropPrefix [] t = return t
|
||||
dropPrefix (a:b) (c:d) | a == c = dropPrefix b d
|
||||
dropPrefix _ _ = []
|
||||
|
||||
dropModifier (c:rest) | c `elem` "#!" = [rest, c:rest]
|
||||
dropModifier x = [x]
|
||||
|
||||
-- Get the variables from indices like ["x", "y"] in ${var[x+y+1]}
|
||||
prop_getIndexReferences1 = getIndexReferences "var[x+y+1]" == ["x", "y"]
|
||||
getIndexReferences s = fromMaybe [] $ do
|
||||
index:_ <- matchRegex re s
|
||||
return $ matchAllStrings variableNameRegex index
|
||||
where
|
||||
re = mkRegex "(\\[.*\\])"
|
||||
|
||||
prop_getOffsetReferences1 = getOffsetReferences ":bar" == ["bar"]
|
||||
prop_getOffsetReferences2 = getOffsetReferences ":bar:baz" == ["bar", "baz"]
|
||||
prop_getOffsetReferences3 = getOffsetReferences "[foo]:bar" == ["bar"]
|
||||
prop_getOffsetReferences4 = getOffsetReferences "[foo]:bar:baz" == ["bar", "baz"]
|
||||
getOffsetReferences mods = fromMaybe [] $ do
|
||||
-- if mods start with [, then drop until ]
|
||||
_:offsets:_ <- matchRegex re mods
|
||||
return $ matchAllStrings variableNameRegex offsets
|
||||
where
|
||||
re = mkRegex "^(\\[.+\\])? *:([^-=?+].*)"
|
||||
|
||||
|
||||
-- Returns whether a token is a parameter expansion without any modifiers.
|
||||
-- True for $var ${var} $1 $#
|
||||
-- False for ${#var} ${var[x]} ${var:-0}
|
||||
isUnmodifiedParameterExpansion t =
|
||||
case t of
|
||||
T_DollarBraced _ False _ -> True
|
||||
T_DollarBraced _ _ list ->
|
||||
let str = concat $ oversimplify list
|
||||
in getBracedReference str == str
|
||||
_ -> False
|
||||
|
||||
-- Return the referenced variable if (and only if) it's an unmodified parameter expansion.
|
||||
getUnmodifiedParameterExpansion t =
|
||||
case t of
|
||||
T_DollarBraced _ _ list -> do
|
||||
let str = concat $ oversimplify list
|
||||
guard $ getBracedReference str == str
|
||||
return str
|
||||
_ -> Nothing
|
||||
|
||||
--- A list of the element and all its parents up to the root node.
|
||||
getPath tree = NE.unfoldr $ \t -> (t, Map.lookup (getId t) tree)
|
||||
|
||||
isClosingFileOp op =
|
||||
case op of
|
||||
T_IoDuplicate _ (T_GREATAND _) "-" -> True
|
||||
T_IoDuplicate _ (T_LESSAND _) "-" -> True
|
||||
_ -> False
|
||||
|
||||
getEnableDirectives root =
|
||||
case root of
|
||||
T_Annotation _ list _ -> [s | EnableComment s <- list]
|
||||
_ -> []
|
||||
|
||||
getExtendedAnalysisDirective :: Token -> Maybe Bool
|
||||
getExtendedAnalysisDirective root =
|
||||
case root of
|
||||
T_Annotation _ list _ -> listToMaybe $ [s | ExtendedAnalysis s <- list]
|
||||
_ -> Nothing
|
||||
|
||||
return []
|
||||
runTests = $quickCheckAll
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,55 +0,0 @@
|
|||
{-
|
||||
Copyright 2012-2022 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
module ShellCheck.Analyzer (analyzeScript, ShellCheck.Analyzer.optionalChecks) where
|
||||
|
||||
import ShellCheck.Analytics
|
||||
import ShellCheck.AnalyzerLib
|
||||
import ShellCheck.Interface
|
||||
import Data.List
|
||||
import Data.Monoid
|
||||
import qualified ShellCheck.Checks.Commands
|
||||
import qualified ShellCheck.Checks.ControlFlow
|
||||
import qualified ShellCheck.Checks.Custom
|
||||
import qualified ShellCheck.Checks.ShellSupport
|
||||
|
||||
|
||||
-- TODO: Clean up the cruft this is layered on
|
||||
analyzeScript :: AnalysisSpec -> AnalysisResult
|
||||
analyzeScript spec = newAnalysisResult {
|
||||
arComments =
|
||||
filterByAnnotation spec params . nub $
|
||||
runChecker params (checkers spec params)
|
||||
}
|
||||
where
|
||||
params = makeParameters spec
|
||||
|
||||
checkers spec params = mconcat $ map ($ params) [
|
||||
ShellCheck.Analytics.checker spec,
|
||||
ShellCheck.Checks.Commands.checker spec,
|
||||
ShellCheck.Checks.ControlFlow.checker spec,
|
||||
ShellCheck.Checks.Custom.checker,
|
||||
ShellCheck.Checks.ShellSupport.checker
|
||||
]
|
||||
|
||||
optionalChecks = mconcat $ [
|
||||
ShellCheck.Analytics.optionalChecks,
|
||||
ShellCheck.Checks.Commands.optionalChecks,
|
||||
ShellCheck.Checks.ControlFlow.optionalChecks
|
||||
]
|
||||
|
|
@ -1,944 +0,0 @@
|
|||
{-
|
||||
Copyright 2012-2022 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
{-# LANGUAGE FlexibleContexts #-}
|
||||
{-# LANGUAGE TemplateHaskell #-}
|
||||
module ShellCheck.AnalyzerLib where
|
||||
|
||||
import ShellCheck.AST
|
||||
import ShellCheck.ASTLib
|
||||
import qualified ShellCheck.CFGAnalysis as CF
|
||||
import ShellCheck.Data
|
||||
import ShellCheck.Interface
|
||||
import ShellCheck.Parser
|
||||
import ShellCheck.Prelude
|
||||
import ShellCheck.Regex
|
||||
|
||||
import Control.Arrow (first)
|
||||
import Control.DeepSeq
|
||||
import Control.Monad
|
||||
import Control.Monad.Identity
|
||||
import Control.Monad.RWS
|
||||
import Control.Monad.State
|
||||
import Control.Monad.Writer
|
||||
import Data.Char
|
||||
import Data.List
|
||||
import Data.Maybe
|
||||
import Data.Semigroup
|
||||
import qualified Data.List.NonEmpty as NE
|
||||
import qualified Data.Map as Map
|
||||
|
||||
import Test.QuickCheck.All (forAllProperties)
|
||||
import Test.QuickCheck.Test (maxSuccess, quickCheckWithResult, stdArgs)
|
||||
|
||||
type Analysis = AnalyzerM ()
|
||||
type AnalyzerM a = RWS Parameters [TokenComment] Cache a
|
||||
nullCheck = const $ return ()
|
||||
|
||||
|
||||
data Checker = Checker {
|
||||
perScript :: Root -> Analysis,
|
||||
perToken :: Token -> Analysis
|
||||
}
|
||||
|
||||
runChecker :: Parameters -> Checker -> [TokenComment]
|
||||
runChecker params checker = notes
|
||||
where
|
||||
root = rootNode params
|
||||
check = perScript checker `composeAnalyzers` (\(Root x) -> void $ doAnalysis (perToken checker) x)
|
||||
notes = snd $ evalRWS (check $ Root root) params Cache
|
||||
|
||||
instance Semigroup Checker where
|
||||
(<>) x y = Checker {
|
||||
perScript = perScript x `composeAnalyzers` perScript y,
|
||||
perToken = perToken x `composeAnalyzers` perToken y
|
||||
}
|
||||
|
||||
instance Monoid Checker where
|
||||
mempty = Checker {
|
||||
perScript = nullCheck,
|
||||
perToken = nullCheck
|
||||
}
|
||||
mappend = (Data.Semigroup.<>)
|
||||
|
||||
composeAnalyzers :: (a -> Analysis) -> (a -> Analysis) -> a -> Analysis
|
||||
composeAnalyzers f g x = f x >> g x
|
||||
|
||||
data Parameters = Parameters {
|
||||
-- Whether this script has the 'lastpipe' option set/default.
|
||||
hasLastpipe :: Bool,
|
||||
-- Whether this script has the 'inherit_errexit' option set/default.
|
||||
hasInheritErrexit :: Bool,
|
||||
-- Whether this script has 'set -e' anywhere.
|
||||
hasSetE :: Bool,
|
||||
-- Whether this script has 'set -o pipefail' anywhere.
|
||||
hasPipefail :: Bool,
|
||||
-- Whether this script has 'shopt -s execfail' anywhere.
|
||||
hasExecfail :: Bool,
|
||||
-- A linear (bad) analysis of data flow
|
||||
variableFlow :: [StackData],
|
||||
-- A map from Id to Token
|
||||
idMap :: Map.Map Id Token,
|
||||
-- A map from Id to parent Token
|
||||
parentMap :: Map.Map Id Token,
|
||||
-- The shell type, such as Bash or Ksh
|
||||
shellType :: Shell,
|
||||
-- True if shell type was forced via flags
|
||||
shellTypeSpecified :: Bool,
|
||||
-- The root node of the AST
|
||||
rootNode :: Token,
|
||||
-- map from token id to start and end position
|
||||
tokenPositions :: Map.Map Id (Position, Position),
|
||||
-- Result from Control Flow Graph analysis (including data flow analysis)
|
||||
cfgAnalysis :: Maybe CF.CFGAnalysis
|
||||
} deriving (Show)
|
||||
|
||||
-- TODO: Cache results of common AST ops here
|
||||
data Cache = Cache {}
|
||||
|
||||
data Scope = SubshellScope String | NoneScope deriving (Show, Eq)
|
||||
data StackData =
|
||||
StackScope Scope
|
||||
| StackScopeEnd
|
||||
-- (Base expression, specific position, var name, assigned values)
|
||||
| Assignment (Token, Token, String, DataType)
|
||||
| Reference (Token, Token, String)
|
||||
deriving (Show)
|
||||
|
||||
data DataType = DataString DataSource | DataArray DataSource
|
||||
deriving (Show)
|
||||
|
||||
data DataSource =
|
||||
SourceFrom [Token]
|
||||
| SourceExternal
|
||||
| SourceDeclaration
|
||||
| SourceInteger
|
||||
| SourceChecked
|
||||
deriving (Show)
|
||||
|
||||
data VariableState = Dead Token String | Alive deriving (Show)
|
||||
|
||||
defaultSpec pr = spec {
|
||||
asShellType = Nothing,
|
||||
asCheckSourced = False,
|
||||
asExecutionMode = Executed,
|
||||
asTokenPositions = prTokenPositions pr
|
||||
} where spec = newAnalysisSpec (fromJust $ prRoot pr)
|
||||
|
||||
pScript s =
|
||||
let
|
||||
pSpec = newParseSpec {
|
||||
psFilename = "script",
|
||||
psScript = s
|
||||
}
|
||||
in runIdentity $ parseScript (mockedSystemInterface []) pSpec
|
||||
|
||||
-- For testing. If parsed, returns whether there are any comments
|
||||
producesComments :: Checker -> String -> Maybe Bool
|
||||
producesComments c s = do
|
||||
let pr = pScript s
|
||||
prRoot pr
|
||||
let spec = defaultSpec pr
|
||||
let params = makeParameters spec
|
||||
return . not . null $ filterByAnnotation spec params $ runChecker params c
|
||||
|
||||
makeComment :: Severity -> Id -> Code -> String -> TokenComment
|
||||
makeComment severity id code note =
|
||||
newTokenComment {
|
||||
tcId = id,
|
||||
tcComment = newComment {
|
||||
cSeverity = severity,
|
||||
cCode = code,
|
||||
cMessage = note
|
||||
}
|
||||
}
|
||||
|
||||
addComment note = note `deepseq` tell [note]
|
||||
|
||||
warn :: MonadWriter [TokenComment] m => Id -> Code -> String -> m ()
|
||||
warn id code str = addComment $ makeComment WarningC id code str
|
||||
err id code str = addComment $ makeComment ErrorC id code str
|
||||
info id code str = addComment $ makeComment InfoC id code str
|
||||
style id code str = addComment $ makeComment StyleC id code str
|
||||
|
||||
errWithFix :: MonadWriter [TokenComment] m => Id -> Code -> String -> Fix -> m ()
|
||||
errWithFix = addCommentWithFix ErrorC
|
||||
warnWithFix :: MonadWriter [TokenComment] m => Id -> Code -> String -> Fix -> m ()
|
||||
warnWithFix = addCommentWithFix WarningC
|
||||
infoWithFix :: MonadWriter [TokenComment] m => Id -> Code -> String -> Fix -> m ()
|
||||
infoWithFix = addCommentWithFix InfoC
|
||||
styleWithFix :: MonadWriter [TokenComment] m => Id -> Code -> String -> Fix -> m ()
|
||||
styleWithFix = addCommentWithFix StyleC
|
||||
|
||||
addCommentWithFix :: MonadWriter [TokenComment] m => Severity -> Id -> Code -> String -> Fix -> m ()
|
||||
addCommentWithFix severity id code str fix =
|
||||
addComment $ makeCommentWithFix severity id code str fix
|
||||
|
||||
makeCommentWithFix :: Severity -> Id -> Code -> String -> Fix -> TokenComment
|
||||
makeCommentWithFix severity id code str fix =
|
||||
let comment = makeComment severity id code str
|
||||
withFix = comment {
|
||||
-- If fix is empty, pretend it wasn't there.
|
||||
tcFix = if null (fixReplacements fix) then Nothing else Just fix
|
||||
}
|
||||
in force withFix
|
||||
|
||||
-- makeParameters :: CheckSpec -> Parameters
|
||||
makeParameters spec = params
|
||||
where
|
||||
extendedAnalysis = fromMaybe True $ msum [asExtendedAnalysis spec, getExtendedAnalysisDirective root]
|
||||
params = Parameters {
|
||||
rootNode = root,
|
||||
shellType = fromMaybe (determineShell (asFallbackShell spec) root) $ asShellType spec,
|
||||
hasSetE = containsSetE root,
|
||||
hasLastpipe =
|
||||
case shellType params of
|
||||
Bash -> isOptionSet "lastpipe" root
|
||||
Dash -> False
|
||||
BusyboxSh -> False
|
||||
Sh -> False
|
||||
Ksh -> True,
|
||||
hasInheritErrexit =
|
||||
case shellType params of
|
||||
Bash -> isOptionSet "inherit_errexit" root
|
||||
Dash -> True
|
||||
BusyboxSh -> True
|
||||
Sh -> True
|
||||
Ksh -> False,
|
||||
hasPipefail =
|
||||
case shellType params of
|
||||
Bash -> isOptionSet "pipefail" root
|
||||
Dash -> True
|
||||
BusyboxSh -> isOptionSet "pipefail" root
|
||||
Sh -> True
|
||||
Ksh -> isOptionSet "pipefail" root,
|
||||
hasExecfail =
|
||||
case shellType params of
|
||||
Bash -> isOptionSet "execfail" root
|
||||
_ -> False,
|
||||
shellTypeSpecified = isJust (asShellType spec) || isJust (asFallbackShell spec),
|
||||
idMap = getTokenMap root,
|
||||
parentMap = getParentTree root,
|
||||
variableFlow = getVariableFlow params root,
|
||||
tokenPositions = asTokenPositions spec,
|
||||
cfgAnalysis = do
|
||||
guard extendedAnalysis
|
||||
return $ CF.analyzeControlFlow cfParams root
|
||||
}
|
||||
cfParams = CF.CFGParameters {
|
||||
CF.cfLastpipe = hasLastpipe params,
|
||||
CF.cfPipefail = hasPipefail params
|
||||
}
|
||||
root = asScript spec
|
||||
|
||||
|
||||
-- Does this script mention 'set -e' anywhere?
|
||||
-- Used as a hack to disable certain warnings.
|
||||
containsSetE root = isNothing $ doAnalysis (guard . not . isSetE) root
|
||||
where
|
||||
isSetE t =
|
||||
case t of
|
||||
T_Script _ (T_Literal _ str) _ -> str `matches` re
|
||||
T_SimpleCommand {} ->
|
||||
t `isUnqualifiedCommand` "set" &&
|
||||
("errexit" `elem` oversimplify t ||
|
||||
"e" `elem` map snd (getAllFlags t))
|
||||
_ -> False
|
||||
re = mkRegex "[[:space:]]-[^-]*e"
|
||||
|
||||
|
||||
containsSetOption opt root = isNothing $ doAnalysis (guard . not . isPipefail) root
|
||||
where
|
||||
isPipefail t =
|
||||
case t of
|
||||
T_SimpleCommand {} ->
|
||||
t `isUnqualifiedCommand` "set" &&
|
||||
(opt `elem` oversimplify t ||
|
||||
"o" `elem` map snd (getAllFlags t))
|
||||
_ -> False
|
||||
|
||||
containsShopt shopt root =
|
||||
isNothing $ doAnalysis (guard . not . isShoptLastPipe) root
|
||||
where
|
||||
isShoptLastPipe t =
|
||||
case t of
|
||||
T_SimpleCommand {} ->
|
||||
t `isUnqualifiedCommand` "shopt" &&
|
||||
(shopt `elem` oversimplify t)
|
||||
_ -> False
|
||||
|
||||
-- Does this script mention 'shopt -s $opt' or 'set -o $opt' anywhere?
|
||||
isOptionSet opt root = containsShopt opt root || containsSetOption opt root
|
||||
|
||||
|
||||
prop_determineShell0 = determineShellTest "#!/bin/sh" == Sh
|
||||
prop_determineShell1 = determineShellTest "#!/usr/bin/env ksh" == Ksh
|
||||
prop_determineShell2 = determineShellTest "" == Bash
|
||||
prop_determineShell3 = determineShellTest "#!/bin/sh -e" == Sh
|
||||
prop_determineShell4 = determineShellTest "#!/bin/ksh\n#shellcheck shell=sh\nfoo" == Sh
|
||||
prop_determineShell5 = determineShellTest "#shellcheck shell=sh\nfoo" == Sh
|
||||
prop_determineShell6 = determineShellTest "#! /bin/sh" == Sh
|
||||
prop_determineShell7 = determineShellTest "#! /bin/ash" == Dash
|
||||
prop_determineShell8 = determineShellTest' (Just Ksh) "#!/bin/sh" == Sh
|
||||
prop_determineShell9 = determineShellTest "#!/bin/env -S dash -x" == Dash
|
||||
prop_determineShell10 = determineShellTest "#!/bin/env --split-string= dash -x" == Dash
|
||||
prop_determineShell11 = determineShellTest "#!/bin/busybox sh" == BusyboxSh -- busybox sh is a specific shell, not posix sh
|
||||
prop_determineShell12 = determineShellTest "#!/bin/busybox ash" == BusyboxSh
|
||||
|
||||
determineShellTest = determineShellTest' Nothing
|
||||
determineShellTest' fallbackShell = determineShell fallbackShell . fromJust . prRoot . pScript
|
||||
determineShell fallbackShell t = fromMaybe Bash $
|
||||
shellForExecutable shellString `mplus` fallbackShell
|
||||
where
|
||||
shellString = getCandidate t
|
||||
getCandidate :: Token -> String
|
||||
getCandidate t@T_Script {} = fromShebang t
|
||||
getCandidate (T_Annotation _ annotations s) =
|
||||
headOrDefault (fromShebang s) [s | ShellOverride s <- annotations]
|
||||
fromShebang (T_Script _ (T_Literal _ s) _) = executableFromShebang s
|
||||
|
||||
-- Given a root node, make a map from Id to parent Token.
|
||||
-- This is used to populate parentMap in Parameters
|
||||
getParentTree :: Token -> Map.Map Id Token
|
||||
getParentTree t =
|
||||
snd $ execState (doStackAnalysis pre post t) ([], Map.empty)
|
||||
where
|
||||
pre t = modify (first ((:) t))
|
||||
post t = do
|
||||
(x, map) <- get
|
||||
case x of
|
||||
_:rest -> case rest of [] -> put (rest, map)
|
||||
(x:_) -> put (rest, Map.insert (getId t) x map)
|
||||
|
||||
-- Given a root node, make a map from Id to Token
|
||||
getTokenMap :: Token -> Map.Map Id Token
|
||||
getTokenMap t =
|
||||
execState (doAnalysis f t) Map.empty
|
||||
where
|
||||
f t = modify (Map.insert (getId t) t)
|
||||
|
||||
|
||||
-- Is this token in a quoting free context? (i.e. would variable expansion split)
|
||||
-- True: Assignments, [[ .. ]], here docs, already in double quotes
|
||||
-- False: Regular words
|
||||
isStrictlyQuoteFree = isQuoteFreeNode True
|
||||
|
||||
-- Like above, but also allow some cases where splitting may be desired.
|
||||
-- True: Like above + for loops
|
||||
-- False: Like above
|
||||
isQuoteFree = isQuoteFreeNode False
|
||||
|
||||
|
||||
isQuoteFreeNode strict shell tree t =
|
||||
isQuoteFreeElement t ||
|
||||
(fromMaybe False $ msum $ map isQuoteFreeContext $ NE.tail $ getPath tree t)
|
||||
where
|
||||
-- Is this node self-quoting in itself?
|
||||
isQuoteFreeElement t =
|
||||
case t of
|
||||
T_Assignment id _ _ _ _ -> assignmentIsQuoting id
|
||||
T_FdRedirect {} -> True
|
||||
_ -> False
|
||||
|
||||
-- Are any subnodes inherently self-quoting?
|
||||
isQuoteFreeContext t =
|
||||
case t of
|
||||
TC_Nullary _ DoubleBracket _ -> return True
|
||||
TC_Unary _ DoubleBracket _ _ -> return True
|
||||
TC_Binary _ DoubleBracket _ _ _ -> return True
|
||||
TA_Sequence {} -> return True
|
||||
T_Arithmetic {} -> return True
|
||||
T_Assignment id _ _ _ _ -> return $ assignmentIsQuoting id
|
||||
T_Redirecting {} -> return False
|
||||
T_DoubleQuoted _ _ -> return True
|
||||
T_DollarDoubleQuoted _ _ -> return True
|
||||
T_CaseExpression {} -> return True
|
||||
T_HereDoc {} -> return True
|
||||
T_DollarBraced {} -> return True
|
||||
-- When non-strict, pragmatically assume it's desirable to split here
|
||||
T_ForIn {} -> return (not strict)
|
||||
T_SelectIn {} -> return (not strict)
|
||||
_ -> Nothing
|
||||
|
||||
-- Check whether this assignment is self-quoting due to being a recognized
|
||||
-- assignment passed to a Declaration Utility. This will soon be required
|
||||
-- by POSIX: https://austingroupbugs.net/view.php?id=351
|
||||
assignmentIsQuoting id = shellParsesParamsAsAssignments || not (isAssignmentParamToCommand id)
|
||||
shellParsesParamsAsAssignments = shell /= Sh
|
||||
|
||||
-- Is this assignment a parameter to a command like export/typeset/etc?
|
||||
isAssignmentParamToCommand id =
|
||||
case Map.lookup id tree of
|
||||
Just (T_SimpleCommand _ _ (_:args)) -> id `elem` (map getId args)
|
||||
_ -> False
|
||||
|
||||
-- Check if a token is a parameter to a certain command by name:
|
||||
-- Example: isParamTo (parentMap params) "sed" t
|
||||
isParamTo :: Map.Map Id Token -> String -> Token -> Bool
|
||||
isParamTo tree cmd =
|
||||
go
|
||||
where
|
||||
go x = case Map.lookup (getId x) tree of
|
||||
Nothing -> False
|
||||
Just parent -> check parent
|
||||
check t =
|
||||
case t of
|
||||
T_SingleQuoted _ _ -> go t
|
||||
T_DoubleQuoted _ _ -> go t
|
||||
T_NormalWord _ _ -> go t
|
||||
T_SimpleCommand {} -> isCommand t cmd
|
||||
T_Redirecting {} -> isCommand t cmd
|
||||
_ -> False
|
||||
|
||||
-- Get the parent command (T_Redirecting) of a Token, if any.
|
||||
getClosestCommand :: Map.Map Id Token -> Token -> Maybe Token
|
||||
getClosestCommand tree t =
|
||||
findFirst findCommand $ NE.toList $ getPath tree t
|
||||
where
|
||||
findCommand t =
|
||||
case t of
|
||||
T_Redirecting {} -> return True
|
||||
T_Script {} -> return False
|
||||
_ -> Nothing
|
||||
|
||||
-- Like above, if koala_man knew Haskell when starting this project.
|
||||
getClosestCommandM t = do
|
||||
params <- ask
|
||||
return $ getClosestCommand (parentMap params) t
|
||||
|
||||
-- Is the token used as a command name (the first word in a T_SimpleCommand)?
|
||||
usedAsCommandName tree token = go (getId token) (NE.tail $ getPath tree token)
|
||||
where
|
||||
go currentId (T_NormalWord id [word]:rest)
|
||||
| currentId == getId word = go id rest
|
||||
go currentId (T_DoubleQuoted id [word]:rest)
|
||||
| currentId == getId word = go id rest
|
||||
go currentId (t@(T_SimpleCommand _ _ (word:_)):_) =
|
||||
getId word == currentId || getId (getCommandTokenOrThis t) == currentId
|
||||
go _ _ = False
|
||||
|
||||
-- Version of the above taking the map from the current context
|
||||
-- Todo: give this the name "getPath"
|
||||
getPathM t = do
|
||||
params <- ask
|
||||
return $ getPath (parentMap params) t
|
||||
|
||||
isParentOf tree parent child =
|
||||
any (\t -> parentId == getId t) (getPath tree child)
|
||||
where
|
||||
parentId = getId parent
|
||||
|
||||
parents params = getPath (parentMap params)
|
||||
|
||||
-- Find the first match in a list where the predicate is Just True.
|
||||
-- Stops if it's Just False and ignores Nothing.
|
||||
findFirst :: (a -> Maybe Bool) -> [a] -> Maybe a
|
||||
findFirst p = foldr go Nothing
|
||||
where
|
||||
go x acc =
|
||||
case p x of
|
||||
Just True -> return x
|
||||
Just False -> Nothing
|
||||
Nothing -> acc
|
||||
|
||||
-- Check whether a word is entirely output from a single command
|
||||
tokenIsJustCommandOutput t = case t of
|
||||
T_NormalWord id [T_DollarExpansion _ cmds] -> check cmds
|
||||
T_NormalWord id [T_DoubleQuoted _ [T_DollarExpansion _ cmds]] -> check cmds
|
||||
T_NormalWord id [T_Backticked _ cmds] -> check cmds
|
||||
T_NormalWord id [T_DoubleQuoted _ [T_Backticked _ cmds]] -> check cmds
|
||||
_ -> False
|
||||
where
|
||||
check [x] = not $ isOnlyRedirection x
|
||||
check _ = False
|
||||
|
||||
-- TODO: Replace this with a proper Control Flow Graph
|
||||
getVariableFlow params t =
|
||||
reverse $ execState (doStackAnalysis startScope endScope t) []
|
||||
where
|
||||
startScope t =
|
||||
let scopeType = leadType params t
|
||||
in do
|
||||
when (scopeType /= NoneScope) $ modify (StackScope scopeType:)
|
||||
when (assignFirst t) $ setWritten t
|
||||
|
||||
endScope t =
|
||||
let scopeType = leadType params t
|
||||
in do
|
||||
setRead t
|
||||
unless (assignFirst t) $ setWritten t
|
||||
when (scopeType /= NoneScope) $ modify (StackScopeEnd:)
|
||||
|
||||
assignFirst T_ForIn {} = True
|
||||
assignFirst T_SelectIn {} = True
|
||||
assignFirst (T_BatsTest {}) = True
|
||||
assignFirst _ = False
|
||||
|
||||
setRead t =
|
||||
let read = getReferencedVariables (parentMap params) t
|
||||
in mapM_ (\v -> modify (Reference v:)) read
|
||||
|
||||
setWritten t =
|
||||
let written = getModifiedVariables t
|
||||
in mapM_ (\v -> modify (Assignment v:)) written
|
||||
|
||||
|
||||
leadType params t =
|
||||
case t of
|
||||
T_DollarExpansion _ _ -> SubshellScope "$(..) expansion"
|
||||
T_Backticked _ _ -> SubshellScope "`..` expansion"
|
||||
T_Backgrounded _ _ -> SubshellScope "backgrounding &"
|
||||
T_Subshell _ _ -> SubshellScope "(..) group"
|
||||
T_BatsTest {} -> SubshellScope "@bats test"
|
||||
T_CoProcBody _ _ -> SubshellScope "coproc"
|
||||
T_Redirecting {} ->
|
||||
if causesSubshell == Just True
|
||||
then SubshellScope "pipeline"
|
||||
else NoneScope
|
||||
_ -> NoneScope
|
||||
where
|
||||
parentPipeline = do
|
||||
parent <- Map.lookup (getId t) (parentMap params)
|
||||
case parent of
|
||||
T_Pipeline {} -> return parent
|
||||
_ -> Nothing
|
||||
|
||||
causesSubshell = do
|
||||
(T_Pipeline _ _ list) <- parentPipeline
|
||||
return $ case list of
|
||||
_:_:_ -> not (hasLastpipe params) || getId (last list) /= getId t
|
||||
_ -> False
|
||||
|
||||
getModifiedVariables t =
|
||||
case t of
|
||||
T_SimpleCommand _ vars [] ->
|
||||
[(x, x, name, dataTypeFrom DataString w) | x@(T_Assignment id _ name _ w) <- vars]
|
||||
T_SimpleCommand {} ->
|
||||
getModifiedVariableCommand t
|
||||
|
||||
TA_Unary _ op v@(TA_Variable _ name _) | "--" `isInfixOf` op || "++" `isInfixOf` op ->
|
||||
[(t, v, name, DataString SourceInteger)]
|
||||
TA_Assignment _ op (TA_Variable _ name _) rhs -> do
|
||||
guard $ op `elem` ["=", "*=", "/=", "%=", "+=", "-=", "<<=", ">>=", "&=", "^=", "|="]
|
||||
return (t, t, name, DataString SourceInteger)
|
||||
|
||||
T_BatsTest {} -> [
|
||||
(t, t, "lines", DataArray SourceExternal),
|
||||
(t, t, "status", DataString SourceInteger),
|
||||
(t, t, "output", DataString SourceExternal),
|
||||
(t, t, "stderr", DataString SourceExternal),
|
||||
(t, t, "stderr_lines", DataArray SourceExternal)
|
||||
]
|
||||
|
||||
-- Count [[ -v foo ]] as an "assignment".
|
||||
-- This is to prevent [ -v foo ] being unassigned or unused.
|
||||
TC_Unary id _ "-v" token -> maybeToList $ do
|
||||
str <- getVariableForTestDashV token
|
||||
return (t, token, str, DataString SourceChecked)
|
||||
|
||||
TC_Unary _ _ "-n" token -> markAsChecked t token
|
||||
TC_Unary _ _ "-z" token -> markAsChecked t token
|
||||
TC_Nullary _ _ token -> markAsChecked t token
|
||||
|
||||
T_DollarBraced _ _ l -> maybeToList $ do
|
||||
let string = concat $ oversimplify l
|
||||
let modifier = getBracedModifier string
|
||||
guard $ any (`isPrefixOf` modifier) ["=", ":="]
|
||||
return (t, t, getBracedReference string, DataString $ SourceFrom [l])
|
||||
|
||||
T_FdRedirect _ ('{':var) op -> -- {foo}>&2 modifies foo
|
||||
[(t, t, takeWhile (/= '}') var, DataString SourceInteger) | not $ isClosingFileOp op]
|
||||
|
||||
T_CoProc _ Nothing _ ->
|
||||
[(t, t, "COPROC", DataArray SourceInteger)]
|
||||
|
||||
T_CoProc _ (Just token) _ -> do
|
||||
name <- maybeToList $ getLiteralString token
|
||||
[(t, t, name, DataArray SourceInteger)]
|
||||
|
||||
--Points to 'for' rather than variable
|
||||
T_ForIn id str [] _ -> [(t, t, str, DataString SourceExternal)]
|
||||
T_ForIn id str words _ -> [(t, t, str, DataString $ SourceFrom words)]
|
||||
T_SelectIn id str words _ -> [(t, t, str, DataString $ SourceFrom words)]
|
||||
_ -> []
|
||||
where
|
||||
markAsChecked place token = mapMaybe (f place) $ getWordParts token
|
||||
f place t = case t of
|
||||
T_DollarBraced _ _ l ->
|
||||
let str = getBracedReference $ concat $ oversimplify l in do
|
||||
guard $ isVariableName str
|
||||
return (place, t, str, DataString SourceChecked)
|
||||
_ -> Nothing
|
||||
|
||||
|
||||
-- Consider 'export/declare -x' a reference, since it makes the var available
|
||||
getReferencedVariableCommand base@(T_SimpleCommand _ _ (T_NormalWord _ (T_Literal _ x:_):rest)) =
|
||||
case x of
|
||||
"declare" -> forDeclare
|
||||
"typeset" -> forDeclare
|
||||
|
||||
"export" -> if "f" `elem` flags
|
||||
then []
|
||||
else concatMap getReference rest
|
||||
"local" -> if "x" `elem` flags
|
||||
then concatMap getReference rest
|
||||
else []
|
||||
"trap" ->
|
||||
case rest of
|
||||
head:_ -> map (\x -> (base, head, x)) $ getVariablesFromLiteralToken head
|
||||
_ -> []
|
||||
"alias" -> [(base, token, name) | token <- rest, name <- getVariablesFromLiteralToken token]
|
||||
_ -> []
|
||||
where
|
||||
forDeclare =
|
||||
if
|
||||
any (`elem` flags) ["x", "p"] &&
|
||||
(not $ any (`elem` flags) ["f", "F"])
|
||||
then concatMap getReference rest
|
||||
else []
|
||||
|
||||
getReference t@(T_Assignment _ _ name _ value) = [(t, t, name)]
|
||||
getReference t@(T_NormalWord _ [T_Literal _ name]) | not ("-" `isPrefixOf` name) = [(t, t, name)]
|
||||
getReference _ = []
|
||||
flags = map snd $ getAllFlags base
|
||||
|
||||
getReferencedVariableCommand _ = []
|
||||
|
||||
-- The function returns a tuple consisting of four items describing an assignment.
|
||||
-- Given e.g. declare foo=bar
|
||||
-- (
|
||||
-- BaseCommand :: Token, -- The command/structure assigning the variable, i.e. declare foo=bar
|
||||
-- AssignmentToken :: Token, -- The specific part that assigns this variable, i.e. foo=bar
|
||||
-- VariableName :: String, -- The variable name, i.e. foo
|
||||
-- VariableValue :: DataType -- A description of the value being assigned, i.e. "Literal string with value foo"
|
||||
-- )
|
||||
getModifiedVariableCommand base@(T_SimpleCommand id cmdPrefix (T_NormalWord _ (T_Literal _ x:_):rest)) =
|
||||
filter (\(_,_,s,_) -> not ("-" `isPrefixOf` s)) $
|
||||
case x of
|
||||
"builtin" ->
|
||||
getModifiedVariableCommand $ T_SimpleCommand id cmdPrefix rest
|
||||
"read" ->
|
||||
let fallback = catMaybes $ takeWhile isJust (reverse $ map getLiteral rest)
|
||||
in fromMaybe fallback $ do
|
||||
parsed <- getGnuOpts flagsForRead rest
|
||||
case lookup "a" parsed of
|
||||
Just (_, var) -> (:[]) <$> getLiteralArray var
|
||||
Nothing -> return $ catMaybes $
|
||||
map (getLiteral . snd . snd) $ filter (null . fst) parsed
|
||||
|
||||
"getopts" ->
|
||||
case rest of
|
||||
opts:var:_ -> maybeToList $ getLiteral var
|
||||
_ -> []
|
||||
|
||||
"let" -> concatMap letParamToLiteral rest
|
||||
|
||||
"export" ->
|
||||
if "f" `elem` flags then [] else concatMap getModifierParamString rest
|
||||
|
||||
"declare" -> forDeclare
|
||||
"typeset" -> forDeclare
|
||||
|
||||
"local" -> concatMap getModifierParamString rest
|
||||
"readonly" ->
|
||||
if any (`elem` flags) ["f", "p"]
|
||||
then []
|
||||
else concatMap getModifierParamString rest
|
||||
"set" -> maybeToList $ do
|
||||
params <- getSetParams rest
|
||||
return (base, base, "@", DataString $ SourceFrom params)
|
||||
|
||||
"printf" -> maybeToList $ getPrintfVariable rest
|
||||
"wait" -> maybeToList $ getWaitVariable rest
|
||||
|
||||
"mapfile" -> maybeToList $ getMapfileArray base rest
|
||||
"readarray" -> maybeToList $ getMapfileArray base rest
|
||||
|
||||
"DEFINE_boolean" -> maybeToList $ getFlagVariable rest
|
||||
"DEFINE_float" -> maybeToList $ getFlagVariable rest
|
||||
"DEFINE_integer" -> maybeToList $ getFlagVariable rest
|
||||
"DEFINE_string" -> maybeToList $ getFlagVariable rest
|
||||
|
||||
_ -> []
|
||||
where
|
||||
flags = map snd $ getAllFlags base
|
||||
stripEquals s = drop 1 $ dropWhile (/= '=') s
|
||||
stripEqualsFrom (T_NormalWord id1 (T_Literal id2 s:rs)) =
|
||||
T_NormalWord id1 (T_Literal id2 (stripEquals s):rs)
|
||||
stripEqualsFrom (T_NormalWord id1 [T_DoubleQuoted id2 [T_Literal id3 s]]) =
|
||||
T_NormalWord id1 [T_DoubleQuoted id2 [T_Literal id3 (stripEquals s)]]
|
||||
stripEqualsFrom t = t
|
||||
|
||||
forDeclare = if any (`elem` flags) ["F", "f", "p"] then [] else declaredVars
|
||||
|
||||
declaredVars = concatMap (getModifierParam defaultType) rest
|
||||
where
|
||||
defaultType = if any (`elem` flags) ["a", "A"] then DataArray else DataString
|
||||
|
||||
getLiteralOfDataType t d = do
|
||||
s <- getLiteralString t
|
||||
when ("-" `isPrefixOf` s) $ fail "argument"
|
||||
return (base, t, s, d)
|
||||
|
||||
getLiteral t = getLiteralOfDataType t (DataString SourceExternal)
|
||||
|
||||
getLiteralArray t = getLiteralOfDataType t (DataArray SourceExternal)
|
||||
|
||||
getModifierParamString = getModifierParam DataString
|
||||
|
||||
getModifierParam def t@(T_Assignment _ _ name _ value) =
|
||||
[(base, t, name, dataTypeFrom def value)]
|
||||
getModifierParam def t@T_NormalWord {} = maybeToList $ do
|
||||
name <- getLiteralString t
|
||||
guard $ isVariableName name
|
||||
return (base, t, name, def SourceDeclaration)
|
||||
getModifierParam _ _ = []
|
||||
|
||||
letParamToLiteral token =
|
||||
if null var
|
||||
then []
|
||||
else [(base, token, var, DataString $ SourceFrom [stripEqualsFrom token])]
|
||||
where var = takeWhile isVariableChar $ dropWhile (`elem` "+-") $ concat $ oversimplify token
|
||||
|
||||
getSetParams (t:_:rest) | getLiteralString t == Just "-o" = getSetParams rest
|
||||
getSetParams (t:rest) =
|
||||
let s = getLiteralString t in
|
||||
case s of
|
||||
Just "--" -> return rest
|
||||
Just ('-':_) -> getSetParams rest
|
||||
_ -> return (t:fromMaybe [] (getSetParams rest))
|
||||
getSetParams [] = Nothing
|
||||
|
||||
getPrintfVariable list = getFlagAssignedVariable "v" (SourceFrom list) $ getBsdOpts "v:" list
|
||||
getWaitVariable list = getFlagAssignedVariable "p" SourceInteger $ return $ getGenericOpts list
|
||||
|
||||
getFlagAssignedVariable str dataSource maybeFlags = do
|
||||
flags <- maybeFlags
|
||||
(_, (flag, value)) <- find ((== str) . fst) flags
|
||||
variableName <- getLiteralStringExt (const $ return "!") value
|
||||
let (baseName, index) = span (/= '[') variableName
|
||||
return (base, value, baseName, (if null index then DataString else DataArray) dataSource)
|
||||
|
||||
-- mapfile has some curious syntax allowing flags plus 0..n variable names
|
||||
-- where only the first non-option one is used if any.
|
||||
getMapfileArray base rest = parseArgs `mplus` fallback
|
||||
where
|
||||
parseArgs :: Maybe (Token, Token, String, DataType)
|
||||
parseArgs = do
|
||||
args <- getGnuOpts "d:n:O:s:u:C:c:t" rest
|
||||
case [y | ("",(_,y)) <- args] of
|
||||
[] ->
|
||||
return (base, base, "MAPFILE", DataArray SourceExternal)
|
||||
first:_ -> do
|
||||
name <- getLiteralString first
|
||||
guard $ isVariableName name
|
||||
return (base, first, name, DataArray SourceExternal)
|
||||
-- If arg parsing fails (due to bad or new flags), get the last variable name
|
||||
fallback :: Maybe (Token, Token, String, DataType)
|
||||
fallback = do
|
||||
(name, token) <- listToMaybe . mapMaybe f $ reverse rest
|
||||
return (base, token, name, DataArray SourceExternal)
|
||||
f arg = do
|
||||
name <- getLiteralString arg
|
||||
guard $ isVariableName name
|
||||
return (name, arg)
|
||||
|
||||
-- get the FLAGS_ variable created by a shflags DEFINE_ call
|
||||
getFlagVariable (n:v:_) = do
|
||||
name <- getLiteralString n
|
||||
return (base, n, "FLAGS_" ++ name, DataString $ SourceExternal)
|
||||
getFlagVariable _ = Nothing
|
||||
|
||||
getModifiedVariableCommand _ = []
|
||||
|
||||
-- Given a NormalWord like foo or foo[$bar], get foo.
|
||||
-- Primarily used to get references for [[ -v foo[bar] ]]
|
||||
getVariableForTestDashV :: Token -> Maybe String
|
||||
getVariableForTestDashV t = do
|
||||
str <- takeWhile ('[' /=) <$> getLiteralStringExt toStr t
|
||||
guard $ isVariableName str
|
||||
return str
|
||||
where
|
||||
-- foo[bar] gets parsed with [bar] as a glob, so undo that
|
||||
toStr (T_Glob _ s) = return s
|
||||
-- Turn foo[$x] into foo[\0] so that we can get the constant array name
|
||||
-- in a non-constant expression (while filtering out foo$x[$y])
|
||||
toStr _ = return "\0"
|
||||
|
||||
getReferencedVariables parents t =
|
||||
case t of
|
||||
T_DollarBraced id _ l -> let str = concat $ oversimplify l in
|
||||
(t, t, getBracedReference str) :
|
||||
map (\x -> (l, l, x)) (
|
||||
getIndexReferences str
|
||||
++ getOffsetReferences (getBracedModifier str))
|
||||
TA_Variable id name _ ->
|
||||
if isArithmeticAssignment t
|
||||
then []
|
||||
else [(t, t, name)]
|
||||
T_Assignment id mode str _ word ->
|
||||
[(t, t, str) | mode == Append] ++ specialReferences str t word
|
||||
|
||||
TC_Unary id _ "-v" token -> getIfReference t token
|
||||
TC_Unary id _ "-R" token -> getIfReference t token
|
||||
TC_Binary id DoubleBracket op lhs rhs ->
|
||||
if isDereferencingBinaryOp op
|
||||
then concatMap (getIfReference t) [lhs, rhs]
|
||||
else []
|
||||
|
||||
T_BatsTest {} -> [ -- pretend @test references vars to avoid warnings
|
||||
(t, t, "lines"),
|
||||
(t, t, "status"),
|
||||
(t, t, "output")
|
||||
]
|
||||
|
||||
T_FdRedirect _ ('{':var) op -> -- {foo}>&- references and closes foo
|
||||
[(t, t, takeWhile (/= '}') var) | isClosingFileOp op]
|
||||
x -> getReferencedVariableCommand x
|
||||
where
|
||||
-- Try to reduce false positives for unused vars only referenced from evaluated vars
|
||||
specialReferences name base word =
|
||||
if name `elem` [
|
||||
"PS1", "PS2", "PS3", "PS4",
|
||||
"PROMPT_COMMAND"
|
||||
]
|
||||
then
|
||||
map (\x -> (base, base, x)) $
|
||||
getVariablesFromLiteralToken word
|
||||
else []
|
||||
|
||||
literalizer t = case t of
|
||||
T_Glob _ s -> return s -- Also when parsed as globs
|
||||
_ -> []
|
||||
|
||||
getIfReference context token = maybeToList $ do
|
||||
str <- getVariableForTestDashV token
|
||||
return (context, token, getBracedReference str)
|
||||
|
||||
isArithmeticAssignment t = case getPath parents t of
|
||||
this NE.:| TA_Assignment _ "=" lhs _ :_ -> lhs == t
|
||||
_ -> False
|
||||
|
||||
isDereferencingBinaryOp = (`elem` ["-eq", "-ne", "-lt", "-le", "-gt", "-ge"])
|
||||
|
||||
dataTypeFrom defaultType v = (case v of T_Array {} -> DataArray; _ -> defaultType) $ SourceFrom [v]
|
||||
|
||||
|
||||
--- Command specific checks
|
||||
|
||||
-- Compare a command to a string: t `isCommand` "sed" (also matches /usr/bin/sed)
|
||||
isCommand token str = isCommandMatch token (\cmd -> cmd == str || ('/' : str) `isSuffixOf` cmd)
|
||||
|
||||
-- Compare a command to a literal. Like above, but checks full path.
|
||||
isUnqualifiedCommand token str = isCommandMatch token (== str)
|
||||
|
||||
isCommandMatch token matcher = maybe False
|
||||
matcher (getCommandName token)
|
||||
|
||||
-- Does this regex look like it was intended as a glob?
|
||||
-- True: *foo*
|
||||
-- False: .*foo.*
|
||||
isConfusedGlobRegex :: String -> Bool
|
||||
isConfusedGlobRegex ('*':_) = True
|
||||
isConfusedGlobRegex [x,'*'] | x `notElem` "\\." = True
|
||||
isConfusedGlobRegex _ = False
|
||||
|
||||
getVariablesFromLiteralToken token =
|
||||
getVariablesFromLiteral (getLiteralStringDef " " token)
|
||||
|
||||
-- Try to get referenced variables from a literal string like "$foo"
|
||||
-- Ignores tons of cases like arithmetic evaluation and array indices.
|
||||
prop_getVariablesFromLiteral1 =
|
||||
getVariablesFromLiteral "$foo${bar//a/b}$BAZ" == ["foo", "bar", "BAZ"]
|
||||
getVariablesFromLiteral string =
|
||||
map head $ matchAllSubgroups variableRegex string
|
||||
where
|
||||
variableRegex = mkRegex "\\$\\{?([A-Za-z0-9_]+)"
|
||||
|
||||
|
||||
-- Run a command if the shell is in the given list
|
||||
whenShell l c = do
|
||||
params <- ask
|
||||
when (shellType params `elem` l ) c
|
||||
|
||||
|
||||
filterByAnnotation asSpec params =
|
||||
filter (not . shouldIgnore)
|
||||
where
|
||||
token = asScript asSpec
|
||||
shouldIgnore note =
|
||||
any (shouldIgnoreFor (getCode note)) $
|
||||
getPath parents (T_Bang $ tcId note)
|
||||
shouldIgnoreFor _ T_Include {} = not $ asCheckSourced asSpec
|
||||
shouldIgnoreFor code t = isAnnotationIgnoringCode code t
|
||||
parents = parentMap params
|
||||
getCode = cCode . tcComment
|
||||
|
||||
shouldIgnoreCode params code t =
|
||||
any (isAnnotationIgnoringCode code) $
|
||||
getPath (parentMap params) t
|
||||
|
||||
-- Is this a ${#anything}, to get string length or array count?
|
||||
isCountingReference (T_DollarBraced id _ token) =
|
||||
case concat $ oversimplify token of
|
||||
'#':_ -> True
|
||||
_ -> False
|
||||
isCountingReference _ = False
|
||||
|
||||
-- FIXME: doesn't handle ${a:+$var} vs ${a:+"$var"}
|
||||
isQuotedAlternativeReference t =
|
||||
case t of
|
||||
T_DollarBraced _ _ l ->
|
||||
getBracedModifier (concat $ oversimplify l) `matches` re
|
||||
_ -> False
|
||||
where
|
||||
re = mkRegex "(^|\\]):?\\+"
|
||||
|
||||
supportsArrays Bash = True
|
||||
supportsArrays Ksh = True
|
||||
supportsArrays _ = False
|
||||
|
||||
isTrueAssignmentSource c =
|
||||
case c of
|
||||
DataString SourceChecked -> False
|
||||
DataString SourceDeclaration -> False
|
||||
DataArray SourceChecked -> False
|
||||
DataArray SourceDeclaration -> False
|
||||
_ -> True
|
||||
|
||||
modifiesVariable params token name =
|
||||
or $ map check flow
|
||||
where
|
||||
flow = getVariableFlow params token
|
||||
check t =
|
||||
case t of
|
||||
Assignment (_, _, n, source) -> isTrueAssignmentSource source && n == name
|
||||
_ -> False
|
||||
|
||||
isTestCommand t =
|
||||
case t of
|
||||
T_Condition {} -> True
|
||||
T_SimpleCommand {} -> t `isCommand` "test"
|
||||
T_Redirecting _ _ t -> isTestCommand t
|
||||
T_Annotation _ _ t -> isTestCommand t
|
||||
T_Pipeline _ _ [t] -> isTestCommand t
|
||||
_ -> False
|
||||
|
||||
return []
|
||||
runTests = $( [| $(forAllProperties) (quickCheckWithResult (stdArgs { maxSuccess = 1 }) ) |])
|
||||
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
|
|
@ -1,567 +0,0 @@
|
|||
{-
|
||||
Copyright 2012-2022 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
{-# LANGUAGE TemplateHaskell #-}
|
||||
module ShellCheck.Checker (checkScript, ShellCheck.Checker.runTests) where
|
||||
|
||||
import ShellCheck.Analyzer
|
||||
import ShellCheck.ASTLib
|
||||
import ShellCheck.Interface
|
||||
import ShellCheck.Parser
|
||||
|
||||
import Debug.Trace -- DO NOT SUBMIT
|
||||
import Data.Either
|
||||
import Data.Functor
|
||||
import Data.List
|
||||
import Data.Maybe
|
||||
import Data.Ord
|
||||
import Control.Monad.Identity
|
||||
import qualified Data.Map as Map
|
||||
import qualified System.IO
|
||||
import Prelude hiding (readFile)
|
||||
import Control.Monad
|
||||
|
||||
import Test.QuickCheck.All
|
||||
|
||||
tokenToPosition startMap t = fromMaybe fail $ do
|
||||
span <- Map.lookup (tcId t) startMap
|
||||
return $ newPositionedComment {
|
||||
pcStartPos = fst span,
|
||||
pcEndPos = snd span,
|
||||
pcComment = tcComment t,
|
||||
pcFix = tcFix t
|
||||
}
|
||||
where
|
||||
fail = error "Internal shellcheck error: id doesn't exist. Please report!"
|
||||
|
||||
shellFromFilename filename = listToMaybe candidates
|
||||
where
|
||||
shellExtensions = [(".ksh", Ksh)
|
||||
,(".bash", Bash)
|
||||
,(".bats", Bash)
|
||||
,(".dash", Dash)]
|
||||
-- The `.sh` is too generic to determine the shell:
|
||||
-- We fallback to Bash in this case and emit SC2148 if there is no shebang
|
||||
candidates =
|
||||
[sh | (ext,sh) <- shellExtensions, ext `isSuffixOf` filename]
|
||||
|
||||
checkScript :: Monad m => SystemInterface m -> CheckSpec -> m CheckResult
|
||||
checkScript sys spec = do
|
||||
results <- checkScript (csScript spec)
|
||||
return emptyCheckResult {
|
||||
crFilename = csFilename spec,
|
||||
crComments = results
|
||||
}
|
||||
where
|
||||
checkScript contents = do
|
||||
result <- parseScript sys newParseSpec {
|
||||
psFilename = csFilename spec,
|
||||
psScript = contents,
|
||||
psCheckSourced = csCheckSourced spec,
|
||||
psIgnoreRC = csIgnoreRC spec,
|
||||
psShellTypeOverride = csShellTypeOverride spec
|
||||
}
|
||||
let parseMessages = prComments result
|
||||
let tokenPositions = prTokenPositions result
|
||||
let analysisSpec root =
|
||||
as {
|
||||
asScript = root,
|
||||
asShellType = csShellTypeOverride spec,
|
||||
asFallbackShell = shellFromFilename $ csFilename spec,
|
||||
asCheckSourced = csCheckSourced spec,
|
||||
asExecutionMode = Executed,
|
||||
asTokenPositions = tokenPositions,
|
||||
asExtendedAnalysis = csExtendedAnalysis spec,
|
||||
asOptionalChecks = getEnableDirectives root ++ csOptionalChecks spec
|
||||
} where as = newAnalysisSpec root
|
||||
let analysisMessages =
|
||||
maybe []
|
||||
(arComments . analyzeScript . analysisSpec)
|
||||
$ prRoot result
|
||||
let translator = tokenToPosition tokenPositions
|
||||
return . nub . sortMessages . filter shouldInclude $
|
||||
(parseMessages ++ map translator analysisMessages)
|
||||
|
||||
shouldInclude pc =
|
||||
severity <= csMinSeverity spec &&
|
||||
case csIncludedWarnings spec of
|
||||
Nothing -> code `notElem` csExcludedWarnings spec
|
||||
Just includedWarnings -> code `elem` includedWarnings
|
||||
where
|
||||
code = cCode (pcComment pc)
|
||||
severity = cSeverity (pcComment pc)
|
||||
|
||||
sortMessages = sortOn order
|
||||
order pc =
|
||||
let pos = pcStartPos pc
|
||||
comment = pcComment pc in
|
||||
(posFile pos,
|
||||
posLine pos,
|
||||
posColumn pos,
|
||||
cSeverity comment,
|
||||
cCode comment,
|
||||
cMessage comment)
|
||||
getPosition = pcStartPos
|
||||
|
||||
|
||||
getErrors sys spec =
|
||||
sort . map getCode . crComments $
|
||||
runIdentity (checkScript sys spec)
|
||||
where
|
||||
getCode = cCode . pcComment
|
||||
|
||||
check = checkWithIncludes []
|
||||
|
||||
checkWithSpec includes =
|
||||
getErrors (mockedSystemInterface includes)
|
||||
|
||||
checkWithIncludes includes src =
|
||||
checkWithSpec includes emptyCheckSpec {
|
||||
csScript = src,
|
||||
csExcludedWarnings = [2148]
|
||||
}
|
||||
|
||||
checkRecursive includes src =
|
||||
checkWithSpec includes emptyCheckSpec {
|
||||
csScript = src,
|
||||
csExcludedWarnings = [2148],
|
||||
csCheckSourced = True
|
||||
}
|
||||
|
||||
checkOptionIncludes includes src =
|
||||
checkWithSpec [] emptyCheckSpec {
|
||||
csScript = src,
|
||||
csIncludedWarnings = includes,
|
||||
csCheckSourced = True
|
||||
}
|
||||
|
||||
checkWithRc rc = getErrors
|
||||
(mockRcFile rc $ mockedSystemInterface [])
|
||||
|
||||
checkWithIncludesAndSourcePath includes mapper = getErrors
|
||||
(mockedSystemInterface includes) {
|
||||
siFindSource = mapper
|
||||
}
|
||||
|
||||
checkWithRcIncludesAndSourcePath rc includes mapper = getErrors
|
||||
(mockRcFile rc $ mockedSystemInterface includes) {
|
||||
siFindSource = mapper
|
||||
}
|
||||
|
||||
prop_findsParseIssue = check "echo \"$12\"" == [1037]
|
||||
|
||||
prop_commentDisablesParseIssue1 =
|
||||
null $ check "#shellcheck disable=SC1037\necho \"$12\""
|
||||
prop_commentDisablesParseIssue2 =
|
||||
null $ check "#shellcheck disable=SC1037\n#lol\necho \"$12\""
|
||||
|
||||
prop_findsAnalysisIssue =
|
||||
check "echo $1" == [2086]
|
||||
prop_commentDisablesAnalysisIssue1 =
|
||||
null $ check "#shellcheck disable=SC2086\necho $1"
|
||||
prop_commentDisablesAnalysisIssue2 =
|
||||
null $ check "#shellcheck disable=SC2086\n#lol\necho $1"
|
||||
|
||||
prop_optionDisablesIssue1 =
|
||||
null $ getErrors
|
||||
(mockedSystemInterface [])
|
||||
emptyCheckSpec {
|
||||
csScript = "echo $1",
|
||||
csExcludedWarnings = [2148, 2086]
|
||||
}
|
||||
|
||||
prop_optionDisablesIssue2 =
|
||||
null $ getErrors
|
||||
(mockedSystemInterface [])
|
||||
emptyCheckSpec {
|
||||
csScript = "echo \"$10\"",
|
||||
csExcludedWarnings = [2148, 1037]
|
||||
}
|
||||
|
||||
prop_wontParseBadShell =
|
||||
[1071] == check "#!/usr/bin/python\ntrue $1\n"
|
||||
|
||||
prop_optionDisablesBadShebang =
|
||||
null $ getErrors
|
||||
(mockedSystemInterface [])
|
||||
emptyCheckSpec {
|
||||
csScript = "#!/usr/bin/python\ntrue\n",
|
||||
csShellTypeOverride = Just Sh
|
||||
}
|
||||
|
||||
prop_annotationDisablesBadShebang =
|
||||
null $ check "#!/usr/bin/python\n# shellcheck shell=sh\ntrue\n"
|
||||
|
||||
|
||||
prop_canParseDevNull =
|
||||
null $ check "source /dev/null"
|
||||
|
||||
prop_failsWhenNotSourcing =
|
||||
[1091, 2154] == check "source lol; echo \"$bar\""
|
||||
|
||||
prop_worksWhenSourcing =
|
||||
null $ checkWithIncludes [("lib", "bar=1")] "source lib; echo \"$bar\""
|
||||
|
||||
prop_worksWhenSourcingWithDashDash =
|
||||
null $ checkWithIncludes [("lib", "bar=1")] "source -- lib; echo \"$bar\""
|
||||
|
||||
prop_worksWhenSourcingWithDashP =
|
||||
null $ checkWithIncludes [("lib", "bar=1")] "source -p \"$MYPATH\" lib; echo \"$bar\""
|
||||
|
||||
prop_worksWhenDotting =
|
||||
null $ checkWithIncludes [("lib", "bar=1")] ". lib; echo \"$bar\""
|
||||
|
||||
-- FIXME: This should really be giving [1093], "recursively sourced"
|
||||
prop_noInfiniteSourcing =
|
||||
null $ checkWithIncludes [("lib", "source lib")] "source lib"
|
||||
|
||||
prop_canSourceBadSyntax =
|
||||
[1094, 2086] == checkWithIncludes [("lib", "for f; do")] "source lib; echo $1"
|
||||
|
||||
prop_cantSourceDynamic =
|
||||
[1090] == checkWithIncludes [("lib", "")] ". \"$1\""
|
||||
|
||||
prop_cantSourceDynamic2 =
|
||||
[1090] == checkWithIncludes [("lib", "")] "source ~/foo"
|
||||
|
||||
prop_canStripPrefixAndSource =
|
||||
null $ checkWithIncludes [("./lib", "")] "source \"$MYDIR/lib\""
|
||||
|
||||
prop_canStripPrefixAndSource2 =
|
||||
null $ checkWithIncludes [("./utils.sh", "")] "source \"$(dirname \"${BASH_SOURCE[0]}\")/utils.sh\""
|
||||
|
||||
prop_canSourceDynamicWhenRedirected =
|
||||
null $ checkWithIncludes [("lib", "")] "#shellcheck source=lib\n. \"$1\""
|
||||
|
||||
prop_canRedirectWithSpaces =
|
||||
null $ checkWithIncludes [("my file", "")] "#shellcheck source=\"my file\"\n. \"$1\""
|
||||
|
||||
prop_recursiveAnalysis =
|
||||
[2086] == checkRecursive [("lib", "echo $1")] "source lib"
|
||||
|
||||
prop_recursiveParsing =
|
||||
[1037] == checkRecursive [("lib", "echo \"$10\"")] "source lib"
|
||||
|
||||
prop_nonRecursiveAnalysis =
|
||||
null $ checkWithIncludes [("lib", "echo $1")] "source lib"
|
||||
|
||||
prop_nonRecursiveParsing =
|
||||
null $ checkWithIncludes [("lib", "echo \"$10\"")] "source lib"
|
||||
|
||||
prop_sourceDirectiveDoesntFollowFile =
|
||||
null $ checkWithIncludes
|
||||
[("foo", "source bar"), ("bar", "baz=3")]
|
||||
"#shellcheck source=foo\n. \"$1\"; echo \"$baz\""
|
||||
|
||||
prop_filewideAnnotationBase = [2086] == check "#!/bin/sh\necho $1"
|
||||
prop_filewideAnnotation1 = null $
|
||||
check "#!/bin/sh\n# shellcheck disable=2086\necho $1"
|
||||
prop_filewideAnnotation2 = null $
|
||||
check "#!/bin/sh\n# shellcheck disable=2086\ntrue\necho $1"
|
||||
prop_filewideAnnotation3 = null $
|
||||
check "#!/bin/sh\n#unrelated\n# shellcheck disable=2086\ntrue\necho $1"
|
||||
prop_filewideAnnotation4 = null $
|
||||
check "#!/bin/sh\n# shellcheck disable=2086\n#unrelated\ntrue\necho $1"
|
||||
prop_filewideAnnotation5 = null $
|
||||
check "#!/bin/sh\n\n\n\n#shellcheck disable=2086\ntrue\necho $1"
|
||||
prop_filewideAnnotation6 = null $
|
||||
check "#shellcheck shell=sh\n#unrelated\n#shellcheck disable=2086\ntrue\necho $1"
|
||||
prop_filewideAnnotation7 = null $
|
||||
check "#!/bin/sh\n# shellcheck disable=2086\n#unrelated\ntrue\necho $1"
|
||||
|
||||
prop_filewideAnnotationBase2 = [2086, 2181] == check "true\n[ $? == 0 ] && echo $1"
|
||||
prop_filewideAnnotation8 = null $
|
||||
check "# Disable $? warning\n#shellcheck disable=SC2181\n# Disable quoting warning\n#shellcheck disable=2086\ntrue\n[ $? == 0 ] && echo $1"
|
||||
|
||||
prop_sourcePartOfOriginalScript = -- #1181: -x disabled posix warning for 'source'
|
||||
3046 `elem` checkWithIncludes [("./saywhat.sh", "echo foo")] "#!/bin/sh\nsource ./saywhat.sh"
|
||||
|
||||
prop_spinBug1413 = null $ check "fun() {\n# shellcheck disable=SC2188\n> /dev/null\n}\n"
|
||||
|
||||
prop_deducesTypeFromExtension = null result
|
||||
where
|
||||
result = checkWithSpec [] emptyCheckSpec {
|
||||
csFilename = "file.ksh",
|
||||
csScript = "(( 3.14 ))"
|
||||
}
|
||||
|
||||
prop_deducesTypeFromExtension2 = result == [2079]
|
||||
where
|
||||
result = checkWithSpec [] emptyCheckSpec {
|
||||
csFilename = "file.bash",
|
||||
csScript = "(( 3.14 ))"
|
||||
}
|
||||
|
||||
prop_canDisableShebangWarning = null $ result
|
||||
where
|
||||
result = checkWithSpec [] emptyCheckSpec {
|
||||
csFilename = "file.sh",
|
||||
csScript = "#shellcheck disable=SC2148\nfoo"
|
||||
}
|
||||
|
||||
prop_canDisableAllWarnings = result == [2086]
|
||||
where
|
||||
result = checkWithSpec [] emptyCheckSpec {
|
||||
csFilename = "file.sh",
|
||||
csScript = "#!/bin/sh\necho $1\n#shellcheck disable=all\necho `echo $1`"
|
||||
}
|
||||
|
||||
prop_canDisableParseErrors = null $ result
|
||||
where
|
||||
result = checkWithSpec [] emptyCheckSpec {
|
||||
csFilename = "file.sh",
|
||||
csScript = "#shellcheck disable=SC1073,SC1072,SC2148\n()"
|
||||
}
|
||||
|
||||
prop_shExtensionDoesntMatter = result == [2148]
|
||||
where
|
||||
result = checkWithSpec [] emptyCheckSpec {
|
||||
csFilename = "file.sh",
|
||||
csScript = "echo 'hello world'"
|
||||
}
|
||||
|
||||
prop_sourcedFileUsesOriginalShellExtension = result == [2079]
|
||||
where
|
||||
result = checkWithSpec [("file.ksh", "(( 3.14 ))")] emptyCheckSpec {
|
||||
csFilename = "file.bash",
|
||||
csScript = "source file.ksh",
|
||||
csCheckSourced = True
|
||||
}
|
||||
|
||||
prop_canEnableOptionalsWithSpec = result == [2244]
|
||||
where
|
||||
result = checkWithSpec [] emptyCheckSpec {
|
||||
csFilename = "file.sh",
|
||||
csScript = "#!/bin/sh\n[ \"$1\" ]",
|
||||
csOptionalChecks = ["avoid-nullary-conditions"]
|
||||
}
|
||||
|
||||
prop_optionIncludes1 =
|
||||
-- expect 2086, but not included, so nothing reported
|
||||
null $ checkOptionIncludes (Just [2080]) "#!/bin/sh\n var='a b'\n echo $var"
|
||||
|
||||
prop_optionIncludes2 =
|
||||
-- expect 2086, included, so it is reported
|
||||
[2086] == checkOptionIncludes (Just [2086]) "#!/bin/sh\n var='a b'\n echo $var"
|
||||
|
||||
prop_optionIncludes3 =
|
||||
-- expect 2086, no inclusions provided, so it is reported
|
||||
[2086] == checkOptionIncludes Nothing "#!/bin/sh\n var='a b'\n echo $var"
|
||||
|
||||
prop_optionIncludes4 =
|
||||
-- expect 2086 & 2154, only 2154 included, so only that's reported
|
||||
[2154] == checkOptionIncludes (Just [2154]) "#!/bin/sh\n var='a b'\n echo $var\n echo $bar"
|
||||
|
||||
|
||||
prop_readsRcFile = null result
|
||||
where
|
||||
result = checkWithRc "disable=2086" emptyCheckSpec {
|
||||
csScript = "#!/bin/sh\necho $1",
|
||||
csIgnoreRC = False
|
||||
}
|
||||
|
||||
prop_canUseNoRC = result == [2086]
|
||||
where
|
||||
result = checkWithRc "disable=2086" emptyCheckSpec {
|
||||
csScript = "#!/bin/sh\necho $1",
|
||||
csIgnoreRC = True
|
||||
}
|
||||
|
||||
prop_NoRCWontLookAtFile = result == [2086]
|
||||
where
|
||||
result = checkWithRc (error "Fail") emptyCheckSpec {
|
||||
csScript = "#!/bin/sh\necho $1",
|
||||
csIgnoreRC = True
|
||||
}
|
||||
|
||||
prop_brokenRcGetsWarning = result == [1134, 2086]
|
||||
where
|
||||
result = checkWithRc "rofl" emptyCheckSpec {
|
||||
csScript = "#!/bin/sh\necho $1",
|
||||
csIgnoreRC = False
|
||||
}
|
||||
|
||||
prop_canEnableOptionalsWithRc = result == [2244]
|
||||
where
|
||||
result = checkWithRc "enable=avoid-nullary-conditions" emptyCheckSpec {
|
||||
csScript = "#!/bin/sh\n[ \"$1\" ]"
|
||||
}
|
||||
|
||||
prop_sourcePathRedirectsName = result == [2086]
|
||||
where
|
||||
f "dir/myscript" _ _ "lib" = return "foo/lib"
|
||||
result = checkWithIncludesAndSourcePath [("foo/lib", "echo $1")] f emptyCheckSpec {
|
||||
csScript = "#!/bin/bash\nsource lib",
|
||||
csFilename = "dir/myscript",
|
||||
csCheckSourced = True
|
||||
}
|
||||
|
||||
prop_sourcePathAddsAnnotation = result == [2086]
|
||||
where
|
||||
f "dir/myscript" _ ["mypath"] "lib" = return "foo/lib"
|
||||
result = checkWithIncludesAndSourcePath [("foo/lib", "echo $1")] f emptyCheckSpec {
|
||||
csScript = "#!/bin/bash\n# shellcheck source-path=mypath\nsource lib",
|
||||
csFilename = "dir/myscript",
|
||||
csCheckSourced = True
|
||||
}
|
||||
|
||||
prop_sourcePathWorksWithSpaces = result == [2086]
|
||||
where
|
||||
f "dir/myscript" _ ["my path"] "lib" = return "foo/lib"
|
||||
result = checkWithIncludesAndSourcePath [("foo/lib", "echo $1")] f emptyCheckSpec {
|
||||
csScript = "#!/bin/bash\n# shellcheck source-path='my path'\nsource lib",
|
||||
csFilename = "dir/myscript",
|
||||
csCheckSourced = True
|
||||
}
|
||||
|
||||
prop_sourcePathRedirectsDirective = result == [2086]
|
||||
where
|
||||
f "dir/myscript" _ _ "lib" = return "foo/lib"
|
||||
f _ _ _ _ = return "/dev/null"
|
||||
result = checkWithIncludesAndSourcePath [("foo/lib", "echo $1")] f emptyCheckSpec {
|
||||
csScript = "#!/bin/bash\n# shellcheck source=lib\nsource kittens",
|
||||
csFilename = "dir/myscript",
|
||||
csCheckSourced = True
|
||||
}
|
||||
|
||||
prop_rcCanAllowExternalSources = result == [2086]
|
||||
where
|
||||
f "dir/myscript" (Just True) _ "mylib" = return "resolved/mylib"
|
||||
f a b c d = error $ show ("Unexpected", a, b, c, d)
|
||||
result = checkWithRcIncludesAndSourcePath "external-sources=true" [("resolved/mylib", "echo $1")] f emptyCheckSpec {
|
||||
csScript = "#!/bin/bash\nsource mylib",
|
||||
csFilename = "dir/myscript",
|
||||
csCheckSourced = True
|
||||
}
|
||||
|
||||
prop_rcCanDenyExternalSources = result == [2086]
|
||||
where
|
||||
f "dir/myscript" (Just False) _ "mylib" = return "resolved/mylib"
|
||||
f a b c d = error $ show ("Unexpected", a, b, c, d)
|
||||
result = checkWithRcIncludesAndSourcePath "external-sources=false" [("resolved/mylib", "echo $1")] f emptyCheckSpec {
|
||||
csScript = "#!/bin/bash\nsource mylib",
|
||||
csFilename = "dir/myscript",
|
||||
csCheckSourced = True
|
||||
}
|
||||
|
||||
prop_rcCanLeaveExternalSourcesUnspecified = result == [2086]
|
||||
where
|
||||
f "dir/myscript" Nothing _ "mylib" = return "resolved/mylib"
|
||||
f a b c d = error $ show ("Unexpected", a, b, c, d)
|
||||
result = checkWithRcIncludesAndSourcePath "" [("resolved/mylib", "echo $1")] f emptyCheckSpec {
|
||||
csScript = "#!/bin/bash\nsource mylib",
|
||||
csFilename = "dir/myscript",
|
||||
csCheckSourced = True
|
||||
}
|
||||
|
||||
prop_fileCanDisableExternalSources = result == [2006, 2086]
|
||||
where
|
||||
f "dir/myscript" (Just True) _ "withExternal" = return "withExternal"
|
||||
f "dir/myscript" (Just False) _ "withoutExternal" = return "withoutExternal"
|
||||
f a b c d = error $ show ("Unexpected", a, b, c, d)
|
||||
result = checkWithRcIncludesAndSourcePath "external-sources=true" [("withExternal", "echo $1"), ("withoutExternal", "_=`foo`")] f emptyCheckSpec {
|
||||
csScript = "#!/bin/bash\ntrue\nsource withExternal\n# shellcheck external-sources=false\nsource withoutExternal",
|
||||
csFilename = "dir/myscript",
|
||||
csCheckSourced = True
|
||||
}
|
||||
|
||||
prop_fileCannotEnableExternalSources = result == [1144]
|
||||
where
|
||||
f "dir/myscript" Nothing _ "foo" = return "foo"
|
||||
f a b c d = error $ show ("Unexpected", a, b, c, d)
|
||||
result = checkWithRcIncludesAndSourcePath "" [("foo", "true")] f emptyCheckSpec {
|
||||
csScript = "#!/bin/bash\n# shellcheck external-sources=true\nsource foo",
|
||||
csFilename = "dir/myscript",
|
||||
csCheckSourced = True
|
||||
}
|
||||
|
||||
prop_fileCannotEnableExternalSources2 = result == [1144]
|
||||
where
|
||||
f "dir/myscript" (Just False) _ "foo" = return "foo"
|
||||
f a b c d = error $ show ("Unexpected", a, b, c, d)
|
||||
result = checkWithRcIncludesAndSourcePath "external-sources=false" [("foo", "true")] f emptyCheckSpec {
|
||||
csScript = "#!/bin/bash\n# shellcheck external-sources=true\nsource foo",
|
||||
csFilename = "dir/myscript",
|
||||
csCheckSourced = True
|
||||
}
|
||||
|
||||
prop_rcCanSuppressEarlyProblems1 = null result
|
||||
where
|
||||
result = checkWithRc "disable=1071" emptyCheckSpec {
|
||||
csScript = "#!/bin/zsh\necho $1"
|
||||
}
|
||||
|
||||
prop_rcCanSuppressEarlyProblems2 = null result
|
||||
where
|
||||
result = checkWithRc "disable=1104" emptyCheckSpec {
|
||||
csScript = "!/bin/bash\necho 'hello world'"
|
||||
}
|
||||
|
||||
prop_sourceWithHereDocWorks = null result
|
||||
where
|
||||
result = checkWithIncludes [("bar", "true\n")] "source bar << eof\nlol\neof"
|
||||
|
||||
prop_hereDocsAreParsedWithoutTrailingLinefeed = 1044 `elem` result
|
||||
where
|
||||
result = check "cat << eof"
|
||||
|
||||
prop_hereDocsWillHaveParsedIndices = null result
|
||||
where
|
||||
result = check "#!/bin/bash\nmy_array=(a b)\ncat <<EOF >> ./test\n $(( 1 + my_array[1] ))\nEOF"
|
||||
|
||||
prop_rcCanSuppressDfa = null result
|
||||
where
|
||||
result = checkWithRc "extended-analysis=false" emptyCheckSpec {
|
||||
csScript = "#!/bin/sh\nexit; foo;"
|
||||
}
|
||||
|
||||
prop_fileCanSuppressDfa = null $ traceShowId result
|
||||
where
|
||||
result = checkWithRc "" emptyCheckSpec {
|
||||
csScript = "#!/bin/sh\n# shellcheck extended-analysis=false\nexit; foo;"
|
||||
}
|
||||
|
||||
prop_fileWinsWhenSuppressingDfa1 = null result
|
||||
where
|
||||
result = checkWithRc "extended-analysis=true" emptyCheckSpec {
|
||||
csScript = "#!/bin/sh\n# shellcheck extended-analysis=false\nexit; foo;"
|
||||
}
|
||||
|
||||
prop_fileWinsWhenSuppressingDfa2 = result == [2317]
|
||||
where
|
||||
result = checkWithRc "extended-analysis=false" emptyCheckSpec {
|
||||
csScript = "#!/bin/sh\n# shellcheck extended-analysis=true\nexit; foo;"
|
||||
}
|
||||
|
||||
prop_flagWinsWhenSuppressingDfa1 = result == [2317]
|
||||
where
|
||||
result = checkWithRc "extended-analysis=false" emptyCheckSpec {
|
||||
csScript = "#!/bin/sh\n# shellcheck extended-analysis=false\nexit; foo;",
|
||||
csExtendedAnalysis = Just True
|
||||
}
|
||||
|
||||
prop_flagWinsWhenSuppressingDfa2 = null result
|
||||
where
|
||||
result = checkWithRc "extended-analysis=true" emptyCheckSpec {
|
||||
csScript = "#!/bin/sh\n# shellcheck extended-analysis=true\nexit; foo;",
|
||||
csExtendedAnalysis = Just False
|
||||
}
|
||||
|
||||
return []
|
||||
runTests = $quickCheckAll
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,101 +0,0 @@
|
|||
{-
|
||||
Copyright 2022 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
{-# LANGUAGE TemplateHaskell #-}
|
||||
|
||||
-- Checks that run on the Control Flow Graph (as opposed to the AST)
|
||||
-- This is scaffolding for a work in progress.
|
||||
|
||||
module ShellCheck.Checks.ControlFlow (checker, optionalChecks, ShellCheck.Checks.ControlFlow.runTests) where
|
||||
|
||||
import ShellCheck.AST
|
||||
import ShellCheck.ASTLib
|
||||
import ShellCheck.CFG hiding (cfgAnalysis)
|
||||
import ShellCheck.CFGAnalysis
|
||||
import ShellCheck.AnalyzerLib
|
||||
import ShellCheck.Data
|
||||
import ShellCheck.Interface
|
||||
|
||||
import Control.Monad
|
||||
import Control.Monad.Reader
|
||||
import Data.Graph.Inductive.Graph
|
||||
import qualified Data.Map as M
|
||||
import qualified Data.Set as S
|
||||
import Data.List
|
||||
import Data.Maybe
|
||||
|
||||
import Test.QuickCheck.All (forAllProperties)
|
||||
import Test.QuickCheck.Test (quickCheckWithResult, stdArgs, maxSuccess)
|
||||
|
||||
|
||||
optionalChecks :: [CheckDescription]
|
||||
optionalChecks = []
|
||||
|
||||
-- A check that runs on the entire graph
|
||||
type ControlFlowCheck = Analysis
|
||||
-- A check invoked once per node, with its (pre,post) data
|
||||
type ControlFlowNodeCheck = LNode CFNode -> (ProgramState, ProgramState) -> Analysis
|
||||
-- A check invoked once per effect, with its node's (pre,post) data
|
||||
type ControlFlowEffectCheck = IdTagged CFEffect -> Node -> (ProgramState, ProgramState) -> Analysis
|
||||
|
||||
|
||||
checker :: AnalysisSpec -> Parameters -> Checker
|
||||
checker spec params = Checker {
|
||||
perScript = const $ sequence_ controlFlowChecks,
|
||||
perToken = const $ return ()
|
||||
}
|
||||
|
||||
controlFlowChecks :: [ControlFlowCheck]
|
||||
controlFlowChecks = [
|
||||
runNodeChecks controlFlowNodeChecks
|
||||
]
|
||||
|
||||
controlFlowNodeChecks :: [ControlFlowNodeCheck]
|
||||
controlFlowNodeChecks = [
|
||||
runEffectChecks controlFlowEffectChecks
|
||||
]
|
||||
|
||||
controlFlowEffectChecks :: [ControlFlowEffectCheck]
|
||||
controlFlowEffectChecks = [
|
||||
]
|
||||
|
||||
runNodeChecks :: [ControlFlowNodeCheck] -> ControlFlowCheck
|
||||
runNodeChecks perNode = do
|
||||
cfg <- asks cfgAnalysis
|
||||
mapM_ runOnAll cfg
|
||||
where
|
||||
getData datas n@(node, label) = do
|
||||
(pre, post) <- M.lookup node datas
|
||||
return (n, (pre, post))
|
||||
|
||||
runOn :: (LNode CFNode, (ProgramState, ProgramState)) -> Analysis
|
||||
runOn (node, prepost) = mapM_ (\c -> c node prepost) perNode
|
||||
runOnAll cfg = mapM_ runOn $ mapMaybe (getData $ nodeToData cfg) $ labNodes (graph cfg)
|
||||
|
||||
runEffectChecks :: [ControlFlowEffectCheck] -> ControlFlowNodeCheck
|
||||
runEffectChecks list = checkNode
|
||||
where
|
||||
checkNode (node, label) prepost =
|
||||
case label of
|
||||
CFApplyEffects effects -> mapM_ (\effect -> mapM_ (\c -> c effect node prepost) list) effects
|
||||
_ -> return ()
|
||||
|
||||
|
||||
return []
|
||||
runTests = $( [| $(forAllProperties) (quickCheckWithResult (stdArgs { maxSuccess = 1 }) ) |])
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
{-
|
||||
This empty file is provided for ease of patching in site specific checks.
|
||||
However, there are no guarantees regarding compatibility between versions.
|
||||
-}
|
||||
|
||||
{-# LANGUAGE TemplateHaskell #-}
|
||||
module ShellCheck.Checks.Custom (checker, ShellCheck.Checks.Custom.runTests) where
|
||||
|
||||
import ShellCheck.AnalyzerLib
|
||||
import Test.QuickCheck
|
||||
|
||||
checker :: Parameters -> Checker
|
||||
checker params = Checker {
|
||||
perScript = const $ return (),
|
||||
perToken = const $ return ()
|
||||
}
|
||||
|
||||
prop_CustomTestsWork = True
|
||||
|
||||
return []
|
||||
runTests = $quickCheckAll
|
||||
|
|
@ -1,701 +0,0 @@
|
|||
{-
|
||||
Copyright 2012-2020 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
{-# LANGUAGE TemplateHaskell #-}
|
||||
{-# LANGUAGE FlexibleContexts #-}
|
||||
{-# LANGUAGE ViewPatterns #-}
|
||||
module ShellCheck.Checks.ShellSupport (checker , ShellCheck.Checks.ShellSupport.runTests) where
|
||||
|
||||
import ShellCheck.AST
|
||||
import ShellCheck.ASTLib
|
||||
import ShellCheck.AnalyzerLib
|
||||
import ShellCheck.Interface
|
||||
import ShellCheck.Prelude
|
||||
import ShellCheck.Regex
|
||||
|
||||
import Control.Monad
|
||||
import Control.Monad.RWS
|
||||
import Data.Char
|
||||
import Data.Functor.Identity
|
||||
import Data.List
|
||||
import Data.Maybe
|
||||
import qualified Data.Map as Map
|
||||
import qualified Data.Set as Set
|
||||
import Test.QuickCheck.All (forAllProperties)
|
||||
import Test.QuickCheck.Test (quickCheckWithResult, stdArgs, maxSuccess)
|
||||
|
||||
data ForShell = ForShell [Shell] (Token -> Analysis)
|
||||
|
||||
getChecker params list = Checker {
|
||||
perScript = nullCheck,
|
||||
perToken = foldl composeAnalyzers nullCheck $ mapMaybe include list
|
||||
}
|
||||
where
|
||||
shell = shellType params
|
||||
include (ForShell list a) = do
|
||||
guard $ shell `elem` list
|
||||
return a
|
||||
|
||||
checker params = getChecker params checks
|
||||
|
||||
checks = [
|
||||
checkForDecimals
|
||||
,checkBashisms
|
||||
,checkEchoSed
|
||||
,checkBraceExpansionVars
|
||||
,checkMultiDimensionalArrays
|
||||
,checkPS1Assignments
|
||||
,checkMultipleBangs
|
||||
,checkBangAfterPipe
|
||||
,checkNegatedUnaryOps
|
||||
]
|
||||
|
||||
testChecker (ForShell _ t) =
|
||||
Checker {
|
||||
perScript = nullCheck,
|
||||
perToken = t
|
||||
}
|
||||
verify c s = producesComments (testChecker c) s == Just True
|
||||
verifyNot c s = producesComments (testChecker c) s == Just False
|
||||
|
||||
prop_checkForDecimals1 = verify checkForDecimals "((3.14*c))"
|
||||
prop_checkForDecimals2 = verify checkForDecimals "foo[1.2]=bar"
|
||||
prop_checkForDecimals3 = verifyNot checkForDecimals "declare -A foo; foo[1.2]=bar"
|
||||
checkForDecimals = ForShell [Sh, Dash, BusyboxSh, Bash] f
|
||||
where
|
||||
f t@(TA_Expansion id _) = sequence_ $ do
|
||||
first:rest <- getLiteralString t
|
||||
guard $ isDigit first && '.' `elem` rest
|
||||
return $ err id 2079 "(( )) doesn't support decimals. Use bc or awk."
|
||||
f _ = return ()
|
||||
|
||||
|
||||
prop_checkBashisms = verify checkBashisms "while read a; do :; done < <(a)"
|
||||
prop_checkBashisms2 = verifyNot checkBashisms "[ foo -nt bar ]"
|
||||
prop_checkBashisms3 = verify checkBashisms "echo $((i++))"
|
||||
prop_checkBashisms4 = verify checkBashisms "rm !(*.hs)"
|
||||
prop_checkBashisms5 = verify checkBashisms "source file"
|
||||
prop_checkBashisms6 = verify checkBashisms "[ \"$a\" == 42 ]"
|
||||
prop_checkBashisms6b = verify checkBashisms "test \"$a\" == 42"
|
||||
prop_checkBashisms6c = verify checkBashisms "[ foo =~ bar ]"
|
||||
prop_checkBashisms6d = verify checkBashisms "test foo =~ bar"
|
||||
prop_checkBashisms7 = verify checkBashisms "echo ${var[1]}"
|
||||
prop_checkBashisms8 = verify checkBashisms "echo ${!var[@]}"
|
||||
prop_checkBashisms9 = verify checkBashisms "echo ${!var*}"
|
||||
prop_checkBashisms10 = verify checkBashisms "echo ${var:4:12}"
|
||||
prop_checkBashisms11 = verifyNot checkBashisms "echo ${var:-4}"
|
||||
prop_checkBashisms12 = verify checkBashisms "echo ${var//foo/bar}"
|
||||
prop_checkBashisms13 = verify checkBashisms "exec -c env"
|
||||
prop_checkBashisms14 = verify checkBashisms "echo -n \"Foo: \""
|
||||
prop_checkBashisms15 = verify checkBashisms "let n++"
|
||||
prop_checkBashisms16 = verify checkBashisms "echo $RANDOM"
|
||||
prop_checkBashisms17 = verify checkBashisms "echo $((RANDOM%6+1))"
|
||||
prop_checkBashisms18 = verify checkBashisms "foo &> /dev/null"
|
||||
prop_checkBashisms19 = verify checkBashisms "foo > file*.txt"
|
||||
prop_checkBashisms20 = verify checkBashisms "read -ra foo"
|
||||
prop_checkBashisms21 = verify checkBashisms "[ -a foo ]"
|
||||
prop_checkBashisms21b = verify checkBashisms "test -a foo"
|
||||
prop_checkBashisms22 = verifyNot checkBashisms "[ foo -a bar ]"
|
||||
prop_checkBashisms23 = verify checkBashisms "trap mything ERR INT"
|
||||
prop_checkBashisms24 = verifyNot checkBashisms "trap mything INT TERM"
|
||||
prop_checkBashisms25 = verify checkBashisms "cat < /dev/tcp/host/123"
|
||||
prop_checkBashisms26 = verify checkBashisms "trap mything ERR SIGTERM"
|
||||
prop_checkBashisms27 = verify checkBashisms "echo *[^0-9]*"
|
||||
prop_checkBashisms28 = verify checkBashisms "exec {n}>&2"
|
||||
prop_checkBashisms29 = verify checkBashisms "echo ${!var}"
|
||||
prop_checkBashisms30 = verify checkBashisms "printf -v '%s' \"$1\""
|
||||
prop_checkBashisms31 = verify checkBashisms "printf '%q' \"$1\""
|
||||
prop_checkBashisms32 = verifyNot checkBashisms "#!/bin/dash\n[ foo -nt bar ]"
|
||||
prop_checkBashisms33 = verify checkBashisms "#!/bin/sh\necho -n foo"
|
||||
prop_checkBashisms34 = verifyNot checkBashisms "#!/bin/dash\necho -n foo"
|
||||
prop_checkBashisms35 = verifyNot checkBashisms "#!/bin/dash\nlocal foo"
|
||||
prop_checkBashisms36 = verifyNot checkBashisms "#!/bin/dash\nread -p foo -r bar"
|
||||
prop_checkBashisms37 = verifyNot checkBashisms "HOSTNAME=foo; echo $HOSTNAME"
|
||||
prop_checkBashisms38 = verify checkBashisms "RANDOM=9; echo $RANDOM"
|
||||
prop_checkBashisms39 = verify checkBashisms "foo-bar() { true; }"
|
||||
prop_checkBashisms40 = verify checkBashisms "echo $(<file)"
|
||||
prop_checkBashisms41 = verify checkBashisms "echo `<file`"
|
||||
prop_checkBashisms42 = verify checkBashisms "trap foo int"
|
||||
prop_checkBashisms43 = verify checkBashisms "trap foo sigint"
|
||||
prop_checkBashisms44 = verifyNot checkBashisms "#!/bin/dash\ntrap foo int"
|
||||
prop_checkBashisms45 = verifyNot checkBashisms "#!/bin/dash\ntrap foo INT"
|
||||
prop_checkBashisms46 = verify checkBashisms "#!/bin/dash\ntrap foo SIGINT"
|
||||
prop_checkBashisms47 = verify checkBashisms "#!/bin/dash\necho foo 42>/dev/null"
|
||||
prop_checkBashisms48 = verifyNot checkBashisms "#!/bin/sh\necho $LINENO"
|
||||
prop_checkBashisms49 = verify checkBashisms "#!/bin/dash\necho $MACHTYPE"
|
||||
prop_checkBashisms50 = verify checkBashisms "#!/bin/sh\ncmd >& file"
|
||||
prop_checkBashisms51 = verifyNot checkBashisms "#!/bin/sh\ncmd 2>&1"
|
||||
prop_checkBashisms52 = verifyNot checkBashisms "#!/bin/sh\ncmd >&2"
|
||||
prop_checkBashisms52b = verifyNot checkBashisms "#!/bin/sh\ncmd >& $var"
|
||||
prop_checkBashisms52c = verify checkBashisms "#!/bin/sh\ncmd >& $dir/$var"
|
||||
prop_checkBashisms53 = verifyNot checkBashisms "#!/bin/sh\nprintf -- -f\n"
|
||||
prop_checkBashisms54 = verify checkBashisms "#!/bin/sh\nfoo+=bar"
|
||||
prop_checkBashisms55 = verify checkBashisms "#!/bin/sh\necho ${@%foo}"
|
||||
prop_checkBashisms56 = verifyNot checkBashisms "#!/bin/sh\necho ${##}"
|
||||
prop_checkBashisms57 = verifyNot checkBashisms "#!/bin/dash\nulimit -c 0"
|
||||
prop_checkBashisms58 = verify checkBashisms "#!/bin/sh\nulimit -c 0"
|
||||
prop_checkBashisms59 = verify checkBashisms "#!/bin/sh\njobs -s"
|
||||
prop_checkBashisms60 = verifyNot checkBashisms "#!/bin/sh\njobs -p"
|
||||
prop_checkBashisms61 = verifyNot checkBashisms "#!/bin/sh\njobs -lp"
|
||||
prop_checkBashisms62 = verify checkBashisms "#!/bin/sh\nexport -f foo"
|
||||
prop_checkBashisms63 = verifyNot checkBashisms "#!/bin/sh\nexport -p"
|
||||
prop_checkBashisms64 = verify checkBashisms "#!/bin/sh\nreadonly -a"
|
||||
prop_checkBashisms65 = verifyNot checkBashisms "#!/bin/sh\nreadonly -p"
|
||||
prop_checkBashisms66 = verifyNot checkBashisms "#!/bin/sh\ncd -P ."
|
||||
prop_checkBashisms67 = verify checkBashisms "#!/bin/sh\ncd -P -e ."
|
||||
prop_checkBashisms68 = verify checkBashisms "#!/bin/sh\numask -p"
|
||||
prop_checkBashisms69 = verifyNot checkBashisms "#!/bin/sh\numask -S"
|
||||
prop_checkBashisms70 = verify checkBashisms "#!/bin/sh\ntrap -l"
|
||||
prop_checkBashisms71 = verify checkBashisms "#!/bin/sh\ntype -a ls"
|
||||
prop_checkBashisms72 = verifyNot checkBashisms "#!/bin/sh\ntype ls"
|
||||
prop_checkBashisms73 = verify checkBashisms "#!/bin/sh\nunset -n namevar"
|
||||
prop_checkBashisms74 = verifyNot checkBashisms "#!/bin/sh\nunset -f namevar"
|
||||
prop_checkBashisms75 = verifyNot checkBashisms "#!/bin/sh\necho \"-n foo\""
|
||||
prop_checkBashisms76 = verifyNot checkBashisms "#!/bin/sh\necho \"-ne foo\""
|
||||
prop_checkBashisms77 = verifyNot checkBashisms "#!/bin/sh\necho -Q foo"
|
||||
prop_checkBashisms78 = verify checkBashisms "#!/bin/sh\necho -ne foo"
|
||||
prop_checkBashisms79 = verify checkBashisms "#!/bin/sh\nhash -l"
|
||||
prop_checkBashisms80 = verifyNot checkBashisms "#!/bin/sh\nhash -r"
|
||||
prop_checkBashisms81 = verifyNot checkBashisms "#!/bin/dash\nhash -v"
|
||||
prop_checkBashisms82 = verifyNot checkBashisms "#!/bin/sh\nset -v +o allexport -o errexit -C"
|
||||
prop_checkBashisms83 = verifyNot checkBashisms "#!/bin/sh\nset --"
|
||||
prop_checkBashisms84 = verify checkBashisms "#!/bin/sh\nset -o pipefail"
|
||||
prop_checkBashisms85 = verify checkBashisms "#!/bin/sh\nset -B"
|
||||
prop_checkBashisms86 = verifyNot checkBashisms "#!/bin/dash\nset -o emacs"
|
||||
prop_checkBashisms87 = verify checkBashisms "#!/bin/sh\nset -o emacs"
|
||||
prop_checkBashisms88 = verifyNot checkBashisms "#!/bin/sh\nset -- wget -o foo 'https://some.url'"
|
||||
prop_checkBashisms89 = verifyNot checkBashisms "#!/bin/sh\nopts=$-\nset -\"$opts\""
|
||||
prop_checkBashisms90 = verifyNot checkBashisms "#!/bin/sh\nset -o \"$opt\""
|
||||
prop_checkBashisms91 = verify checkBashisms "#!/bin/sh\nwait -n"
|
||||
prop_checkBashisms92 = verify checkBashisms "#!/bin/sh\necho $((16#FF))"
|
||||
prop_checkBashisms93 = verify checkBashisms "#!/bin/sh\necho $(( 10#$(date +%m) ))"
|
||||
prop_checkBashisms94 = verify checkBashisms "#!/bin/sh\n[ -v var ]"
|
||||
prop_checkBashisms95 = verify checkBashisms "#!/bin/sh\necho $_"
|
||||
prop_checkBashisms96 = verifyNot checkBashisms "#!/bin/dash\necho $_"
|
||||
prop_checkBashisms97 = verify checkBashisms "#!/bin/sh\necho ${var,}"
|
||||
prop_checkBashisms98 = verify checkBashisms "#!/bin/sh\necho ${var^^}"
|
||||
prop_checkBashisms99 = verify checkBashisms "#!/bin/dash\necho [^f]oo"
|
||||
prop_checkBashisms100 = verify checkBashisms "read -r"
|
||||
prop_checkBashisms101 = verify checkBashisms "read"
|
||||
prop_checkBashisms102 = verifyNot checkBashisms "read -r foo"
|
||||
prop_checkBashisms103 = verifyNot checkBashisms "read foo"
|
||||
prop_checkBashisms104 = verifyNot checkBashisms "read ''"
|
||||
prop_checkBashisms105 = verifyNot checkBashisms "#!/bin/busybox sh\nset -o pipefail"
|
||||
prop_checkBashisms106 = verifyNot checkBashisms "#!/bin/busybox sh\nx=x\n[[ \"$x\" = \"$x\" ]]"
|
||||
prop_checkBashisms107 = verifyNot checkBashisms "#!/bin/busybox sh\nx=x\n[ \"$x\" == \"$x\" ]"
|
||||
prop_checkBashisms108 = verifyNot checkBashisms "#!/bin/busybox sh\necho magic &> /dev/null"
|
||||
prop_checkBashisms109 = verifyNot checkBashisms "#!/bin/busybox sh\ntrap stop EXIT SIGTERM"
|
||||
prop_checkBashisms110 = verifyNot checkBashisms "#!/bin/busybox sh\nsource /dev/null"
|
||||
prop_checkBashisms111 = verify checkBashisms "#!/bin/dash\nx='test'\n${x:0:3}" -- SC3057
|
||||
prop_checkBashisms112 = verifyNot checkBashisms "#!/bin/busybox sh\nx='test'\n${x:0:3}" -- SC3057
|
||||
prop_checkBashisms113 = verify checkBashisms "#!/bin/dash\nx='test'\n${x/st/xt}" -- SC3060
|
||||
prop_checkBashisms114 = verifyNot checkBashisms "#!/bin/busybox sh\nx='test'\n${x/st/xt}" -- SC3060
|
||||
prop_checkBashisms115 = verify checkBashisms "#!/bin/busybox sh\nx='test'\n${!x}" -- SC3053
|
||||
prop_checkBashisms116 = verify checkBashisms "#!/bin/busybox sh\nx='test'\n${x[1]}" -- SC3054
|
||||
prop_checkBashisms117 = verify checkBashisms "#!/bin/busybox sh\nx='test'\n${!x[@]}" -- SC3055
|
||||
prop_checkBashisms118 = verify checkBashisms "#!/bin/busybox sh\nxyz=1\n${!x*}" -- SC3056
|
||||
prop_checkBashisms119 = verify checkBashisms "#!/bin/busybox sh\nx='test'\n${x^^[t]}" -- SC3059
|
||||
prop_checkBashisms120 = verify checkBashisms "#!/bin/sh\n[ x == y ]"
|
||||
prop_checkBashisms121 = verifyNot checkBashisms "#!/bin/sh\n# shellcheck shell=busybox\n[ x == y ]"
|
||||
prop_checkBashisms122 = verify checkBashisms "#!/bin/dash\n$'a'"
|
||||
prop_checkBashisms123 = verifyNot checkBashisms "#!/bin/busybox sh\n$'a'"
|
||||
prop_checkBashisms124 = verify checkBashisms "#!/bin/dash\ntype -p test"
|
||||
prop_checkBashisms125 = verifyNot checkBashisms "#!/bin/busybox sh\ntype -p test"
|
||||
prop_checkBashisms126 = verifyNot checkBashisms "#!/bin/busybox sh\nread -p foo -r bar"
|
||||
prop_checkBashisms127 = verifyNot checkBashisms "#!/bin/busybox sh\necho -ne foo"
|
||||
prop_checkBashisms128 = verify checkBashisms "#!/bin/dash\ntype -p test"
|
||||
prop_checkBashisms129 = verify checkBashisms "#!/bin/sh\n[ -k /tmp ]"
|
||||
prop_checkBashisms130 = verifyNot checkBashisms "#!/bin/dash\ntest -k /tmp"
|
||||
prop_checkBashisms131 = verify checkBashisms "#!/bin/sh\n[ -o errexit ]"
|
||||
checkBashisms = ForShell [Sh, Dash, BusyboxSh] $ \t -> do
|
||||
params <- ask
|
||||
kludge params t
|
||||
where
|
||||
-- This code was copy-pasted from Analytics where params was a variable
|
||||
kludge params = bashism
|
||||
where
|
||||
isBusyboxSh = shellType params == BusyboxSh
|
||||
isDash = shellType params == Dash || isBusyboxSh
|
||||
warnMsg id code s =
|
||||
if isDash
|
||||
then err id code $ "In dash, " ++ s ++ " not supported."
|
||||
else warn id code $ "In POSIX sh, " ++ s ++ " undefined."
|
||||
asStr = getLiteralString
|
||||
|
||||
bashism (T_ProcSub id _ _) = warnMsg id 3001 "process substitution is"
|
||||
bashism (T_Extglob id _ _) = warnMsg id 3002 "extglob is"
|
||||
bashism (T_DollarSingleQuoted id _) =
|
||||
unless isBusyboxSh $ warnMsg id 3003 "$'..' is"
|
||||
bashism (T_DollarDoubleQuoted id _) = warnMsg id 3004 "$\"..\" is"
|
||||
bashism (T_ForArithmetic id _ _ _ _) = warnMsg id 3005 "arithmetic for loops are"
|
||||
bashism (T_Arithmetic id _) = warnMsg id 3006 "standalone ((..)) is"
|
||||
bashism (T_DollarBracket id _) = warnMsg id 3007 "$[..] in place of $((..)) is"
|
||||
bashism (T_SelectIn id _ _ _) = warnMsg id 3008 "select loops are"
|
||||
bashism (T_BraceExpansion id _) = warnMsg id 3009 "brace expansion is"
|
||||
bashism (T_Condition id DoubleBracket _) =
|
||||
unless isBusyboxSh $ warnMsg id 3010 "[[ ]] is"
|
||||
bashism (T_HereString id _) = warnMsg id 3011 "here-strings are"
|
||||
|
||||
bashism (TC_Binary id _ op _ _) =
|
||||
checkTestOp bashismBinaryTestFlags op id
|
||||
bashism (T_SimpleCommand id _ [asStr -> Just "test", lhs, asStr -> Just op, rhs]) =
|
||||
checkTestOp bashismBinaryTestFlags op id
|
||||
bashism (TC_Unary id _ op _) =
|
||||
checkTestOp bashismUnaryTestFlags op id
|
||||
bashism (T_SimpleCommand id _ [asStr -> Just "test", asStr -> Just op, _]) =
|
||||
checkTestOp bashismUnaryTestFlags op id
|
||||
|
||||
bashism (TA_Unary id op _)
|
||||
| op `elem` [ "|++", "|--", "++|", "--|"] =
|
||||
warnMsg id 3018 $ filter (/= '|') op ++ " is"
|
||||
bashism (TA_Binary id "**" _ _) = warnMsg id 3019 "exponentials are"
|
||||
bashism (T_FdRedirect id "&" (T_IoFile _ (T_Greater _) _)) =
|
||||
unless isBusyboxSh $ warnMsg id 3020 "&> is"
|
||||
bashism (T_FdRedirect id "" (T_IoFile _ (T_GREATAND _) file)) =
|
||||
unless (all isDigit $ onlyLiteralString file) $ warnMsg id 3021 ">& filename (as opposed to >& fd) is"
|
||||
bashism (T_FdRedirect id ('{':_) _) = warnMsg id 3022 "named file descriptors are"
|
||||
bashism (T_FdRedirect id num _)
|
||||
| all isDigit num && length num > 1 = warnMsg id 3023 "FDs outside 0-9 are"
|
||||
bashism (T_Assignment id Append _ _ _) =
|
||||
warnMsg id 3024 "+= is"
|
||||
bashism (T_IoFile id _ word) | isNetworked =
|
||||
warnMsg id 3025 "/dev/{tcp,udp} is"
|
||||
where
|
||||
file = onlyLiteralString word
|
||||
isNetworked = any (`isPrefixOf` file) ["/dev/tcp", "/dev/udp"]
|
||||
bashism (T_Glob id str) | "[^" `isInfixOf` str =
|
||||
warnMsg id 3026 "^ in place of ! in glob bracket expressions is"
|
||||
|
||||
bashism t@(TA_Variable id str _) | isBashVariable str =
|
||||
warnMsg id 3028 $ str ++ " is"
|
||||
|
||||
bashism t@(T_DollarBraced id _ token) = do
|
||||
unless isBusyboxSh $ mapM_ check simpleExpansions
|
||||
mapM_ check advancedExpansions
|
||||
when (isBashVariable var) $
|
||||
warnMsg id 3028 $ var ++ " is"
|
||||
where
|
||||
str = concat $ oversimplify token
|
||||
var = getBracedReference str
|
||||
check (regex, code, feature) =
|
||||
when (isJust $ matchRegex regex str) $ warnMsg id code feature
|
||||
|
||||
bashism t@(T_Pipe id "|&") =
|
||||
warnMsg id 3029 "|& in place of 2>&1 | is"
|
||||
bashism (T_Array id _) =
|
||||
warnMsg id 3030 "arrays are"
|
||||
bashism (T_IoFile id _ t) | isGlob t =
|
||||
warnMsg id 3031 "redirecting to/from globs is"
|
||||
bashism (T_CoProc id _ _) =
|
||||
warnMsg id 3032 "coproc is"
|
||||
|
||||
bashism (T_Function id _ _ str _) | not (isVariableName str) =
|
||||
warnMsg id 3033 "naming functions outside [a-zA-Z_][a-zA-Z0-9_]* is"
|
||||
|
||||
bashism (T_DollarExpansion id [x]) | isOnlyRedirection x =
|
||||
warnMsg id 3034 "$(<file) to read files is"
|
||||
bashism (T_Backticked id [x]) | isOnlyRedirection x =
|
||||
warnMsg id 3035 "`<file` to read files is"
|
||||
|
||||
bashism t@(T_SimpleCommand _ _ (cmd:arg:_))
|
||||
| t `isCommand` "echo" && argString `matches` flagRegex =
|
||||
if isBusyboxSh
|
||||
then
|
||||
unless (argString `matches` busyboxFlagRegex) $
|
||||
warnMsg (getId arg) 3036 "echo flags besides -n and -e"
|
||||
else if isDash
|
||||
then
|
||||
when (argString /= "-n") $
|
||||
warnMsg (getId arg) 3036 "echo flags besides -n"
|
||||
else
|
||||
warnMsg (getId arg) 3037 "echo flags are"
|
||||
where
|
||||
argString = concat $ oversimplify arg
|
||||
flagRegex = mkRegex "^-[eEsn]+$"
|
||||
busyboxFlagRegex = mkRegex "^-[en]+$"
|
||||
|
||||
bashism t@(T_SimpleCommand _ _ (cmd:arg:_))
|
||||
| getLiteralString cmd == Just "exec" && "-" `isPrefixOf` concat (oversimplify arg) =
|
||||
warnMsg (getId arg) 3038 "exec flags are"
|
||||
bashism t@(T_SimpleCommand id _ _)
|
||||
| t `isCommand` "let" = warnMsg id 3039 "'let' is"
|
||||
bashism t@(T_SimpleCommand _ _ (cmd:args))
|
||||
| t `isCommand` "set" = unless isDash $
|
||||
checkOptions $ getLiteralArgs args
|
||||
where
|
||||
-- Get the literal options from a list of arguments,
|
||||
-- up until the first non-literal one
|
||||
getLiteralArgs :: [Token] -> [(Id, String)]
|
||||
getLiteralArgs = foldr go []
|
||||
where
|
||||
go first rest = case getLiteralString first of
|
||||
Just str -> (getId first, str) : rest
|
||||
Nothing -> []
|
||||
|
||||
-- Check a flag-option pair (such as -o errexit)
|
||||
checkOptions (flag@(fid,flag') : opt@(oid,opt') : rest)
|
||||
| flag' `matches` oFlagRegex = do
|
||||
when (opt' `notElem` longOptions) $
|
||||
warnMsg oid 3040 $ "set option " <> opt' <> " is"
|
||||
checkFlags (flag:rest)
|
||||
| otherwise = checkFlags (flag:opt:rest)
|
||||
checkOptions (flag:rest) = checkFlags (flag:rest)
|
||||
checkOptions _ = return ()
|
||||
|
||||
-- Check that each option in a sequence of flags
|
||||
-- (such as -aveo) is valid
|
||||
checkFlags (flag@(fid, flag'):rest)
|
||||
| startsOption flag' = do
|
||||
unless (flag' `matches` validFlagsRegex) $
|
||||
forM_ (tail flag') $ \letter ->
|
||||
when (letter `notElem` optionsSet) $
|
||||
warnMsg fid 3041 $ "set flag " <> ('-':letter:" is")
|
||||
checkOptions rest
|
||||
| beginsWithDoubleDash flag' = do
|
||||
warnMsg fid 3042 $ "set flag " <> flag' <> " is"
|
||||
checkOptions rest
|
||||
-- Either a word that doesn't start with a dash, or simply '--',
|
||||
-- so stop checking.
|
||||
| otherwise = return ()
|
||||
checkFlags [] = return ()
|
||||
|
||||
options = "abCefhmnuvxo"
|
||||
optionsSet = Set.fromList options
|
||||
startsOption = (`matches` mkRegex "^(\\+|-[^-])")
|
||||
oFlagRegex = mkRegex $ "^[-+][" <> options <> "]*o$"
|
||||
validFlagsRegex = mkRegex $ "^[-+]([" <> options <> "]+o?|o)$"
|
||||
beginsWithDoubleDash = (`matches` mkRegex "^--.+$")
|
||||
longOptions = Set.fromList
|
||||
[ "allexport", "errexit", "ignoreeof", "monitor", "noclobber"
|
||||
, "noexec", "noglob", "nolog", "notify" , "nounset", "verbose"
|
||||
, "vi", "xtrace" ]
|
||||
|
||||
bashism t@(T_SimpleCommand id _ (cmd:rest)) =
|
||||
let name = fromMaybe "" $ getCommandName t
|
||||
flags = getLeadingFlags t
|
||||
in do
|
||||
when (name == "local" && not isDash) $
|
||||
-- This is so commonly accepted that we'll make it a special case
|
||||
warnMsg id 3043 $ "'local' is"
|
||||
when (name `elem` unsupportedCommands) $
|
||||
warnMsg id 3044 $ "'" ++ name ++ "' is"
|
||||
sequence_ $ do
|
||||
allowed' <- Map.lookup name allowedFlags
|
||||
allowed <- allowed'
|
||||
(word, flag) <- find
|
||||
(\x -> (not . null . snd $ x) && snd x `notElem` allowed) flags
|
||||
return . warnMsg (getId word) 3045 $ name ++ " -" ++ flag ++ " is"
|
||||
|
||||
when (name == "source" && not isBusyboxSh) $
|
||||
warnMsg id 3046 "'source' in place of '.' is"
|
||||
when (name == "trap") $
|
||||
let
|
||||
check token = sequence_ $ do
|
||||
str <- getLiteralString token
|
||||
let upper = map toUpper str
|
||||
return $ do
|
||||
when (upper `elem` ["ERR", "DEBUG", "RETURN"]) $
|
||||
warnMsg (getId token) 3047 $ "trapping " ++ str ++ " is"
|
||||
when (not isBusyboxSh && "SIG" `isPrefixOf` upper) $
|
||||
warnMsg (getId token) 3048
|
||||
"prefixing signal names with 'SIG' is"
|
||||
when (not isDash && upper /= str) $
|
||||
warnMsg (getId token) 3049
|
||||
"using lower/mixed case for signal names is"
|
||||
in
|
||||
mapM_ check (drop 1 rest)
|
||||
|
||||
when (name == "printf") $ sequence_ $ do
|
||||
format <- rest !!! 0 -- flags are covered by allowedFlags
|
||||
let literal = onlyLiteralString format
|
||||
guard $ "%q" `isInfixOf` literal
|
||||
return $ warnMsg (getId format) 3050 "printf %q is"
|
||||
|
||||
when (name == "read" && all isFlag rest) $
|
||||
warnMsg (getId cmd) 3061 "read without a variable is"
|
||||
where
|
||||
unsupportedCommands = [
|
||||
"let", "caller", "builtin", "complete", "compgen", "declare", "dirs", "disown",
|
||||
"enable", "mapfile", "readarray", "pushd", "popd", "shopt", "suspend",
|
||||
"typeset"
|
||||
]
|
||||
allowedFlags = Map.fromList [
|
||||
("cd", Just ["L", "P"]),
|
||||
("exec", Just []),
|
||||
("export", Just ["p"]),
|
||||
("hash", Just $ if isDash then ["r", "v"] else ["r"]),
|
||||
("jobs", Just ["l", "p"]),
|
||||
("printf", Just []),
|
||||
("read", Just $ if isDash || isBusyboxSh then ["r", "p"] else ["r"]),
|
||||
("readonly", Just ["p"]),
|
||||
("trap", Just []),
|
||||
("type", Just $ if isBusyboxSh then ["p"] else []),
|
||||
("ulimit", if isDash then Nothing else Just ["f"]),
|
||||
("umask", Just ["S"]),
|
||||
("unset", Just ["f", "v"]),
|
||||
("wait", Just [])
|
||||
]
|
||||
bashism t@(T_SourceCommand id src _)
|
||||
| getCommandName src == Just "source" =
|
||||
unless isBusyboxSh $
|
||||
warnMsg id 3051 "'source' in place of '.' is"
|
||||
bashism (TA_Expansion _ (T_Literal id str : _))
|
||||
| str `matches` radix = warnMsg id 3052 "arithmetic base conversion is"
|
||||
where
|
||||
radix = mkRegex "^[0-9]+#"
|
||||
bashism _ = return ()
|
||||
|
||||
varChars="_0-9a-zA-Z"
|
||||
advancedExpansions = let re = mkRegex in [
|
||||
(re $ "^![" ++ varChars ++ "]", 3053, "indirect expansion is"),
|
||||
(re $ "^[" ++ varChars ++ "]+\\[.*\\]$", 3054, "array references are"),
|
||||
(re $ "^![" ++ varChars ++ "]+\\[[*@]]$", 3055, "array key expansion is"),
|
||||
(re $ "^![" ++ varChars ++ "]+[*@]$", 3056, "name matching prefixes are"),
|
||||
(re $ "^[" ++ varChars ++ "*@]+(\\[.*\\])?[,^]", 3059, "case modification is")
|
||||
]
|
||||
simpleExpansions = let re = mkRegex in [
|
||||
(re $ "^[" ++ varChars ++ "*@]+:[^-=?+]", 3057, "string indexing is"),
|
||||
(re $ "^([*@][%#]|#[@*])", 3058, "string operations on $@/$* are"),
|
||||
(re $ "^[" ++ varChars ++ "*@]+(\\[.*\\])?/", 3060, "string replacement is")
|
||||
]
|
||||
bashVars = [
|
||||
-- This list deliberately excludes $BASH_VERSION as it's often used
|
||||
-- for shell identification.
|
||||
"OSTYPE", "MACHTYPE", "HOSTTYPE", "HOSTNAME",
|
||||
"DIRSTACK", "EUID", "UID", "SHLVL", "PIPESTATUS", "SHELLOPTS",
|
||||
"_", "BASHOPTS", "BASHPID", "BASH_ALIASES", "BASH_ARGC",
|
||||
"BASH_ARGV", "BASH_ARGV0", "BASH_CMDS", "BASH_COMMAND",
|
||||
"BASH_EXECUTION_STRING", "BASH_LINENO", "BASH_REMATCH", "BASH_SOURCE",
|
||||
"BASH_SUBSHELL", "BASH_VERSINFO", "EPOCHREALTIME", "EPOCHSECONDS",
|
||||
"FUNCNAME", "GROUPS", "MACHTYPE", "MAPFILE"
|
||||
]
|
||||
bashDynamicVars = [ "RANDOM", "SECONDS" ]
|
||||
dashVars = [ "_" ]
|
||||
isBashVariable var =
|
||||
(var `elem` bashDynamicVars
|
||||
|| var `elem` bashVars && not (isAssigned var))
|
||||
&& not (isDash && var `elem` dashVars)
|
||||
isAssigned var = any f (variableFlow params)
|
||||
where
|
||||
f x = case x of
|
||||
Assignment (_, _, name, _) -> name == var
|
||||
_ -> False
|
||||
|
||||
checkTestOp table op id = sequence_ $ do
|
||||
(code, shells, msg) <- Map.lookup op table
|
||||
guard . not $ shellType params `elem` shells
|
||||
return $ warnMsg id code (msg op)
|
||||
|
||||
|
||||
buildTestFlagMap list = Map.fromList $ concatMap (\(x,y) -> map (\c -> (c,y)) x) list
|
||||
bashismBinaryTestFlags = buildTestFlagMap [
|
||||
-- ([list of applicable flags],
|
||||
-- (error code, exempt shells, message builder :: String -> String)),
|
||||
--
|
||||
-- Distinct error codes allow the wiki to give more helpful, targeted
|
||||
-- information.
|
||||
(["<", ">", "\\<", "\\>", "<=", ">=", "\\<=", "\\>="],
|
||||
(3012, [Dash, BusyboxSh], \op -> "lexicographical " ++ op ++ " is")),
|
||||
(["=="],
|
||||
(3014, [BusyboxSh], \op -> op ++ " in place of = is")),
|
||||
(["=~"],
|
||||
(3015, [], \op -> op ++ " regex matching is")),
|
||||
|
||||
([], (0,[],const ""))
|
||||
]
|
||||
bashismUnaryTestFlags = buildTestFlagMap [
|
||||
(["-v"],
|
||||
(3016, [], \op -> "test " ++ op ++ " (in place of [ -n \"${var+x}\" ]) is")),
|
||||
(["-a"],
|
||||
(3017, [], \op -> "unary " ++ op ++ " in place of -e is")),
|
||||
(["-o"],
|
||||
(3062, [], \op -> "test " ++ op ++ " to check options is")),
|
||||
(["-R"],
|
||||
(3063, [], \op -> "test " ++ op ++ " and namerefs in general are")),
|
||||
(["-N"],
|
||||
(3064, [], \op -> "test " ++ op ++ " is")),
|
||||
(["-k"],
|
||||
(3065, [Dash, BusyboxSh], \op -> "test " ++ op ++ " is")),
|
||||
(["-G"],
|
||||
(3066, [Dash, BusyboxSh], \op -> "test " ++ op ++ " is")),
|
||||
(["-O"],
|
||||
(3067, [Dash, BusyboxSh], \op -> "test " ++ op ++ " is")),
|
||||
|
||||
([], (0,[],const ""))
|
||||
]
|
||||
|
||||
|
||||
prop_checkEchoSed1 = verify checkEchoSed "FOO=$(echo \"$cow\" | sed 's/foo/bar/g')"
|
||||
prop_checkEchoSed1b = verify checkEchoSed "FOO=$(sed 's/foo/bar/g' <<< \"$cow\")"
|
||||
prop_checkEchoSed2 = verify checkEchoSed "rm $(echo $cow | sed -e 's,foo,bar,')"
|
||||
prop_checkEchoSed2b = verify checkEchoSed "rm $(sed -e 's,foo,bar,' <<< $cow)"
|
||||
checkEchoSed = ForShell [Bash, Ksh] f
|
||||
where
|
||||
f (T_Redirecting id lefts r) =
|
||||
when (any redirectHereString lefts) $
|
||||
checkSed id rcmd
|
||||
where
|
||||
redirectHereString :: Token -> Bool
|
||||
redirectHereString t = case t of
|
||||
(T_FdRedirect _ _ T_HereString{}) -> True
|
||||
_ -> False
|
||||
rcmd = oversimplify r
|
||||
|
||||
f (T_Pipeline id _ [a, b]) =
|
||||
when (acmd == ["echo", "${VAR}"]) $
|
||||
checkSed id bcmd
|
||||
where
|
||||
acmd = oversimplify a
|
||||
bcmd = oversimplify b
|
||||
|
||||
f _ = return ()
|
||||
|
||||
checkSed id ["sed", v] = checkIn id v
|
||||
checkSed id ["sed", "-e", v] = checkIn id v
|
||||
checkSed _ _ = return ()
|
||||
|
||||
-- This should have used backreferences, but TDFA doesn't support them
|
||||
sedRe = mkRegex "^s(.)([^\n]*)g?$"
|
||||
isSimpleSed s = isJust $ do
|
||||
[h:_,rest] <- matchRegex sedRe s
|
||||
let delimiters = filter (== h) rest
|
||||
guard $ length delimiters == 2
|
||||
checkIn id s =
|
||||
when (isSimpleSed s) $
|
||||
style id 2001 "See if you can use ${variable//search/replace} instead."
|
||||
|
||||
|
||||
prop_checkBraceExpansionVars1 = verify checkBraceExpansionVars "echo {1..$n}"
|
||||
prop_checkBraceExpansionVars2 = verifyNot checkBraceExpansionVars "echo {1,3,$n}"
|
||||
prop_checkBraceExpansionVars3 = verify checkBraceExpansionVars "eval echo DSC{0001..$n}.jpg"
|
||||
prop_checkBraceExpansionVars4 = verify checkBraceExpansionVars "echo {$i..100}"
|
||||
checkBraceExpansionVars = ForShell [Bash] f
|
||||
where
|
||||
f t@(T_BraceExpansion id list) = mapM_ check list
|
||||
where
|
||||
check element =
|
||||
when (any (`isInfixOf` toString element) ["$..", "..$"]) $ do
|
||||
c <- isEvaled element
|
||||
if c
|
||||
then style id 2175 "Quote this invalid brace expansion since it should be passed literally to eval."
|
||||
else warn id 2051 "Bash doesn't support variables in brace range expansions."
|
||||
f _ = return ()
|
||||
|
||||
literalExt t =
|
||||
case t of
|
||||
T_DollarBraced {} -> return "$"
|
||||
T_DollarExpansion {} -> return "$"
|
||||
T_DollarArithmetic {} -> return "$"
|
||||
_ -> return "-"
|
||||
toString t = runIdentity $ getLiteralStringExt literalExt t
|
||||
isEvaled t = do
|
||||
cmd <- getClosestCommandM t
|
||||
return $ maybe False (`isUnqualifiedCommand` "eval") cmd
|
||||
|
||||
|
||||
prop_checkMultiDimensionalArrays1 = verify checkMultiDimensionalArrays "foo[a][b]=3"
|
||||
prop_checkMultiDimensionalArrays2 = verifyNot checkMultiDimensionalArrays "foo[a]=3"
|
||||
prop_checkMultiDimensionalArrays3 = verify checkMultiDimensionalArrays "foo=( [a][b]=c )"
|
||||
prop_checkMultiDimensionalArrays4 = verifyNot checkMultiDimensionalArrays "foo=( [a]=c )"
|
||||
prop_checkMultiDimensionalArrays5 = verify checkMultiDimensionalArrays "echo ${foo[bar][baz]}"
|
||||
prop_checkMultiDimensionalArrays6 = verifyNot checkMultiDimensionalArrays "echo ${foo[bar]}"
|
||||
checkMultiDimensionalArrays = ForShell [Bash] f
|
||||
where
|
||||
f token =
|
||||
case token of
|
||||
T_Assignment _ _ name (first:second:_) _ -> about second
|
||||
T_IndexedElement _ (first:second:_) _ -> about second
|
||||
T_DollarBraced _ _ l ->
|
||||
when (isMultiDim l) $ about token
|
||||
_ -> return ()
|
||||
about t = warn (getId t) 2180 "Bash does not support multidimensional arrays. Use 1D or associative arrays."
|
||||
|
||||
re = mkRegex "^\\[.*\\]\\[.*\\]" -- Fixme, this matches ${foo:- [][]} and such as well
|
||||
isMultiDim l = getBracedModifier (concat $ oversimplify l) `matches` re
|
||||
|
||||
prop_checkPS11 = verify checkPS1Assignments "PS1='\\033[1;35m\\$ '"
|
||||
prop_checkPS11a = verify checkPS1Assignments "export PS1='\\033[1;35m\\$ '"
|
||||
prop_checkPSf2 = verify checkPS1Assignments "PS1='\\h \\e[0m\\$ '"
|
||||
prop_checkPS13 = verify checkPS1Assignments "PS1=$'\\x1b[c '"
|
||||
prop_checkPS14 = verify checkPS1Assignments "PS1=$'\\e[3m; '"
|
||||
prop_checkPS14a = verify checkPS1Assignments "export PS1=$'\\e[3m; '"
|
||||
prop_checkPS15 = verifyNot checkPS1Assignments "PS1='\\[\\033[1;35m\\]\\$ '"
|
||||
prop_checkPS16 = verifyNot checkPS1Assignments "PS1='\\[\\e1m\\e[1m\\]\\$ '"
|
||||
prop_checkPS17 = verifyNot checkPS1Assignments "PS1='e033x1B'"
|
||||
prop_checkPS18 = verifyNot checkPS1Assignments "PS1='\\[\\e\\]'"
|
||||
checkPS1Assignments = ForShell [Bash] f
|
||||
where
|
||||
f token = case token of
|
||||
(T_Assignment _ _ "PS1" _ word) -> warnFor word
|
||||
_ -> return ()
|
||||
|
||||
warnFor word =
|
||||
let contents = concat $ oversimplify word in
|
||||
when (containsUnescaped contents) $
|
||||
info (getId word) 2025 "Make sure all escape sequences are enclosed in \\[..\\] to prevent line wrapping issues"
|
||||
containsUnescaped s =
|
||||
let unenclosed = subRegex enclosedRegex s "" in
|
||||
isJust $ matchRegex escapeRegex unenclosed
|
||||
enclosedRegex = mkRegex "\\\\\\[.*\\\\\\]" -- FIXME: shouldn't be eager
|
||||
escapeRegex = mkRegex "\\\\x1[Bb]|\\\\e|\x1B|\\\\033"
|
||||
|
||||
|
||||
prop_checkMultipleBangs1 = verify checkMultipleBangs "! ! true"
|
||||
prop_checkMultipleBangs2 = verifyNot checkMultipleBangs "! true"
|
||||
checkMultipleBangs = ForShell [Dash, BusyboxSh, Sh] f
|
||||
where
|
||||
f token = case token of
|
||||
T_Banged id (T_Banged _ _) ->
|
||||
err id 2325 "Multiple ! in front of pipelines are a bash/ksh extension. Use only 0 or 1."
|
||||
_ -> return ()
|
||||
|
||||
|
||||
prop_checkBangAfterPipe1 = verify checkBangAfterPipe "true | ! true"
|
||||
prop_checkBangAfterPipe2 = verifyNot checkBangAfterPipe "true | ( ! true )"
|
||||
prop_checkBangAfterPipe3 = verifyNot checkBangAfterPipe "! ! true | true"
|
||||
checkBangAfterPipe = ForShell [Dash, BusyboxSh, Sh, Bash] f
|
||||
where
|
||||
f token = case token of
|
||||
T_Pipeline _ _ cmds -> mapM_ check cmds
|
||||
_ -> return ()
|
||||
|
||||
check token = case token of
|
||||
T_Banged id _ ->
|
||||
err id 2326 "! is not allowed in the middle of pipelines. Use command group as in cmd | { ! cmd; } if necessary."
|
||||
_ -> return ()
|
||||
|
||||
|
||||
prop_checkNegatedUnaryOps1 = verify checkNegatedUnaryOps "[ ! -o braceexpand ]"
|
||||
prop_checkNegatedUnaryOps2 = verifyNot checkNegatedUnaryOps "[ -o braceexpand ]"
|
||||
prop_checkNegatedUnaryOps3 = verifyNot checkNegatedUnaryOps "[[ ! -o braceexpand ]]"
|
||||
prop_checkNegatedUnaryOps4 = verifyNot checkNegatedUnaryOps "! [ -o braceexpand ]"
|
||||
prop_checkNegatedUnaryOps5 = verify checkNegatedUnaryOps "[ ! -a file ]"
|
||||
checkNegatedUnaryOps = ForShell [Bash] f
|
||||
where
|
||||
f token = case token of
|
||||
TC_Unary id SingleBracket "!" (TC_Unary _ _ op _) | op `elem` ["-a", "-o"] ->
|
||||
err id 2332 $ msg op
|
||||
_ -> return ()
|
||||
|
||||
msg "-o" = "[ ! -o opt ] is always true because -o becomes logical OR. Use [[ ]] or ! [ -o opt ]."
|
||||
msg "-a" = "[ ! -a file ] is always true because -a becomes logical AND. Use -e instead."
|
||||
msg _ = pleaseReport "unhandled negated unary message"
|
||||
|
||||
return []
|
||||
runTests = $( [| $(forAllProperties) (quickCheckWithResult (stdArgs { maxSuccess = 1 }) ) |])
|
||||
|
|
@ -1,177 +0,0 @@
|
|||
module ShellCheck.Data where
|
||||
|
||||
import ShellCheck.Interface
|
||||
import Data.Version (showVersion)
|
||||
|
||||
|
||||
{-
|
||||
If you are here because you saw an error about Paths_ShellCheck in this file,
|
||||
simply comment out the import below and define the version as a constant string.
|
||||
|
||||
Instead of:
|
||||
|
||||
import Paths_ShellCheck (version)
|
||||
shellcheckVersion = showVersion version
|
||||
|
||||
Use:
|
||||
|
||||
-- import Paths_ShellCheck (version)
|
||||
shellcheckVersion = "kludge"
|
||||
|
||||
-}
|
||||
|
||||
import Paths_ShellCheck (version)
|
||||
shellcheckVersion = showVersion version -- VERSIONSTRING
|
||||
|
||||
|
||||
internalVariables = [
|
||||
-- Generic
|
||||
"", "_", "rest", "REST",
|
||||
|
||||
-- Bash
|
||||
"BASH", "BASHOPTS", "BASHPID", "BASH_ALIASES", "BASH_ARGC",
|
||||
"BASH_ARGV", "BASH_ARGV0", "BASH_CMDS", "BASH_COMMAND",
|
||||
"BASH_EXECUTION_STRING", "BASH_LINENO", "BASH_LOADABLES_PATH",
|
||||
"BASH_REMATCH", "BASH_SOURCE", "BASH_SUBSHELL", "BASH_VERSINFO",
|
||||
"BASH_VERSION", "COMP_CWORD", "COMP_KEY", "COMP_LINE", "COMP_POINT",
|
||||
"COMP_TYPE", "COMP_WORDBREAKS", "COMP_WORDS", "COPROC", "DIRSTACK",
|
||||
"EPOCHREALTIME", "EPOCHSECONDS", "EUID", "FUNCNAME", "GROUPS", "HISTCMD",
|
||||
"HOSTNAME", "HOSTTYPE", "LINENO", "MACHTYPE", "MAPFILE", "OLDPWD",
|
||||
"OPTARG", "OPTIND", "OSTYPE", "PIPESTATUS", "PPID", "PWD", "RANDOM",
|
||||
"READLINE_ARGUMENT", "READLINE_LINE", "READLINE_MARK", "READLINE_POINT",
|
||||
"REPLY", "SECONDS", "SHELLOPTS", "SHLVL", "SRANDOM", "UID", "BASH_COMPAT",
|
||||
"BASH_ENV", "BASH_XTRACEFD", "CDPATH", "CHILD_MAX", "COLUMNS",
|
||||
"COMPREPLY", "EMACS", "ENV", "EXECIGNORE", "FCEDIT", "FIGNORE",
|
||||
"FUNCNEST", "GLOBIGNORE", "HISTCONTROL", "HISTFILE", "HISTFILESIZE",
|
||||
"HISTIGNORE", "HISTSIZE", "HISTTIMEFORMAT", "HOME", "HOSTFILE", "IFS",
|
||||
"IGNOREEOF", "INPUTRC", "INSIDE_EMACS", "LANG", "LC_ALL", "LC_COLLATE",
|
||||
"LC_CTYPE", "LC_MESSAGES", "LC_MONETARY", "LC_NUMERIC", "LC_TIME",
|
||||
"LINES", "MAIL", "MAILCHECK", "MAILPATH", "OPTERR", "PATH",
|
||||
"POSIXLY_CORRECT", "PROMPT_COMMAND", "PROMPT_DIRTRIM", "PS0", "PS1",
|
||||
"PS2", "PS3", "PS4", "SHELL", "TIMEFORMAT", "TMOUT", "TMPDIR",
|
||||
"BASH_MONOSECONDS", "BASH_TRAPSIG", "GLOBSORT",
|
||||
"auto_resume", "histchars",
|
||||
|
||||
-- Other
|
||||
"USER", "TZ", "TERM", "LOGNAME", "LD_LIBRARY_PATH", "LANGUAGE", "DISPLAY",
|
||||
"HOSTNAME", "KRB5CCNAME", "XAUTHORITY"
|
||||
|
||||
-- Ksh
|
||||
, ".sh.version"
|
||||
|
||||
-- shflags
|
||||
, "FLAGS_ARGC", "FLAGS_ARGV", "FLAGS_ERROR", "FLAGS_FALSE", "FLAGS_HELP",
|
||||
"FLAGS_PARENT", "FLAGS_RESERVED", "FLAGS_TRUE", "FLAGS_VERSION",
|
||||
"flags_error", "flags_return"
|
||||
|
||||
-- Bats
|
||||
,"stderr", "stderr_lines"
|
||||
]
|
||||
|
||||
specialIntegerVariables = [
|
||||
"$", "?", "!", "#"
|
||||
]
|
||||
|
||||
specialVariablesWithoutSpaces = "-" : specialIntegerVariables
|
||||
|
||||
variablesWithoutSpaces = specialVariablesWithoutSpaces ++ [
|
||||
"BASHPID", "BASH_ARGC", "BASH_LINENO", "BASH_SUBSHELL", "EUID",
|
||||
"EPOCHREALTIME", "EPOCHSECONDS", "LINENO", "OPTIND", "PPID", "RANDOM",
|
||||
"READLINE_ARGUMENT", "READLINE_MARK", "READLINE_POINT", "SECONDS",
|
||||
"SHELLOPTS", "SHLVL", "SRANDOM", "UID", "COLUMNS", "HISTFILESIZE",
|
||||
"HISTSIZE", "LINES", "BASH_MONOSECONDS", "BASH_TRAPSIG"
|
||||
|
||||
-- shflags
|
||||
, "FLAGS_ERROR", "FLAGS_FALSE", "FLAGS_TRUE"
|
||||
]
|
||||
|
||||
specialVariables = specialVariablesWithoutSpaces ++ ["@", "*"]
|
||||
|
||||
unbracedVariables = specialVariables ++ [
|
||||
"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"
|
||||
]
|
||||
|
||||
arrayVariables = [
|
||||
"BASH_ALIASES", "BASH_ARGC", "BASH_ARGV", "BASH_CMDS", "BASH_LINENO",
|
||||
"BASH_REMATCH", "BASH_SOURCE", "BASH_VERSINFO", "COMP_WORDS", "COPROC",
|
||||
"DIRSTACK", "FUNCNAME", "GROUPS", "MAPFILE", "PIPESTATUS", "COMPREPLY"
|
||||
]
|
||||
|
||||
commonCommands = [
|
||||
"admin", "alias", "ar", "asa", "at", "awk", "basename", "batch",
|
||||
"bc", "bg", "break", "c99", "cal", "cat", "cd", "cflow", "chgrp",
|
||||
"chmod", "chown", "cksum", "cmp", "colon", "comm", "command",
|
||||
"compress", "continue", "cp", "crontab", "csplit", "ctags", "cut",
|
||||
"cxref", "date", "dd", "delta", "df", "diff", "dirname", "dot",
|
||||
"du", "echo", "ed", "env", "eval", "ex", "exec", "exit", "expand",
|
||||
"export", "expr", "fc", "fg", "file", "find", "fold", "fort77",
|
||||
"fuser", "gencat", "get", "getconf", "getopts", "grep", "hash",
|
||||
"head", "iconv", "ipcrm", "ipcs", "jobs", "join", "kill", "lex",
|
||||
"link", "ln", "locale", "localedef", "logger", "logname", "lp",
|
||||
"ls", "m4", "mailx", "make", "man", "mesg", "mkdir", "mkfifo",
|
||||
"more", "mv", "newgrp", "nice", "nl", "nm", "nohup", "od", "paste",
|
||||
"patch", "pathchk", "pax", "pr", "printf", "prs", "ps", "pwd",
|
||||
"qalter", "qdel", "qhold", "qmove", "qmsg", "qrerun", "qrls",
|
||||
"qselect", "qsig", "qstat", "qsub", "read", "readonly", "renice",
|
||||
"return", "rm", "rmdel", "rmdir", "sact", "sccs", "sed", "set",
|
||||
"sh", "shift", "sleep", "sort", "split", "strings", "strip", "stty",
|
||||
"tabs", "tail", "talk", "tee", "test", "time", "times", "touch",
|
||||
"tput", "tr", "trap", "tsort", "tty", "type", "ulimit", "umask",
|
||||
"unalias", "uname", "uncompress", "unexpand", "unget", "uniq",
|
||||
"unlink", "unset", "uucp", "uudecode", "uuencode", "uustat", "uux",
|
||||
"val", "vi", "wait", "wc", "what", "who", "write", "xargs", "yacc",
|
||||
"zcat"
|
||||
]
|
||||
|
||||
nonReadingCommands = [
|
||||
"alias", "basename", "bg", "cal", "cd", "chgrp", "chmod", "chown",
|
||||
"cp", "du", "echo", "export", "fg", "fuser", "getconf",
|
||||
"getopt", "getopts", "ipcrm", "ipcs", "jobs", "kill", "ln", "ls",
|
||||
"locale", "mv", "printf", "ps", "pwd", "renice", "rm", "rmdir",
|
||||
"set", "sleep", "touch", "trap", "ulimit", "unalias", "uname"
|
||||
]
|
||||
|
||||
sampleWords = [
|
||||
"alpha", "bravo", "charlie", "delta", "echo", "foxtrot",
|
||||
"golf", "hotel", "india", "juliett", "kilo", "lima", "mike",
|
||||
"november", "oscar", "papa", "quebec", "romeo", "sierra",
|
||||
"tango", "uniform", "victor", "whiskey", "xray", "yankee",
|
||||
"zulu"
|
||||
]
|
||||
|
||||
binaryTestOps = [
|
||||
"-nt", "-ot", "-ef", "==", "!=", "<=", ">=", "-eq", "-ne", "-lt", "-le",
|
||||
"-gt", "-ge", "=~", ">", "<", "=", "\\<", "\\>", "\\<=", "\\>="
|
||||
]
|
||||
|
||||
arithmeticBinaryTestOps = [
|
||||
"-eq", "-ne", "-lt", "-le", "-gt", "-ge"
|
||||
]
|
||||
|
||||
unaryTestOps = [
|
||||
"!", "-a", "-b", "-c", "-d", "-e", "-f", "-g", "-h", "-L", "-k", "-p",
|
||||
"-r", "-s", "-S", "-t", "-u", "-w", "-x", "-O", "-G", "-N", "-z", "-n",
|
||||
"-o", "-v", "-R"
|
||||
]
|
||||
|
||||
shellForExecutable :: String -> Maybe Shell
|
||||
shellForExecutable name =
|
||||
case name of
|
||||
"sh" -> return Sh
|
||||
"bash" -> return Bash
|
||||
"bats" -> return Bash
|
||||
"busybox" -> return BusyboxSh -- Used for directives and --shell=busybox
|
||||
"busybox sh" -> return BusyboxSh
|
||||
"busybox ash" -> return BusyboxSh
|
||||
"dash" -> return Dash
|
||||
"ash" -> return Dash -- There's also a warning for this.
|
||||
"ksh" -> return Ksh
|
||||
"ksh88" -> return Ksh
|
||||
"ksh93" -> return Ksh
|
||||
"oksh" -> return Ksh
|
||||
_ -> Nothing
|
||||
|
||||
flagsForRead = "sreu:n:N:i:p:a:t:"
|
||||
flagsForMapfile = "d:n:O:s:u:C:c:t"
|
||||
|
||||
declaringCommands = ["local", "declare", "export", "readonly", "typeset", "let"]
|
||||
|
|
@ -1,313 +0,0 @@
|
|||
{-
|
||||
|
||||
This file contains useful functions for debugging and developing ShellCheck.
|
||||
|
||||
To invoke them interactively, run:
|
||||
|
||||
cabal repl
|
||||
|
||||
At the ghci prompt, enter:
|
||||
|
||||
:load ShellCheck.Debug
|
||||
|
||||
You can now invoke the functions. Here are some examples:
|
||||
|
||||
shellcheckString "echo $1"
|
||||
stringToAst "(( x+1 ))"
|
||||
stringToCfg "if foo; then bar; else baz; fi"
|
||||
writeFile "/tmp/test.dot" $ stringToCfgViz "while foo; do bar; done"
|
||||
|
||||
The latter file can be rendered to png with GraphViz:
|
||||
|
||||
dot -Tpng /tmp/test.dot > /tmp/test.png
|
||||
|
||||
To run all unit tests in a module:
|
||||
|
||||
ShellCheck.Parser.runTests
|
||||
ShellCheck.Analytics.runTests
|
||||
|
||||
To run a specific test:
|
||||
|
||||
:load ShellCheck.Analytics
|
||||
prop_checkUuoc3
|
||||
|
||||
If you make code changes, reload in seconds at any time with:
|
||||
|
||||
:r
|
||||
|
||||
===========================================================================
|
||||
|
||||
Crash course in printf debugging in Haskell:
|
||||
|
||||
import Debug.Trace
|
||||
|
||||
greet 0 = return ()
|
||||
-- Print when a function is invoked
|
||||
greet n | trace ("calling greet " ++ show n) False = undefined
|
||||
greet n = do
|
||||
putStrLn "Enter name"
|
||||
name <- getLine
|
||||
-- Print at some point in any monadic function
|
||||
traceM $ "user entered " ++ name
|
||||
putStrLn $ "Hello " ++ name
|
||||
-- Print a value before passing it on
|
||||
greet $ traceShowId (n - 1)
|
||||
|
||||
|
||||
===========================================================================
|
||||
|
||||
If you want to invoke `ghci` directly, such as on `shellcheck.hs`, to
|
||||
debug all of ShellCheck including I/O, you may see an error like this:
|
||||
|
||||
src/ShellCheck/Data.hs:5:1: error:
|
||||
Could not load module ‘Paths_ShellCheck’
|
||||
it is a hidden module in the package ‘ShellCheck-0.8.0’
|
||||
|
||||
This can easily be circumvented by running `./setgitversion` or manually
|
||||
editing src/ShellCheck/Data.hs to replace the auto-deduced version number
|
||||
with a constant string as indicated.
|
||||
|
||||
Afterwards, you can run the ShellCheck tool, as if from the shell, with:
|
||||
|
||||
$ ghci shellcheck.hs
|
||||
ghci> runMain ["-x", "file.sh"]
|
||||
|
||||
-}
|
||||
|
||||
module ShellCheck.Debug () where
|
||||
|
||||
import ShellCheck.Analyzer
|
||||
import ShellCheck.AST
|
||||
import ShellCheck.CFG
|
||||
import ShellCheck.Checker
|
||||
import ShellCheck.CFGAnalysis as CF
|
||||
import ShellCheck.Interface
|
||||
import ShellCheck.Parser
|
||||
import ShellCheck.Prelude
|
||||
|
||||
import Control.Monad
|
||||
import Control.Monad.Identity
|
||||
import Control.Monad.RWS
|
||||
import Control.Monad.Writer
|
||||
import Data.Graph.Inductive.Graph as G
|
||||
import Data.List
|
||||
import Data.Maybe
|
||||
import qualified Data.Map as M
|
||||
import qualified Data.Set as S
|
||||
|
||||
|
||||
-- Run all of ShellCheck (minus output formatters)
|
||||
shellcheckString :: String -> CheckResult
|
||||
shellcheckString scriptString =
|
||||
runIdentity $ checkScript dummySystemInterface checkSpec
|
||||
where
|
||||
checkSpec :: CheckSpec
|
||||
checkSpec = emptyCheckSpec {
|
||||
csScript = scriptString
|
||||
}
|
||||
|
||||
dummySystemInterface :: SystemInterface Identity
|
||||
dummySystemInterface = mockedSystemInterface [
|
||||
-- A tiny, fake filesystem for sourced files
|
||||
("lib/mylib1.sh", "foo=$(cat $1 | wc -l)"),
|
||||
("lib/mylib2.sh", "bar=42")
|
||||
]
|
||||
|
||||
-- Parameters used when generating Control Flow Graphs
|
||||
cfgParams :: CFGParameters
|
||||
cfgParams = CFGParameters {
|
||||
cfLastpipe = False,
|
||||
cfPipefail = False
|
||||
}
|
||||
|
||||
-- An example script to play with
|
||||
exampleScript :: String
|
||||
exampleScript = unlines [
|
||||
"#!/bin/sh",
|
||||
"count=0",
|
||||
"for file in *",
|
||||
"do",
|
||||
" (( count++ ))",
|
||||
"done",
|
||||
"echo $count"
|
||||
]
|
||||
|
||||
-- Parse the script string into ShellCheck's ParseResult
|
||||
parseScriptString :: String -> ParseResult
|
||||
parseScriptString scriptString =
|
||||
runIdentity $ parseScript dummySystemInterface parseSpec
|
||||
where
|
||||
parseSpec :: ParseSpec
|
||||
parseSpec = newParseSpec {
|
||||
psFilename = "myscript",
|
||||
psScript = scriptString
|
||||
}
|
||||
|
||||
|
||||
-- Parse the script string into an Abstract Syntax Tree
|
||||
stringToAst :: String -> Token
|
||||
stringToAst scriptString =
|
||||
case maybeRoot of
|
||||
Just root -> root
|
||||
Nothing -> error $ "Script failed to parse: " ++ show parserWarnings
|
||||
where
|
||||
parseResult :: ParseResult
|
||||
parseResult = parseScriptString scriptString
|
||||
|
||||
maybeRoot :: Maybe Token
|
||||
maybeRoot = prRoot parseResult
|
||||
|
||||
parserWarnings :: [PositionedComment]
|
||||
parserWarnings = prComments parseResult
|
||||
|
||||
|
||||
astToCfgResult :: Token -> CFGResult
|
||||
astToCfgResult = buildGraph cfgParams
|
||||
|
||||
astToDfa :: Token -> CFGAnalysis
|
||||
astToDfa = analyzeControlFlow cfgParams
|
||||
|
||||
astToCfg :: Token -> CFGraph
|
||||
astToCfg = cfGraph . astToCfgResult
|
||||
|
||||
stringToCfg :: String -> CFGraph
|
||||
stringToCfg = astToCfg . stringToAst
|
||||
|
||||
stringToDfa :: String -> CFGAnalysis
|
||||
stringToDfa = astToDfa . stringToAst
|
||||
|
||||
cfgToGraphViz :: CFGraph -> String
|
||||
cfgToGraphViz = cfgToGraphVizWith show
|
||||
|
||||
stringToCfgViz :: String -> String
|
||||
stringToCfgViz = cfgToGraphViz . stringToCfg
|
||||
|
||||
stringToDfaViz :: String -> String
|
||||
stringToDfaViz = dfaToGraphViz . stringToDfa
|
||||
|
||||
-- Dump a Control Flow Graph as GraphViz with extended information
|
||||
stringToDetailedCfgViz :: String -> String
|
||||
stringToDetailedCfgViz scriptString = cfgToGraphVizWith nodeLabel graph
|
||||
where
|
||||
ast :: Token
|
||||
ast = stringToAst scriptString
|
||||
|
||||
cfgResult :: CFGResult
|
||||
cfgResult = astToCfgResult ast
|
||||
|
||||
graph :: CFGraph
|
||||
graph = cfGraph cfgResult
|
||||
|
||||
idToToken :: M.Map Id Token
|
||||
idToToken = M.fromList $ execWriter $ doAnalysis (\c -> tell [(getId c, c)]) ast
|
||||
|
||||
idToNode :: M.Map Id (Node, Node)
|
||||
idToNode = cfIdToRange cfgResult
|
||||
|
||||
nodeToStartIds :: M.Map Node (S.Set Id)
|
||||
nodeToStartIds =
|
||||
M.fromListWith S.union $
|
||||
map (\(id, (start, _)) -> (start, S.singleton id)) $
|
||||
M.toList idToNode
|
||||
|
||||
nodeToEndIds :: M.Map Node (S.Set Id)
|
||||
nodeToEndIds =
|
||||
M.fromListWith S.union $
|
||||
map (\(id, (_, end)) -> (end, S.singleton id)) $
|
||||
M.toList idToNode
|
||||
|
||||
formatId :: Id -> String
|
||||
formatId id = fromMaybe ("Unknown " ++ show id) $ do
|
||||
(OuterToken _ token) <- M.lookup id idToToken
|
||||
firstWord <- words (show token) !!! 0
|
||||
-- Strip off "Inner_"
|
||||
(_ : tokenName) <- return $ dropWhile (/= '_') firstWord
|
||||
return $ tokenName ++ " " ++ show id
|
||||
|
||||
formatGroup :: S.Set Id -> String
|
||||
formatGroup set = intercalate ", " $ map formatId $ S.toList set
|
||||
|
||||
nodeLabel (node, label) = unlines [
|
||||
show node ++ ". " ++ show label,
|
||||
"Begin: " ++ formatGroup (M.findWithDefault S.empty node nodeToStartIds),
|
||||
"End: " ++ formatGroup (M.findWithDefault S.empty node nodeToEndIds)
|
||||
]
|
||||
|
||||
|
||||
-- Dump a Control Flow Graph with Data Flow Analysis as GraphViz
|
||||
dfaToGraphViz :: CF.CFGAnalysis -> String
|
||||
dfaToGraphViz analysis = cfgToGraphVizWith label $ CF.graph analysis
|
||||
where
|
||||
label (node, label) =
|
||||
let
|
||||
desc = show node ++ ". " ++ show label
|
||||
in
|
||||
fromMaybe ("No DFA available\n\n" ++ desc) $ do
|
||||
(pre, post) <- M.lookup node $ CF.nodeToData analysis
|
||||
return $ unlines [
|
||||
"Precondition: " ++ show pre,
|
||||
"",
|
||||
desc,
|
||||
"",
|
||||
"Postcondition: " ++ show post
|
||||
]
|
||||
|
||||
|
||||
-- Dump an Control Flow Graph to GraphViz with a given node formatter
|
||||
cfgToGraphVizWith :: (LNode CFNode -> String) -> CFGraph -> String
|
||||
cfgToGraphVizWith nodeLabel graph = concat [
|
||||
"digraph {\n",
|
||||
concatMap dumpNode (labNodes graph),
|
||||
concatMap dumpLink (labEdges graph),
|
||||
tagVizEntries graph,
|
||||
"}\n"
|
||||
]
|
||||
where
|
||||
dumpNode l@(node, label) = show node ++ " [label=" ++ quoteViz (nodeLabel l) ++ "]\n"
|
||||
dumpLink (from, to, typ) = show from ++ " -> " ++ show to ++ " [style=" ++ quoteViz (edgeStyle typ) ++ "]\n"
|
||||
edgeStyle CFEFlow = "solid"
|
||||
edgeStyle CFEExit = "bold"
|
||||
edgeStyle CFEFalseFlow = "dotted"
|
||||
|
||||
quoteViz str = "\"" ++ escapeViz str ++ "\""
|
||||
escapeViz [] = []
|
||||
escapeViz (c:rest) =
|
||||
case c of
|
||||
'\"' -> '\\' : '\"' : escapeViz rest
|
||||
'\n' -> '\\' : 'l' : escapeViz rest
|
||||
'\\' -> '\\' : '\\' : escapeViz rest
|
||||
_ -> c : escapeViz rest
|
||||
|
||||
|
||||
-- Dump an Abstract Syntax Tree (or branch thereof) to GraphViz format
|
||||
astToGraphViz :: Token -> String
|
||||
astToGraphViz token = concat [
|
||||
"digraph {\n",
|
||||
formatTree token,
|
||||
"}\n"
|
||||
]
|
||||
where
|
||||
formatTree :: Token -> String
|
||||
formatTree t = snd $ execRWS (doStackAnalysis push pop t) () []
|
||||
|
||||
push :: Token -> RWS () String [Int] ()
|
||||
push (OuterToken (Id n) inner) = do
|
||||
stack <- get
|
||||
put (n : stack)
|
||||
case stack of
|
||||
[] -> return ()
|
||||
(top:_) -> tell $ show top ++ " -> " ++ show n ++ "\n"
|
||||
tell $ show n ++ " [label=" ++ quoteViz (show n ++ ": " ++ take 32 (show inner)) ++ "]\n"
|
||||
|
||||
pop :: Token -> RWS () String [Int] ()
|
||||
pop _ = modify tail
|
||||
|
||||
|
||||
-- For each entry point, set the rank so that they'll align in the graph
|
||||
tagVizEntries :: CFGraph -> String
|
||||
tagVizEntries graph = "{ rank=same " ++ rank ++ " }"
|
||||
where
|
||||
entries = mapMaybe find $ labNodes graph
|
||||
find (node, CFEntryPoint name) = return (node, name)
|
||||
find _ = Nothing
|
||||
rank = unwords $ map (\(c, _) -> show c) entries
|
||||
|
|
@ -1,412 +0,0 @@
|
|||
{-
|
||||
Copyright 2018-2019 Vidar Holen, Ng Zhi An
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
|
||||
{-# LANGUAGE TemplateHaskell #-}
|
||||
module ShellCheck.Fixer (applyFix, removeTabStops, mapPositions, Ranged(..), runTests) where
|
||||
|
||||
import ShellCheck.Interface
|
||||
import ShellCheck.Prelude
|
||||
import Control.Monad
|
||||
import Control.Monad.State
|
||||
import Data.Array
|
||||
import Data.List
|
||||
import Data.Semigroup
|
||||
import GHC.Exts (sortWith)
|
||||
import Test.QuickCheck
|
||||
|
||||
-- The Ranged class is used for types that has a start and end position.
|
||||
class Ranged a where
|
||||
start :: a -> Position
|
||||
end :: a -> Position
|
||||
overlap :: a -> a -> Bool
|
||||
overlap x y =
|
||||
xEnd > yStart && yEnd > xStart
|
||||
where
|
||||
yStart = start y
|
||||
yEnd = end y
|
||||
xStart = start x
|
||||
xEnd = end x
|
||||
-- Set a new start and end position on a Ranged
|
||||
setRange :: (Position, Position) -> a -> a
|
||||
|
||||
-- Tests auto-verify that overlap commutes
|
||||
assertOverlap x y = overlap x y && overlap y x
|
||||
assertNoOverlap x y = not (overlap x y) && not (overlap y x)
|
||||
|
||||
prop_overlap_contiguous = assertNoOverlap
|
||||
(tFromStart 10 12 "foo" 1)
|
||||
(tFromStart 12 14 "bar" 2)
|
||||
|
||||
prop_overlap_adjacent_zerowidth = assertNoOverlap
|
||||
(tFromStart 3 3 "foo" 1)
|
||||
(tFromStart 3 3 "bar" 2)
|
||||
|
||||
prop_overlap_enclosed = assertOverlap
|
||||
(tFromStart 3 5 "foo" 1)
|
||||
(tFromStart 1 10 "bar" 2)
|
||||
|
||||
prop_overlap_partial = assertOverlap
|
||||
(tFromStart 1 5 "foo" 1)
|
||||
(tFromStart 3 7 "bar" 2)
|
||||
|
||||
|
||||
instance Ranged PositionedComment where
|
||||
start = pcStartPos
|
||||
end = pcEndPos
|
||||
setRange (s, e) pc = pc {
|
||||
pcStartPos = s,
|
||||
pcEndPos = e
|
||||
}
|
||||
|
||||
instance Ranged Replacement where
|
||||
start = repStartPos
|
||||
end = repEndPos
|
||||
setRange (s, e) r = r {
|
||||
repStartPos = s,
|
||||
repEndPos = e
|
||||
}
|
||||
|
||||
-- The Monoid instance for Fix merges fixes that do not conflict.
|
||||
-- TODO: Make an efficient 'mconcat'
|
||||
instance Monoid Fix where
|
||||
mempty = newFix
|
||||
mappend = (<>)
|
||||
mconcat = foldl mappend mempty -- fold left to right since <> discards right on overlap
|
||||
|
||||
instance Semigroup Fix where
|
||||
f1 <> f2 =
|
||||
-- FIXME: This might need to also discard adjacent zero-width ranges for
|
||||
-- when two fixes change the same AST node, e.g. `foo` -> "$(foo)"
|
||||
if or [ r2 `overlap` r1 | r1 <- fixReplacements f1, r2 <- fixReplacements f2 ]
|
||||
then f1
|
||||
else newFix {
|
||||
fixReplacements = fixReplacements f1 ++ fixReplacements f2
|
||||
}
|
||||
|
||||
-- Conveniently apply a transformation to positions in a Fix
|
||||
mapPositions :: (Position -> Position) -> Fix -> Fix
|
||||
mapPositions f = adjustFix
|
||||
where
|
||||
adjustReplacement rep =
|
||||
rep {
|
||||
repStartPos = f $ repStartPos rep,
|
||||
repEndPos = f $ repEndPos rep
|
||||
}
|
||||
adjustFix fix =
|
||||
fix {
|
||||
fixReplacements = map adjustReplacement $ fixReplacements fix
|
||||
}
|
||||
|
||||
-- Rewrite a Ranged from a tabstop of 8 to 1
|
||||
removeTabStops :: Ranged a => a -> Array Int String -> a
|
||||
removeTabStops range ls =
|
||||
let startColumn = realignColumn lineNo colNo range
|
||||
endColumn = realignColumn endLineNo endColNo range
|
||||
startPosition = (start range) { posColumn = startColumn }
|
||||
endPosition = (end range) { posColumn = endColumn } in
|
||||
setRange (startPosition, endPosition) range
|
||||
where
|
||||
realignColumn lineNo colNo c =
|
||||
if lineNo c > 0 && lineNo c <= fromIntegral (length ls)
|
||||
then real (ls ! fromIntegral (lineNo c)) 0 0 (colNo c)
|
||||
else colNo c
|
||||
real _ r v target | target <= v = r
|
||||
-- hit this case at the end of line, and if we don't hit the target
|
||||
-- return real + (target - v)
|
||||
real [] r v target = r + (target - v)
|
||||
real ('\t':rest) r v target = real rest (r+1) (v + 8 - (v `mod` 8)) target
|
||||
real (_:rest) r v target = real rest (r+1) (v+1) target
|
||||
lineNo = posLine . start
|
||||
endLineNo = posLine . end
|
||||
colNo = posColumn . start
|
||||
endColNo = posColumn . end
|
||||
|
||||
|
||||
-- A replacement that spans multiple line is applied by:
|
||||
-- 1. merging the affected lines into a single string using `unlines`
|
||||
-- 2. apply the replacement as if it only spanned a single line
|
||||
-- The tricky part is adjusting the end column of the replacement
|
||||
-- (the end line doesn't matter because there is only one line)
|
||||
--
|
||||
-- aaS <--- start of replacement (row 1 column 3)
|
||||
-- bbbb
|
||||
-- cEc
|
||||
-- \------- end of replacement (row 3 column 2)
|
||||
--
|
||||
-- a flattened string will look like:
|
||||
--
|
||||
-- "aaS\nbbbb\ncEc\n"
|
||||
--
|
||||
-- The column of E has to be adjusted by:
|
||||
-- 1. lengths of lines to be replaced, except the end row itself
|
||||
-- 2. end column of the replacement
|
||||
-- 3. number of '\n' by `unlines`
|
||||
multiToSingleLine :: [Fix] -> Array Int String -> ([Fix], String)
|
||||
multiToSingleLine fixes lines =
|
||||
(map (mapPositions adjust) fixes, unlines $ elems lines)
|
||||
where
|
||||
-- A prefix sum tree from line number to column shift.
|
||||
-- FIXME: The tree will be totally unbalanced.
|
||||
shiftTree :: PSTree Int
|
||||
shiftTree =
|
||||
foldl (\t (n,s) -> addPSValue (n+1) (length s + 1) t) newPSTree $
|
||||
assocs lines
|
||||
singleString = unlines $ elems lines
|
||||
adjust pos =
|
||||
pos {
|
||||
posLine = 1,
|
||||
posColumn = (posColumn pos) +
|
||||
(fromIntegral $ getPrefixSum (fromIntegral $ posLine pos) shiftTree)
|
||||
}
|
||||
|
||||
-- Apply a fix and return resulting lines.
|
||||
-- The number of lines can increase or decrease with no obvious mapping back, so
|
||||
-- the function does not return an array.
|
||||
applyFix :: Fix -> Array Int String -> [String]
|
||||
applyFix fix fileLines =
|
||||
let
|
||||
untabbed = fix {
|
||||
fixReplacements =
|
||||
map (\c -> removeTabStops c fileLines) $
|
||||
fixReplacements fix
|
||||
}
|
||||
(adjustedFixes, singleLine) = multiToSingleLine [untabbed] fileLines
|
||||
in
|
||||
lines . runFixer $ applyFixes2 adjustedFixes singleLine
|
||||
|
||||
|
||||
-- start and end comes from pos, which is 1 based
|
||||
prop_doReplace1 = doReplace 0 0 "1234" "A" == "A1234" -- technically not valid
|
||||
prop_doReplace2 = doReplace 1 1 "1234" "A" == "A1234"
|
||||
prop_doReplace3 = doReplace 1 2 "1234" "A" == "A234"
|
||||
prop_doReplace4 = doReplace 3 3 "1234" "A" == "12A34"
|
||||
prop_doReplace5 = doReplace 4 4 "1234" "A" == "123A4"
|
||||
prop_doReplace6 = doReplace 5 5 "1234" "A" == "1234A"
|
||||
doReplace start end o r =
|
||||
let si = fromIntegral (start-1)
|
||||
ei = fromIntegral (end-1)
|
||||
(x, xs) = splitAt si o
|
||||
z = drop (ei - si) xs
|
||||
in
|
||||
x ++ r ++ z
|
||||
|
||||
-- Fail if the 'expected' string is not result when applying 'fixes' to 'original'.
|
||||
testFixes :: String -> String -> [Fix] -> Bool
|
||||
testFixes expected original fixes =
|
||||
actual == expected
|
||||
where
|
||||
actual = runFixer (applyFixes2 fixes original)
|
||||
|
||||
|
||||
-- A Fixer allows doing repeated modifications of a string where each
|
||||
-- replacement automatically accounts for shifts from previous ones.
|
||||
type Fixer a = State (PSTree Int) a
|
||||
|
||||
-- Apply a single replacement using its indices into the original string.
|
||||
-- It does not handle multiple lines, all line indices must be 1.
|
||||
applyReplacement2 :: Replacement -> String -> Fixer String
|
||||
applyReplacement2 rep string = do
|
||||
tree <- get
|
||||
let transform pos = pos + getPrefixSum pos tree
|
||||
let originalPos = (repStartPos rep, repEndPos rep)
|
||||
(oldStart, oldEnd) = tmap (fromInteger . posColumn) originalPos
|
||||
(newStart, newEnd) = tmap transform (oldStart, oldEnd)
|
||||
|
||||
let (l1, l2) = tmap posLine originalPos in
|
||||
when (l1 /= 1 || l2 /= 1) $
|
||||
error $ pleaseReport "bad cross-line fix"
|
||||
|
||||
let replacer = repString rep
|
||||
let shift = (length replacer) - (oldEnd - oldStart)
|
||||
let insertionPoint =
|
||||
case repInsertionPoint rep of
|
||||
InsertBefore -> oldStart
|
||||
InsertAfter -> oldEnd+1
|
||||
put $ addPSValue insertionPoint shift tree
|
||||
|
||||
return $ doReplace newStart newEnd string replacer
|
||||
where
|
||||
tmap f (a,b) = (f a, f b)
|
||||
|
||||
-- Apply a list of Replacements in the correct order
|
||||
applyReplacements2 :: [Replacement] -> String -> Fixer String
|
||||
applyReplacements2 reps str =
|
||||
foldM (flip applyReplacement2) str $
|
||||
reverse $ sortWith repPrecedence reps
|
||||
|
||||
-- Apply all fixes with replacements in the correct order
|
||||
applyFixes2 :: [Fix] -> String -> Fixer String
|
||||
applyFixes2 fixes = applyReplacements2 (concatMap fixReplacements fixes)
|
||||
|
||||
-- Get the final value of a Fixer.
|
||||
runFixer :: Fixer a -> a
|
||||
runFixer f = evalState f newPSTree
|
||||
|
||||
|
||||
|
||||
-- A Prefix Sum Tree that lets you look up the sum of values at and below an index.
|
||||
-- It's implemented essentially as a Fenwick tree without the bit-based balancing.
|
||||
-- The last Num is the sum of the left branch plus current element.
|
||||
data PSTree n = PSBranch n (PSTree n) (PSTree n) n | PSLeaf
|
||||
deriving (Show)
|
||||
|
||||
newPSTree :: Num n => PSTree n
|
||||
newPSTree = PSLeaf
|
||||
|
||||
-- Get the sum of values whose keys are <= 'target'
|
||||
getPrefixSum :: (Ord n, Num n) => n -> PSTree n -> n
|
||||
getPrefixSum = f 0
|
||||
where
|
||||
f sum _ PSLeaf = sum
|
||||
f sum target (PSBranch pivot left right cumulative) =
|
||||
case target `compare` pivot of
|
||||
LT -> f sum target left
|
||||
GT -> f (sum+cumulative) target right
|
||||
EQ -> sum+cumulative
|
||||
|
||||
-- Add a value to the Prefix Sum tree at the given index.
|
||||
-- Values accumulate: addPSValue 42 2 . addPSValue 42 3 == addPSValue 42 5
|
||||
addPSValue :: (Ord n, Num n) => n -> n -> PSTree n -> PSTree n
|
||||
addPSValue key value tree = if value == 0 then tree else f tree
|
||||
where
|
||||
f PSLeaf = PSBranch key PSLeaf PSLeaf value
|
||||
f (PSBranch pivot left right sum) =
|
||||
case key `compare` pivot of
|
||||
LT -> PSBranch pivot (f left) right (sum + value)
|
||||
GT -> PSBranch pivot left (f right) sum
|
||||
EQ -> PSBranch pivot left right (sum + value)
|
||||
|
||||
prop_pstreeSumsCorrectly kvs targets =
|
||||
let
|
||||
-- Trivial O(n * m) implementation
|
||||
dumbPrefixSums :: [(Int, Int)] -> [Int] -> [Int]
|
||||
dumbPrefixSums kvs targets =
|
||||
let prefixSum target = sum [v | (k,v) <- kvs, k <= target]
|
||||
in map prefixSum targets
|
||||
-- PSTree O(n * log m) implementation
|
||||
smartPrefixSums :: [(Int, Int)] -> [Int] -> [Int]
|
||||
smartPrefixSums kvs targets =
|
||||
let tree = foldl (\tree (pos, shift) -> addPSValue pos shift tree) PSLeaf kvs
|
||||
in map (\x -> getPrefixSum x tree) targets
|
||||
in smartPrefixSums kvs targets == dumbPrefixSums kvs targets
|
||||
|
||||
|
||||
-- Semi-convenient functions for constructing tests.
|
||||
testFix :: [Replacement] -> Fix
|
||||
testFix list = newFix {
|
||||
fixReplacements = list
|
||||
}
|
||||
|
||||
tFromStart :: Int -> Int -> String -> Int -> Replacement
|
||||
tFromStart start end repl order =
|
||||
newReplacement {
|
||||
repStartPos = newPosition {
|
||||
posLine = 1,
|
||||
posColumn = fromIntegral start
|
||||
},
|
||||
repEndPos = newPosition {
|
||||
posLine = 1,
|
||||
posColumn = fromIntegral end
|
||||
},
|
||||
repString = repl,
|
||||
repPrecedence = order,
|
||||
repInsertionPoint = InsertAfter
|
||||
}
|
||||
|
||||
tFromEnd start end repl order =
|
||||
(tFromStart start end repl order) {
|
||||
repInsertionPoint = InsertBefore
|
||||
}
|
||||
|
||||
prop_simpleFix1 = testFixes "hello world" "hell world" [
|
||||
testFix [
|
||||
tFromEnd 5 5 "o" 1
|
||||
]]
|
||||
|
||||
prop_anchorsLeft = testFixes "-->foobar<--" "--><--" [
|
||||
testFix [
|
||||
tFromStart 4 4 "foo" 1,
|
||||
tFromStart 4 4 "bar" 2
|
||||
]]
|
||||
|
||||
prop_anchorsRight = testFixes "-->foobar<--" "--><--" [
|
||||
testFix [
|
||||
tFromEnd 4 4 "bar" 1,
|
||||
tFromEnd 4 4 "foo" 2
|
||||
]]
|
||||
|
||||
prop_anchorsBoth1 = testFixes "-->foobar<--" "--><--" [
|
||||
testFix [
|
||||
tFromStart 4 4 "bar" 2,
|
||||
tFromEnd 4 4 "foo" 1
|
||||
]]
|
||||
|
||||
prop_anchorsBoth2 = testFixes "-->foobar<--" "--><--" [
|
||||
testFix [
|
||||
tFromEnd 4 4 "foo" 2,
|
||||
tFromStart 4 4 "bar" 1
|
||||
]]
|
||||
|
||||
prop_composeFixes1 = testFixes "cd \"$1\" || exit" "cd $1" [
|
||||
testFix [
|
||||
tFromStart 4 4 "\"" 10,
|
||||
tFromEnd 6 6 "\"" 10
|
||||
],
|
||||
testFix [
|
||||
tFromEnd 6 6 " || exit" 5
|
||||
]]
|
||||
|
||||
prop_composeFixes2 = testFixes "$(\"$1\")" "`$1`" [
|
||||
testFix [
|
||||
tFromStart 1 2 "$(" 5,
|
||||
tFromEnd 4 5 ")" 5
|
||||
],
|
||||
testFix [
|
||||
tFromStart 2 2 "\"" 10,
|
||||
tFromEnd 4 4 "\"" 10
|
||||
]]
|
||||
|
||||
prop_composeFixes3 = testFixes "(x)[x]" "xx" [
|
||||
testFix [
|
||||
tFromStart 1 1 "(" 4,
|
||||
tFromEnd 2 2 ")" 3,
|
||||
tFromStart 2 2 "[" 2,
|
||||
tFromEnd 3 3 "]" 1
|
||||
]]
|
||||
|
||||
prop_composeFixes4 = testFixes "(x)[x]" "xx" [
|
||||
testFix [
|
||||
tFromStart 1 1 "(" 4,
|
||||
tFromStart 2 2 "[" 3,
|
||||
tFromEnd 2 2 ")" 2,
|
||||
tFromEnd 3 3 "]" 1
|
||||
]]
|
||||
|
||||
prop_composeFixes5 = testFixes "\"$(x)\"" "`x`" [
|
||||
testFix [
|
||||
tFromStart 1 2 "$(" 2,
|
||||
tFromEnd 3 4 ")" 2,
|
||||
tFromStart 1 1 "\"" 1,
|
||||
tFromEnd 4 4 "\"" 1
|
||||
]]
|
||||
|
||||
|
||||
return []
|
||||
runTests = $quickCheckAll
|
||||
|
|
@ -1,95 +0,0 @@
|
|||
{-
|
||||
Copyright 2012-2019 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
module ShellCheck.Formatter.CheckStyle (format) where
|
||||
|
||||
import ShellCheck.Interface
|
||||
import ShellCheck.Formatter.Format
|
||||
|
||||
import Data.Char
|
||||
import Data.List
|
||||
import System.IO
|
||||
import qualified Data.List.NonEmpty as NE
|
||||
|
||||
format :: IO Formatter
|
||||
format = return Formatter {
|
||||
header = do
|
||||
putStrLn "<?xml version='1.0' encoding='UTF-8'?>"
|
||||
putStrLn "<checkstyle version='4.3'>",
|
||||
|
||||
onFailure = outputError,
|
||||
onResult = outputResults,
|
||||
|
||||
footer = putStrLn "</checkstyle>"
|
||||
}
|
||||
|
||||
outputResults cr sys =
|
||||
if null comments
|
||||
then outputFile (crFilename cr) "" []
|
||||
else mapM_ outputGroup fileGroups
|
||||
where
|
||||
comments = crComments cr
|
||||
fileGroups = NE.groupWith sourceFile comments
|
||||
outputGroup group = do
|
||||
let filename = sourceFile (NE.head group)
|
||||
result <- siReadFile sys (Just True) filename
|
||||
let contents = either (const "") id result
|
||||
outputFile filename contents (NE.toList group)
|
||||
|
||||
outputFile filename contents warnings = do
|
||||
let comments = makeNonVirtual warnings contents
|
||||
putStrLn . formatFile filename $ comments
|
||||
|
||||
formatFile name comments = concat [
|
||||
"<file ", attr "name" name, ">\n",
|
||||
concatMap formatComment comments,
|
||||
"</file>"
|
||||
]
|
||||
|
||||
formatComment c = concat [
|
||||
"<error ",
|
||||
attr "line" $ show . lineNo $ c,
|
||||
attr "column" $ show . colNo $ c,
|
||||
attr "severity" . severity $ severityText c,
|
||||
attr "message" $ messageText c,
|
||||
attr "source" $ "ShellCheck.SC" ++ show (codeNo c),
|
||||
"/>\n"
|
||||
]
|
||||
|
||||
outputError file error = putStrLn $ concat [
|
||||
"<file ", attr "name" file, ">\n",
|
||||
"<error ",
|
||||
attr "line" "1",
|
||||
attr "column" "1",
|
||||
attr "severity" "error",
|
||||
attr "message" error,
|
||||
attr "source" "ShellCheck",
|
||||
"/>\n",
|
||||
"</file>"
|
||||
]
|
||||
|
||||
|
||||
attr s v = concat [ s, "='", escape v, "' " ]
|
||||
escape = concatMap escape'
|
||||
escape' c = if isOk c then [c] else "&#" ++ show (ord c) ++ ";"
|
||||
isOk x = any ($ x) [isAsciiUpper, isAsciiLower, isDigit, (`elem` " ./")]
|
||||
|
||||
severity "error" = "error"
|
||||
severity "warning" = "warning"
|
||||
severity _ = "info"
|
||||
|
|
@ -1,260 +0,0 @@
|
|||
{-
|
||||
Copyright 2019 Vidar 'koala_man' Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
{-# LANGUAGE TemplateHaskell #-}
|
||||
module ShellCheck.Formatter.Diff (format, ShellCheck.Formatter.Diff.runTests) where
|
||||
|
||||
import ShellCheck.Interface
|
||||
import ShellCheck.Fixer
|
||||
import ShellCheck.Formatter.Format
|
||||
|
||||
import Control.Monad
|
||||
import Data.Algorithm.Diff
|
||||
import Data.Array
|
||||
import Data.IORef
|
||||
import Data.List
|
||||
import qualified Data.Monoid as Monoid
|
||||
import Data.Maybe
|
||||
import qualified Data.Map as M
|
||||
import GHC.Exts (sortWith)
|
||||
import System.IO
|
||||
import System.FilePath
|
||||
|
||||
import Test.QuickCheck
|
||||
|
||||
format :: FormatterOptions -> IO Formatter
|
||||
format options = do
|
||||
foundIssues <- newIORef False
|
||||
reportedIssues <- newIORef False
|
||||
shouldColor <- shouldOutputColor (foColorOption options)
|
||||
let color = if shouldColor then colorize else nocolor
|
||||
return Formatter {
|
||||
header = return (),
|
||||
footer = checkFooter foundIssues reportedIssues color,
|
||||
onFailure = reportFailure color,
|
||||
onResult = reportResult foundIssues reportedIssues color
|
||||
}
|
||||
|
||||
|
||||
contextSize = 3
|
||||
red = 31
|
||||
green = 32
|
||||
yellow = 33
|
||||
cyan = 36
|
||||
bold = 1
|
||||
|
||||
nocolor n = id
|
||||
colorize n s = (ansi n) ++ s ++ (ansi 0)
|
||||
ansi n = "\x1B[" ++ show n ++ "m"
|
||||
|
||||
printErr :: ColorFunc -> String -> IO ()
|
||||
printErr color = hPutStrLn stderr . color bold . color red
|
||||
reportFailure color file msg = printErr color $ file ++ ": " ++ msg
|
||||
|
||||
checkFooter foundIssues reportedIssues color = do
|
||||
found <- readIORef foundIssues
|
||||
output <- readIORef reportedIssues
|
||||
when (found && not output) $
|
||||
printErr color "Issues were detected, but none were auto-fixable. Use another format to see them."
|
||||
|
||||
type ColorFunc = (Int -> String -> String)
|
||||
data LFStatus = LinefeedMissing | LinefeedOk
|
||||
data DiffDoc a = DiffDoc String LFStatus [DiffRegion a]
|
||||
data DiffRegion a = DiffRegion (Int, Int) (Int, Int) [Diff a]
|
||||
|
||||
reportResult :: (IORef Bool) -> (IORef Bool) -> ColorFunc -> CheckResult -> SystemInterface IO -> IO ()
|
||||
reportResult foundIssues reportedIssues color result sys = do
|
||||
let comments = crComments result
|
||||
unless (null comments) $ writeIORef foundIssues True
|
||||
let suggestedFixes = mapMaybe pcFix comments
|
||||
let fixmap = buildFixMap suggestedFixes
|
||||
mapM_ output $ M.toList fixmap
|
||||
where
|
||||
output (name, fix) = do
|
||||
file <- siReadFile sys (Just True) name
|
||||
case file of
|
||||
Right contents -> do
|
||||
putStrLn $ formatDoc color $ makeDiff name contents fix
|
||||
writeIORef reportedIssues True
|
||||
Left msg -> reportFailure color name msg
|
||||
|
||||
hasTrailingLinefeed str =
|
||||
case str of
|
||||
[] -> True
|
||||
_ -> last str == '\n'
|
||||
|
||||
coversLastLine regions =
|
||||
case regions of
|
||||
[] -> False
|
||||
_ -> (fst $ last regions)
|
||||
|
||||
-- TODO: Factor this out into a unified diff library because we're doing a lot
|
||||
-- of the heavy lifting anyways.
|
||||
makeDiff :: String -> String -> Fix -> DiffDoc String
|
||||
makeDiff name contents fix = do
|
||||
let hunks = groupDiff $ computeDiff contents fix
|
||||
let lf = if coversLastLine hunks && not (hasTrailingLinefeed contents)
|
||||
then LinefeedMissing
|
||||
else LinefeedOk
|
||||
DiffDoc name lf $ findRegions hunks
|
||||
|
||||
computeDiff :: String -> Fix -> [Diff String]
|
||||
computeDiff contents fix =
|
||||
let old = lines contents
|
||||
array = listArray (1, fromIntegral $ (length old)) old
|
||||
new = applyFix fix array
|
||||
in getDiff old new
|
||||
|
||||
-- Group changes into hunks
|
||||
groupDiff :: [Diff a] -> [(Bool, [Diff a])]
|
||||
groupDiff = filter (\(_, l) -> not (null l)) . hunt []
|
||||
where
|
||||
-- Churn through 'Both's until we find a difference
|
||||
hunt current [] = [(False, reverse current)]
|
||||
hunt current (x@Both {}:rest) = hunt (x:current) rest
|
||||
hunt current list =
|
||||
let (context, previous) = splitAt contextSize current
|
||||
in (False, reverse previous) : gather context 0 list
|
||||
|
||||
-- Pick out differences until we find a run of Both's
|
||||
gather current n [] =
|
||||
let (extras, patch) = splitAt (max 0 $ n - contextSize) current
|
||||
in [(True, reverse patch), (False, reverse extras)]
|
||||
|
||||
gather current n list@(Both {}:_) | n == contextSize*2 =
|
||||
let (context, previous) = splitAt contextSize current
|
||||
in (True, reverse previous) : hunt context list
|
||||
|
||||
gather current n (x@Both {}:rest) = gather (x:current) (n+1) rest
|
||||
gather current n (x:rest) = gather (x:current) 0 rest
|
||||
|
||||
-- Get line numbers for hunks
|
||||
findRegions :: [(Bool, [Diff String])] -> [DiffRegion String]
|
||||
findRegions = find' 1 1
|
||||
where
|
||||
find' _ _ [] = []
|
||||
find' left right ((output, run):rest) =
|
||||
let (dl, dr) = countDelta run
|
||||
remainder = find' (left+dl) (right+dr) rest
|
||||
in
|
||||
if output
|
||||
then DiffRegion (left, dl) (right, dr) run : remainder
|
||||
else remainder
|
||||
|
||||
-- Get left/right line counts for a hunk
|
||||
countDelta :: [Diff a] -> (Int, Int)
|
||||
countDelta = count' 0 0
|
||||
where
|
||||
count' left right [] = (left, right)
|
||||
count' left right (x:rest) =
|
||||
case x of
|
||||
Both {} -> count' (left+1) (right+1) rest
|
||||
First {} -> count' (left+1) right rest
|
||||
Second {} -> count' left (right+1) rest
|
||||
|
||||
formatRegion :: ColorFunc -> LFStatus -> DiffRegion String -> String
|
||||
formatRegion color lf (DiffRegion left right diffs) =
|
||||
let header = color cyan ("@@ -" ++ (tup left) ++ " +" ++ (tup right) ++" @@")
|
||||
in
|
||||
unlines $ header : reverse (getStrings lf (reverse diffs))
|
||||
where
|
||||
noLF = "\\ No newline at end of file"
|
||||
|
||||
getStrings LinefeedOk list = map format list
|
||||
getStrings LinefeedMissing list@((Both _ _):_) = noLF : map format list
|
||||
getStrings LinefeedMissing list@((First _):_) = noLF : map format list
|
||||
getStrings LinefeedMissing (last:rest) = format last : getStrings LinefeedMissing rest
|
||||
|
||||
tup (a,b) = (show a) ++ "," ++ (show b)
|
||||
format (Both x _) = ' ':x
|
||||
format (First x) = color red $ '-':x
|
||||
format (Second x) = color green $ '+':x
|
||||
|
||||
splitLast [] = ([], [])
|
||||
splitLast x =
|
||||
let (last, rest) = splitAt 1 $ reverse x
|
||||
in (reverse rest, last)
|
||||
|
||||
-- git patch does not like `\` on Windows
|
||||
normalizePath path =
|
||||
case path of
|
||||
c:rest -> (if c == pathSeparator then '/' else c) : normalizePath rest
|
||||
[] -> []
|
||||
|
||||
formatDoc color (DiffDoc name lf regions) =
|
||||
let (most, last) = splitLast regions
|
||||
in
|
||||
(color bold $ "--- " ++ (normalizePath $ "a" </> name)) ++ "\n" ++
|
||||
(color bold $ "+++ " ++ (normalizePath $ "b" </> name)) ++ "\n" ++
|
||||
concatMap (formatRegion color LinefeedOk) most ++
|
||||
concatMap (formatRegion color lf) last
|
||||
|
||||
-- Create a Map from filename to Fix
|
||||
buildFixMap :: [Fix] -> M.Map String Fix
|
||||
buildFixMap fixes = perFile
|
||||
where
|
||||
splitFixes = splitFixByFile $ mconcat fixes
|
||||
perFile = groupByMap (posFile . repStartPos . head . fixReplacements) splitFixes
|
||||
|
||||
splitFixByFile :: Fix -> [Fix]
|
||||
splitFixByFile fix = map makeFix $ groupBy sameFile (fixReplacements fix)
|
||||
where
|
||||
sameFile rep1 rep2 = (posFile $ repStartPos rep1) == (posFile $ repStartPos rep2)
|
||||
makeFix reps = newFix { fixReplacements = reps }
|
||||
|
||||
groupByMap :: (Ord k, Monoid v) => (v -> k) -> [v] -> M.Map k v
|
||||
groupByMap f = M.fromListWith Monoid.mappend . map (\x -> (f x, x))
|
||||
|
||||
-- For building unit tests
|
||||
b n = Both n n
|
||||
l = First
|
||||
r = Second
|
||||
|
||||
prop_identifiesProperContext = groupDiff [b 1, b 2, b 3, b 4, l 5, b 6, b 7, b 8, b 9] ==
|
||||
[(False, [b 1]), -- Omitted
|
||||
(True, [b 2, b 3, b 4, l 5, b 6, b 7, b 8]), -- A change with three lines of context
|
||||
(False, [b 9])] -- Omitted
|
||||
|
||||
prop_includesContextFromStartIfNecessary = groupDiff [b 4, l 5, b 6, b 7, b 8, b 9] ==
|
||||
[ -- Nothing omitted
|
||||
(True, [b 4, l 5, b 6, b 7, b 8]), -- A change with three lines of context
|
||||
(False, [b 9])] -- Omitted
|
||||
|
||||
prop_includesContextUntilEndIfNecessary = groupDiff [b 4, l 5] ==
|
||||
[ -- Nothing omitted
|
||||
(True, [b 4, l 5])
|
||||
] -- Nothing Omitted
|
||||
|
||||
prop_splitsIntoMultipleHunks = groupDiff [l 1, b 1, b 2, b 3, b 4, b 5, b 6, b 7, r 8] ==
|
||||
[ -- Nothing omitted
|
||||
(True, [l 1, b 1, b 2, b 3]),
|
||||
(False, [b 4]),
|
||||
(True, [b 5, b 6, b 7, r 8])
|
||||
] -- Nothing Omitted
|
||||
|
||||
prop_splitsIntoMultipleHunksUnlessTouching = groupDiff [l 1, b 1, b 2, b 3, b 4, b 5, b 6, r 7] ==
|
||||
[
|
||||
(True, [l 1, b 1, b 2, b 3, b 4, b 5, b 6, r 7])
|
||||
]
|
||||
|
||||
prop_countDeltasWorks = countDelta [b 1, l 2, r 3, r 4, b 5] == (3,4)
|
||||
prop_countDeltasWorks2 = countDelta [] == (0,0)
|
||||
|
||||
return []
|
||||
runTests = $quickCheckAll
|
||||
|
|
@ -1,82 +0,0 @@
|
|||
{-
|
||||
Copyright 2012-2019 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
module ShellCheck.Formatter.Format where
|
||||
|
||||
import ShellCheck.Data
|
||||
import ShellCheck.Interface
|
||||
import ShellCheck.Fixer
|
||||
|
||||
import Control.Monad
|
||||
import Data.Array
|
||||
import Data.List
|
||||
import System.IO
|
||||
import System.Info
|
||||
import System.Environment
|
||||
|
||||
-- A formatter that carries along an arbitrary piece of data
|
||||
data Formatter = Formatter {
|
||||
header :: IO (),
|
||||
onResult :: CheckResult -> SystemInterface IO -> IO (),
|
||||
onFailure :: FilePath -> ErrorMessage -> IO (),
|
||||
footer :: IO ()
|
||||
}
|
||||
|
||||
sourceFile = posFile . pcStartPos
|
||||
lineNo = posLine . pcStartPos
|
||||
endLineNo = posLine . pcEndPos
|
||||
colNo = posColumn . pcStartPos
|
||||
endColNo = posColumn . pcEndPos
|
||||
codeNo = cCode . pcComment
|
||||
messageText = cMessage . pcComment
|
||||
|
||||
severityText :: PositionedComment -> String
|
||||
severityText pc =
|
||||
case cSeverity (pcComment pc) of
|
||||
ErrorC -> "error"
|
||||
WarningC -> "warning"
|
||||
InfoC -> "info"
|
||||
StyleC -> "style"
|
||||
|
||||
-- Realign comments from a tabstop of 8 to 1
|
||||
makeNonVirtual comments contents =
|
||||
map fix comments
|
||||
where
|
||||
list = lines contents
|
||||
arr = listArray (1, length list) list
|
||||
untabbedFix f = newFix {
|
||||
fixReplacements = map (\r -> removeTabStops r arr) (fixReplacements f)
|
||||
}
|
||||
fix c = (removeTabStops c arr) {
|
||||
pcFix = fmap untabbedFix (pcFix c)
|
||||
}
|
||||
|
||||
|
||||
shouldOutputColor :: ColorOption -> IO Bool
|
||||
shouldOutputColor colorOption =
|
||||
case colorOption of
|
||||
ColorAlways -> return True
|
||||
ColorNever -> return False
|
||||
ColorAuto -> do
|
||||
isTerminal <- hIsTerminalDevice stdout
|
||||
term <- lookupEnv "TERM"
|
||||
let windows = "mingw" `isPrefixOf` os
|
||||
let dumbTerm = term `elem` [Just "dumb", Just "", Nothing]
|
||||
let isUsableTty = isTerminal && not windows && not dumbTerm
|
||||
return isUsableTty
|
||||
|
|
@ -1,65 +0,0 @@
|
|||
{-
|
||||
Copyright 2012-2019 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
module ShellCheck.Formatter.GCC (format) where
|
||||
|
||||
import ShellCheck.Interface
|
||||
import ShellCheck.Formatter.Format
|
||||
|
||||
import Data.List
|
||||
import System.IO
|
||||
import qualified Data.List.NonEmpty as NE
|
||||
|
||||
format :: IO Formatter
|
||||
format = return Formatter {
|
||||
header = return (),
|
||||
footer = return (),
|
||||
onFailure = outputError,
|
||||
onResult = outputAll
|
||||
}
|
||||
|
||||
outputError file error = hPutStrLn stderr $ file ++ ": " ++ error
|
||||
|
||||
outputAll cr sys = mapM_ f groups
|
||||
where
|
||||
comments = crComments cr
|
||||
groups = NE.groupWith sourceFile comments
|
||||
f :: NE.NonEmpty PositionedComment -> IO ()
|
||||
f group = do
|
||||
let filename = sourceFile (NE.head group)
|
||||
result <- siReadFile sys (Just True) filename
|
||||
let contents = either (const "") id result
|
||||
outputResult filename contents (NE.toList group)
|
||||
|
||||
outputResult filename contents warnings = do
|
||||
let comments = makeNonVirtual warnings contents
|
||||
mapM_ (putStrLn . formatComment filename) comments
|
||||
|
||||
formatComment filename c = concat [
|
||||
filename, ":",
|
||||
show $ lineNo c, ":",
|
||||
show $ colNo c, ": ",
|
||||
case severityText c of
|
||||
"error" -> "error"
|
||||
"warning" -> "warning"
|
||||
_ -> "note",
|
||||
": ",
|
||||
concat . lines $ messageText c,
|
||||
" [SC", show $ codeNo c, "]"
|
||||
]
|
||||
|
|
@ -1,111 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
{-
|
||||
Copyright 2012-2019 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
module ShellCheck.Formatter.JSON (format) where
|
||||
|
||||
import ShellCheck.Interface
|
||||
import ShellCheck.Formatter.Format
|
||||
|
||||
import Control.DeepSeq
|
||||
import Data.Aeson
|
||||
import Data.IORef
|
||||
import Data.Monoid
|
||||
import GHC.Exts
|
||||
import System.IO
|
||||
import qualified Data.ByteString.Lazy.Char8 as BL
|
||||
|
||||
format :: IO Formatter
|
||||
format = do
|
||||
ref <- newIORef []
|
||||
return Formatter {
|
||||
header = return (),
|
||||
onResult = collectResult ref,
|
||||
onFailure = outputError,
|
||||
footer = finish ref
|
||||
}
|
||||
|
||||
instance ToJSON Replacement where
|
||||
toJSON replacement =
|
||||
let start = repStartPos replacement
|
||||
end = repEndPos replacement
|
||||
str = repString replacement in
|
||||
object [
|
||||
"precedence" .= repPrecedence replacement,
|
||||
"insertionPoint" .=
|
||||
case repInsertionPoint replacement of
|
||||
InsertBefore -> "beforeStart" :: String
|
||||
InsertAfter -> "afterEnd",
|
||||
"line" .= posLine start,
|
||||
"column" .= posColumn start,
|
||||
"endLine" .= posLine end,
|
||||
"endColumn" .= posColumn end,
|
||||
"replacement" .= str
|
||||
]
|
||||
|
||||
instance ToJSON PositionedComment where
|
||||
toJSON comment =
|
||||
let start = pcStartPos comment
|
||||
end = pcEndPos comment
|
||||
c = pcComment comment in
|
||||
object [
|
||||
"file" .= posFile start,
|
||||
"line" .= posLine start,
|
||||
"endLine" .= posLine end,
|
||||
"column" .= posColumn start,
|
||||
"endColumn" .= posColumn end,
|
||||
"level" .= severityText comment,
|
||||
"code" .= cCode c,
|
||||
"message" .= cMessage c,
|
||||
"fix" .= pcFix comment
|
||||
]
|
||||
|
||||
toEncoding comment =
|
||||
let start = pcStartPos comment
|
||||
end = pcEndPos comment
|
||||
c = pcComment comment in
|
||||
pairs (
|
||||
"file" .= posFile start
|
||||
<> "line" .= posLine start
|
||||
<> "endLine" .= posLine end
|
||||
<> "column" .= posColumn start
|
||||
<> "endColumn" .= posColumn end
|
||||
<> "level" .= severityText comment
|
||||
<> "code" .= cCode c
|
||||
<> "message" .= cMessage c
|
||||
<> "fix" .= pcFix comment
|
||||
)
|
||||
|
||||
instance ToJSON Fix where
|
||||
toJSON fix = object [
|
||||
"replacements" .= fixReplacements fix
|
||||
]
|
||||
|
||||
outputError file msg = hPutStrLn stderr $ file ++ ": " ++ msg
|
||||
|
||||
collectResult ref cr sys = mapM_ f groups
|
||||
where
|
||||
comments = crComments cr
|
||||
groups = groupWith sourceFile comments
|
||||
f :: [PositionedComment] -> IO ()
|
||||
f group = deepseq comments $ modifyIORef ref (\x -> comments ++ x)
|
||||
|
||||
finish ref = do
|
||||
list <- readIORef ref
|
||||
BL.putStrLn $ encode list
|
||||
|
|
@ -1,128 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
{-
|
||||
Copyright 2012-2019 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
module ShellCheck.Formatter.JSON1 (format) where
|
||||
|
||||
import ShellCheck.Interface
|
||||
import ShellCheck.Formatter.Format
|
||||
|
||||
import Control.DeepSeq
|
||||
import Data.Aeson
|
||||
import Data.IORef
|
||||
import Data.Monoid
|
||||
import System.IO
|
||||
import qualified Data.ByteString.Lazy.Char8 as BL
|
||||
import qualified Data.List.NonEmpty as NE
|
||||
|
||||
format :: IO Formatter
|
||||
format = do
|
||||
ref <- newIORef []
|
||||
return Formatter {
|
||||
header = return (),
|
||||
onResult = collectResult ref,
|
||||
onFailure = outputError,
|
||||
footer = finish ref
|
||||
}
|
||||
|
||||
data Json1Output = Json1Output {
|
||||
comments :: [PositionedComment]
|
||||
}
|
||||
|
||||
instance ToJSON Json1Output where
|
||||
toJSON result = object [
|
||||
"comments" .= comments result
|
||||
]
|
||||
toEncoding result = pairs (
|
||||
"comments" .= comments result
|
||||
)
|
||||
|
||||
instance ToJSON Replacement where
|
||||
toJSON replacement =
|
||||
let start = repStartPos replacement
|
||||
end = repEndPos replacement
|
||||
str = repString replacement in
|
||||
object [
|
||||
"precedence" .= repPrecedence replacement,
|
||||
"insertionPoint" .=
|
||||
case repInsertionPoint replacement of
|
||||
InsertBefore -> "beforeStart" :: String
|
||||
InsertAfter -> "afterEnd",
|
||||
"line" .= posLine start,
|
||||
"column" .= posColumn start,
|
||||
"endLine" .= posLine end,
|
||||
"endColumn" .= posColumn end,
|
||||
"replacement" .= str
|
||||
]
|
||||
|
||||
instance ToJSON PositionedComment where
|
||||
toJSON comment =
|
||||
let start = pcStartPos comment
|
||||
end = pcEndPos comment
|
||||
c = pcComment comment in
|
||||
object [
|
||||
"file" .= posFile start,
|
||||
"line" .= posLine start,
|
||||
"endLine" .= posLine end,
|
||||
"column" .= posColumn start,
|
||||
"endColumn" .= posColumn end,
|
||||
"level" .= severityText comment,
|
||||
"code" .= cCode c,
|
||||
"message" .= cMessage c,
|
||||
"fix" .= pcFix comment
|
||||
]
|
||||
|
||||
toEncoding comment =
|
||||
let start = pcStartPos comment
|
||||
end = pcEndPos comment
|
||||
c = pcComment comment in
|
||||
pairs (
|
||||
"file" .= posFile start
|
||||
<> "line" .= posLine start
|
||||
<> "endLine" .= posLine end
|
||||
<> "column" .= posColumn start
|
||||
<> "endColumn" .= posColumn end
|
||||
<> "level" .= severityText comment
|
||||
<> "code" .= cCode c
|
||||
<> "message" .= cMessage c
|
||||
<> "fix" .= pcFix comment
|
||||
)
|
||||
|
||||
instance ToJSON Fix where
|
||||
toJSON fix = object [
|
||||
"replacements" .= fixReplacements fix
|
||||
]
|
||||
|
||||
outputError file msg = hPutStrLn stderr $ file ++ ": " ++ msg
|
||||
|
||||
collectResult ref cr sys = mapM_ f groups
|
||||
where
|
||||
comments = crComments cr
|
||||
groups = NE.groupWith sourceFile comments
|
||||
f :: NE.NonEmpty PositionedComment -> IO ()
|
||||
f group = do
|
||||
let filename = sourceFile (NE.head group)
|
||||
result <- siReadFile sys (Just True) filename
|
||||
let contents = either (const "") id result
|
||||
let comments' = makeNonVirtual comments contents
|
||||
deepseq comments' $ modifyIORef ref (\x -> comments' ++ x)
|
||||
|
||||
finish ref = do
|
||||
list <- readIORef ref
|
||||
BL.putStrLn $ encode $ Json1Output { comments = list }
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
{-
|
||||
Copyright 2019 Austin Voecks
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
module ShellCheck.Formatter.Quiet (format) where
|
||||
|
||||
import ShellCheck.Interface
|
||||
import ShellCheck.Formatter.Format
|
||||
|
||||
import Control.Monad
|
||||
import Data.IORef
|
||||
import System.Exit
|
||||
|
||||
format :: FormatterOptions -> IO Formatter
|
||||
format options =
|
||||
return Formatter {
|
||||
header = return (),
|
||||
footer = return (),
|
||||
onFailure = \ _ _ -> exitFailure,
|
||||
onResult = \ result _ -> unless (null $ crComments result) exitFailure
|
||||
}
|
||||
|
|
@ -1,197 +0,0 @@
|
|||
{-
|
||||
Copyright 2012-2019 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
module ShellCheck.Formatter.TTY (format) where
|
||||
|
||||
import ShellCheck.Fixer
|
||||
import ShellCheck.Interface
|
||||
import ShellCheck.Formatter.Format
|
||||
|
||||
import Control.DeepSeq
|
||||
import Control.Monad
|
||||
import Data.Array
|
||||
import Data.Foldable
|
||||
import Data.Ord
|
||||
import Data.IORef
|
||||
import Data.List
|
||||
import Data.Maybe
|
||||
import System.IO
|
||||
import System.Info
|
||||
import qualified Data.List.NonEmpty as NE
|
||||
|
||||
wikiLink = "https://www.shellcheck.net/wiki/"
|
||||
|
||||
-- An arbitrary Ord thing to order warnings
|
||||
type Ranking = (Char, Severity, Integer)
|
||||
-- Ansi coloring function
|
||||
type ColorFunc = (String -> String -> String)
|
||||
|
||||
format :: FormatterOptions -> IO Formatter
|
||||
format options = do
|
||||
topErrorRef <- newIORef []
|
||||
return Formatter {
|
||||
header = return (),
|
||||
footer = outputWiki topErrorRef,
|
||||
onFailure = outputError options,
|
||||
onResult = outputResult options topErrorRef
|
||||
}
|
||||
|
||||
colorForLevel level =
|
||||
case level of
|
||||
"error" -> 31 -- red
|
||||
"warning" -> 33 -- yellow
|
||||
"info" -> 32 -- green
|
||||
"style" -> 32 -- green
|
||||
"verbose" -> 32 -- green
|
||||
"message" -> 1 -- bold
|
||||
"source" -> 0 -- none
|
||||
_ -> 0 -- none
|
||||
|
||||
rankError :: PositionedComment -> Ranking
|
||||
rankError err = (ranking, cSeverity $ pcComment err, cCode $ pcComment err)
|
||||
where
|
||||
ranking =
|
||||
if cCode (pcComment err) `elem` uninteresting
|
||||
then 'Z'
|
||||
else 'A'
|
||||
|
||||
-- A list of the most generic, least directly helpful
|
||||
-- error codes to downrank.
|
||||
uninteresting = [
|
||||
1009, -- Mentioned parser error was..
|
||||
1019, -- Expected this to be an argument
|
||||
1036, -- ( is invalid here
|
||||
1047, -- Expected 'fi'
|
||||
1062, -- Expected 'done'
|
||||
1070, -- Parsing stopped here (generic)
|
||||
1072, -- Missing/unexpected ..
|
||||
1073, -- Couldn't parse this ..
|
||||
1088, -- Parsing stopped here (paren)
|
||||
1089 -- Parsing stopped here (keyword)
|
||||
]
|
||||
|
||||
appendComments errRef comments max = do
|
||||
previous <- readIORef errRef
|
||||
let current = map (\x -> (rankError x, cCode $ pcComment x, cMessage $ pcComment x)) comments
|
||||
writeIORef errRef $! force . take max . nubBy equal . sort $ previous ++ current
|
||||
where
|
||||
fst3 (x,_,_) = x
|
||||
equal x y = fst3 x == fst3 y
|
||||
|
||||
outputWiki :: IORef [(Ranking, Integer, String)] -> IO ()
|
||||
outputWiki errRef = do
|
||||
issues <- readIORef errRef
|
||||
unless (null issues) $ do
|
||||
putStrLn "For more information:"
|
||||
mapM_ showErr issues
|
||||
where
|
||||
showErr (_, code, msg) =
|
||||
putStrLn $ " " ++ wikiLink ++ "SC" ++ show code ++ " -- " ++ shorten msg
|
||||
limit = 36
|
||||
shorten msg =
|
||||
if length msg < limit
|
||||
then msg
|
||||
else (take (limit-3) msg) ++ "..."
|
||||
|
||||
outputError options file error = do
|
||||
color <- getColorFunc $ foColorOption options
|
||||
hPutStrLn stderr $ color "error" $ file ++ ": " ++ error
|
||||
|
||||
outputResult options ref result sys = do
|
||||
color <- getColorFunc $ foColorOption options
|
||||
let comments = crComments result
|
||||
appendComments ref comments (fromIntegral $ foWikiLinkCount options)
|
||||
let fileGroups = NE.groupWith sourceFile comments
|
||||
mapM_ (outputForFile color sys) fileGroups
|
||||
|
||||
outputForFile color sys comments = do
|
||||
let fileName = sourceFile (NE.head comments)
|
||||
result <- siReadFile sys (Just True) fileName
|
||||
let contents = either (const "") id result
|
||||
let fileLinesList = lines contents
|
||||
let lineCount = length fileLinesList
|
||||
let fileLines = listArray (1, lineCount) fileLinesList
|
||||
let groups = NE.groupWith lineNo comments
|
||||
forM_ groups $ \commentsForLine -> do
|
||||
let lineNum = fromIntegral $ lineNo (NE.head commentsForLine)
|
||||
let line = if lineNum < 1 || lineNum > lineCount
|
||||
then ""
|
||||
else fileLines ! fromIntegral lineNum
|
||||
putStrLn ""
|
||||
putStrLn $ color "message" $
|
||||
"In " ++ fileName ++" line " ++ show lineNum ++ ":"
|
||||
putStrLn (color "source" line)
|
||||
forM_ commentsForLine $ \c -> putStrLn $ color (severityText c) $ cuteIndent c
|
||||
putStrLn ""
|
||||
showFixedString color (toList commentsForLine) (fromIntegral lineNum) fileLines
|
||||
|
||||
-- Pick out only the lines necessary to show a fix in action
|
||||
sliceFile :: Fix -> Array Int String -> (Fix, Array Int String)
|
||||
sliceFile fix lines =
|
||||
(mapPositions adjust fix, sliceLines lines)
|
||||
where
|
||||
(minLine, maxLine) =
|
||||
foldl (\(mm, mx) pos -> ((min mm $ fromIntegral $ posLine pos), (max mx $ fromIntegral $ posLine pos)))
|
||||
(maxBound, minBound) $
|
||||
concatMap (\x -> [repStartPos x, repEndPos x]) $ fixReplacements fix
|
||||
sliceLines :: Array Int String -> Array Int String
|
||||
sliceLines = ixmap (1, maxLine - minLine + 1) (\x -> x + minLine - 1)
|
||||
adjust pos =
|
||||
pos {
|
||||
posLine = posLine pos - (fromIntegral minLine) + 1
|
||||
}
|
||||
|
||||
showFixedString :: ColorFunc -> [PositionedComment] -> Int -> Array Int String -> IO ()
|
||||
showFixedString color comments lineNum fileLines =
|
||||
let line = fileLines ! fromIntegral lineNum in
|
||||
case mapMaybe pcFix comments of
|
||||
[] -> return ()
|
||||
fixes -> do
|
||||
-- Folding automatically removes overlap
|
||||
let mergedFix = fold fixes
|
||||
-- We show the complete, associated fixes, whether or not it includes this
|
||||
-- and/or other unrelated lines.
|
||||
let (excerptFix, excerpt) = sliceFile mergedFix fileLines
|
||||
-- in the spirit of error prone
|
||||
putStrLn $ color "message" "Did you mean:"
|
||||
putStrLn $ unlines $ applyFix excerptFix excerpt
|
||||
|
||||
cuteIndent :: PositionedComment -> String
|
||||
cuteIndent comment =
|
||||
replicate (fromIntegral $ colNo comment - 1) ' ' ++
|
||||
makeArrow ++ " " ++ code (codeNo comment) ++ " (" ++ severityText comment ++ "): " ++ messageText comment
|
||||
where
|
||||
arrow n = '^' : replicate (fromIntegral $ n-2) '-' ++ "^"
|
||||
makeArrow =
|
||||
let sameLine = lineNo comment == endLineNo comment
|
||||
delta = endColNo comment - colNo comment
|
||||
in
|
||||
if sameLine && delta > 2 && delta < 32 then arrow delta else "^--"
|
||||
|
||||
code num = "SC" ++ show num
|
||||
|
||||
getColorFunc :: ColorOption -> IO ColorFunc
|
||||
getColorFunc colorOption = do
|
||||
useColor <- shouldOutputColor colorOption
|
||||
return $ if useColor then colorComment else const id
|
||||
where
|
||||
colorComment level comment =
|
||||
ansi (colorForLevel level) ++ comment ++ clear
|
||||
clear = ansi 0
|
||||
ansi n = "\x1B[" ++ show n ++ "m"
|
||||
|
|
@ -1,341 +0,0 @@
|
|||
{-
|
||||
Copyright 2012-2024 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}
|
||||
module ShellCheck.Interface
|
||||
(
|
||||
SystemInterface(..)
|
||||
, CheckSpec(csFilename, csScript, csCheckSourced, csIncludedWarnings, csExcludedWarnings, csShellTypeOverride, csMinSeverity, csIgnoreRC, csExtendedAnalysis, csOptionalChecks)
|
||||
, CheckResult(crFilename, crComments)
|
||||
, ParseSpec(psFilename, psScript, psCheckSourced, psIgnoreRC, psShellTypeOverride)
|
||||
, ParseResult(prComments, prTokenPositions, prRoot)
|
||||
, AnalysisSpec(asScript, asShellType, asFallbackShell, asExecutionMode, asCheckSourced, asTokenPositions, asExtendedAnalysis, asOptionalChecks)
|
||||
, AnalysisResult(arComments)
|
||||
, FormatterOptions(foColorOption, foWikiLinkCount)
|
||||
, Shell(Ksh, Sh, Bash, Dash, BusyboxSh)
|
||||
, ExecutionMode(Executed, Sourced)
|
||||
, ErrorMessage
|
||||
, Code
|
||||
, Severity(ErrorC, WarningC, InfoC, StyleC)
|
||||
, Position(posFile, posLine, posColumn)
|
||||
, Comment(cSeverity, cCode, cMessage)
|
||||
, PositionedComment(pcStartPos , pcEndPos , pcComment, pcFix)
|
||||
, ColorOption(ColorAuto, ColorAlways, ColorNever)
|
||||
, TokenComment(tcId, tcComment, tcFix)
|
||||
, emptyCheckResult
|
||||
, newAnalysisResult
|
||||
, newAnalysisSpec
|
||||
, newFormatterOptions
|
||||
, newParseResult
|
||||
, newPosition
|
||||
, newSystemInterface
|
||||
, newTokenComment
|
||||
, mockedSystemInterface
|
||||
, mockRcFile
|
||||
, newParseSpec
|
||||
, emptyCheckSpec
|
||||
, newPositionedComment
|
||||
, newComment
|
||||
, Fix(fixReplacements)
|
||||
, newFix
|
||||
, InsertionPoint(InsertBefore, InsertAfter)
|
||||
, Replacement(repStartPos, repEndPos, repString, repPrecedence, repInsertionPoint)
|
||||
, newReplacement
|
||||
, CheckDescription(cdName, cdDescription, cdPositive, cdNegative)
|
||||
, newCheckDescription
|
||||
) where
|
||||
|
||||
import ShellCheck.AST
|
||||
|
||||
import Control.DeepSeq
|
||||
import Control.Monad.Identity
|
||||
import Data.List
|
||||
import Data.Monoid
|
||||
import Data.Ord
|
||||
import Data.Semigroup
|
||||
import GHC.Generics (Generic)
|
||||
import qualified Data.Map as Map
|
||||
|
||||
|
||||
data SystemInterface m = SystemInterface {
|
||||
-- | Given:
|
||||
-- What annotations say about including external files (if anything)
|
||||
-- A resolved filename from siFindSource
|
||||
-- Read the file or return an error
|
||||
siReadFile :: Maybe Bool -> String -> m (Either ErrorMessage String),
|
||||
-- | Given:
|
||||
-- the current script,
|
||||
-- what annotations say about including external files (if anything)
|
||||
-- a list of source-path annotations in effect,
|
||||
-- and a sourced file,
|
||||
-- find the sourced file
|
||||
siFindSource :: String -> Maybe Bool -> [String] -> String -> m FilePath,
|
||||
-- | Get the configuration file (name, contents) for a filename
|
||||
siGetConfig :: String -> m (Maybe (FilePath, String))
|
||||
}
|
||||
|
||||
-- ShellCheck input and output
|
||||
data CheckSpec = CheckSpec {
|
||||
csFilename :: String,
|
||||
csScript :: String,
|
||||
csCheckSourced :: Bool,
|
||||
csIgnoreRC :: Bool,
|
||||
csExcludedWarnings :: [Integer],
|
||||
csIncludedWarnings :: Maybe [Integer],
|
||||
csShellTypeOverride :: Maybe Shell,
|
||||
csMinSeverity :: Severity,
|
||||
csExtendedAnalysis :: Maybe Bool,
|
||||
csOptionalChecks :: [String]
|
||||
} deriving (Show, Eq)
|
||||
|
||||
data CheckResult = CheckResult {
|
||||
crFilename :: String,
|
||||
crComments :: [PositionedComment]
|
||||
} deriving (Show, Eq)
|
||||
|
||||
emptyCheckResult :: CheckResult
|
||||
emptyCheckResult = CheckResult {
|
||||
crFilename = "",
|
||||
crComments = []
|
||||
}
|
||||
|
||||
emptyCheckSpec :: CheckSpec
|
||||
emptyCheckSpec = CheckSpec {
|
||||
csFilename = "",
|
||||
csScript = "",
|
||||
csCheckSourced = False,
|
||||
csIgnoreRC = False,
|
||||
csExcludedWarnings = [],
|
||||
csIncludedWarnings = Nothing,
|
||||
csShellTypeOverride = Nothing,
|
||||
csMinSeverity = StyleC,
|
||||
csExtendedAnalysis = Nothing,
|
||||
csOptionalChecks = []
|
||||
}
|
||||
|
||||
newParseSpec :: ParseSpec
|
||||
newParseSpec = ParseSpec {
|
||||
psFilename = "",
|
||||
psScript = "",
|
||||
psCheckSourced = False,
|
||||
psIgnoreRC = False,
|
||||
psShellTypeOverride = Nothing
|
||||
}
|
||||
|
||||
newSystemInterface :: Monad m => SystemInterface m
|
||||
newSystemInterface =
|
||||
SystemInterface {
|
||||
siReadFile = \_ _ -> return $ Left "Not implemented",
|
||||
siFindSource = \_ _ _ name -> return name,
|
||||
siGetConfig = \_ -> return Nothing
|
||||
}
|
||||
|
||||
-- Parser input and output
|
||||
data ParseSpec = ParseSpec {
|
||||
psFilename :: String,
|
||||
psScript :: String,
|
||||
psCheckSourced :: Bool,
|
||||
psIgnoreRC :: Bool,
|
||||
psShellTypeOverride :: Maybe Shell
|
||||
} deriving (Show, Eq)
|
||||
|
||||
data ParseResult = ParseResult {
|
||||
prComments :: [PositionedComment],
|
||||
prTokenPositions :: Map.Map Id (Position, Position),
|
||||
prRoot :: Maybe Token
|
||||
} deriving (Show, Eq)
|
||||
|
||||
newParseResult :: ParseResult
|
||||
newParseResult = ParseResult {
|
||||
prComments = [],
|
||||
prTokenPositions = Map.empty,
|
||||
prRoot = Nothing
|
||||
}
|
||||
|
||||
-- Analyzer input and output
|
||||
data AnalysisSpec = AnalysisSpec {
|
||||
asScript :: Token,
|
||||
asShellType :: Maybe Shell,
|
||||
asFallbackShell :: Maybe Shell,
|
||||
asExecutionMode :: ExecutionMode,
|
||||
asCheckSourced :: Bool,
|
||||
asOptionalChecks :: [String],
|
||||
asExtendedAnalysis :: Maybe Bool,
|
||||
asTokenPositions :: Map.Map Id (Position, Position)
|
||||
}
|
||||
|
||||
newAnalysisSpec token = AnalysisSpec {
|
||||
asScript = token,
|
||||
asShellType = Nothing,
|
||||
asFallbackShell = Nothing,
|
||||
asExecutionMode = Executed,
|
||||
asCheckSourced = False,
|
||||
asOptionalChecks = [],
|
||||
asExtendedAnalysis = Nothing,
|
||||
asTokenPositions = Map.empty
|
||||
}
|
||||
|
||||
newtype AnalysisResult = AnalysisResult {
|
||||
arComments :: [TokenComment]
|
||||
}
|
||||
|
||||
newAnalysisResult = AnalysisResult {
|
||||
arComments = []
|
||||
}
|
||||
|
||||
-- Formatter options
|
||||
data FormatterOptions = FormatterOptions {
|
||||
foColorOption :: ColorOption,
|
||||
foWikiLinkCount :: Integer
|
||||
}
|
||||
|
||||
newFormatterOptions = FormatterOptions {
|
||||
foColorOption = ColorAuto,
|
||||
foWikiLinkCount = 3
|
||||
}
|
||||
|
||||
data CheckDescription = CheckDescription {
|
||||
cdName :: String,
|
||||
cdDescription :: String,
|
||||
cdPositive :: String,
|
||||
cdNegative :: String
|
||||
}
|
||||
|
||||
newCheckDescription = CheckDescription {
|
||||
cdName = "",
|
||||
cdDescription = "",
|
||||
cdPositive = "",
|
||||
cdNegative = ""
|
||||
}
|
||||
|
||||
-- Supporting data types
|
||||
data Shell = Ksh | Sh | Bash | Dash | BusyboxSh deriving (Show, Eq)
|
||||
data ExecutionMode = Executed | Sourced deriving (Show, Eq)
|
||||
|
||||
type ErrorMessage = String
|
||||
type Code = Integer
|
||||
|
||||
data Severity = ErrorC | WarningC | InfoC | StyleC
|
||||
deriving (Show, Eq, Ord, Generic, NFData)
|
||||
data Position = Position {
|
||||
posFile :: String, -- Filename
|
||||
posLine :: Integer, -- 1 based source line
|
||||
posColumn :: Integer -- 1 based source column, where tabs are 8
|
||||
} deriving (Show, Eq, Generic, NFData, Ord)
|
||||
|
||||
newPosition :: Position
|
||||
newPosition = Position {
|
||||
posFile = "",
|
||||
posLine = 1,
|
||||
posColumn = 1
|
||||
}
|
||||
|
||||
data Comment = Comment {
|
||||
cSeverity :: Severity,
|
||||
cCode :: Code,
|
||||
cMessage :: String
|
||||
} deriving (Show, Eq, Generic, NFData)
|
||||
|
||||
newComment :: Comment
|
||||
newComment = Comment {
|
||||
cSeverity = StyleC,
|
||||
cCode = 0,
|
||||
cMessage = ""
|
||||
}
|
||||
|
||||
-- only support single line for now
|
||||
data Replacement = Replacement {
|
||||
repStartPos :: Position,
|
||||
repEndPos :: Position,
|
||||
repString :: String,
|
||||
-- Order in which the replacements should happen: highest precedence first.
|
||||
repPrecedence :: Int,
|
||||
-- Whether to insert immediately before or immediately after the specified region.
|
||||
repInsertionPoint :: InsertionPoint
|
||||
} deriving (Show, Eq, Generic, NFData)
|
||||
|
||||
data InsertionPoint = InsertBefore | InsertAfter
|
||||
deriving (Show, Eq, Generic, NFData)
|
||||
|
||||
newReplacement = Replacement {
|
||||
repStartPos = newPosition,
|
||||
repEndPos = newPosition,
|
||||
repString = "",
|
||||
repPrecedence = 1,
|
||||
repInsertionPoint = InsertAfter
|
||||
}
|
||||
|
||||
data Fix = Fix {
|
||||
fixReplacements :: [Replacement]
|
||||
} deriving (Show, Eq, Generic, NFData)
|
||||
|
||||
newFix = Fix {
|
||||
fixReplacements = []
|
||||
}
|
||||
|
||||
data PositionedComment = PositionedComment {
|
||||
pcStartPos :: Position,
|
||||
pcEndPos :: Position,
|
||||
pcComment :: Comment,
|
||||
pcFix :: Maybe Fix
|
||||
} deriving (Show, Eq, Generic, NFData)
|
||||
|
||||
newPositionedComment :: PositionedComment
|
||||
newPositionedComment = PositionedComment {
|
||||
pcStartPos = newPosition,
|
||||
pcEndPos = newPosition,
|
||||
pcComment = newComment,
|
||||
pcFix = Nothing
|
||||
}
|
||||
|
||||
data TokenComment = TokenComment {
|
||||
tcId :: Id,
|
||||
tcComment :: Comment,
|
||||
tcFix :: Maybe Fix
|
||||
} deriving (Show, Eq, Generic, NFData)
|
||||
|
||||
newTokenComment = TokenComment {
|
||||
tcId = Id 0,
|
||||
tcComment = newComment,
|
||||
tcFix = Nothing
|
||||
}
|
||||
|
||||
data ColorOption =
|
||||
ColorAuto
|
||||
| ColorAlways
|
||||
| ColorNever
|
||||
deriving (Ord, Eq, Show)
|
||||
|
||||
-- For testing
|
||||
mockedSystemInterface :: [(String, String)] -> SystemInterface Identity
|
||||
mockedSystemInterface files = (newSystemInterface :: SystemInterface Identity) {
|
||||
siReadFile = rf,
|
||||
siFindSource = fs,
|
||||
siGetConfig = const $ return Nothing
|
||||
}
|
||||
where
|
||||
rf _ file = return $
|
||||
case find ((== file) . fst) files of
|
||||
Nothing -> Left "File not included in mock."
|
||||
Just (_, contents) -> Right contents
|
||||
fs _ _ _ file = return file
|
||||
|
||||
mockRcFile rcfile mock = mock {
|
||||
siGetConfig = const . return $ Just (".shellcheckrc", rcfile)
|
||||
}
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,51 +0,0 @@
|
|||
{-
|
||||
Copyright 2022 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
|
||||
-- Generic basic utility functions
|
||||
module ShellCheck.Prelude where
|
||||
|
||||
import Data.Semigroup
|
||||
|
||||
|
||||
-- Get element 0 or a default. Like `head` but safe.
|
||||
headOrDefault _ (a:_) = a
|
||||
headOrDefault def _ = def
|
||||
|
||||
-- Get the last element or a default. Like `last` but safe.
|
||||
lastOrDefault def [] = def
|
||||
lastOrDefault _ list = last list
|
||||
|
||||
--- Get element n of a list, or Nothing. Like `!!` but safe.
|
||||
(!!!) list i =
|
||||
case drop i list of
|
||||
[] -> Nothing
|
||||
(r:_) -> Just r
|
||||
|
||||
|
||||
-- Like mconcat but for Semigroups
|
||||
sconcat1 :: (Semigroup t) => [t] -> t
|
||||
sconcat1 [x] = x
|
||||
sconcat1 (x:xs) = x <> sconcat1 xs
|
||||
|
||||
sconcatOrDefault def [] = def
|
||||
sconcatOrDefault _ list = sconcat1 list
|
||||
|
||||
-- For more actionable "impossible" errors
|
||||
pleaseReport str = "ShellCheck internal error, please report: " ++ str
|
||||
|
|
@ -1,80 +0,0 @@
|
|||
{-
|
||||
Copyright 2012-2019 Vidar Holen
|
||||
|
||||
This file is part of ShellCheck.
|
||||
https://www.shellcheck.net
|
||||
|
||||
ShellCheck is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
ShellCheck is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
-}
|
||||
{-# LANGUAGE FlexibleContexts #-}
|
||||
|
||||
-- Basically Text.Regex based on regex-tdfa instead of the buggy regex-posix.
|
||||
module ShellCheck.Regex where
|
||||
|
||||
import Data.List
|
||||
import Data.Maybe
|
||||
import Control.Monad
|
||||
import Text.Regex.TDFA
|
||||
|
||||
-- Precompile the regex
|
||||
mkRegex :: String -> Regex
|
||||
mkRegex str =
|
||||
let make :: String -> Regex
|
||||
make = makeRegex
|
||||
in
|
||||
make str
|
||||
|
||||
-- Does the regex match?
|
||||
matches :: String -> Regex -> Bool
|
||||
matches = flip match
|
||||
|
||||
-- Get all subgroups of the first match
|
||||
matchRegex :: Regex -> String -> Maybe [String]
|
||||
matchRegex re str = do
|
||||
(_, _, _, groups) <- matchM re str :: Maybe (String,String,String,[String])
|
||||
return groups
|
||||
|
||||
-- Get all full matches
|
||||
matchAllStrings :: Regex -> String -> [String]
|
||||
matchAllStrings re = unfoldr f
|
||||
where
|
||||
f :: String -> Maybe (String, String)
|
||||
f str = do
|
||||
(_, match, rest, _) <- matchM re str :: Maybe (String, String, String, [String])
|
||||
return (match, rest)
|
||||
|
||||
-- Get all subgroups from all matches
|
||||
matchAllSubgroups :: Regex -> String -> [[String]]
|
||||
matchAllSubgroups re = unfoldr f
|
||||
where
|
||||
f :: String -> Maybe ([String], String)
|
||||
f str = do
|
||||
(_, _, rest, groups) <- matchM re str :: Maybe (String, String, String, [String])
|
||||
return (groups, rest)
|
||||
|
||||
-- Replace regex in input with string
|
||||
subRegex :: Regex -> String -> String -> String
|
||||
subRegex re input replacement = f input
|
||||
where
|
||||
f str = fromMaybe str $ do
|
||||
(before, match, after) <- matchM re str :: Maybe (String, String, String)
|
||||
when (null match) $ error ("Internal error: substituted empty in " ++ str)
|
||||
return $ before ++ replacement ++ f after
|
||||
|
||||
-- Split a string based on a regex.
|
||||
splitOn :: String -> Regex -> [String]
|
||||
splitOn input re =
|
||||
case matchM re input :: Maybe (String, String, String) of
|
||||
Just (before, match, after) -> before : after `splitOn` re
|
||||
Nothing -> [input]
|
||||
35
stack.yaml
35
stack.yaml
|
|
@ -1,35 +0,0 @@
|
|||
# This file was automatically generated by stack init
|
||||
# For more information, see: https://docs.haskellstack.org/en/stable/yaml_configuration/
|
||||
|
||||
# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)
|
||||
resolver: lts-18.15
|
||||
|
||||
# Local packages, usually specified by relative directory name
|
||||
packages:
|
||||
- '.'
|
||||
# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
|
||||
extra-deps: []
|
||||
|
||||
# Override default flag values for local packages and extra-deps
|
||||
flags: {}
|
||||
|
||||
# Extra package databases containing global packages
|
||||
extra-package-dbs: []
|
||||
|
||||
# Control whether we use the GHC we find on the path
|
||||
# system-ghc: true
|
||||
|
||||
# Require a specific version of stack, using version ranges
|
||||
# require-stack-version: -any # Default
|
||||
# require-stack-version: >= 1.0.0
|
||||
|
||||
# Override the architecture used by stack, especially useful on Windows
|
||||
# arch: i386
|
||||
# arch: x86_64
|
||||
|
||||
# Extra directories used by stack for building
|
||||
# extra-include-dirs: [/path/to/dir]
|
||||
# extra-lib-dirs: [/path/to/dir]
|
||||
|
||||
# Allow a newer minor version of GHC than the snapshot specifies
|
||||
# compiler-check: newer-minor
|
||||
78
striptests
78
striptests
|
|
@ -1,78 +0,0 @@
|
|||
#!/usr/bin/env bash
|
||||
# This file strips all unit tests from ShellCheck, removing
|
||||
# the dependency on QuickCheck and Template Haskell and
|
||||
# reduces the binary size considerably.
|
||||
set -o pipefail
|
||||
|
||||
sponge() {
|
||||
local data
|
||||
data="$(cat)"
|
||||
printf '%s\n' "$data" > "$1"
|
||||
}
|
||||
|
||||
modify() {
|
||||
if ! "${@:2}" < "$1" | sponge "$1"
|
||||
then
|
||||
{
|
||||
printf 'Failed to modify %s: ' "$1"
|
||||
printf '%q ' "${@:2}"
|
||||
printf '\n'
|
||||
} >&2
|
||||
exit 1
|
||||
fi
|
||||
}
|
||||
|
||||
detestify() {
|
||||
printf '%s\n' '-- AUTOGENERATED from ShellCheck by striptests. Do not modify.'
|
||||
awk '
|
||||
BEGIN {
|
||||
state = 0;
|
||||
}
|
||||
|
||||
/STRIP/ { next; }
|
||||
/LANGUAGE TemplateHaskell/ { next; }
|
||||
/^import.*Test\./ { next; }
|
||||
|
||||
/^module/ {
|
||||
sub(/,[^,)]*runTests/, "");
|
||||
}
|
||||
|
||||
# Delete tests
|
||||
/^prop_/ { state = 1; next; }
|
||||
|
||||
# ..and any blank lines following them.
|
||||
state == 1 && /^ / { next; }
|
||||
|
||||
# Template Haskell marker
|
||||
/^return / {
|
||||
exit;
|
||||
}
|
||||
|
||||
{ state = 0; print; }
|
||||
'
|
||||
}
|
||||
|
||||
|
||||
|
||||
if [[ ! -e 'ShellCheck.cabal' ]]
|
||||
then
|
||||
echo "Run me from the ShellCheck directory." >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [[ -d '.git' ]] && ! git diff --exit-code > /dev/null 2>&1
|
||||
then
|
||||
echo "You have local changes! These may be overwritten." >&2
|
||||
exit 2
|
||||
fi
|
||||
|
||||
modify 'ShellCheck.cabal' sed -e '
|
||||
/QuickCheck/d
|
||||
/^test-suite/{ s/.*//; q; }
|
||||
'
|
||||
|
||||
find . -name '.git' -prune -o -type f -name '*.hs' -print |
|
||||
while IFS= read -r file
|
||||
do
|
||||
modify "$file" detestify
|
||||
done
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
#!/bin/bash
|
||||
# This script configures, builds and runs tests.
|
||||
# It's meant for automatic cross-distro testing.
|
||||
|
||||
die() { echo "$*" >&2; exit 1; }
|
||||
|
||||
[ -e "ShellCheck.cabal" ] ||
|
||||
die "ShellCheck.cabal not in current dir"
|
||||
command -v cabal ||
|
||||
die "cabal is missing"
|
||||
|
||||
cabal update ||
|
||||
die "can't update"
|
||||
|
||||
if [ -e "cabal.project.freeze" ]
|
||||
then
|
||||
echo "Renaming cabal.project.freeze to .bak to avoid it interferring" >&2
|
||||
mv "cabal.project.freeze" "cabal.project.freeze.bak" || die "Couldn't rename"
|
||||
fi
|
||||
|
||||
if [ -e /etc/arch-release ]
|
||||
then
|
||||
# Arch has an unconventional packaging setup
|
||||
flags=(--disable-library-vanilla --enable-shared --enable-executable-dynamic --ghc-options=-dynamic)
|
||||
else
|
||||
flags=()
|
||||
fi
|
||||
|
||||
cabal install --dependencies-only --enable-tests "${flags[@]}" ||
|
||||
cabal install --dependencies-only "${flags[@]}" ||
|
||||
cabal install --dependencies-only --max-backjumps -1 "${flags[@]}" ||
|
||||
die "can't install dependencies"
|
||||
cabal configure --enable-tests "${flags[@]}" ||
|
||||
die "configure failed"
|
||||
cabal build ||
|
||||
die "build failed"
|
||||
cabal test ||
|
||||
die "test failed"
|
||||
cabal haddock ||
|
||||
die "haddock failed"
|
||||
|
||||
sc="$(find . -name shellcheck -type f -perm -111)"
|
||||
[ -x "$sc" ] || die "Can't find executable"
|
||||
|
||||
"$sc" - << 'EOF' || die "execution failed"
|
||||
#!/bin/sh
|
||||
echo "Hello World"
|
||||
EOF
|
||||
|
||||
"$sc" - << 'EOF' && die "negative execution failed"
|
||||
#!/bin/sh
|
||||
echo $1
|
||||
EOF
|
||||
|
||||
|
||||
echo "Success"
|
||||
exit 0
|
||||
|
|
@ -1,90 +0,0 @@
|
|||
#!/usr/bin/env bash
|
||||
# shellcheck disable=SC2257
|
||||
|
||||
failed=0
|
||||
fail() {
|
||||
echo "$(tput setaf 1)$*$(tput sgr0)"
|
||||
failed=1
|
||||
}
|
||||
|
||||
i=1 j=1
|
||||
cat << EOF
|
||||
|
||||
Manual Checklist
|
||||
|
||||
$((i++)). Make sure README.md examples are up to date
|
||||
$((i++)). Format and read over the manual for bad formatting and outdated info.
|
||||
$((i++)). Run \`builders/build_builder build/*/\` to update all builder images.
|
||||
$((i++)). \`builders/run_builder dist-newstyle/sdist/ShellCheck-*.tar.gz builders/*/\` to verify that they work.
|
||||
$((i++)). \`for f in \$(cat build/*/tag); do docker push "\$f"; done\` to upload them.
|
||||
$((i++)). Run test/distrotest to ensure that most distros can build OOTB.
|
||||
$((i++)). Make sure GitHub Build currently passes: https://github.com/koalaman/shellcheck/actions
|
||||
$((i++)). Make sure SnapCraft build currently works: https://snapcraft.io/shellcheck/builds
|
||||
$((i++)). Make sure the Hackage package builds locally.
|
||||
$((i++)). Make sure none of the automated checks below fail
|
||||
|
||||
Release Steps
|
||||
|
||||
$((j++)). \`cabal sdist\` to generate a Hackage package
|
||||
$((j++)). \`git push --follow-tags\` to push commit
|
||||
$((j++)). Wait for GitHub Actions to build. (v0.11.0 "Deploy" failed, but worked on retry)
|
||||
$((j++)). Verify release:
|
||||
a. Check that the new versions are uploaded: https://github.com/koalaman/shellcheck/tags
|
||||
b. Check that the docker images have version tags: https://hub.docker.com/u/koalaman
|
||||
$((j++)). If no disaster, upload to Hackage: http://hackage.haskell.org/upload
|
||||
$((j++)). Run 'autoupdate' from https://github.com/koalaman/shellcheck-precommit
|
||||
$((j++)). Release new snap versions on https://snapcraft.io/shellcheck/releases
|
||||
$((j++)). Push a new commit that updates CHANGELOG.md
|
||||
|
||||
Automated Checks
|
||||
|
||||
EOF
|
||||
|
||||
if git diff | grep -q ""
|
||||
then
|
||||
fail "There are uncommitted changes"
|
||||
fi
|
||||
|
||||
if [[ $(git log -1 --pretty=%B) != *"CHANGELOG"* ]]
|
||||
then
|
||||
fail "Expected git log message to contain CHANGELOG"
|
||||
fi
|
||||
|
||||
version=${current#v}
|
||||
if ! grep "Version:" ShellCheck.cabal | grep -qFw "$version"
|
||||
then
|
||||
fail "The cabal file does not match tag version $version"
|
||||
fi
|
||||
|
||||
if ! grep -qF "## $current" CHANGELOG.md
|
||||
then
|
||||
fail "CHANGELOG.md does not contain '## $current'"
|
||||
fi
|
||||
|
||||
current=$(git tag --points-at)
|
||||
if [[ -z "$current" ]]
|
||||
then
|
||||
fail "No git tag on the current commit"
|
||||
echo "Create one with: git tag -a v0.0.0"
|
||||
fi
|
||||
|
||||
if [[ "$current" != v* ]]
|
||||
then
|
||||
fail "Bad tag format: expected v0.0.0"
|
||||
fi
|
||||
|
||||
if [[ "$(git cat-file -t "$current")" != "tag" ]]
|
||||
then
|
||||
fail "Current tag is not annotated (required for Snap)."
|
||||
fi
|
||||
|
||||
if [[ "$(git tag --points-at master)" != "$current" ]]
|
||||
then
|
||||
fail "You are not on master"
|
||||
fi
|
||||
|
||||
if [[ $(git log -1 --pretty=%B) != "Stable version "* ]]
|
||||
then
|
||||
fail "Expected git log message to be 'Stable version ...'"
|
||||
fi
|
||||
exit "$failed"
|
||||
|
|
@ -1,94 +0,0 @@
|
|||
#!/bin/bash
|
||||
# This script runs 'buildtest' on each of several distros
|
||||
# via Docker.
|
||||
set -o pipefail
|
||||
|
||||
exec 3>&1 4>&2
|
||||
die() { echo "$*" >&4; exit 1; }
|
||||
|
||||
[ -e "ShellCheck.cabal" ] || die "ShellCheck.cabal not in this dir"
|
||||
|
||||
if ( snap list | grep -q docker ) > /dev/null 2>&1
|
||||
then
|
||||
# Snap docker can't mount /tmp in containers
|
||||
echo "You appear to be using Docker from snap. Creating ~/tmp for temp files." >&2
|
||||
echo >&2
|
||||
export TMPDIR="$HOME/tmp"
|
||||
mkdir -p "$TMPDIR"
|
||||
fi
|
||||
|
||||
[ "$1" = "--run" ] || {
|
||||
cat << EOF
|
||||
This script pulls multiple distros via Docker and compiles
|
||||
ShellCheck and dependencies for each one. It takes hours,
|
||||
and is still highly experimental.
|
||||
|
||||
Make sure you're plugged in and have screen/tmux in place,
|
||||
then re-run with $0 --run to continue.
|
||||
|
||||
Also note that dist*/ and .stack-work/ will be deleted.
|
||||
EOF
|
||||
exit 0
|
||||
}
|
||||
|
||||
echo "Deleting 'dist', 'dist-newstyle', and '.stack-work'..."
|
||||
rm -rf dist dist-newstyle .stack-work
|
||||
|
||||
execs=$(find . -name shellcheck)
|
||||
|
||||
if [ -n "$execs" ]
|
||||
then
|
||||
die "Found unexpected executables. Remove and try again: $execs"
|
||||
fi
|
||||
|
||||
log=$(mktemp) || die "Can't create temp file"
|
||||
date >> "$log" || die "Can't write to log"
|
||||
|
||||
echo "Logging to $log" >&3
|
||||
exec >> "$log" 2>&1
|
||||
|
||||
final=0
|
||||
while read -r distro setup
|
||||
do
|
||||
[[ "$distro" = "#"* || -z "$distro" ]] && continue
|
||||
printf '%s ' "$distro" >&3
|
||||
docker pull "$distro" || die "Can't pull $distro"
|
||||
printf 'pulled. ' >&3
|
||||
|
||||
tmp=$(mktemp -d) || die "Can't make temp dir"
|
||||
cp -r . "$tmp/" || die "Can't populate test dir"
|
||||
printf 'Result: ' >&3
|
||||
< /dev/null docker run -v "$tmp:/mnt" "$distro" sh -c "
|
||||
$setup
|
||||
cd /mnt || exit 1
|
||||
test/buildtest
|
||||
"
|
||||
ret=$?
|
||||
if [ "$ret" = 0 ]
|
||||
then
|
||||
echo "OK" >&3
|
||||
else
|
||||
echo "FAIL with $ret. See $log" >&3
|
||||
final=1
|
||||
fi
|
||||
rm -rf "$tmp"
|
||||
done << EOF
|
||||
# Docker tag Setup command
|
||||
debian:stable apt-get update && apt-get install -y cabal-install
|
||||
debian:testing apt-get update && apt-get install -y cabal-install
|
||||
ubuntu:latest apt-get update && apt-get install -y cabal-install
|
||||
haskell:latest true
|
||||
opensuse/leap:latest zypper install -y cabal-install ghc
|
||||
fedora:latest dnf install -y cabal-install ghc-template-haskell-devel findutils libstdc++-static gcc-c++
|
||||
archlinux:latest pacman -S -y --noconfirm cabal-install ghc-static base-devel
|
||||
|
||||
# Ubuntu LTS
|
||||
ubuntu:24.04 apt-get update && apt-get install -y cabal-install
|
||||
ubuntu:22.04 apt-get update && apt-get install -y cabal-install
|
||||
ubuntu:20.04 apt-get update && apt-get install -y cabal-install
|
||||
|
||||
# Stack on Ubuntu LTS
|
||||
ubuntu:24.04 set -e; apt-get update && apt-get install -y curl && curl -sSL https://get.haskellstack.org/ | sh -s - -f && cd /mnt && exec test/stacktest
|
||||
EOF
|
||||
|
||||
exit "$final"
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
module Main where
|
||||
|
||||
import Control.Monad
|
||||
import System.Exit
|
||||
import qualified ShellCheck.Analytics
|
||||
import qualified ShellCheck.AnalyzerLib
|
||||
import qualified ShellCheck.ASTLib
|
||||
import qualified ShellCheck.CFG
|
||||
import qualified ShellCheck.CFGAnalysis
|
||||
import qualified ShellCheck.Checker
|
||||
import qualified ShellCheck.Checks.Commands
|
||||
import qualified ShellCheck.Checks.ControlFlow
|
||||
import qualified ShellCheck.Checks.Custom
|
||||
import qualified ShellCheck.Checks.ShellSupport
|
||||
import qualified ShellCheck.Fixer
|
||||
import qualified ShellCheck.Formatter.Diff
|
||||
import qualified ShellCheck.Parser
|
||||
|
||||
main = do
|
||||
putStrLn "Running ShellCheck tests..."
|
||||
failures <- filter (not . snd) <$> mapM sequenceA tests
|
||||
if null failures then exitSuccess else do
|
||||
putStrLn "Tests failed for the following module(s):"
|
||||
mapM (putStrLn . ("- ShellCheck." ++) . fst) failures
|
||||
exitFailure
|
||||
where
|
||||
tests =
|
||||
[ ("Analytics" , ShellCheck.Analytics.runTests)
|
||||
, ("AnalyzerLib" , ShellCheck.AnalyzerLib.runTests)
|
||||
, ("ASTLib" , ShellCheck.ASTLib.runTests)
|
||||
, ("CFG" , ShellCheck.CFG.runTests)
|
||||
, ("CFGAnalysis" , ShellCheck.CFGAnalysis.runTests)
|
||||
, ("Checker" , ShellCheck.Checker.runTests)
|
||||
, ("Checks.Commands" , ShellCheck.Checks.Commands.runTests)
|
||||
, ("Checks.ControlFlow" , ShellCheck.Checks.ControlFlow.runTests)
|
||||
, ("Checks.Custom" , ShellCheck.Checks.Custom.runTests)
|
||||
, ("Checks.ShellSupport", ShellCheck.Checks.ShellSupport.runTests)
|
||||
, ("Fixer" , ShellCheck.Fixer.runTests)
|
||||
, ("Formatter.Diff" , ShellCheck.Formatter.Diff.runTests)
|
||||
, ("Parser" , ShellCheck.Parser.runTests)
|
||||
]
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
#!/bin/bash
|
||||
# This script builds ShellCheck through `stack` using
|
||||
# various resolvers. It's run via distrotest.
|
||||
|
||||
resolvers=(
|
||||
# nightly-"$(date -d "3 days ago" +"%Y-%m-%d")"
|
||||
)
|
||||
|
||||
die() { echo "$*" >&2; exit 1; }
|
||||
|
||||
[ -e "ShellCheck.cabal" ] ||
|
||||
die "ShellCheck.cabal not in current dir"
|
||||
[ -e "stack.yaml" ] ||
|
||||
die "stack.yaml not in current dir"
|
||||
command -v stack ||
|
||||
die "stack is missing"
|
||||
|
||||
stack setup --allow-different-user || die "Failed to setup with default resolver"
|
||||
stack build --test || die "Failed to build/test with default resolver"
|
||||
|
||||
# Nice to haves, but not necessary
|
||||
for resolver in "${resolvers[@]}"
|
||||
do
|
||||
stack --resolver="$resolver" setup || die "Failed to setup $resolver. This probably doesn't matter."
|
||||
stack --resolver="$resolver" build --test || die "Failed build/test with $resolver! This probably doesn't matter."
|
||||
done
|
||||
|
||||
echo "Success"
|
||||
Loading…
Add table
Add a link
Reference in a new issue