268 lines
7 KiB
Nix
268 lines
7 KiB
Nix
# https://github.com/siers/nix-gitignore/
|
|
|
|
{ lib, runCommand }:
|
|
|
|
# An interesting bit from the gitignore(5):
|
|
# - A slash followed by two consecutive asterisks then a slash matches
|
|
# - zero or more directories. For example, "a/**/b" matches "a/b",
|
|
# - "a/x/b", "a/x/y/b" and so on.
|
|
|
|
let
|
|
inherit (builtins) filterSource;
|
|
|
|
inherit (lib)
|
|
concatStringsSep
|
|
elemAt
|
|
filter
|
|
head
|
|
isList
|
|
length
|
|
optionals
|
|
optionalString
|
|
pathExists
|
|
readFile
|
|
removePrefix
|
|
replaceStrings
|
|
stringLength
|
|
sub
|
|
substring
|
|
toList
|
|
trace
|
|
;
|
|
|
|
inherit (lib.strings) match split typeOf;
|
|
|
|
debug = a: trace a a;
|
|
last = l: elemAt l ((length l) - 1);
|
|
in
|
|
rec {
|
|
# [["good/relative/source/file" true] ["bad.tmpfile" false]] -> root -> path
|
|
filterPattern =
|
|
patterns: root:
|
|
(
|
|
name: _type:
|
|
let
|
|
relPath = removePrefix ((toString root) + "/") name;
|
|
matches = pair: (match (head pair) relPath) != null;
|
|
matched = map (pair: [
|
|
(matches pair)
|
|
(last pair)
|
|
]) patterns;
|
|
in
|
|
last (
|
|
last (
|
|
[
|
|
[
|
|
true
|
|
true
|
|
]
|
|
]
|
|
++ (filter head matched)
|
|
)
|
|
)
|
|
);
|
|
|
|
# string -> [[regex bool]]
|
|
gitignoreToPatterns =
|
|
gitignore:
|
|
let
|
|
# ignore -> bool
|
|
isComment = i: (match "^(#.*|$)" i) != null;
|
|
|
|
# ignore -> [ignore bool]
|
|
computeNegation =
|
|
l:
|
|
let
|
|
split = match "^(!?)(.*)" l;
|
|
in
|
|
[
|
|
(elemAt split 1)
|
|
(head split == "!")
|
|
];
|
|
|
|
# regex -> regex
|
|
handleHashesBangs =
|
|
replaceStrings
|
|
[
|
|
"\\#"
|
|
"\\!"
|
|
]
|
|
[
|
|
"#"
|
|
"!"
|
|
];
|
|
|
|
# ignore -> regex
|
|
substWildcards =
|
|
let
|
|
special = "^$.+{}()";
|
|
escs = "\\*?";
|
|
splitString =
|
|
let
|
|
recurse =
|
|
str:
|
|
[ (substring 0 1 str) ] ++ (optionals (str != "") (recurse (substring 1 (stringLength (str)) str)));
|
|
in
|
|
str: recurse str;
|
|
chars = s: filter (c: c != "" && !isList c) (splitString s);
|
|
escape = s: map (c: "\\" + c) (chars s);
|
|
in
|
|
replaceStrings
|
|
(
|
|
(chars special)
|
|
++ (escape escs)
|
|
++ [
|
|
"**/"
|
|
"**"
|
|
"*"
|
|
"?"
|
|
]
|
|
)
|
|
(
|
|
(escape special)
|
|
++ (escape escs)
|
|
++ [
|
|
"(.*/)?"
|
|
".*"
|
|
"[^/]*"
|
|
"[^/]"
|
|
]
|
|
);
|
|
|
|
# (regex -> regex) -> regex -> regex
|
|
mapAroundCharclass =
|
|
f: r: # rl = regex or list
|
|
let
|
|
slightFix = replaceStrings [ "\\]" ] [ "]" ];
|
|
in
|
|
concatStringsSep "" (
|
|
map (rl: if isList rl then slightFix (elemAt rl 0) else f rl) (split "(\\[([^\\\\]|\\\\.)+])" r)
|
|
);
|
|
|
|
# regex -> regex
|
|
handleSlashPrefix =
|
|
l:
|
|
let
|
|
split = (match "^(/?)(.*)" l);
|
|
findSlash = l: optionalString ((match ".+/.+" l) == null) l;
|
|
hasSlash = mapAroundCharclass findSlash l != l;
|
|
in
|
|
(if (elemAt split 0) == "/" || hasSlash then "^" else "(^|.*/)") + (elemAt split 1);
|
|
|
|
# regex -> regex
|
|
handleSlashSuffix =
|
|
l:
|
|
let
|
|
split = (match "^(.*)/$" l);
|
|
in
|
|
if split != null then (elemAt split 0) + "($|/.*)" else l;
|
|
|
|
# (regex -> regex) -> [regex, bool] -> [regex, bool]
|
|
mapPat = f: l: [
|
|
(f (head l))
|
|
(last l)
|
|
];
|
|
in
|
|
map (
|
|
l: # `l' for "line"
|
|
mapPat (
|
|
l: handleSlashSuffix (handleSlashPrefix (handleHashesBangs (mapAroundCharclass substWildcards l)))
|
|
) (computeNegation l)
|
|
) (filter (l: !isList l && !isComment l) (split "\n" gitignore));
|
|
|
|
gitignoreFilter = ign: root: filterPattern (gitignoreToPatterns ign) root;
|
|
|
|
# string|[string|file] (→ [string|file] → [string]) -> string
|
|
gitignoreCompileIgnore =
|
|
file_str_patterns: root:
|
|
let
|
|
onPath = f: a: if typeOf a == "path" then f a else a;
|
|
str_patterns = map (onPath readFile) (toList file_str_patterns);
|
|
in
|
|
concatStringsSep "\n" str_patterns;
|
|
|
|
gitignoreFilterPure =
|
|
predicate: patterns: root: name: type:
|
|
gitignoreFilter (gitignoreCompileIgnore patterns root) root name type && predicate name type;
|
|
|
|
# This is a very hacky way of programming this!
|
|
# A better way would be to reuse existing filtering by making multiple gitignore functions per each root.
|
|
# Then for each file find the set of roots with gitignores (and functions).
|
|
# This would make gitignoreFilterSource very different from gitignoreFilterPure.
|
|
# rootPath → gitignoresConcatenated
|
|
compileRecursiveGitignore =
|
|
root:
|
|
let
|
|
dirOrIgnore = file: type: baseNameOf file == ".gitignore" || type == "directory";
|
|
ignores = builtins.filterSource dirOrIgnore root;
|
|
in
|
|
readFile (
|
|
runCommand "${baseNameOf root}-recursive-gitignore" { } ''
|
|
cd ${ignores}
|
|
|
|
find -type f -exec sh -c '
|
|
rel="$(realpath --relative-to=. "$(dirname "$1")")/"
|
|
if [ "$rel" = "./" ]; then rel=""; fi
|
|
|
|
awk -v prefix="$rel" -v root="$1" -v top="$(test -z "$rel" && echo 1)" "
|
|
BEGIN { print \"# \"root }
|
|
|
|
/^!?[^\\/]+\/?$/ {
|
|
match(\$0, /^!?/, negation)
|
|
sub(/^!?/, \"\")
|
|
|
|
if (top) { middle = \"\" } else { middle = \"**/\" }
|
|
|
|
print negation[0] prefix middle \$0
|
|
}
|
|
|
|
/^!?(\\/|.*\\/.+$)/ {
|
|
match(\$0, /^!?/, negation)
|
|
sub(/^!?/, \"\")
|
|
|
|
if (!top) sub(/^\//, \"\")
|
|
|
|
print negation[0] prefix \$0
|
|
}
|
|
|
|
END { print \"\" }
|
|
" "$1"
|
|
' sh {} \; > $out
|
|
''
|
|
);
|
|
|
|
withGitignoreFile = patterns: root: toList patterns ++ [ ".git" ] ++ [ (root + "/.gitignore") ];
|
|
|
|
withRecursiveGitignoreFile =
|
|
patterns: root: toList patterns ++ [ ".git" ] ++ [ (compileRecursiveGitignore root) ];
|
|
|
|
# filterSource derivatives
|
|
|
|
gitignoreFilterSourcePure =
|
|
predicate: patterns: root:
|
|
filterSource (gitignoreFilterPure predicate patterns root) root;
|
|
|
|
gitignoreFilterSource =
|
|
predicate: patterns: root:
|
|
gitignoreFilterSourcePure predicate (withGitignoreFile patterns root) root;
|
|
|
|
gitignoreFilterRecursiveSource =
|
|
predicate: patterns: root:
|
|
gitignoreFilterSourcePure predicate (withRecursiveGitignoreFile patterns root) root;
|
|
|
|
# "Predicate"-less alternatives
|
|
|
|
gitignoreSourcePure = gitignoreFilterSourcePure (_: _: true);
|
|
gitignoreSource =
|
|
patterns:
|
|
let
|
|
type = typeOf patterns;
|
|
in
|
|
if (type == "string" && pathExists patterns) || type == "path" then
|
|
throw "type error in gitignoreSource(patterns -> source -> path), " "use [] or \"\" if there are no additional patterns"
|
|
else
|
|
gitignoreFilterSource (_: _: true) patterns;
|
|
|
|
gitignoreRecursiveSource = gitignoreFilterSourcePure (_: _: true);
|
|
}
|