2009-02-09 16:51:03 +00:00
|
|
|
|
/* String manipulation functions. */
|
2017-07-29 00:05:35 +00:00
|
|
|
|
{ lib }:
|
|
|
|
|
let
|
2009-05-24 10:57:46 +00:00
|
|
|
|
|
2014-10-04 15:02:29 +00:00
|
|
|
|
inherit (builtins) length;
|
2009-05-24 10:57:46 +00:00
|
|
|
|
|
|
|
|
|
in
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
|
|
|
|
rec {
|
2013-11-12 12:48:19 +00:00
|
|
|
|
|
2020-10-20 11:47:24 +00:00
|
|
|
|
inherit (builtins)
|
|
|
|
|
compareVersions
|
|
|
|
|
elem
|
|
|
|
|
elemAt
|
|
|
|
|
filter
|
|
|
|
|
fromJSON
|
|
|
|
|
head
|
|
|
|
|
isInt
|
|
|
|
|
isList
|
2022-04-27 08:02:49 +00:00
|
|
|
|
isAttrs
|
2020-10-20 11:47:24 +00:00
|
|
|
|
isString
|
|
|
|
|
match
|
|
|
|
|
parseDrvName
|
|
|
|
|
readFile
|
|
|
|
|
replaceStrings
|
|
|
|
|
split
|
|
|
|
|
storeDir
|
|
|
|
|
stringLength
|
|
|
|
|
substring
|
|
|
|
|
tail
|
|
|
|
|
toJSON
|
|
|
|
|
typeOf
|
|
|
|
|
unsafeDiscardStringContext
|
|
|
|
|
;
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Concatenate a list of strings.
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: concatStrings :: [string] -> string
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
concatStrings ["foo" "bar"]
|
|
|
|
|
=> "foobar"
|
|
|
|
|
*/
|
2016-06-17 10:06:48 +00:00
|
|
|
|
concatStrings = builtins.concatStringsSep "";
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Map a function over a list and concatenate the resulting strings.
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: concatMapStrings :: (a -> string) -> [a] -> string
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
concatMapStrings (x: "a" + x) ["foo" "bar"]
|
|
|
|
|
=> "afooabar"
|
|
|
|
|
*/
|
2009-02-09 16:51:03 +00:00
|
|
|
|
concatMapStrings = f: list: concatStrings (map f list);
|
2016-02-28 23:27:35 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
/* Like `concatMapStrings` except that the f functions also gets the
|
2016-02-28 23:27:35 +00:00
|
|
|
|
position as a parameter.
|
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: concatImapStrings :: (int -> a -> string) -> [a] -> string
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
concatImapStrings (pos: x: "${toString pos}-${x}") ["foo" "bar"]
|
|
|
|
|
=> "1-foo2-bar"
|
|
|
|
|
*/
|
2017-07-04 22:29:23 +00:00
|
|
|
|
concatImapStrings = f: list: concatStrings (lib.imap1 f list);
|
2012-03-28 15:43:39 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Place an element between each element of a list
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: intersperse :: a -> [a] -> [a]
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
intersperse "/" ["usr" "local" "bin"]
|
|
|
|
|
=> ["usr" "/" "local" "/" "bin"].
|
|
|
|
|
*/
|
2018-10-27 15:44:17 +00:00
|
|
|
|
intersperse =
|
|
|
|
|
# Separator to add between elements
|
|
|
|
|
separator:
|
|
|
|
|
# Input list
|
|
|
|
|
list:
|
2012-08-13 18:19:31 +00:00
|
|
|
|
if list == [] || length list == 1
|
2009-02-09 16:51:03 +00:00
|
|
|
|
then list
|
2015-07-24 13:55:39 +00:00
|
|
|
|
else tail (lib.concatMap (x: [separator x]) list);
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Concatenate a list of strings with a separator between each element
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: concatStringsSep :: string -> [string] -> string
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
concatStringsSep "/" ["usr" "local" "bin"]
|
|
|
|
|
=> "usr/local/bin"
|
|
|
|
|
*/
|
2015-07-24 00:38:46 +00:00
|
|
|
|
concatStringsSep = builtins.concatStringsSep or (separator: list:
|
2021-08-26 23:54:30 +00:00
|
|
|
|
lib.foldl' (x: y: x + y) "" (intersperse separator list));
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
/* Maps a function over a list of strings and then concatenates the
|
|
|
|
|
result with the specified separator interspersed between
|
|
|
|
|
elements.
|
|
|
|
|
|
2021-07-04 18:52:48 +00:00
|
|
|
|
Type: concatMapStringsSep :: string -> (a -> string) -> [a] -> string
|
2016-02-28 23:27:35 +00:00
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
concatMapStringsSep "-" (x: toUpper x) ["foo" "bar" "baz"]
|
|
|
|
|
=> "FOO-BAR-BAZ"
|
|
|
|
|
*/
|
2018-10-27 15:44:17 +00:00
|
|
|
|
concatMapStringsSep =
|
|
|
|
|
# Separator to add between elements
|
|
|
|
|
sep:
|
|
|
|
|
# Function to map over the list
|
|
|
|
|
f:
|
|
|
|
|
# List of input strings
|
|
|
|
|
list: concatStringsSep sep (map f list);
|
2016-02-28 23:27:35 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
/* Same as `concatMapStringsSep`, but the mapping function
|
|
|
|
|
additionally receives the position of its argument.
|
2016-02-28 23:27:35 +00:00
|
|
|
|
|
2021-07-04 18:52:48 +00:00
|
|
|
|
Type: concatIMapStringsSep :: string -> (int -> a -> string) -> [a] -> string
|
2016-02-28 23:27:35 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Example:
|
2016-02-28 23:27:35 +00:00
|
|
|
|
concatImapStringsSep "-" (pos: x: toString (x / pos)) [ 6 6 6 ]
|
|
|
|
|
=> "6-3-2"
|
|
|
|
|
*/
|
2018-10-27 15:44:17 +00:00
|
|
|
|
concatImapStringsSep =
|
|
|
|
|
# Separator to add between elements
|
|
|
|
|
sep:
|
|
|
|
|
# Function that receives elements and their positions
|
|
|
|
|
f:
|
|
|
|
|
# List of input strings
|
|
|
|
|
list: concatStringsSep sep (lib.imap1 f list);
|
2014-08-25 08:23:10 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
/* Construct a Unix-style, colon-separated search path consisting of
|
|
|
|
|
the given `subDir` appended to each of the given paths.
|
|
|
|
|
|
|
|
|
|
Type: makeSearchPath :: string -> [string] -> string
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
makeSearchPath "bin" ["/root" "/usr" "/usr/local"]
|
|
|
|
|
=> "/root/bin:/usr/bin:/usr/local/bin"
|
2018-10-27 15:44:17 +00:00
|
|
|
|
makeSearchPath "bin" [""]
|
|
|
|
|
=> "/bin"
|
2016-02-28 23:27:35 +00:00
|
|
|
|
*/
|
2018-10-27 15:44:17 +00:00
|
|
|
|
makeSearchPath =
|
|
|
|
|
# Directory name to append
|
|
|
|
|
subDir:
|
|
|
|
|
# List of base paths
|
|
|
|
|
paths:
|
2020-10-20 11:47:24 +00:00
|
|
|
|
concatStringsSep ":" (map (path: path + "/" + subDir) (filter (x: x != null) paths));
|
2018-10-27 15:44:17 +00:00
|
|
|
|
|
|
|
|
|
/* Construct a Unix-style search path by appending the given
|
|
|
|
|
`subDir` to the specified `output` of each of the packages. If no
|
|
|
|
|
output by the given name is found, fallback to `.out` and then to
|
|
|
|
|
the default.
|
2009-04-05 18:05:11 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: string -> string -> [package] -> string
|
2016-04-13 12:33:21 +00:00
|
|
|
|
|
|
|
|
|
Example:
|
2016-04-14 15:14:28 +00:00
|
|
|
|
makeSearchPathOutput "dev" "bin" [ pkgs.openssl pkgs.zlib ]
|
|
|
|
|
=> "/nix/store/9rz8gxhzf8sw4kf2j2f1grr49w8zx5vj-openssl-1.0.1r-dev/bin:/nix/store/wwh7mhwh269sfjkm6k5665b5kgp7jrk2-zlib-1.2.8/bin"
|
2016-04-13 12:33:21 +00:00
|
|
|
|
*/
|
2018-10-27 15:44:17 +00:00
|
|
|
|
makeSearchPathOutput =
|
|
|
|
|
# Package output to use
|
|
|
|
|
output:
|
|
|
|
|
# Directory name to append
|
|
|
|
|
subDir:
|
|
|
|
|
# List of packages
|
|
|
|
|
pkgs: makeSearchPath subDir (map (lib.getOutput output) pkgs);
|
2016-04-13 12:33:21 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Construct a library search path (such as RPATH) containing the
|
|
|
|
|
libraries for a set of packages
|
2009-04-05 18:05:11 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
makeLibraryPath [ "/usr" "/usr/local" ]
|
|
|
|
|
=> "/usr/lib:/usr/local/lib"
|
|
|
|
|
pkgs = import <nixpkgs> { }
|
|
|
|
|
makeLibraryPath [ pkgs.openssl pkgs.zlib ]
|
|
|
|
|
=> "/nix/store/9rz8gxhzf8sw4kf2j2f1grr49w8zx5vj-openssl-1.0.1r/lib:/nix/store/wwh7mhwh269sfjkm6k5665b5kgp7jrk2-zlib-1.2.8/lib"
|
|
|
|
|
*/
|
2016-04-14 15:15:11 +00:00
|
|
|
|
makeLibraryPath = makeSearchPathOutput "lib" "lib";
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Construct a binary search path (such as $PATH) containing the
|
|
|
|
|
binaries for a set of packages.
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
makeBinPath ["/root" "/usr" "/usr/local"]
|
|
|
|
|
=> "/root/bin:/usr/bin:/usr/local/bin"
|
|
|
|
|
*/
|
2016-04-14 15:15:11 +00:00
|
|
|
|
makeBinPath = makeSearchPathOutput "bin" "bin";
|
2015-12-10 11:40:38 +00:00
|
|
|
|
|
2017-04-19 19:41:28 +00:00
|
|
|
|
/* Depending on the boolean `cond', return either the given string
|
|
|
|
|
or the empty string. Useful to concatenate against a bigger string.
|
2011-01-05 12:54:37 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: optionalString :: bool -> string -> string
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
optionalString true "some-string"
|
|
|
|
|
=> "some-string"
|
|
|
|
|
optionalString false "some-string"
|
|
|
|
|
=> ""
|
|
|
|
|
*/
|
2018-10-27 15:44:17 +00:00
|
|
|
|
optionalString =
|
|
|
|
|
# Condition
|
|
|
|
|
cond:
|
|
|
|
|
# String to return if condition is true
|
|
|
|
|
string: if cond then string else "";
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Determine whether a string has given prefix.
|
2012-03-28 15:43:39 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: hasPrefix :: string -> string -> bool
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
hasPrefix "foo" "foobar"
|
|
|
|
|
=> true
|
|
|
|
|
hasPrefix "foo" "barfoo"
|
|
|
|
|
=> false
|
|
|
|
|
*/
|
2018-10-27 15:44:17 +00:00
|
|
|
|
hasPrefix =
|
|
|
|
|
# Prefix to check for
|
|
|
|
|
pref:
|
|
|
|
|
# Input string
|
|
|
|
|
str: substring 0 (stringLength pref) str == pref;
|
2016-02-28 23:27:35 +00:00
|
|
|
|
|
|
|
|
|
/* Determine whether a string has given suffix.
|
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: hasSuffix :: string -> string -> bool
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
hasSuffix "foo" "foobar"
|
|
|
|
|
=> false
|
|
|
|
|
hasSuffix "foo" "barfoo"
|
|
|
|
|
=> true
|
|
|
|
|
*/
|
2018-10-27 15:44:17 +00:00
|
|
|
|
hasSuffix =
|
|
|
|
|
# Suffix to check for
|
|
|
|
|
suffix:
|
|
|
|
|
# Input string
|
|
|
|
|
content:
|
2014-06-10 09:55:25 +00:00
|
|
|
|
let
|
2016-08-10 18:06:28 +00:00
|
|
|
|
lenContent = stringLength content;
|
|
|
|
|
lenSuffix = stringLength suffix;
|
|
|
|
|
in lenContent >= lenSuffix &&
|
|
|
|
|
substring (lenContent - lenSuffix) lenContent content == suffix;
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2018-06-06 20:04:35 +00:00
|
|
|
|
/* Determine whether a string contains the given infix
|
|
|
|
|
|
|
|
|
|
Type: hasInfix :: string -> string -> bool
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
hasInfix "bc" "abcd"
|
|
|
|
|
=> true
|
|
|
|
|
hasInfix "ab" "abcd"
|
|
|
|
|
=> true
|
|
|
|
|
hasInfix "cd" "abcd"
|
|
|
|
|
=> true
|
|
|
|
|
hasInfix "foo" "abcd"
|
|
|
|
|
=> false
|
|
|
|
|
*/
|
|
|
|
|
hasInfix = infix: content:
|
2022-04-22 16:43:25 +00:00
|
|
|
|
builtins.match ".*${escapeRegex infix}.*" content != null;
|
2018-06-06 20:04:35 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Convert a string to a list of characters (i.e. singleton strings).
|
|
|
|
|
This allows you to, e.g., map a function over each character. However,
|
|
|
|
|
note that this will likely be horribly inefficient; Nix is not a
|
|
|
|
|
general purpose programming language. Complex string manipulations
|
|
|
|
|
should, if appropriate, be done in a derivation.
|
|
|
|
|
Also note that Nix treats strings as a list of bytes and thus doesn't
|
|
|
|
|
handle unicode.
|
|
|
|
|
|
2020-02-05 18:27:16 +00:00
|
|
|
|
Type: stringToCharacters :: string -> [string]
|
2018-10-27 15:44:17 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
stringToCharacters ""
|
|
|
|
|
=> [ ]
|
|
|
|
|
stringToCharacters "abc"
|
|
|
|
|
=> [ "a" "b" "c" ]
|
|
|
|
|
stringToCharacters "💩"
|
|
|
|
|
=> [ "<EFBFBD>" "<EFBFBD>" "<EFBFBD>" "<EFBFBD>" ]
|
|
|
|
|
*/
|
2015-07-24 13:45:41 +00:00
|
|
|
|
stringToCharacters = s:
|
|
|
|
|
map (p: substring p 1 s) (lib.range 0 (stringLength s - 1));
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Manipulate a string character by character and replace them by
|
|
|
|
|
strings before concatenating the results.
|
2012-03-28 15:43:39 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: stringAsChars :: (string -> string) -> string -> string
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
stringAsChars (x: if x == "a" then "i" else x) "nax"
|
|
|
|
|
=> "nix"
|
|
|
|
|
*/
|
2018-10-27 15:44:17 +00:00
|
|
|
|
stringAsChars =
|
|
|
|
|
# Function to map over each individual character
|
|
|
|
|
f:
|
|
|
|
|
# Input string
|
|
|
|
|
s: concatStrings (
|
2009-10-06 09:21:52 +00:00
|
|
|
|
map f (stringToCharacters s)
|
|
|
|
|
);
|
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
/* Escape occurrence of the elements of `list` in `string` by
|
2016-02-28 23:27:35 +00:00
|
|
|
|
prefixing it with a backslash.
|
2012-03-28 15:43:39 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: escape :: [string] -> string -> string
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
escape ["(" ")"] "(foo)"
|
|
|
|
|
=> "\\(foo\\)"
|
|
|
|
|
*/
|
2015-07-24 13:45:41 +00:00
|
|
|
|
escape = list: replaceChars list (map (c: "\\${c}") list);
|
2009-05-06 16:06:41 +00:00
|
|
|
|
|
2016-06-20 16:31:49 +00:00
|
|
|
|
/* Quote string to be used safely within the Bourne shell.
|
2012-03-28 15:43:39 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: escapeShellArg :: string -> string
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
2016-06-20 16:31:49 +00:00
|
|
|
|
escapeShellArg "esc'ape\nme"
|
|
|
|
|
=> "'esc'\\''ape\nme'"
|
2016-02-28 23:27:35 +00:00
|
|
|
|
*/
|
2016-06-20 16:31:49 +00:00
|
|
|
|
escapeShellArg = arg: "'${replaceStrings ["'"] ["'\\''"] (toString arg)}'";
|
2016-06-12 17:11:37 +00:00
|
|
|
|
|
2016-06-20 16:31:49 +00:00
|
|
|
|
/* Quote all arguments to be safely passed to the Bourne shell.
|
2016-06-12 17:11:37 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: escapeShellArgs :: [string] -> string
|
|
|
|
|
|
2016-06-12 17:11:37 +00:00
|
|
|
|
Example:
|
2016-06-20 16:31:49 +00:00
|
|
|
|
escapeShellArgs ["one" "two three" "four'five"]
|
|
|
|
|
=> "'one' 'two three' 'four'\\''five'"
|
2016-06-12 17:11:37 +00:00
|
|
|
|
*/
|
|
|
|
|
escapeShellArgs = concatMapStringsSep " " escapeShellArg;
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2022-04-27 08:02:49 +00:00
|
|
|
|
/* Test whether the given name is a valid POSIX shell variable name.
|
|
|
|
|
|
|
|
|
|
Type: string -> bool
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
isValidPosixName "foo_bar000"
|
|
|
|
|
=> true
|
|
|
|
|
isValidPosixName "0-bad.jpg"
|
|
|
|
|
=> false
|
|
|
|
|
*/
|
|
|
|
|
isValidPosixName = name: match "[a-zA-Z_][a-zA-Z0-9_]*" name != null;
|
|
|
|
|
|
|
|
|
|
/* Translate a Nix value into a shell variable declaration, with proper escaping.
|
|
|
|
|
|
|
|
|
|
Supported value types are strings (mapped to regular variables), lists of strings
|
|
|
|
|
(mapped to Bash-style arrays) and attribute sets of strings (mapped to Bash-style
|
|
|
|
|
associative arrays). Note that "strings" include string-coercible values like paths.
|
|
|
|
|
|
|
|
|
|
Strings are translated into POSIX sh-compatible code; lists and attribute sets
|
|
|
|
|
assume a shell that understands Bash syntax (e.g. Bash or ZSH).
|
|
|
|
|
|
|
|
|
|
Type: string -> (string | listOf string | attrsOf string) -> string
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
''
|
|
|
|
|
${toShellVar foo "some string"}
|
|
|
|
|
[[ "$foo" == "some string" ]]
|
|
|
|
|
''
|
|
|
|
|
*/
|
|
|
|
|
toShellVar = name: value:
|
|
|
|
|
lib.throwIfNot (isValidPosixName name) "toShellVar: ${name} is not a valid shell variable name" (
|
|
|
|
|
if isAttrs value then
|
|
|
|
|
"declare -A ${name}=(${
|
|
|
|
|
concatStringsSep " " (lib.mapAttrsToList (n: v:
|
|
|
|
|
"[${escapeShellArg n}]=${escapeShellArg v}"
|
|
|
|
|
) value)
|
|
|
|
|
})"
|
|
|
|
|
else if isList value then
|
|
|
|
|
"declare -a ${name}=(${escapeShellArgs value})"
|
|
|
|
|
else
|
|
|
|
|
"${name}=${escapeShellArg value}"
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
/* Translate an attribute set into corresponding shell variable declarations
|
|
|
|
|
using `toShellVar`.
|
|
|
|
|
|
|
|
|
|
Type: attrsOf (string | listOf string | attrsOf string) -> string
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
let
|
|
|
|
|
foo = "value";
|
|
|
|
|
bar = foo;
|
|
|
|
|
in ''
|
|
|
|
|
${toShellVars { inherit foo bar; }}
|
|
|
|
|
[[ "$foo" == "$bar" ]]
|
|
|
|
|
''
|
|
|
|
|
*/
|
|
|
|
|
toShellVars = vars: concatStringsSep "\n" (lib.mapAttrsToList toShellVar vars);
|
|
|
|
|
|
2017-12-02 18:03:40 +00:00
|
|
|
|
/* Turn a string into a Nix expression representing that string
|
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: string -> string
|
|
|
|
|
|
2017-12-02 18:03:40 +00:00
|
|
|
|
Example:
|
|
|
|
|
escapeNixString "hello\${}\n"
|
|
|
|
|
=> "\"hello\\\${}\\n\""
|
|
|
|
|
*/
|
2020-10-20 11:47:24 +00:00
|
|
|
|
escapeNixString = s: escape ["$"] (toJSON s);
|
2017-12-02 18:03:40 +00:00
|
|
|
|
|
2020-10-18 10:15:40 +00:00
|
|
|
|
/* Turn a string into an exact regular expression
|
|
|
|
|
|
|
|
|
|
Type: string -> string
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
escapeRegex "[^a-z]*"
|
|
|
|
|
=> "\\[\\^a-z]\\*"
|
|
|
|
|
*/
|
|
|
|
|
escapeRegex = escape (stringToCharacters "\\[{()^$?*+|.");
|
|
|
|
|
|
2020-03-14 16:53:47 +00:00
|
|
|
|
/* Quotes a string if it can't be used as an identifier directly.
|
|
|
|
|
|
|
|
|
|
Type: string -> string
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
escapeNixIdentifier "hello"
|
|
|
|
|
=> "hello"
|
|
|
|
|
escapeNixIdentifier "0abc"
|
|
|
|
|
=> "\"0abc\""
|
|
|
|
|
*/
|
|
|
|
|
escapeNixIdentifier = s:
|
|
|
|
|
# Regex from https://github.com/NixOS/nix/blob/d048577909e383439c2549e849c5c2f2016c997e/src/libexpr/lexer.l#L91
|
2020-10-20 11:47:24 +00:00
|
|
|
|
if match "[a-zA-Z_][a-zA-Z0-9_'-]*" s != null
|
2020-03-14 16:53:47 +00:00
|
|
|
|
then s else escapeNixString s;
|
|
|
|
|
|
2021-10-03 09:28:03 +00:00
|
|
|
|
/* Escapes a string such that it is safe to include verbatim in an XML
|
|
|
|
|
document.
|
|
|
|
|
|
|
|
|
|
Type: string -> string
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
escapeXML ''"test" 'test' < & >''
|
2021-11-02 21:43:25 +00:00
|
|
|
|
=> ""test" 'test' < & >"
|
2021-10-03 09:28:03 +00:00
|
|
|
|
*/
|
|
|
|
|
escapeXML = builtins.replaceStrings
|
|
|
|
|
["\"" "'" "<" ">" "&"]
|
|
|
|
|
[""" "'" "<" ">" "&"];
|
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
# Obsolete - use replaceStrings instead.
|
2015-07-24 13:45:41 +00:00
|
|
|
|
replaceChars = builtins.replaceStrings or (
|
|
|
|
|
del: new: s:
|
2009-10-06 09:21:52 +00:00
|
|
|
|
let
|
2015-07-13 21:46:38 +00:00
|
|
|
|
substList = lib.zipLists del new;
|
2009-10-06 09:21:52 +00:00
|
|
|
|
subst = c:
|
2015-07-13 21:46:38 +00:00
|
|
|
|
let found = lib.findFirst (sub: sub.fst == c) null substList; in
|
|
|
|
|
if found == null then
|
|
|
|
|
c
|
|
|
|
|
else
|
|
|
|
|
found.snd;
|
2009-10-06 09:21:52 +00:00
|
|
|
|
in
|
2015-07-24 13:45:41 +00:00
|
|
|
|
stringAsChars subst s);
|
2009-10-06 09:21:52 +00:00
|
|
|
|
|
2015-07-24 13:45:41 +00:00
|
|
|
|
# Case conversion utilities.
|
2013-02-09 17:38:26 +00:00
|
|
|
|
lowerChars = stringToCharacters "abcdefghijklmnopqrstuvwxyz";
|
|
|
|
|
upperChars = stringToCharacters "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
2016-02-28 23:27:35 +00:00
|
|
|
|
|
|
|
|
|
/* Converts an ASCII string to lower-case.
|
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: toLower :: string -> string
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
toLower "HOME"
|
|
|
|
|
=> "home"
|
|
|
|
|
*/
|
2013-02-09 17:38:26 +00:00
|
|
|
|
toLower = replaceChars upperChars lowerChars;
|
2016-02-28 23:27:35 +00:00
|
|
|
|
|
|
|
|
|
/* Converts an ASCII string to upper-case.
|
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: toUpper :: string -> string
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
2016-08-12 08:30:11 +00:00
|
|
|
|
toUpper "home"
|
2016-02-28 23:27:35 +00:00
|
|
|
|
=> "HOME"
|
|
|
|
|
*/
|
2013-02-09 17:38:26 +00:00
|
|
|
|
toUpper = replaceChars lowerChars upperChars;
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Appends string context from another string. This is an implementation
|
|
|
|
|
detail of Nix.
|
2013-02-09 17:38:26 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Strings in Nix carry an invisible `context` which is a list of strings
|
2016-02-28 23:27:35 +00:00
|
|
|
|
representing store paths. If the string is later used in a derivation
|
|
|
|
|
attribute, the derivation will properly populate the inputDrvs and
|
|
|
|
|
inputSrcs.
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
pkgs = import <nixpkgs> { };
|
|
|
|
|
addContextFrom pkgs.coreutils "bar"
|
|
|
|
|
=> "bar"
|
|
|
|
|
*/
|
2014-10-04 15:02:29 +00:00
|
|
|
|
addContextFrom = a: b: substring 0 0 a + b;
|
2009-09-28 18:22:37 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Cut a string with a separator and produces a list of strings which
|
|
|
|
|
were separated by this separator.
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
splitString "." "foo.bar.baz"
|
|
|
|
|
=> [ "foo" "bar" "baz" ]
|
|
|
|
|
splitString "/" "/usr/local/bin"
|
|
|
|
|
=> [ "" "usr" "local" "bin" ]
|
|
|
|
|
*/
|
2014-06-10 09:55:25 +00:00
|
|
|
|
splitString = _sep: _s:
|
2009-09-28 18:22:37 +00:00
|
|
|
|
let
|
2020-10-18 10:15:40 +00:00
|
|
|
|
sep = builtins.unsafeDiscardStringContext _sep;
|
|
|
|
|
s = builtins.unsafeDiscardStringContext _s;
|
|
|
|
|
splits = builtins.filter builtins.isString (builtins.split (escapeRegex sep) s);
|
2009-09-28 18:22:37 +00:00
|
|
|
|
in
|
2020-10-18 10:15:40 +00:00
|
|
|
|
map (v: addContextFrom _sep (addContextFrom _s v)) splits;
|
2009-10-06 09:21:39 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
/* Return a string without the specified prefix, if the prefix matches.
|
|
|
|
|
|
|
|
|
|
Type: string -> string -> string
|
2012-03-28 15:43:39 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
removePrefix "foo." "foo.bar.baz"
|
|
|
|
|
=> "bar.baz"
|
|
|
|
|
removePrefix "xxx" "foo.bar.baz"
|
|
|
|
|
=> "foo.bar.baz"
|
|
|
|
|
*/
|
2018-10-27 15:44:17 +00:00
|
|
|
|
removePrefix =
|
|
|
|
|
# Prefix to remove if it matches
|
|
|
|
|
prefix:
|
|
|
|
|
# Input string
|
|
|
|
|
str:
|
2009-10-06 09:21:39 +00:00
|
|
|
|
let
|
2018-10-27 15:44:17 +00:00
|
|
|
|
preLen = stringLength prefix;
|
|
|
|
|
sLen = stringLength str;
|
2009-10-06 09:21:39 +00:00
|
|
|
|
in
|
2018-10-27 15:44:17 +00:00
|
|
|
|
if hasPrefix prefix str then
|
|
|
|
|
substring preLen (sLen - preLen) str
|
2009-10-06 09:21:39 +00:00
|
|
|
|
else
|
2018-10-27 15:44:17 +00:00
|
|
|
|
str;
|
|
|
|
|
|
|
|
|
|
/* Return a string without the specified suffix, if the suffix matches.
|
2009-10-06 09:21:39 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: string -> string -> string
|
2016-02-28 23:27:35 +00:00
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
removeSuffix "front" "homefront"
|
|
|
|
|
=> "home"
|
|
|
|
|
removeSuffix "xxx" "homefront"
|
|
|
|
|
=> "homefront"
|
|
|
|
|
*/
|
2018-10-27 15:44:17 +00:00
|
|
|
|
removeSuffix =
|
|
|
|
|
# Suffix to remove if it matches
|
|
|
|
|
suffix:
|
|
|
|
|
# Input string
|
|
|
|
|
str:
|
2014-05-09 13:50:40 +00:00
|
|
|
|
let
|
2018-10-27 15:44:17 +00:00
|
|
|
|
sufLen = stringLength suffix;
|
|
|
|
|
sLen = stringLength str;
|
2014-05-09 13:50:40 +00:00
|
|
|
|
in
|
2018-10-27 15:44:17 +00:00
|
|
|
|
if sufLen <= sLen && suffix == substring (sLen - sufLen) sufLen str then
|
|
|
|
|
substring 0 (sLen - sufLen) str
|
2014-05-09 13:50:40 +00:00
|
|
|
|
else
|
2018-10-27 15:44:17 +00:00
|
|
|
|
str;
|
2014-05-09 13:50:40 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
/* Return true if string v1 denotes a version older than v2.
|
2016-02-28 23:27:35 +00:00
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
versionOlder "1.1" "1.2"
|
|
|
|
|
=> true
|
|
|
|
|
versionOlder "1.1" "1.1"
|
|
|
|
|
=> false
|
|
|
|
|
*/
|
2020-10-20 11:47:24 +00:00
|
|
|
|
versionOlder = v1: v2: compareVersions v2 v1 == 1;
|
2012-03-19 18:04:47 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
/* Return true if string v1 denotes a version equal to or newer than v2.
|
2012-10-05 17:45:27 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
versionAtLeast "1.1" "1.0"
|
|
|
|
|
=> true
|
|
|
|
|
versionAtLeast "1.1" "1.1"
|
|
|
|
|
=> true
|
|
|
|
|
versionAtLeast "1.1" "1.2"
|
|
|
|
|
=> false
|
|
|
|
|
*/
|
2013-07-17 09:14:26 +00:00
|
|
|
|
versionAtLeast = v1: v2: !versionOlder v1 v2;
|
|
|
|
|
|
2019-11-24 16:19:32 +00:00
|
|
|
|
/* This function takes an argument that's either a derivation or a
|
|
|
|
|
derivation's "name" attribute and extracts the name part from that
|
|
|
|
|
argument.
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
getName "youtube-dl-2016.01.01"
|
|
|
|
|
=> "youtube-dl"
|
|
|
|
|
getName pkgs.youtube-dl
|
|
|
|
|
=> "youtube-dl"
|
|
|
|
|
*/
|
|
|
|
|
getName = x:
|
|
|
|
|
let
|
2020-10-20 11:47:24 +00:00
|
|
|
|
parse = drv: (parseDrvName drv).name;
|
2019-11-24 16:19:32 +00:00
|
|
|
|
in if isString x
|
|
|
|
|
then parse x
|
|
|
|
|
else x.pname or (parse x.name);
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* This function takes an argument that's either a derivation or a
|
|
|
|
|
derivation's "name" attribute and extracts the version part from that
|
|
|
|
|
argument.
|
2013-07-17 09:14:26 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
getVersion "youtube-dl-2016.01.01"
|
|
|
|
|
=> "2016.01.01"
|
|
|
|
|
getVersion pkgs.youtube-dl
|
|
|
|
|
=> "2016.01.01"
|
|
|
|
|
*/
|
2016-08-13 15:16:37 +00:00
|
|
|
|
getVersion = x:
|
|
|
|
|
let
|
2020-10-20 11:47:24 +00:00
|
|
|
|
parse = drv: (parseDrvName drv).version;
|
2016-08-13 15:16:37 +00:00
|
|
|
|
in if isString x
|
|
|
|
|
then parse x
|
|
|
|
|
else x.version or (parse x.name);
|
2012-10-05 17:45:27 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Extract name with version from URL. Ask for separator which is
|
|
|
|
|
supposed to start extension.
|
2012-10-05 17:45:27 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
nameFromURL "https://nixos.org/releases/nix/nix-1.7/nix-1.7-x86_64-linux.tar.bz2" "-"
|
|
|
|
|
=> "nix"
|
|
|
|
|
nameFromURL "https://nixos.org/releases/nix/nix-1.7/nix-1.7-x86_64-linux.tar.bz2" "_"
|
|
|
|
|
=> "nix-1.7-x86"
|
|
|
|
|
*/
|
2015-07-24 13:48:29 +00:00
|
|
|
|
nameFromURL = url: sep:
|
|
|
|
|
let
|
|
|
|
|
components = splitString "/" url;
|
|
|
|
|
filename = lib.last components;
|
2020-10-20 11:47:24 +00:00
|
|
|
|
name = head (splitString sep filename);
|
2018-08-05 23:36:09 +00:00
|
|
|
|
in assert name != filename; name;
|
2012-09-13 09:59:23 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Create an --{enable,disable}-<feat> string that can be passed to
|
|
|
|
|
standard GNU Autoconf scripts.
|
2013-02-24 18:28:24 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
enableFeature true "shared"
|
|
|
|
|
=> "--enable-shared"
|
|
|
|
|
enableFeature false "shared"
|
|
|
|
|
=> "--disable-shared"
|
|
|
|
|
*/
|
2018-08-12 08:17:08 +00:00
|
|
|
|
enableFeature = enable: feat:
|
|
|
|
|
assert isString feat; # e.g. passing openssl instead of "openssl"
|
|
|
|
|
"--${if enable then "enable" else "disable"}-${feat}";
|
2013-02-24 18:28:24 +00:00
|
|
|
|
|
2018-05-11 15:12:15 +00:00
|
|
|
|
/* Create an --{enable-<feat>=<value>,disable-<feat>} string that can be passed to
|
|
|
|
|
standard GNU Autoconf scripts.
|
|
|
|
|
|
|
|
|
|
Example:
|
2020-12-03 18:50:14 +00:00
|
|
|
|
enableFeatureAs true "shared" "foo"
|
2018-05-11 15:12:15 +00:00
|
|
|
|
=> "--enable-shared=foo"
|
2020-12-03 18:50:14 +00:00
|
|
|
|
enableFeatureAs false "shared" (throw "ignored")
|
2018-05-11 15:12:15 +00:00
|
|
|
|
=> "--disable-shared"
|
|
|
|
|
*/
|
|
|
|
|
enableFeatureAs = enable: feat: value: enableFeature enable feat + optionalString enable "=${value}";
|
|
|
|
|
|
|
|
|
|
/* Create an --{with,without}-<feat> string that can be passed to
|
|
|
|
|
standard GNU Autoconf scripts.
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
withFeature true "shared"
|
|
|
|
|
=> "--with-shared"
|
|
|
|
|
withFeature false "shared"
|
|
|
|
|
=> "--without-shared"
|
|
|
|
|
*/
|
2018-08-12 08:17:08 +00:00
|
|
|
|
withFeature = with_: feat:
|
|
|
|
|
assert isString feat; # e.g. passing openssl instead of "openssl"
|
|
|
|
|
"--${if with_ then "with" else "without"}-${feat}";
|
2018-05-11 15:12:15 +00:00
|
|
|
|
|
|
|
|
|
/* Create an --{with-<feat>=<value>,without-<feat>} string that can be passed to
|
|
|
|
|
standard GNU Autoconf scripts.
|
|
|
|
|
|
|
|
|
|
Example:
|
2020-12-04 19:35:27 +00:00
|
|
|
|
withFeatureAs true "shared" "foo"
|
2018-05-11 15:12:15 +00:00
|
|
|
|
=> "--with-shared=foo"
|
2020-12-04 19:35:27 +00:00
|
|
|
|
withFeatureAs false "shared" (throw "ignored")
|
2018-05-11 15:12:15 +00:00
|
|
|
|
=> "--without-shared"
|
|
|
|
|
*/
|
|
|
|
|
withFeatureAs = with_: feat: value: withFeature with_ feat + optionalString with_ "=${value}";
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Create a fixed width string with additional prefix to match
|
|
|
|
|
required width.
|
2015-07-23 15:41:35 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
This function will fail if the input string is longer than the
|
|
|
|
|
requested length.
|
|
|
|
|
|
2021-05-01 15:29:00 +00:00
|
|
|
|
Type: fixedWidthString :: int -> string -> string -> string
|
2018-10-27 15:44:17 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
fixedWidthString 5 "0" (toString 15)
|
|
|
|
|
=> "00015"
|
|
|
|
|
*/
|
2015-03-08 17:29:14 +00:00
|
|
|
|
fixedWidthString = width: filler: str:
|
|
|
|
|
let
|
|
|
|
|
strw = lib.stringLength str;
|
|
|
|
|
reqWidth = width - (lib.stringLength filler);
|
|
|
|
|
in
|
2018-08-05 23:36:09 +00:00
|
|
|
|
assert lib.assertMsg (strw <= width)
|
|
|
|
|
"fixedWidthString: requested string length (${
|
|
|
|
|
toString width}) must not be shorter than actual length (${
|
|
|
|
|
toString strw})";
|
2015-03-08 17:29:14 +00:00
|
|
|
|
if strw == width then str else filler + fixedWidthString reqWidth filler str;
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Format a number adding leading zeroes up to fixed width.
|
2015-07-23 15:41:35 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
fixedWidthNumber 5 15
|
|
|
|
|
=> "00015"
|
|
|
|
|
*/
|
2015-03-08 17:29:14 +00:00
|
|
|
|
fixedWidthNumber = width: n: fixedWidthString width "0" (toString n);
|
2015-08-06 17:55:42 +00:00
|
|
|
|
|
2020-03-07 01:44:56 +00:00
|
|
|
|
/* Convert a float to a string, but emit a warning when precision is lost
|
|
|
|
|
during the conversion
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
floatToString 0.000001
|
|
|
|
|
=> "0.000001"
|
|
|
|
|
floatToString 0.0000001
|
|
|
|
|
=> trace: warning: Imprecise conversion from float to string 0.000000
|
|
|
|
|
"0.000000"
|
|
|
|
|
*/
|
|
|
|
|
floatToString = float: let
|
|
|
|
|
result = toString float;
|
2020-10-20 11:47:24 +00:00
|
|
|
|
precise = float == fromJSON result;
|
2021-04-27 13:52:15 +00:00
|
|
|
|
in lib.warnIf (!precise) "Imprecise conversion from float to string ${result}"
|
|
|
|
|
result;
|
2020-03-07 01:44:56 +00:00
|
|
|
|
|
2018-03-09 22:21:12 +00:00
|
|
|
|
/* Check whether a value can be coerced to a string */
|
|
|
|
|
isCoercibleToString = x:
|
2020-10-20 11:47:24 +00:00
|
|
|
|
elem (typeOf x) [ "path" "string" "null" "int" "float" "bool" ] ||
|
|
|
|
|
(isList x && lib.all isCoercibleToString x) ||
|
2018-03-09 22:21:12 +00:00
|
|
|
|
x ? outPath ||
|
|
|
|
|
x ? __toString;
|
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
/* Check whether a value is a store path.
|
2015-08-06 17:55:42 +00:00
|
|
|
|
|
2016-02-28 23:27:35 +00:00
|
|
|
|
Example:
|
|
|
|
|
isStorePath "/nix/store/d945ibfx9x185xf04b890y4f9g3cbb63-python-2.7.11/bin/python"
|
|
|
|
|
=> false
|
2021-04-14 10:02:36 +00:00
|
|
|
|
isStorePath "/nix/store/d945ibfx9x185xf04b890y4f9g3cbb63-python-2.7.11"
|
2016-02-28 23:27:35 +00:00
|
|
|
|
=> true
|
|
|
|
|
isStorePath pkgs.python
|
|
|
|
|
=> true
|
2017-05-29 23:20:37 +00:00
|
|
|
|
isStorePath [] || isStorePath 42 || isStorePath {} || …
|
|
|
|
|
=> false
|
2016-02-28 23:27:35 +00:00
|
|
|
|
*/
|
2017-05-29 23:20:37 +00:00
|
|
|
|
isStorePath = x:
|
2021-05-04 13:07:56 +00:00
|
|
|
|
if !(isList x) && isCoercibleToString x then
|
2018-10-20 11:23:58 +00:00
|
|
|
|
let str = toString x; in
|
2020-10-20 11:47:24 +00:00
|
|
|
|
substring 0 1 str == "/"
|
|
|
|
|
&& dirOf str == storeDir
|
2018-10-20 11:23:58 +00:00
|
|
|
|
else
|
|
|
|
|
false;
|
2015-08-06 17:55:42 +00:00
|
|
|
|
|
2020-12-05 14:35:30 +00:00
|
|
|
|
/* Parse a string as an int.
|
2018-10-27 15:44:17 +00:00
|
|
|
|
|
|
|
|
|
Type: string -> int
|
2016-02-28 23:27:35 +00:00
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
toInt "1337"
|
|
|
|
|
=> 1337
|
|
|
|
|
toInt "-4"
|
|
|
|
|
=> -4
|
|
|
|
|
toInt "3.14"
|
|
|
|
|
=> error: floating point JSON numbers are not supported
|
|
|
|
|
*/
|
2018-10-27 15:44:17 +00:00
|
|
|
|
# Obviously, it is a bit hacky to use fromJSON this way.
|
2015-11-24 09:00:44 +00:00
|
|
|
|
toInt = str:
|
2020-10-20 11:47:24 +00:00
|
|
|
|
let may_be_int = fromJSON str; in
|
|
|
|
|
if isInt may_be_int
|
2015-11-24 09:00:44 +00:00
|
|
|
|
then may_be_int
|
|
|
|
|
else throw "Could not convert ${str} to int.";
|
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
/* Read a list of paths from `file`, relative to the `rootPath`.
|
|
|
|
|
Lines beginning with `#` are treated as comments and ignored.
|
|
|
|
|
Whitespace is significant.
|
2016-02-28 23:27:35 +00:00
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
NOTE: This function is not performant and should be avoided.
|
2016-02-28 23:27:35 +00:00
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
readPathsFromFile /prefix
|
|
|
|
|
./pkgs/development/libraries/qt-5/5.4/qtbase/series
|
|
|
|
|
=> [ "/prefix/dlopen-resolv.patch" "/prefix/tzdir.patch"
|
|
|
|
|
"/prefix/dlopen-libXcursor.patch" "/prefix/dlopen-openssl.patch"
|
|
|
|
|
"/prefix/dlopen-dbus.patch" "/prefix/xdg-config-dirs.patch"
|
|
|
|
|
"/prefix/nix-profiles-library-paths.patch"
|
|
|
|
|
"/prefix/compose-search-path.patch" ]
|
|
|
|
|
*/
|
2020-08-25 10:12:05 +00:00
|
|
|
|
readPathsFromFile = lib.warn "lib.readPathsFromFile is deprecated, use a list instead"
|
|
|
|
|
(rootPath: file:
|
|
|
|
|
let
|
2020-10-20 11:47:24 +00:00
|
|
|
|
lines = lib.splitString "\n" (readFile file);
|
2020-08-25 10:12:05 +00:00
|
|
|
|
removeComments = lib.filter (line: line != "" && !(lib.hasPrefix "#" line));
|
|
|
|
|
relativePaths = removeComments lines;
|
2020-10-20 11:47:24 +00:00
|
|
|
|
absolutePaths = map (path: rootPath + "/${path}") relativePaths;
|
2020-08-25 10:12:05 +00:00
|
|
|
|
in
|
|
|
|
|
absolutePaths);
|
2016-07-29 08:15:37 +00:00
|
|
|
|
|
|
|
|
|
/* Read the contents of a file removing the trailing \n
|
|
|
|
|
|
2018-10-27 15:44:17 +00:00
|
|
|
|
Type: fileContents :: path -> string
|
|
|
|
|
|
2016-07-29 08:15:37 +00:00
|
|
|
|
Example:
|
|
|
|
|
$ echo "1.0" > ./version
|
|
|
|
|
|
|
|
|
|
fileContents ./version
|
|
|
|
|
=> "1.0"
|
|
|
|
|
*/
|
2020-10-20 11:47:24 +00:00
|
|
|
|
fileContents = file: removeSuffix "\n" (readFile file);
|
2020-01-27 22:03:38 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Creates a valid derivation name from a potentially invalid one.
|
|
|
|
|
|
|
|
|
|
Type: sanitizeDerivationName :: String -> String
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
sanitizeDerivationName "../hello.bar # foo"
|
|
|
|
|
=> "-hello.bar-foo"
|
|
|
|
|
sanitizeDerivationName ""
|
|
|
|
|
=> "unknown"
|
|
|
|
|
sanitizeDerivationName pkgs.hello
|
|
|
|
|
=> "-nix-store-2g75chlbpxlrqn15zlby2dfh8hr9qwbk-hello-2.10"
|
|
|
|
|
*/
|
2022-03-30 09:19:37 +00:00
|
|
|
|
sanitizeDerivationName =
|
2022-04-05 17:14:09 +00:00
|
|
|
|
let okRegex = match "[[:alnum:]+_?=-][[:alnum:]+._?=-]*";
|
2022-03-30 09:19:37 +00:00
|
|
|
|
in
|
|
|
|
|
string:
|
|
|
|
|
# First detect the common case of already valid strings, to speed those up
|
|
|
|
|
if stringLength string <= 207 && okRegex string != null
|
|
|
|
|
then unsafeDiscardStringContext string
|
|
|
|
|
else lib.pipe string [
|
2020-01-27 22:03:38 +00:00
|
|
|
|
# Get rid of string context. This is safe under the assumption that the
|
|
|
|
|
# resulting string is only used as a derivation name
|
2020-10-20 11:47:24 +00:00
|
|
|
|
unsafeDiscardStringContext
|
2020-01-27 22:03:38 +00:00
|
|
|
|
# Strip all leading "."
|
2020-10-20 11:47:24 +00:00
|
|
|
|
(x: elemAt (match "\\.*(.*)" x) 0)
|
2020-01-27 22:03:38 +00:00
|
|
|
|
# Split out all invalid characters
|
|
|
|
|
# https://github.com/NixOS/nix/blob/2.3.2/src/libstore/store-api.cc#L85-L112
|
|
|
|
|
# https://github.com/NixOS/nix/blob/2242be83c61788b9c0736a92bb0b5c7bbfc40803/nix-rust/src/store/path.rs#L100-L125
|
2020-10-20 11:47:24 +00:00
|
|
|
|
(split "[^[:alnum:]+._?=-]+")
|
2020-01-27 22:03:38 +00:00
|
|
|
|
# Replace invalid character ranges with a "-"
|
|
|
|
|
(concatMapStrings (s: if lib.isList s then "-" else s))
|
|
|
|
|
# Limit to 211 characters (minus 4 chars for ".drv")
|
|
|
|
|
(x: substring (lib.max (stringLength x - 207) 0) (-1) x)
|
|
|
|
|
# If the result is empty, replace it with "unknown"
|
|
|
|
|
(x: if stringLength x == 0 then "unknown" else x)
|
|
|
|
|
];
|
|
|
|
|
|
2020-07-25 17:53:15 +00:00
|
|
|
|
/* Computes the Levenshtein distance between two strings.
|
|
|
|
|
Complexity O(n*m) where n and m are the lengths of the strings.
|
|
|
|
|
Algorithm adjusted from https://stackoverflow.com/a/9750974/6605742
|
|
|
|
|
|
|
|
|
|
Type: levenshtein :: string -> string -> int
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
levenshtein "foo" "foo"
|
|
|
|
|
=> 0
|
|
|
|
|
levenshtein "book" "hook"
|
|
|
|
|
=> 1
|
|
|
|
|
levenshtein "hello" "Heyo"
|
|
|
|
|
=> 3
|
|
|
|
|
*/
|
|
|
|
|
levenshtein = a: b: let
|
|
|
|
|
# Two dimensional array with dimensions (stringLength a + 1, stringLength b + 1)
|
|
|
|
|
arr = lib.genList (i:
|
|
|
|
|
lib.genList (j:
|
|
|
|
|
dist i j
|
|
|
|
|
) (stringLength b + 1)
|
|
|
|
|
) (stringLength a + 1);
|
|
|
|
|
d = x: y: lib.elemAt (lib.elemAt arr x) y;
|
|
|
|
|
dist = i: j:
|
|
|
|
|
let c = if substring (i - 1) 1 a == substring (j - 1) 1 b
|
|
|
|
|
then 0 else 1;
|
|
|
|
|
in
|
|
|
|
|
if j == 0 then i
|
|
|
|
|
else if i == 0 then j
|
|
|
|
|
else lib.min
|
|
|
|
|
( lib.min (d (i - 1) j + 1) (d i (j - 1) + 1))
|
|
|
|
|
( d (i - 1) (j - 1) + c );
|
|
|
|
|
in d (stringLength a) (stringLength b);
|
|
|
|
|
|
|
|
|
|
/* Returns the length of the prefix common to both strings.
|
|
|
|
|
*/
|
|
|
|
|
commonPrefixLength = a: b:
|
|
|
|
|
let
|
|
|
|
|
m = lib.min (stringLength a) (stringLength b);
|
|
|
|
|
go = i: if i >= m then m else if substring i 1 a == substring i 1 b then go (i + 1) else i;
|
|
|
|
|
in go 0;
|
|
|
|
|
|
|
|
|
|
/* Returns the length of the suffix common to both strings.
|
|
|
|
|
*/
|
|
|
|
|
commonSuffixLength = a: b:
|
|
|
|
|
let
|
|
|
|
|
m = lib.min (stringLength a) (stringLength b);
|
|
|
|
|
go = i: if i >= m then m else if substring (stringLength a - i - 1) 1 a == substring (stringLength b - i - 1) 1 b then go (i + 1) else i;
|
|
|
|
|
in go 0;
|
|
|
|
|
|
|
|
|
|
/* Returns whether the levenshtein distance between two strings is at most some value
|
|
|
|
|
Complexity is O(min(n,m)) for k <= 2 and O(n*m) otherwise
|
|
|
|
|
|
|
|
|
|
Type: levenshteinAtMost :: int -> string -> string -> bool
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
levenshteinAtMost 0 "foo" "foo"
|
|
|
|
|
=> true
|
|
|
|
|
levenshteinAtMost 1 "foo" "boa"
|
|
|
|
|
=> false
|
|
|
|
|
levenshteinAtMost 2 "foo" "boa"
|
|
|
|
|
=> true
|
|
|
|
|
levenshteinAtMost 2 "This is a sentence" "this is a sentense."
|
|
|
|
|
=> false
|
|
|
|
|
levenshteinAtMost 3 "This is a sentence" "this is a sentense."
|
|
|
|
|
=> true
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
levenshteinAtMost = let
|
|
|
|
|
infixDifferAtMost1 = x: y: stringLength x <= 1 && stringLength y <= 1;
|
|
|
|
|
|
|
|
|
|
# This function takes two strings stripped by their common pre and suffix,
|
|
|
|
|
# and returns whether they differ by at most two by Levenshtein distance.
|
|
|
|
|
# Because of this stripping, if they do indeed differ by at most two edits,
|
|
|
|
|
# we know that those edits were (if at all) done at the start or the end,
|
|
|
|
|
# while the middle has to have stayed the same. This fact is used in the
|
|
|
|
|
# implementation.
|
|
|
|
|
infixDifferAtMost2 = x: y:
|
|
|
|
|
let
|
|
|
|
|
xlen = stringLength x;
|
|
|
|
|
ylen = stringLength y;
|
|
|
|
|
# This function is only called with |x| >= |y| and |x| - |y| <= 2, so
|
|
|
|
|
# diff is one of 0, 1 or 2
|
|
|
|
|
diff = xlen - ylen;
|
|
|
|
|
|
|
|
|
|
# Infix of x and y, stripped by the left and right most character
|
|
|
|
|
xinfix = substring 1 (xlen - 2) x;
|
|
|
|
|
yinfix = substring 1 (ylen - 2) y;
|
|
|
|
|
|
|
|
|
|
# x and y but a character deleted at the left or right
|
|
|
|
|
xdelr = substring 0 (xlen - 1) x;
|
|
|
|
|
xdell = substring 1 (xlen - 1) x;
|
|
|
|
|
ydelr = substring 0 (ylen - 1) y;
|
|
|
|
|
ydell = substring 1 (ylen - 1) y;
|
|
|
|
|
in
|
|
|
|
|
# A length difference of 2 can only be gotten with 2 delete edits,
|
|
|
|
|
# which have to have happened at the start and end of x
|
|
|
|
|
# Example: "abcdef" -> "bcde"
|
|
|
|
|
if diff == 2 then xinfix == y
|
|
|
|
|
# A length difference of 1 can only be gotten with a deletion on the
|
|
|
|
|
# right and a replacement on the left or vice versa.
|
|
|
|
|
# Example: "abcdef" -> "bcdez" or "zbcde"
|
|
|
|
|
else if diff == 1 then xinfix == ydelr || xinfix == ydell
|
|
|
|
|
# No length difference can either happen through replacements on both
|
|
|
|
|
# sides, or a deletion on the left and an insertion on the right or
|
|
|
|
|
# vice versa
|
|
|
|
|
# Example: "abcdef" -> "zbcdez" or "bcdefz" or "zabcde"
|
|
|
|
|
else xinfix == yinfix || xdelr == ydell || xdell == ydelr;
|
|
|
|
|
|
|
|
|
|
in k: if k <= 0 then a: b: a == b else
|
|
|
|
|
let f = a: b:
|
|
|
|
|
let
|
|
|
|
|
alen = stringLength a;
|
|
|
|
|
blen = stringLength b;
|
|
|
|
|
prelen = commonPrefixLength a b;
|
|
|
|
|
suflen = commonSuffixLength a b;
|
|
|
|
|
presuflen = prelen + suflen;
|
|
|
|
|
ainfix = substring prelen (alen - presuflen) a;
|
|
|
|
|
binfix = substring prelen (blen - presuflen) b;
|
|
|
|
|
in
|
|
|
|
|
# Make a be the bigger string
|
|
|
|
|
if alen < blen then f b a
|
|
|
|
|
# If a has over k more characters than b, even with k deletes on a, b can't be reached
|
|
|
|
|
else if alen - blen > k then false
|
|
|
|
|
else if k == 1 then infixDifferAtMost1 ainfix binfix
|
|
|
|
|
else if k == 2 then infixDifferAtMost2 ainfix binfix
|
|
|
|
|
else levenshtein ainfix binfix <= k;
|
|
|
|
|
in f;
|
2009-02-24 16:19:08 +00:00
|
|
|
|
}
|