{
description = "A compression multi-tool for the command line.";
inputs = {
nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
crane = {
url = "github:ipetkov/crane";
};
fenix = {
# Needed because rust-overlay, normally used by crane, doesn't have llvm-tools for coverage
url = "github:nix-community/fenix";
inputs.nixpkgs.follows = "nixpkgs";
inputs.rust-analyzer-src.follows = "";
};
# Flake helper for better organization with modules.
flake-parts = {
url = "github:hercules-ci/flake-parts";
inputs.nixpkgs-lib.follows = "nixpkgs";
};
# For creating a universal `nix fmt`
treefmt-nix = {
url = "github:numtide/treefmt-nix";
inputs.nixpkgs.follows = "nixpkgs";
};
};
outputs = inputs @ {
self,
flake-parts,
...
}:
flake-parts.lib.mkFlake {inherit inputs;} {
systems = [
"aarch64-darwin"
"aarch64-linux"
"x86_64-darwin"
"x86_64-linux"
];
imports = [
flake-parts.flakeModules.easyOverlay
inputs.treefmt-nix.flakeModule
];
perSystem = {
config,
system,
pkgs,
...
}: let
# Use the stable rust tools from fenix
fenixStable = inputs.fenix.packages.${system}.stable;
rustSrc = fenixStable.rust-src;
toolChain = fenixStable.completeToolchain;
# Use the toolchain with the crane helper functions
craneLib = (inputs.crane.mkLib pkgs).overrideToolchain toolChain;
# Common arguments for mkCargoDerivation, a helper for the crane functions
# Arguments can be included here even if they aren't used, but we only
# place them here if they would otherwise show up in multiple places
commonArgs = {
inherit cargoArtifacts;
# Clean the src to only have the Rust-relevant files
src = craneLib.cleanCargoSource ./.;
strictDeps = true;
nativeBuildInputs = [
pkgs.pkg-config
pkgs.gcc
];
};
# Build only the cargo dependencies so we can cache them all when running in CI
cargoArtifacts = craneLib.buildDepsOnly commonArgs;
# Build the actual crate itself, reusing the cargoArtifacts
cmprss = craneLib.buildPackage (commonArgs
// {
doCheck = false; # Tests are run as a separate build with nextest
meta.mainProgram = "cmprss";
nativeBuildInputs = commonArgs.nativeBuildInputs ++ [pkgs.installShellFiles];
postInstall = pkgs.lib.optionalString (pkgs.stdenv.buildPlatform.canExecute pkgs.stdenv.hostPlatform) ''
installShellCompletion --cmd cmprss \
--bash <($out/bin/cmprss completions bash) \
--fish <($out/bin/cmprss completions fish) \
--zsh <($out/bin/cmprss completions zsh)
'';
});
# Fully static musl build (Linux only)
staticMusl = pkgs.lib.optionalAttrs pkgs.stdenv.isLinux (
let
muslTarget =
if system == "x86_64-linux"
then "x86_64-unknown-linux-musl"
else "aarch64-unknown-linux-musl";
muslToolchain = inputs.fenix.packages.${system}.combine [
fenixStable.cargo
fenixStable.rustc
inputs.fenix.packages.${system}.targets.${muslTarget}.stable.rust-std
];
craneLibMusl = (inputs.crane.mkLib pkgs).overrideToolchain muslToolchain;
musl-cc = pkgs.pkgsStatic.stdenv.cc;
staticArgs = {
src = craneLibMusl.cleanCargoSource ./.;
strictDeps = true;
CARGO_BUILD_TARGET = muslTarget;
CARGO_BUILD_RUSTFLAGS = "-C target-feature=+crt-static";
TARGET_CC = "${musl-cc}/bin/${musl-cc.targetPrefix}cc";
HOST_CC = "${pkgs.stdenv.cc}/bin/cc";
nativeBuildInputs = [
musl-cc
pkgs.pkg-config
];
};
cargoArtifactsStatic = craneLibMusl.buildDepsOnly staticArgs;
in {
cmprss-static = craneLibMusl.buildPackage (staticArgs
// {
cargoArtifacts = cargoArtifactsStatic;
doCheck = false;
meta.mainProgram = "cmprss";
nativeBuildInputs = staticArgs.nativeBuildInputs ++ [pkgs.installShellFiles];
postInstall = pkgs.lib.optionalString (pkgs.stdenv.buildPlatform.canExecute pkgs.stdenv.hostPlatform) ''
installShellCompletion --cmd cmprss \
--bash <($out/bin/cmprss completions bash) \
--fish <($out/bin/cmprss completions fish) \
--zsh <($out/bin/cmprss completions zsh)
'';
});
}
);
# Source filtered to specific file extensions for lightweight linter checks
cleanSrc = pkgs.lib.cleanSource ./.;
sourceWithExts = exts:
pkgs.lib.cleanSourceWith {
src = cleanSrc;
filter = path: type:
(type == "directory")
|| (pkgs.lib.any (ext: pkgs.lib.hasSuffix ".${ext}" path) exts);
};
mkSimpleLinter = {
name,
packages ? [],
src ? cleanSrc,
command,
}:
pkgs.runCommand "lint-${name}" {
nativeBuildInputs = packages;
inherit src;
} ''
cd $src
${command}
mkdir -p $out
'';
linters = {
statix = mkSimpleLinter {
name = "statix";
packages = [pkgs.statix];
src = sourceWithExts ["nix"];
command = "statix check .";
};
deadnix = mkSimpleLinter {
name = "deadnix";
packages = [pkgs.deadnix];
src = sourceWithExts ["nix"];
command = "deadnix --fail .";
};
shellcheck = mkSimpleLinter {
name = "shellcheck";
packages = [pkgs.shellcheck pkgs.findutils];
src = sourceWithExts ["sh"];
command = ''find . -name "*.sh" -type f -exec shellcheck {} +'';
};
actionlint = mkSimpleLinter {
name = "actionlint";
packages = [pkgs.actionlint pkgs.shellcheck pkgs.findutils];
src = pkgs.lib.cleanSourceWith {
src = cleanSrc;
filter = path: type:
(type == "directory")
|| (pkgs.lib.hasSuffix ".yml" path && pkgs.lib.hasInfix ".github" path);
};
command = ''find .github/workflows -name "*.yml" -exec actionlint {} +'';
};
};
in {
packages =
{
default = cmprss;
inherit cmprss;
# Check code coverage with tarpaulin
coverage = craneLib.cargoTarpaulin (commonArgs
// {
# Use lcov output as thats far more widely supported
cargoTarpaulinExtraArgs = "--skip-clean --include-tests --output-dir $out --out lcov";
});
# Run clippy (and deny all warnings) on the crate source
clippy = craneLib.cargoClippy (commonArgs
// {
cargoClippyExtraArgs = "--all-targets -- --deny warnings";
});
# Check docs build successfully
doc = craneLib.cargoDoc commonArgs;
# Check formatting
fmt = craneLib.cargoFmt commonArgs;
# Run tests with cargo-nextest
test = craneLib.cargoNextest commonArgs;
# Audit dependencies, check licenses, and detect duplicate crates
deny = craneLib.cargoDeny (commonArgs
// {
# advisories excluded: needs network access (blocked by nix sandbox)
cargoDenyChecks = "bans licenses sources";
});
}
// staticMusl;
checks =
{
inherit cmprss;
# Build almost every package in checks, with exceptions:
# - coverage: It requires a full rebuild, and only needs to be run occasionally
inherit (self.packages.${system}) clippy doc fmt test deny;
}
// linters;
# This also sets up `nix fmt` to run all formatters
treefmt = {
projectRootFile = "./flake.nix";
programs = {
alejandra.enable = true;
prettier.enable = true;
rustfmt.enable = true;
shfmt.enable = true;
typos = {
enable = true;
configFile = "./.config/typos.toml";
};
};
};
apps = rec {
default = cmprss;
cmprss.program = self.packages.${system}.cmprss;
};
overlayAttrs = {
inherit (config.packages) cmprss;
};
devShells.default = pkgs.mkShell {
name = "cmprss";
shellHook = ''
echo ---------------------
just --list
echo ---------------------
'';
# Include the packages from the defined checks and packages
# Installs the full cargo toolchain and the extra tools, e.g. cargo-tarpaulin.
inputsFrom =
(builtins.attrValues self.checks.${system})
++ (builtins.attrValues self.packages.${system});
# Extra inputs can be added here
packages = with pkgs; [
act # For running Github Actions locally
alejandra
actionlint
deadnix
git-cliff
gum # Pretty printing in scripts
just
nodePackages.prettier
shellcheck
statix
typos
# For running tests
diffutils
# Official tools
brotli
bzip2
gnutar
gzip
lz4
p7zip
snzip
unzip
xz
zip
zstd
];
# Many tools read this to find the sources for rust stdlib
RUST_SRC_PATH = "${rustSrc}/lib/rustlib/src/rust/library";
};
};
};
}