Merge master into staging-next

.github/workflows/direct-push.yml

···
+name: "Direct Push Warning"
+on:
+  push:
+    branches:
+     - master
+     - release-**
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    if: github.repository_owner == 'NixOS'
+    env:
+      GITHUB_SHA: ${{ github.sha }}
+      GITHUB_REPOSITORY: ${{ github.repository }}
+    steps:
+    - name: Check if commit is a merge commit
+      id: ismerge
+      run: |
+        ISMERGE=$(curl -H 'Accept: application/vnd.github.groot-preview+json' -H "authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" https://api.github.com/repos/${{ env.GITHUB_REPOSITORY }}/commits/${{ env.GITHUB_SHA }}/pulls | jq -r '.[] | select(.merge_commit_sha == "${{ env.GITHUB_SHA }}") | any')
+        echo "::set-output name=ismerge::$ISMERGE"
+    - name: Warn if the commit was a direct push
+      if: steps.ismerge.outputs.ismerge != 'true'
+      uses: peter-evans/commit-comment@v1
+      with:
+        body: |
+          @${{ github.actor }}, you pushed a commit directly to master/release branch
+          instead of going through a Pull Request.
+
+          That's highly discouraged beyond the few exceptions listed
+          on https://github.com/NixOS/nixpkgs/issues/118661

maintainers/maintainer-list.nix

···
     githubId = 786394;
     name = "Alexander Krupenkin ";
   };
+  akshgpt7 = {
+    email = "[e-mail]";
+    github = "akshgpt7";
+    githubId = 20405311;
+    name = "Aksh Gupta";
+  };
   albakham = {
     email = "[e-mail]";
     github = "albakham";
···
     github = "jansol";
     githubId = 2588851;
     name = "Jan Solanti";
+  };
+  jappie = {
+    email = "[e-mail]";
+    github = "jappeace";
+    githubId = 3874017;
+    name = "Jappie Klooster";
   };
   javaguirre = {
     email = "[e-mail]";
···
     email = "[e-mail]";
     github = "pulsation";
     githubId = 1838397;
+  };
+  zane = {
+    name = "Zane van Iperen";
+    email = "[e-mail]";
+    github = "vs49688";
+    githubId = 4423262;
+    keys = [{
+      longkeyid = "rsa4096/0x68616B2D8AC4DCC5";
+      fingerprint = "61AE D40F 368B 6F26 9DAE  3892 6861 6B2D 8AC4 DCC5";
+    }];
   };
   zseri = {
     name = "zseri";

nixos/modules/module-list.nix

···
   ./services/networking/nar-serve.nix
   ./services/networking/nat.nix
   ./services/networking/ndppd.nix
+  ./services/networking/nebula.nix
   ./services/networking/networkmanager.nix
   ./services/networking/nextdns.nix
   ./services/networking/nftables.nix

nixos/modules/services/networking/nebula.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+
+  cfg = config.services.nebula;
+  enabledNetworks = filterAttrs (n: v: v.enable) cfg.networks;
+
+  format = pkgs.formats.yaml {};
+
+  nameToId = netName: "nebula-${netName}";
+in
+{
+  # Interface
+
+  options = {
+    services.nebula = {
+      networks = mkOption {
+        description = "Nebula network definitions.";
+        default = {};
+        type = types.attrsOf (types.submodule {
+          options = {
+            enable = mkOption {
+              type = types.bool;
+              default = true;
+              description = "Enable or disable this network.";
+            };
+
+            package = mkOption {
+              type = types.package;
+              default = pkgs.nebula;
+              defaultText = "pkgs.nebula";
+              description = "Nebula derivation to use.";
+            };
+
+            ca = mkOption {
+              type = types.path;
+              description = "Path to the certificate authority certificate.";
+              example = "/etc/nebula/ca.crt";
+            };
+
+            cert = mkOption {
+              type = types.path;
+              description = "Path to the host certificate.";
+              example = "/etc/nebula/host.crt";
+            };
+
+            key = mkOption {
+              type = types.path;
+              description = "Path to the host key.";
+              example = "/etc/nebula/host.key";
+            };
+
+            staticHostMap = mkOption {
+              type = types.attrsOf (types.listOf (types.str));
+              default = {};
+              description = ''
+                The static host map defines a set of hosts with fixed IP addresses on the internet (or any network).
+                A host can have multiple fixed IP addresses defined here, and nebula will try each when establishing a tunnel.
+              '';
+              example = literalExample ''
+                { "192.168.100.1" = [ "100.64.22.11:4242" ]; }
+              '';
+            };
+
+            isLighthouse = mkOption {
+              type = types.bool;
+              default = false;
+              description = "Whether this node is a lighthouse.";
+            };
+
+            lighthouses = mkOption {
+              type = types.listOf types.str;
+              default = [];
+              description = ''
+                List of IPs of lighthouse hosts this node should report to and query from. This should be empty on lighthouse
+                nodes. The IPs should be the lighthouse's Nebula IPs, not their external IPs.
+              '';
+              example = ''[ "192.168.100.1" ]'';
+            };
+
+            listen.host = mkOption {
+              type = types.str;
+              default = "0.0.0.0";
+              description = "IP address to listen on.";
+            };
+
+            listen.port = mkOption {
+              type = types.port;
+              default = 4242;
+              description = "Port number to listen on.";
+            };
+
+            tun.disable = mkOption {
+              type = types.bool;
+              default = false;
+              description = ''
+                When tun is disabled, a lighthouse can be started without a local tun interface (and therefore without root).
+              '';
+            };
+
+            tun.device = mkOption {
+              type = types.nullOr types.str;
+              default = null;
+              description = "Name of the tun device. Defaults to nebula.\${networkName}.";
+            };
+
+            firewall.outbound = mkOption {
+              type = types.listOf types.attrs;
+              default = [];
+              description = "Firewall rules for outbound traffic.";
+              example = ''[ { port = "any"; proto = "any"; host = "any"; } ]'';
+            };
+
+            firewall.inbound = mkOption {
+              type = types.listOf types.attrs;
+              default = [];
+              description = "Firewall rules for inbound traffic.";
+              example = ''[ { port = "any"; proto = "any"; host = "any"; } ]'';
+            };
+
+            settings = mkOption {
+              type = format.type;
+              default = {};
+              description = ''
+                Nebula configuration. Refer to
+                <link xlink:href="https://github.com/slackhq/nebula/blob/master/examples/config.yml"/>
+                for details on supported values.
+              '';
+              example = literalExample ''
+                {
+                  lighthouse.dns = {
+                    host = "0.0.0.0";
+                    port = 53;
+                  };
+                }
+              '';
+            };
+          };
+        });
+      };
+    };
+  };
+
+  # Implementation
+  config = mkIf (enabledNetworks != {}) {
+    systemd.services = mkMerge (mapAttrsToList (netName: netCfg:
+      let
+        networkId = nameToId netName;
+        settings = recursiveUpdate {
+          pki = {
+            ca = netCfg.ca;
+            cert = netCfg.cert;
+            key = netCfg.key;
+          };
+          static_host_map = netCfg.staticHostMap;
+          lighthouse = {
+            am_lighthouse = netCfg.isLighthouse;
+            hosts = netCfg.lighthouses;
+          };
+          listen = {
+            host = netCfg.listen.host;
+            port = netCfg.listen.port;
+          };
+          tun = {
+            disabled = netCfg.tun.disable;
+            dev = if (netCfg.tun.device != null) then netCfg.tun.device else "nebula.${netName}";
+          };
+          firewall = {
+            inbound = netCfg.firewall.inbound;
+            outbound = netCfg.firewall.outbound;
+          };
+        } netCfg.settings;
+        configFile = format.generate "nebula-config-${netName}.yml" settings;
+        in
+        {
+          # Create systemd service for Nebula.
+          "nebula@${netName}" = {
+            description = "Nebula VPN service for ${netName}";
+            wants = [ "basic.target" ];
+            after = [ "basic.target" "network.target" ];
+            before = [ "sshd.service" ];
+            wantedBy = [ "multi-user.target" ];
+            serviceConfig = mkMerge [
+              {
+                Type = "simple";
+                Restart = "always";
+                ExecStart = "${netCfg.package}/bin/nebula -config ${configFile}";
+              }
+              # The service needs to launch as root to access the tun device, if it's enabled.
+              (mkIf netCfg.tun.disable {
+                User = networkId;
+                Group = networkId;
+              })
+            ];
+          };
+        }) enabledNetworks);
+
+    # Open the chosen ports for UDP.
+    networking.firewall.allowedUDPPorts =
+      unique (mapAttrsToList (netName: netCfg: netCfg.listen.port) enabledNetworks);
+
+    # Create the service users and groups.
+    users.users = mkMerge (mapAttrsToList (netName: netCfg:
+      mkIf netCfg.tun.disable {
+        ${nameToId netName} = {
+          group = nameToId netName;
+          description = "Nebula service user for network ${netName}";
+          isSystemUser = true;
+        };
+      }) enabledNetworks);
+
+    users.groups = mkMerge (mapAttrsToList (netName: netCfg:
+      mkIf netCfg.tun.disable {
+        ${nameToId netName} = {};
+      }) enabledNetworks);
+  };
+}

nixos/tests/all-tests.nix

···
   nat.standalone = handleTest ./nat.nix { withFirewall = false; };
   ncdns = handleTest ./ncdns.nix {};
   ndppd = handleTest ./ndppd.nix {};
+  nebula = handleTest ./nebula.nix {};
   neo4j = handleTest ./neo4j.nix {};
   netdata = handleTest ./netdata.nix {};
   networking.networkd = handleTest ./networking.nix { networkd = true; };

nixos/tests/nebula.nix

···
+import ./make-test-python.nix ({ pkgs, lib, ... }: let
+
+  # We'll need to be able to trade cert files between nodes via scp.
+  inherit (import ./ssh-keys.nix pkgs)
+    snakeOilPrivateKey snakeOilPublicKey;
+
+  makeNebulaNode = { config, ... }: name: extraConfig: lib.mkMerge [
+    {
+      # Expose nebula for doing cert signing.
+      environment.systemPackages = [ pkgs.nebula ];
+      users.users.root.openssh.authorizedKeys.keys = [ snakeOilPublicKey ];
+      services.openssh.enable = true;
+
+      services.nebula.networks.smoke = {
+        # Note that these paths won't exist when the machine is first booted.
+        ca = "/etc/nebula/ca.crt";
+        cert = "/etc/nebula/${name}.crt";
+        key = "/etc/nebula/${name}.key";
+        listen = { host = "0.0.0.0"; port = 4242; };
+      };
+    }
+    extraConfig
+  ];
+
+in
+{
+  name = "nebula";
+
+  nodes = {
+
+    lighthouse = { ... } @ args:
+      makeNebulaNode args "lighthouse" {
+        networking.interfaces.eth1.ipv4.addresses = [{
+          address = "192.168.1.1";
+          prefixLength = 24;
+        }];
+
+        services.nebula.networks.smoke = {
+          isLighthouse = true;
+          firewall = {
+            outbound = [ { port = "any"; proto = "any"; host = "any"; } ];
+            inbound = [ { port = "any"; proto = "any"; host = "any"; } ];
+          };
+        };
+      };
+
+    node2 = { ... } @ args:
+      makeNebulaNode args "node2" {
+        networking.interfaces.eth1.ipv4.addresses = [{
+          address = "192.168.1.2";
+          prefixLength = 24;
+        }];
+
+        services.nebula.networks.smoke = {
+          staticHostMap = { "10.0.100.1" = [ "192.168.1.1:4242" ]; };
+          isLighthouse = false;
+          lighthouses = [ "10.0.100.1" ];
+          firewall = {
+            outbound = [ { port = "any"; proto = "any"; host = "any"; } ];
+            inbound = [ { port = "any"; proto = "any"; host = "any"; } ];
+          };
+        };
+      };
+
+    node3 = { ... } @ args:
+      makeNebulaNode args "node3" {
+        networking.interfaces.eth1.ipv4.addresses = [{
+          address = "192.168.1.3";
+          prefixLength = 24;
+        }];
+
+        services.nebula.networks.smoke = {
+          staticHostMap = { "10.0.100.1" = [ "192.168.1.1:4242" ]; };
+          isLighthouse = false;
+          lighthouses = [ "10.0.100.1" ];
+          firewall = {
+            outbound = [ { port = "any"; proto = "any"; host = "any"; } ];
+            inbound = [ { port = "any"; proto = "any"; host = "lighthouse"; } ];
+          };
+        };
+      };
+
+    node4 = { ... } @ args:
+      makeNebulaNode args "node4" {
+        networking.interfaces.eth1.ipv4.addresses = [{
+          address = "192.168.1.4";
+          prefixLength = 24;
+        }];
+
+        services.nebula.networks.smoke = {
+          enable = true;
+          staticHostMap = { "10.0.100.1" = [ "192.168.1.1:4242" ]; };
+          isLighthouse = false;
+          lighthouses = [ "10.0.100.1" ];
+          firewall = {
+            outbound = [ { port = "any"; proto = "any"; host = "lighthouse"; } ];
+            inbound = [ { port = "any"; proto = "any"; host = "any"; } ];
+          };
+        };
+      };
+
+    node5 = { ... } @ args:
+      makeNebulaNode args "node5" {
+        networking.interfaces.eth1.ipv4.addresses = [{
+          address = "192.168.1.5";
+          prefixLength = 24;
+        }];
+
+        services.nebula.networks.smoke = {
+          enable = false;
+          staticHostMap = { "10.0.100.1" = [ "192.168.1.1:4242" ]; };
+          isLighthouse = false;
+          lighthouses = [ "10.0.100.1" ];
+          firewall = {
+            outbound = [ { port = "any"; proto = "any"; host = "lighthouse"; } ];
+            inbound = [ { port = "any"; proto = "any"; host = "any"; } ];
+          };
+        };
+      };
+
+  };
+
+  testScript = let
+
+    setUpPrivateKey = name: ''
+    ${name}.succeed(
+        "mkdir -p /root/.ssh",
+        "chown 700 /root/.ssh",
+        "cat '${snakeOilPrivateKey}' > /root/.ssh/id_snakeoil",
+        "chown 600 /root/.ssh/id_snakeoil",
+    )
+    '';
+
+    # From what I can tell, StrictHostKeyChecking=no is necessary for ssh to work between machines.
+    sshOpts = "-oStrictHostKeyChecking=no -oUserKnownHostsFile=/dev/null -oIdentityFile=/root/.ssh/id_snakeoil";
+
+    restartAndCheckNebula = name: ip: ''
+      ${name}.systemctl("restart [e-mail]")
+      ${name}.succeed("ping -c5 ${ip}")
+    '';
+
+    # Create a keypair on the client node, then use the public key to sign a cert on the lighthouse.
+    signKeysFor = name: ip: ''
+      lighthouse.wait_for_unit("sshd.service")
+      ${name}.wait_for_unit("sshd.service")
+      ${name}.succeed(
+          "mkdir -p /etc/nebula",
+          "nebula-cert keygen -out-key /etc/nebula/${name}.key -out-pub /etc/nebula/${name}.pub",
+          "scp ${sshOpts} /etc/nebula/${name}.pub 192.168.1.1:/tmp/${name}.pub",
+      )
+      lighthouse.succeed(
+          'nebula-cert sign -ca-crt /etc/nebula/ca.crt -ca-key /etc/nebula/ca.key -name "${name}" -groups "${name}" -ip "${ip}" -in-pub /tmp/${name}.pub -out-crt /tmp/${name}.crt',
+      )
+      ${name}.succeed(
+          "scp ${sshOpts} 192.168.1.1:/tmp/${name}.crt /etc/nebula/${name}.crt",
+          "scp ${sshOpts} 192.168.1.1:/etc/nebula/ca.crt /etc/nebula/ca.crt",
+      )
+    '';
+
+  in ''
+    start_all()
+
+    # Create the certificate and sign the lighthouse's keys.
+    ${setUpPrivateKey "lighthouse"}
+    lighthouse.succeed(
+        "mkdir -p /etc/nebula",
+        'nebula-cert ca -name "Smoke Test" -out-crt /etc/nebula/ca.crt -out-key /etc/nebula/ca.key',
+        'nebula-cert sign -ca-crt /etc/nebula/ca.crt -ca-key /etc/nebula/ca.key -name "lighthouse" -groups "lighthouse" -ip "10.0.100.1/24" -out-crt /etc/nebula/lighthouse.crt -out-key /etc/nebula/lighthouse.key',
+    )
+
+    # Reboot the lighthouse and verify that the nebula service comes up on boot.
+    # Since rebooting takes a while, we'll just restart the service on the other nodes.
+    lighthouse.shutdown()
+    lighthouse.start()
+    lighthouse.wait_for_unit("[e-mail]")
+    lighthouse.succeed("ping -c5 10.0.100.1")
+
+    # Create keys for node2's nebula service and test that it comes up.
+    ${setUpPrivateKey "node2"}
+    ${signKeysFor "node2" "10.0.100.2/24"}
+    ${restartAndCheckNebula "node2" "10.0.100.2"}
+
+    # Create keys for node3's nebula service and test that it comes up.
+    ${setUpPrivateKey "node3"}
+    ${signKeysFor "node3" "10.0.100.3/24"}
+    ${restartAndCheckNebula "node3" "10.0.100.3"}
+
+    # Create keys for node4's nebula service and test that it comes up.
+    ${setUpPrivateKey "node4"}
+    ${signKeysFor "node4" "10.0.100.4/24"}
+    ${restartAndCheckNebula "node4" "10.0.100.4"}
+
+    # Create keys for node4's nebula service and test that it does not come up.
+    ${setUpPrivateKey "node5"}
+    ${signKeysFor "node5" "10.0.100.5/24"}
+    node5.fail("systemctl status [e-mail]")
+    node5.fail("ping -c5 10.0.100.5")
+
+    # The lighthouse can ping node2 and node3 but not node5
+    lighthouse.succeed("ping -c3 10.0.100.2")
+    lighthouse.succeed("ping -c3 10.0.100.3")
+    lighthouse.fail("ping -c3 10.0.100.5")
+
+    # node2 can ping the lighthouse, but not node3 because of its inbound firewall
+    node2.succeed("ping -c3 10.0.100.1")
+    node2.fail("ping -c3 10.0.100.3")
+
+    # node3 can ping the lighthouse and node2
+    node3.succeed("ping -c3 10.0.100.1")
+    node3.succeed("ping -c3 10.0.100.2")
+
+    # node4 can ping the lighthouse but not node2 or node3
+    node4.succeed("ping -c3 10.0.100.1")
+    node4.fail("ping -c3 10.0.100.2")
+    node4.fail("ping -c3 10.0.100.3")
+
+    # node2 can ping node3 now that node3 pinged it first
+    node2.succeed("ping -c3 10.0.100.3")
+    # node4 can ping node2 if node2 pings it first
+    node2.succeed("ping -c3 10.0.100.4")
+    node4.succeed("ping -c3 10.0.100.2")
+  '';
+})

pkgs/applications/editors/neovim/wrapper.nix

···
 { stdenv, symlinkJoin, lib, makeWrapper
-, vimUtils
 , writeText
 , bundlerEnv, ruby
 , nodejs

pkgs/applications/networking/cluster/k3s/default.nix

···
 # Those pieces of software we entirely ignore upstream's handling of, and just
 # make sure they're in the path if desired.
 let
-  k3sVersion = "1.20.5+k3s1";     # k3s git tag
+  k3sVersion = "1.20.6+k3s1";     # k3s git tag
   traefikChartVersion = "1.81.0"; # taken from ./scripts/download at the above k3s tag
   k3sRootVersion = "0.8.1";       # taken from ./scripts/download at the above k3s tag
   k3sCNIVersion = "0.8.6-k3s1";   # taken from ./scripts/version.sh at the above k3s tag
···
     url = "https://github.com/k3s-io/k3s";
     rev = "v${k3sVersion}";
     leaveDotGit = true; # ./scripts/version.sh depends on git
-    sha256 = "sha256-7RAZkSTh15BEZ3p6u2xE9vd5fpy4KBYrl2TjtpIiStM=";
+    sha256 = "sha256-IIZotJKQ/+WNmfcEJU5wFtZBufWjUp4MeVCRk4tSjyQ=";
   };
   # Stage 1 of the k3s build:
   # Let's talk about how k3s is structured.

pkgs/applications/networking/instant-messengers/zoom-us/default.nix

···
 , atk
 , cairo
 , dbus
+, dpkg
 , libGL
 , fontconfig
 , freetype
···
 assert pulseaudioSupport -> libpulseaudio != null;
 
 let
-  version = "5.6.13632.0328";
+  version = "5.6.16775.0418";
   srcs = {
     x86_64-linux = fetchurl {
-      url = "https://zoom.us/client/${version}/zoom_x86_64.pkg.tar.xz";
-      sha256 = "0nskpg3rbv40jcbih95sfdr0kfv5hjv50z9jdz1cddl8v7hbqg71";
+      url = "https://zoom.us/client/${version}/zoom_amd64.deb";
+      sha256 = "1fmzwxq8jv5k1b2kvg1ij9g6cdp1hladd8vm3cxzd8fywdjcndim";
     };
   };
 
···
   inherit version;
   src = srcs.${stdenv.hostPlatform.system};
 
-  dontUnpack = true;
-
   nativeBuildInputs = [
+    dpkg
     makeWrapper
   ];
 
+  unpackCmd = ''
+    mkdir out
+    dpkg -x $curSrc out
+  '';
+
   installPhase = ''
     runHook preInstall
     mkdir $out
-    tar -C $out -xf ${src}
-    mv $out/usr/* $out/
+    mv usr/* $out/
+    mv opt $out/
     runHook postInstall
   '';
 

pkgs/applications/networking/mailreaders/himalaya/default.nix

···
+{ lib
+, stdenv
+, rustPlatform
+, fetchFromGitHub
+, openssl
+, pkg-config
+, installShellFiles
+, enableCompletions ? stdenv.hostPlatform == stdenv.buildPlatform
+, Security
+, libiconv
+}:
+rustPlatform.buildRustPackage rec {
+  pname = "himalaya";
+  version = "0.2.6";
+
+  src = fetchFromGitHub {
+    owner = "soywod";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "1fl3lingb4wdh6bz4calzbibixg44wnnwi1qh0js1ijp8b6ll560";
+  };
+
+  cargoSha256 = "10p8di71w7hn36b1994wgk33fnj641lsp80zmccinlg5fiwyzncx";
+
+  nativeBuildInputs = [ ]
+    ++ lib.optionals (enableCompletions) [ installShellFiles ]
+    ++ lib.optionals (!stdenv.hostPlatform.isDarwin) [ pkg-config ];
+
+  buildInputs =
+    if stdenv.hostPlatform.isDarwin then [
+      Security
+      libiconv
+    ] else [
+      openssl
+    ];
+
+  # The completions are correctly installed, and there is issue that himalaya
+  # generate empty completion files without mail configure.
+  # This supposed to be fixed in 0.2.7
+  postInstall = lib.optionalString enableCompletions ''
+    # Install shell function
+    installShellCompletion --cmd himalaya \
+      --bash <($out/bin/himalaya completion bash) \
+      --fish <($out/bin/himalaya completion fish) \
+      --zsh <($out/bin/himalaya completion zsh)
+  '';
+
+  meta = with lib; {
+    description = "CLI email client written in Rust";
+    homepage = "https://github.com/soywod/himalaya";
+    license = licenses.bsd3;
+    maintainers = with maintainers; [ yanganto ];
+  };
+}

pkgs/applications/science/electronics/kicad/default.nix

···
     in
     (concatStringsSep "\n"
       (flatten [
+        "runHook preInstall"
+
         (optionalString (withScripting) "buildPythonPath \"${base} $pythonPath\" \n")
 
         # wrap each of the directly usable tools
···
 
         # link in the CLI utils
         (map (util: "ln -s ${base}/bin/${util} $out/bin/${util}") utils)
+
+        "runHook postInstall"
       ])
     )
   ;
 
+  postInstall = ''
+    mkdir -p $out/share
+    ln -s ${base}/share/applications $out/share/applications
+    ln -s ${base}/share/icons $out/share/icons
+    ln -s ${base}/share/mime $out/share/mime
+  '';
+
   # can't run this for each pname
   # stable and unstable are in the same versions.nix
   # and kicad-small reuses stable
···
       KiCad is an open source software suite for Electronic Design Automation.
       The Programs handle Schematic Capture, and PCB Layout with Gerber output.
     '';
-    license = lib.licenses.agpl3;
+    license = lib.licenses.gpl3Plus;
     # berce seems inactive...
     maintainers = with lib.maintainers; [ evils kiwi berce ];
     # kicad is cross platform

pkgs/applications/science/logic/beluga/default.nix

···
 { lib, fetchFromGitHub, ocamlPackages, rsync }:
 
-ocamlPackages.buildDunePackage {
+ocamlPackages.buildDunePackage rec {
   pname = "beluga";
-  version = "unstable-2020-03-11";
+  version = "1.0";
 
   src = fetchFromGitHub {
     owner  = "Beluga-lang";
     repo   = "Beluga";
-    rev    = "6133b2f572219333f304bb4f77c177592324c55b";
-    sha256 = "0sy6mi50z3mvs5z7dx38piydapk89all81rh038x3559b5fsk68q";
+    rev    = "v${version}";
+    sha256 = "1ziqjfv8jwidl8lj2mid2shhgqhv31dfh5wad2zxjpvf6038ahsw";
   };
 
   useDune2 = true;

pkgs/applications/version-management/git-and-tools/git-interactive-rebase-tool/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "git-interactive-rebase-tool";
-  version = "2.0.0";
+  version = "2.1.0";
 
   src = fetchFromGitHub {
     owner = "MitMaro";
     repo = pname;
     rev = version;
-    sha256 = "117zwxyq2vc33nbnfpjbdr5vc2l5ymf6ln1dm5551ha3y3gdq3bf";
+    sha256 = "sha256-DYl/GUbeNtKmXoR3gq8mK8EfsZNVNlrdngAwfzG+epw=";
   };
 
-  cargoSha256 = "051llwk9swq03xdqwyj0hlyv2ywq2f1cnks95nygyy393q7v930x";
+  cargoSha256 = "sha256-1joMWPfn0s+pLsO6NHMT6AoXZ33R8MY2AWSrROY2mw8=";
 
   buildInputs = lib.optionals stdenv.isDarwin [ libiconv Security ];
 
-  # external_editor::tests::* tests fail
-  doCheck = false;
+  checkFlags = [
+    "--skip=external_editor::tests::edit_success"
+    "--skip=external_editor::tests::editor_non_zero_exit"
+    "--skip=external_editor::tests::empty_edit_abort_rebase"
+    "--skip=external_editor::tests::empty_edit_error"
+    "--skip=external_editor::tests::empty_edit_noop"
+    "--skip=external_editor::tests::empty_edit_re_edit_rebase_file"
+    "--skip=external_editor::tests::empty_edit_undo_and_edit"
+  ];
 
   meta = with lib; {
     homepage = "https://github.com/MitMaro/git-interactive-rebase-tool";

pkgs/applications/video/jellyfin-media-player/default.nix

···
   meta = with lib; {
     homepage = "https://github.com/jellyfin/jellyfin-media-player";
     description = "Jellyfin Desktop Client based on Plex Media Player";
-    license = with licenses; [ gpl2Plus mit ];
+    license = with licenses; [ gpl2Only mit ];
     platforms = [ "x86_64-linux" "x86_64-darwin" ];
     maintainers = with maintainers; [ jojosch ];
   };

pkgs/applications/video/mpv/scripts/autoload.nix

···
-{ stdenv, fetchurl, mpv-unwrapped, lib }:
+{ stdenvNoCC, mpv-unwrapped, lib }:
 
-stdenv.mkDerivation rec {
+stdenvNoCC.mkDerivation rec {
   pname = "mpv-autoload";
   version = mpv-unwrapped.version;
   src = "${mpv-unwrapped.src.outPath}/TOOLS/lua/autoload.lua";

pkgs/applications/video/mpv/scripts/convert.nix

···
-{ stdenv, fetchgit, lib
+{ stdenvNoCC, fetchgit, lib
 , yad, mkvtoolnix-cli, libnotify }:
 
-stdenv.mkDerivation {
+stdenvNoCC.mkDerivation {
   pname = "mpv-convert-script";
   version = "2016-03-18";
   src = fetchgit {
···
   '';
   passthru.scriptName = "convert_script.lua";
 
-  meta = {
+  meta = with lib; {
     description = "Convert parts of a video while you are watching it in mpv";
     homepage = "https://gist.github.com/Zehkul/25ea7ae77b30af959be0";
-    maintainers = [ lib.maintainers.Profpatsch ];
+    maintainers = [ maintainers.Profpatsch ];
     longDescription = ''
       When this script is loaded into mpv, you can hit Alt+W to mark the beginning
       and Alt+W again to mark the end of the clip. Then a settings window opens.
     '';
+    license = licenses.unfree;
+    # script crashes mpv. See https://github.com/NixOS/nixpkgs/issues/113202
+    broken = true;
   };
 }
 

pkgs/applications/video/mpv/scripts/mpvacious.nix

···
-{ lib, stdenv, fetchFromGitHub, curl, xclip }:
+{ lib, stdenvNoCC, fetchFromGitHub, curl, xclip }:
 
-stdenv.mkDerivation rec {
+stdenvNoCC.mkDerivation rec {
   pname = "mpvacious";
   version = "0.14";
 

pkgs/applications/video/mpv/scripts/simple-mpv-webui.nix

···
-{ lib, stdenv
+{ lib, stdenvNoCC
 , fetchFromGitHub }:
-stdenv.mkDerivation rec {
+stdenvNoCC.mkDerivation rec {
   pname = "simple-mpv-ui";
   version = "1.0.0";
 

pkgs/applications/video/mpv/scripts/sponsorblock.nix

···
-{ lib, stdenv, fetchFromGitHub, fetchpatch, python3 }:
+{ lib, stdenvNoCC, fetchFromGitHub, fetchpatch, python3 }:
 
 # Usage: `pkgs.mpv.override { scripts = [ pkgs.mpvScripts.sponsorblock ]; }`
-stdenv.mkDerivation {
+stdenvNoCC.mkDerivation {
   pname = "mpv_sponsorblock";
   version = "unstable-2020-07-05";
 

pkgs/applications/video/mpv/scripts/thumbnail.nix

···
-{ fetchFromGitHub, lib, python3, stdenv }:
+{ fetchFromGitHub, lib, python3, stdenvNoCC }:
 
-stdenv.mkDerivation rec {
+stdenvNoCC.mkDerivation rec {
   pname = "mpv_thumbnail_script";
   version = "unstable-2020-01-16";
 

pkgs/development/libraries/SDL2/default.nix

···
 , libGLSupported ? lib.elem stdenv.hostPlatform.system lib.platforms.mesaPlatforms
 , openglSupport ? libGLSupported, libGL
 , alsaSupport ? stdenv.isLinux && !stdenv.hostPlatform.isAndroid, alsaLib
-, x11Support ? !stdenv.isCygwin && !stdenv.hostPlatform.isAndroid
+, x11Support ? !stdenv.targetPlatform.isWindows && !stdenv.hostPlatform.isAndroid
 , libX11, xorgproto, libICE, libXi, libXScrnSaver, libXcursor
 , libXinerama, libXext, libXxf86vm, libXrandr
 , waylandSupport ? stdenv.isLinux && !stdenv.hostPlatform.isAndroid
···
     "--disable-oss"
   ] ++ optional (!x11Support) "--without-x"
     ++ optional alsaSupport "--with-alsa-prefix=${alsaLib.out}/lib"
+    ++ optional stdenv.targetPlatform.isWindows "--disable-video-opengles"
     ++ optional stdenv.isDarwin "--disable-sdltest";
 
   # We remove libtool .la files when static libs are requested,

pkgs/development/libraries/cxxopts/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "cxxopts";
-  version = "2.2.1";
+  version = "unstable-2020-12-14";
 
   src = fetchFromGitHub {
     owner = "jarro2783";
     repo = name;
-    rev = "v${version}";
-    sha256 = "0d3y747lsh1wkalc39nxd088rbypxigm991lk3j91zpn56whrpha";
+    rev = "2d8e17c4f88efce80e274cb03eeb902e055a91d3";
+    sha256 = "0pwrac81zfqjs17g3hx8r3ds2xf04npb6mz111qjy4bx17314ib7";
   };
 
   buildInputs = lib.optional enableUnicodeHelp [ icu.dev ];

pkgs/development/libraries/iodash/0001-Add-cmake-install-directives.patch

···
+From 89c7c160f897f64e17fb74efffccfd1fc16f8b7d Mon Sep 17 00:00:00 2001
+From: Jappie Klooster <[e-mail]>
+Date: Fri, 2 Apr 2021 14:22:02 -0400
+Subject: [PATCH] Add cmake install directives.
+
+To make nix builds work, it expect a `make install` command to
+be available.
+Adding these directives seems to fix the build.
+
+If it's no trouble to you, please add them.
+
+Maybe don't need endian
+---
+ CMakeLists.txt | 10 ++++++++++
+ 1 file changed, 10 insertions(+)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 06e416f..8d6f489 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -6,6 +6,8 @@ set(CMAKE_CXX_STANDARD 17)
+ add_library(IODash INTERFACE)
+ target_include_directories(IODash INTERFACE .)
+ 
++include(GNUInstallDirs)
++
+ add_executable(IODash_Test test.cpp)
+ target_link_libraries(IODash_Test IODash)
+ 
+@@ -20,3 +22,11 @@ if (DEFINED BUILD_BENCHMARKS AND (${BUILD_BENCHMARKS}))
+     target_link_libraries(boost_Benchmark_HTTP boost_system pthread)
+ endif()
+ 
++install(TARGETS IODash
++        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
++install(FILES IODash.hpp
++        DESTINATION include/)
++
++install(FILES
++        IODash/Buffer.hpp IODash/SocketAddress.hpp IODash/File.hpp IODash/Socket.hpp IODash/EventLoop.hpp IODash/Serial.hpp IODash/Timer.hpp
++        DESTINATION include/IODash)
+-- 
+2.29.2
+

pkgs/development/libraries/iodash/default.nix

···
+{ lib, stdenv, fetchFromGitHub, cmake, pkg-config }:
+
+stdenv.mkDerivation rec {
+  pname = "iodash";
+  version = "0.1.7";
+
+  src  = fetchFromGitHub {
+    owner  = "YukiWorkshop";
+    repo   = "IODash";
+    rev    = "9dcb26621a9c17dbab704b5bab0c3a5fc72624cb";
+    sha256 = "0db5y2206fwh3h1pzjm9hy3m76inm0xpm1c5gvrladz6hiqfp7bx";
+    fetchSubmodules = true;
+  };
+  # adds missing cmake install directives
+  # https://github.com/YukiWorkshop/IODash/pull/2
+  patches = [ ./0001-Add-cmake-install-directives.patch];
+
+  nativeBuildInputs = [ cmake pkg-config ];
+
+  meta = with lib; {
+    homepage = "https://github.com/YukiWorkshop/IODash";
+    description = "Lightweight C++ I/O library for POSIX operation systems";
+    license = licenses.mit;
+    maintainers = with maintainers; [ jappie ];
+    platforms = with platforms; linux;
+  };
+}

pkgs/development/libraries/libconfig/default.nix

···
 
   doCheck = true;
 
+  configureFlags = lib.optional stdenv.targetPlatform.isWindows "--disable-examples";
+
   meta = with lib; {
     homepage = "http://www.hyperrealm.com/libconfig";
     description = "A simple library for processing structured configuration files";
     license = licenses.lgpl3;
     maintainers = [ maintainers.goibhniu ];
-    platforms = platforms.linux ++ platforms.darwin;
+    platforms = with platforms; linux ++ darwin ++ windows;
   };
 }

pkgs/development/libraries/libevdevplus/0001-Add-cmake-install-directives.patch

···
+From 7f208aaf21aa468013fc41e67c32f6a6c8c08249 Mon Sep 17 00:00:00 2001
+From: Jappie Klooster <[e-mail]>
+Date: Fri, 2 Apr 2021 16:01:05 -0400
+Subject: [PATCH] Add cmake install directives
+
+To make nix builds work, it expect a make install command to
+be available.
+Adding these directives seems to fix the build.
+
+If it's no trouble to you, please add them.
+---
+ CMakeLists.txt | 9 ++++++++-
+ 1 file changed, 8 insertions(+), 1 deletion(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index f9db618..425d391 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -4,10 +4,17 @@ project(libevdevPlus)
+ set(SOURCE_FILES
+         evdevPlus.cpp evdevPlus.hpp CommonIncludes.hpp InputEvent.hpp Resource.cpp)
+ 
++include(GNUInstallDirs)
++
+ add_library(evdevPlus ${SOURCE_FILES})
+ target_include_directories(evdevPlus PUBLIC .)
+ 
+ add_executable(evdevPlus_test test.cpp)
+ target_link_libraries(evdevPlus_test evdevPlus)
+ 
+-configure_file(evdevPlus.pc.in evdevPlus.pc @ONLY)
+\ No newline at end of file
++configure_file(evdevPlus.pc.in evdevPlus.pc @ONLY)
++
++install(TARGETS evdevPlus
++        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
++install(FILES evdevPlus.hpp CommonIncludes.hpp InputEvent.hpp
++        DESTINATION include/)
+-- 
+2.29.2
+

pkgs/development/libraries/libevdevplus/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libevdevplus";
-  version = "unstable-2019-10-01";
+  version = "unstable-2021-04-02";
+
+  # adds missing cmake install directives
+  # https://github.com/YukiWorkshop/libevdevPlus/pull/10
+  patches = [ ./0001-Add-cmake-install-directives.patch];
 
   src  = fetchFromGitHub {
     owner  = "YukiWorkshop";
     repo   = "libevdevPlus";
-    rev    = "e863df2ade43e2c7d7748cc33ca27fb3eed325ca";
-    sha256 = "18z6pn4j7fhmwwh0q22ip5nn7sc1hfgwvkdzqhkja60i8cw2cvvj";
+    rev    = "b4d4b3143056424a3da9f0516ca02a47209ef757";
+    sha256 = "09y65s16gch0w7fy1s9yjk9gz3bjzxix36h5wmwww6lkj2i1z3rj";
   };
 
   nativeBuildInputs = [ cmake pkg-config ];

pkgs/development/libraries/libuinputplus/0001-Add-cmake-install-directives.patch

···
+From 265e406e254c8d84016b12b344d8df71d1765dd1 Mon Sep 17 00:00:00 2001
+From: Jappie Klooster <[e-mail]>
+Date: Fri, 2 Apr 2021 16:33:18 -0400
+Subject: [PATCH] Add cmake install directives
+
+To make nix builds work, it expect a make install command to
+be available.
+Adding these directives seems to fix the build.
+
+If it's no trouble to you, please consider adding them.
+---
+ CMakeLists.txt | 8 ++++++++
+ 1 file changed, 8 insertions(+)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index cbfc9c1..948c432 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -7,6 +7,8 @@ set(SOURCE_FILES
+         uInput.cpp uInputSetup.cpp uInputResource.cpp
+         uInput.hpp CommonIncludes.hpp uInputSetup.hpp)
+ 
++include(GNUInstallDirs)
++
+ add_library(uInputPlus ${SOURCE_FILES})
+ target_include_directories(uInputPlus PUBLIC .)
+ 
+@@ -15,3 +17,9 @@ target_link_libraries(uInputPlus_test uInputPlus)
+ 
+ configure_file(uInputPlus.pc.in uInputPlus.pc @ONLY)
+ 
++
++install(TARGETS uInputPlus
++        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
++install(FILES uInput.hpp CommonIncludes.hpp uInputSetup.hpp
++        DESTINATION include/)
++
+-- 
+2.29.2
+

pkgs/development/libraries/libuinputplus/default.nix

···
 { lib, stdenv, fetchFromGitHub, cmake, pkg-config }:
-
 stdenv.mkDerivation rec {
   pname = "libuinputplus";
-  version = "2019-10-01";
+  version = "2021-04-02";
+
+  # adds missing cmake install directives
+  # https://github.com/YukiWorkshop/libuInputPlus/pull/7
+  patches = [ ./0001-Add-cmake-install-directives.patch];
 
   src  = fetchFromGitHub {
     owner  = "YukiWorkshop";
     repo   = "libuInputPlus";
-    rev    = "962f180b4cc670e1f5cc73c2e4d5d196ae52d630";
-    sha256 = "0jy5i7bmjad7hw1qcyjl4swqribp2027s9g3609zwj7lj8z5x0bg";
+    rev    = "f7f18eb339bba61a43f2cad481a9b1a453a66957";
+    sha256 = "0sind2ghhy4h9kfkr5hsmhcq0di4ifwqyv4gac96rgj5mwvs33lp";
   };
 
   nativeBuildInputs = [ cmake pkg-config ];

pkgs/development/libraries/simgear/default.nix

···
 { lib, stdenv, fetchurl, plib, freeglut, xorgproto, libX11, libXext, libXi
 , libICE, libSM, libXt, libXmu, libGLU, libGL, boost, zlib, libjpeg, freealut
-, openscenegraph, openal, expat, cmake, apr
+, openscenegraph, openal, expat, cmake, apr, xz
 , curl
 }:
 let
-  version = "2020.3.6";
+  version = "2020.3.8";
   shortVersion = builtins.substring 0 6 version;
 in
 stdenv.mkDerivation rec {
···
 
   src = fetchurl {
     url = "mirror://sourceforge/flightgear/release-${shortVersion}/${pname}-${version}.tar.bz2";
-    sha256 = "sha256-7D7KRNIffgUr6vwbni1XwW+8GtXwM6vJZ7V6/QLDVmk=";
+    sha256 = "sha256-UXcWV9MPu7c+QlFjrhxtQ6ruAcxuKtewwphu4tt5dWc=";
   };
 
   nativeBuildInputs = [ cmake ];
   buildInputs = [ plib freeglut xorgproto libX11 libXext libXi
                   libICE libSM libXt libXmu libGLU libGL boost zlib libjpeg freealut
-                  openscenegraph openal expat apr curl ];
+                  openscenegraph openal expat apr curl xz ];
 
   meta = with lib; {
     description = "Simulation construction toolkit";

pkgs/development/ocaml-modules/labltk/default.nix

···
-{ stdenv, lib, fetchurl, fetchzip, ocaml, findlib, tcl, tk }:
-
-let OCamlVersionAtLeast = lib.versionAtLeast ocaml.version; in
-
-if !OCamlVersionAtLeast "4.04"
-then throw "labltk is not available for OCaml ${ocaml.version}"
-else
+{ stdenv, lib, makeWrapper, fetchzip, ocaml, findlib, tcl, tk }:
 
-let param =
-  let mkNewParam = { version, sha256 }: {
+let
+ params =
+  let mkNewParam = { version, sha256, rev ? version }: {
     inherit version;
     src = fetchzip {
-      url = "https://github.com/garrigue/labltk/archive/${version}.tar.gz";
+      url = "https://github.com/garrigue/labltk/archive/${rev}.tar.gz";
       inherit sha256;
     };
   }; in
-  let mkOldParam = { version, key, sha256 }: {
-    src = fetchurl {
-      url = "https://forge.ocamlcore.org/frs/download.php/${key}/labltk-${version}.tar.gz";
-      inherit sha256;
-    };
-    inherit version;
-  }; in
  rec {
-  "4.04" = mkOldParam {
-    version = "8.06.2";
-    key = "1628";
-    sha256 = "1p97j9s33axkb4yyl0byhmhlyczqarb886ajpyggizy2br3a0bmk";
-  };
-  "4.05" = mkOldParam {
-    version = "8.06.3";
-    key = "1701";
-    sha256 = "1rka9jpg3kxqn7dmgfsa7pmsdwm16x7cn4sh15ijyyrad9phgdxn";
-  };
-  "4.06" = mkOldParam {
+  "4.06" = mkNewParam {
     version = "8.06.4";
-    key = "1727";
-    sha256 = "0j3rz0zz4r993wa3ssnk5s416b1jhj58l6z2jk8238a86y7xqcii";
+    rev = "labltk-8.06.4";
+    sha256 = "03xwnnnahb2rf4siymzqyqy8zgrx3h26qxjgbp5dh1wdl7n02c7g";
   };
-  "4.07" = mkOldParam {
+  "4.07" = mkNewParam {
     version = "8.06.5";
-    key = "1764";
-    sha256 = "0wgx65y1wkgf22ihpqmspqfp95fqbj3pldhp1p3b1mi8rmc37zwj";
+    rev = "1b71e2c6f3ae6847d3d5e79bf099deb7330fb419";
+    sha256 = "02vchmrm3izrk7daldd22harhgrjhmbw6i1pqw6hmfmrmrypypg2";
   };
   _8_06_7 = mkNewParam {
     version = "8.06.7";
···
     version = "8.06.10";
     sha256 = "06cck7wijq4zdshzhxm6jyl8k3j0zglj2axsyfk6q1sq754zyf4a";
   };
-}.${builtins.substring 0 4 ocaml.version};
+ };
+ param = params . ${lib.versions.majorMinor ocaml.version}
+   or (throw "labltk is not available for OCaml ${ocaml.version}");
 in
 
 stdenv.mkDerivation rec {
   inherit (param) version src;
   name = "ocaml${ocaml.version}-labltk-${version}";
 
-  buildInputs = [ ocaml findlib tcl tk ];
+  buildInputs = [ ocaml findlib tcl tk makeWrapper ];
 
   configureFlags = [ "--use-findlib" "--installbindir" "$(out)/bin" ];
   dontAddPrefix = true;
···
   postInstall = ''
     mkdir -p $OCAMLFIND_DESTDIR/stublibs
     mv $OCAMLFIND_DESTDIR/labltk/dlllabltk.so $OCAMLFIND_DESTDIR/stublibs/
+    for p in $out/bin/*
+    do
+      wrapProgram $p --set CAML_LD_LIBRARY_PATH $OCAMLFIND_DESTDIR/stublibs
+    done
   '';
 
   meta = {

pkgs/development/python-modules/hachoir/default.nix

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, pytestCheckHook
+, urwid
+}:
+
+buildPythonPackage rec {
+  pname = "hachoir";
+  version = "3.1.2";
+
+  src = fetchFromGitHub {
+    owner = "vstinner";
+    repo = pname;
+    rev = version;
+    sha256 = "06544qmmimvaznwcjs8wwfih1frdd7anwcw5z07cf69l8p146p0y";
+  };
+
+  propagatedBuildInputs = [
+    urwid
+  ];
+
+  checkInputs = [
+    pytestCheckHook
+  ];
+
+  pythonImportsCheck = [ "hachoir" ];
+
+  meta = with lib; {
+    description = "Python library to view and edit a binary stream";
+    homepage = "https://hachoir.readthedocs.io/";
+    license = with licenses; [ gpl2Only ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

pkgs/development/python-modules/jellyfin-apiclient-python/default.nix

···
   meta = with lib; {
     homepage = "https://github.com/jellyfin/jellyfin-apiclient-python";
     description = "Python API client for Jellyfin";
-    license = licenses.gpl3;
+    license = licenses.gpl3Only;
     maintainers = with maintainers; [ jojosch ];
   };
 }

pkgs/development/python-modules/pystray/default.nix

···
   meta = with lib; {
     homepage = "https://github.com/moses-palmer/pystray";
     description = "This library allows you to create a system tray icon";
-    license = with licenses; [ gpl3Only lgpl3Only ];
+    license = with licenses; [ gpl3Plus lgpl3Plus ];
     platforms = platforms.linux;
     maintainers = with maintainers; [ jojosch ];
   };

pkgs/development/python-modules/pytube/default.nix

···
 
 buildPythonPackage rec {
   pname = "pytube";
-  version = "10.7.1";
+  version = "10.7.2";
 
   disabled = pythonOlder "3.6";
 
···
     owner = "pytube";
     repo = "pytube";
     rev = "v${version}";
-    sha256 = "sha256-a9MYEQFJXfPXYkWiuZkjt/PGs73Dm5614/Xvv6Nn8RA=";
+    sha256 = "sha256-85pHzfQYyqwX8mQ5msIojM/0FSfeaC12KJw4mXmji3g=";
   };
 
   checkInputs = [

pkgs/development/tools/analysis/radare2/default.nix

···
 { lib
+, fetchpatch
 , stdenv
 , fetchFromGitHub
 , buildPackages
···
 , python3
 , ruby
 , lua
+, capstone
 , useX11 ? false
 , rubyBindings ? false
 , pythonBindings ? false
···
 
   #<generated>
   # DO NOT EDIT! Automatically generated by ./update.py
-  gittap = "5.1.1";
-  gittip = "a86f8077fc148abd6443384362a3717cd4310e64";
-  rev = "5.1.1";
-  version = "5.1.1";
-  sha256 = "0hv9x31iabasj12g8f04incr1rbcdkxi3xnqn3ggp8gl4h6pf2f3";
-  cs_ver = "4.0.2";
-  cs_sha256 = "0y5g74yjyliciawpn16zhdwya7bd3d7b1cccpcccc2wg8vni1k2w";
+  gittap = "5.2.0";
+  gittip = "cf3db945083fb4dab951874e5ec1283128deab11";
+  rev = "5.2.0";
+  version = "5.2.0";
+  sha256 = "08azxfk6mw2vr0x4zbz0612rk7pj4mfz8shrzc9ima77wb52b8sm";
   #</generated>
 in
 stdenv.mkDerivation {
···
     inherit rev sha256;
   };
 
-  postPatch =
-    let
-      capstone = fetchFromGitHub {
-        owner = "aquynh";
-        repo = "capstone";
-        # version from $sourceRoot/shlr/Makefile
-        rev = cs_ver;
-        sha256 = cs_sha256;
-      };
-    in
-    ''
-      mkdir -p build/shlr
-      cp -r ${capstone} capstone-${cs_ver}
-      chmod -R +w capstone-${cs_ver}
-      tar -czvf shlr/capstone-${cs_ver}.tar.gz capstone-${cs_ver}
-    '';
+  patches = [
+    # fix build against openssl, included in next release
+    (fetchpatch {
+      url = "https://github.com/radareorg/radare2/commit/e5e7469b6450c374e0884d35d44824e1a4eb46b4.patch";
+      sha256 = "sha256-xTmMHvUdW7d2QG7d4hlvMgEcegND7pGU745TWGqzY44=";
+    })
+  ];
 
   postInstall = ''
     install -D -m755 $src/binr/r2pm/r2pm $out/bin/r2pm
···
     "--with-sysmagic"
     "--with-syszip"
     "--with-sysxxhash"
+    "--with-syscapstone"
     "--with-openssl"
   ];
 
···
   depsBuildBuild = [ buildPackages.stdenv.cc ];
 
   nativeBuildInputs = [ pkg-config ];
-  buildInputs = [ file readline libusb-compat-0_1 libewf perl zlib openssl libuv ]
-    ++ optional useX11 [ gtkdialog vte gtk2 ]
+  buildInputs = [
+    capstone
+    file
+    readline
+    libusb-compat-0_1
+    libewf
+    perl
+    zlib
+    openssl
+    libuv
+  ] ++ optional useX11 [ gtkdialog vte gtk2 ]
     ++ optional rubyBindings [ ruby ]
     ++ optional pythonBindings [ python3 ]
     ++ optional luaBindings [ lua ];

pkgs/development/tools/analysis/radare2/update.py

···
 def get_repo_info(dirname: str, rev: str) -> Dict[str, str]:
     sha256 = prefetch_github("radare", "radare2", rev)
 
-    cs_ver = None
-    with open(Path(dirname).joinpath("shlr", "Makefile")) as makefile:
-        for l in makefile:
-            match = re.match("CS_VER=(\S+)", l)
-            if match:
-                cs_ver = match.group(1)
-    assert cs_ver is not None
-
-    cs_sha256 = prefetch_github("aquynh", "capstone", cs_ver)
-
     return dict(
         rev=rev,
         sha256=sha256,
         version_commit=git(dirname, "rev-list", "--all", "--count"),
         gittap=git(dirname, "describe", "--tags", "--match", "[0-9]*"),
         gittip=git(dirname, "rev-parse", "HEAD"),
-        cs_ver=cs_ver,
-        cs_sha256=cs_sha256,
     )
 
 
···
   rev = "{info["rev"]}";
   version = "{version}";
   sha256 = "{info["sha256"]}";
-  cs_ver = "{info["cs_ver"]}";
-  cs_sha256 = "{info["cs_sha256"]}";
   #</generated>"""
                     )
                 elif "#</generated>" in l:

pkgs/development/tools/analysis/tflint/default.nix

···
 
 buildGoModule rec {
   pname = "tflint";
-  version = "0.26.0";
+  version = "0.27.0";
 
   src = fetchFromGitHub {
     owner = "terraform-linters";
     repo = pname;
     rev = "v${version}";
-    sha256 = "054g0lr0r1xzbss4b4j9ixkls9p1llmw61afib1381z4k0lvzgwn";
+    sha256 = "1s49a3yihfkd8ib336a29ch53mpcyxzicglss7bqmqapv6zi37dg";
   };
 
-  vendorSha256 = "0j2avkhyq6vz6113lkf004d4hysygc6iw78v70z98s6m15mg9imn";
+  vendorSha256 = "1w72n1sprwylaj96aj03h4qq43525q15iwb6vf23gf6913zhvqy3";
 
   doCheck = false;
 

pkgs/development/tools/build-managers/remake/default.nix

···
-{ lib, stdenv, fetchurl, readline }:
+{ lib
+, stdenv
+, fetchurl
+, pkg-config
+, readline
+, guileSupport ? false
+, guile
+}:
 
 stdenv.mkDerivation rec {
   pname = "remake";
-  remakeVersion = "4.1";
-  dbgVersion = "1.1";
+  remakeVersion = "4.3";
+  dbgVersion = "1.5";
   version = "${remakeVersion}+dbg-${dbgVersion}";
 
   src = fetchurl {
-    url = "mirror://sourceforge/project/bashdb/remake/${version}/remake-${remakeVersion}+dbg${dbgVersion}.tar.bz2";
-    sha256 = "1zi16pl7sqn1aa8b7zqm9qnd9vjqyfywqm8s6iap4clf86l7kss2";
+    url = "mirror://sourceforge/project/bashdb/remake/${version}/remake-${remakeVersion}+dbg-${dbgVersion}.tar.gz";
+    sha256 = "0xlx2485y0israv2pfghmv74lxcv9i5y65agy69mif76yc4vfvif";
   };
 
   patches = [
     ./glibc-2.27-glob.patch
   ];
 
-  buildInputs = [ readline ];
+  nativeBuildInputs = [
+    pkg-config
+  ];
+  buildInputs = [ readline ]
+    ++ lib.optionals guileSupport [ guile ];
+
+  # make check fails, see https://github.com/rocky/remake/issues/117
 
   meta = {
     homepage = "http://bashdb.sourceforge.net/remake/";
-    license = lib.licenses.gpl3;
+    license = lib.licenses.gpl3Plus;
     description = "GNU Make with comprehensible tracing and a debugger";
     platforms = with lib.platforms; linux ++ darwin;
-    maintainers = with lib.maintainers; [ bjornfor ];
+    maintainers = with lib.maintainers; [ bjornfor shamilton ];
   };
 }

pkgs/development/tools/continuous-integration/gitlab-runner/default.nix

···
 { lib, buildGoPackage, fetchFromGitLab, fetchurl }:
 
 let
-  version = "13.10.0";
+  version = "13.11.0";
   # Gitlab runner embeds some docker images these are prebuilt for arm and x86_64
   docker_x86_64 = fetchurl {
     url = "https://gitlab-runner-downloads.s3.amazonaws.com/v${version}/helper-images/prebuilt-x86_64.tar.xz";
-    sha256 = "0lw087xcbzf4d68mq0h0s31na7lww2d9nv43icw9qx05aknlcddv";
+    sha256 = "1vmj7vxz1a4js9kqz7mm6xgnkmb37c1jbx2lwsq2qkrybkxfcw8k";
   };
 
   docker_arm = fetchurl {
     url = "https://gitlab-runner-downloads.s3.amazonaws.com/v${version}/helper-images/prebuilt-arm.tar.xz";
-    sha256 = "1mf3w85ivc8r2rmb78r4b87rrxmbb1zda9pp8n4nvd0igg23xqk8";
+    sha256 = "1c1pywz7ylaysplvq1m15v7rf1sgdkh9scbqklzcm55fjk128lif";
   };
 in
 buildGoPackage rec {
···
     owner = "gitlab-org";
     repo = "gitlab-runner";
     rev = "v${version}";
-    sha256 = "0xy5mpcpxcmwfdrspd29z8nyn1m9i4ma7d5kbihwa2yxznylydpx";
+    sha256 = "07jqsxac50xwmhlv0nbnn098290nkpsmrxw872yh67n1s9gqfd27";
   };
 
   patches = [ ./fix-shell-path.patch ];

pkgs/development/tools/continuous-integration/laminar/default.nix

···
   meta = with lib; {
     description = "Lightweight and modular continuous integration service";
     homepage = "https://laminar.ohwg.net";
-    license = licenses.gpl3;
+    license = licenses.gpl3Plus;
     platforms = platforms.linux;
     maintainers = with maintainers; [ kaction maralorn ];
   };

pkgs/development/tools/jql/default.nix

···
+{ lib, fetchFromGitHub, rustPlatform }:
+
+rustPlatform.buildRustPackage rec {
+  pname = "jql";
+  version = "2.9.4";
+
+  src = fetchFromGitHub {
+    owner = "yamafaktory";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "1rwnmp2rnzwc7anmk7nr8l4ncza8s1f8sn0r2la4ai2sx1iqn06h";
+  };
+
+  cargoSha256 = "1c83mmdxci7l3c6ja5fhk4cak1gcbg0r0nlpbpims5gi16nf99r3";
+
+  meta = with lib; {
+    description = "A JSON Query Language CLI tool built with Rust";
+    homepage = "https://github.com/yamafaktory/jql";
+    license = with licenses; [ mit ];
+    maintainers = with maintainers; [ akshgpt7 ];
+  };
+}

pkgs/development/tools/ocaml/ocamlformat/default.nix

···
     version = "0.17.0";
   };
 
-  ocamlformat = ocamlformat_0_17_0;
+  ocamlformat_0_18_0 = mkOCamlformat {
+    version = "0.18.0";
+  };
+
+  ocamlformat = ocamlformat_0_18_0;
 }

pkgs/development/tools/ocaml/ocamlformat/generic.nix

···
       "0.15.1" = "1x6fha495sgk4z05g0p0q3zfqm5l6xzmf6vjm9g9g7c820ym2q9a";
       "0.16.0" = "1vwjvvwha0ljc014v8jp8snki5zsqxlwd7x0dl0rg2i9kcmwc4mr";
       "0.17.0" = "0f1lxp697yq61z8gqxjjaqd2ns8fd1vjfggn55x0gh9dx098p138";
+      "0.18.0" = "0571kzmb1h03qj74090n3mg8wfbh29qqrkdjkai6rnl5chll86lq";
     }."${version}";
-  }
-; in
-
-let ocamlPackages =
+  };
+  ocamlPackages =
   if lib.versionAtLeast version "0.14.3"
   then ocaml-ng.ocamlPackages
   else ocaml-ng.ocamlPackages_4_07
···
 
 with ocamlPackages;
 
-buildDunePackage rec {
+buildDunePackage {
   pname = "ocamlformat";
   inherit src version;
 
···
   useDune2 = true;
 
   buildInputs =
-    if lib.versionAtLeast version "0.17.0"
+    if lib.versionAtLeast version "0.18.0"
+    then [
+      base
+      cmdliner
+      fpath
+      odoc
+      re
+      stdio
+      uuseg
+      uutf
+      fix
+      menhir
+      dune-build-info
+      ocaml-version
+      # Changed since 0.16.0:
+      (ppxlib.override { version = "0.22.0"; })
+    ]
+    else if lib.versionAtLeast version "0.17.0"
     then [
       base
       cmdliner

pkgs/development/web/deno/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "deno";
-  version = "1.9.0";
+  version = "1.9.1";
 
   src = fetchFromGitHub {
     owner = "denoland";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-LrJGwsP+P8zXYwboF5791YuWGVdhcQJLOoBv+VzrYzs=";
+    sha256 = "sha256-h8dXGSu7DebzwZdc92A2d9xlYy6wD34phBUj5v5KuIc=";
   };
-  cargoSha256 = "sha256-JDapls3nRNETri6nZPRjZFlAFVN1Owhp965zf0Rn3ug=";
+  cargoSha256 = "sha256-htxpaALOXFQpQ68YE4b0T0jhcCIONgUZwpMPCcSdcgs=";
 
   # Install completions post-install
   nativeBuildInputs = [ installShellFiles ];

pkgs/development/web/nodejs/v16.nix

···
+{ callPackage, openssl, python3, enableNpm ? true }:
+
+let
+  buildNodejs = callPackage ./nodejs.nix {
+    inherit openssl;
+    python = python3;
+  };
+in
+  buildNodejs {
+    inherit enableNpm;
+    version = "16.0.0";
+    sha256 = "00mada0vvybizygwhzsq6gcz0m2k864lfiiqqlnw8gcc3q8r1js7";
+  }

pkgs/games/flightgear/default.nix

···
 }:
 
 let
-  version = "2020.3.4";
+  version = "2020.3.8";
   shortVersion = builtins.substring 0 6 version;
   data = stdenv.mkDerivation rec {
     pname = "flightgear-data";
     inherit version;
 
     src = fetchurl {
-      url = "mirror://sourceforge/flightgear/release-${shortVersion}/FlightGear-${version}-data.tar.bz2";
-      sha256 = "1cqikbqvidfaynml9bhqfr9yw5ga35gpqrbz62z94a1skdijkpkg";
+      url = "mirror://sourceforge/flightgear/release-${shortVersion}/FlightGear-${version}-data.txz";
+      sha256 = "sha256-/KFumHRkmRvsU/L1i11jG/KbqobnOEP7l4lyPMKHycA=";
     };
 
     phases = [ "installPhase" ];
···
 
   src = fetchurl {
     url = "mirror://sourceforge/flightgear/release-${shortVersion}/${pname}-${version}.tar.bz2";
-    sha256 = "02d9h10p8hyn0a25csragj6pbwmrir1z8zb92023s9vi21j7bwy8";
+    sha256 = "XXDqhZ9nR+FwQ3LauZe8iGxOjlyDXDrEtj61BQGVDYc=";
   };
 
   # Of all the files in the source and data archives, there doesn't seem to be

pkgs/misc/openrussian-cli/default.nix

···
+{ stdenv, lib, fetchFromGitHub, gnumake, pkg-config, wget, unzip, gawk
+, sqlite, which, luaPackages, installShellFiles, makeWrapper
+}:
+stdenv.mkDerivation rec {
+  pname   = "openrussian-cli";
+  version = "1.0.0";
+
+  src = fetchFromGitHub {
+    owner   = "rhaberkorn";
+    repo    = "openrussian-cli";
+    rev     = version;
+    sha256  = "1ria7s7dpqip2wdwn35wmkry84g8ghdqnxc9cbxzzq63vl6pgvcn";
+  };
+
+  nativeBuildInputs = [
+    gnumake pkg-config wget unzip gawk sqlite which installShellFiles makeWrapper
+  ];
+
+  buildInputs = with luaPackages; [ lua luasql-sqlite3 luautf8 ];
+
+  makeFlags = [
+    "LUA=${luaPackages.lua}/bin/lua"
+    "LUAC=${luaPackages.lua}/bin/luac"
+  ];
+
+  dontConfigure = true;
+
+  # Disable check as it's too slow.
+  # doCheck = true;
+
+  #This is needed even though it's the default for some reason.
+  checkTarget = "check";
+
+  # Can't use "make install" here
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p $out/bin $out/share/openrussian
+    cp openrussian-sqlite3.db $out/share/openrussian
+    cp openrussian $out/bin
+
+    wrapProgram $out/bin/openrussian \
+      --prefix LUA_PATH ';' "$LUA_PATH" \
+      --prefix LUA_CPATH ';' "$LUA_CPATH"
+
+    runHook postInstall
+  '';
+
+  postInstall = ''
+    installShellCompletion --cmd openrussian --bash ./openrussian-completion.bash
+    installManPage ./openrussian.1
+  '';
+
+  meta = with lib; {
+    homepage    = "https://github.com/rhaberkorn/openrussian-cli";
+    description = "Offline Console Russian Dictionary (based on openrussian.org)";
+    license     = with licenses; [ gpl3Only mit cc-by-sa-40 ];
+    maintainers = with maintainers; [ zane ];
+    platforms   = platforms.unix;
+  };
+}

pkgs/misc/vim-plugins/vim-utils.nix

···
-{ lib, stdenv, vim, vimPlugins, vim_configurable, neovim, buildEnv, writeText, writeScriptBin
+# tests available at pkgs/test/vim
+{ lib, stdenv, vim, vimPlugins, vim_configurable, buildEnv, writeText, writeScriptBin
 , nix-prefetch-hg, nix-prefetch-git
 , fetchFromGitHub, runtimeShell
 }:
···
 
   rtpPath = "share/vim-plugins";
 
+  nativeImpl = packages: lib.optionalString (packages != null)
+  (let
+    link = (packageName: dir: pluginPath: "ln -sf ${pluginPath}/share/vim-plugins/* $out/pack/${packageName}/${dir}");
+    packageLinks = (packageName: {start ? [], opt ? []}:
+    let
+      # `nativeImpl` expects packages to be derivations, not strings (as
+      # opposed to older implementations that have to maintain backwards
+      # compatibility). Therefore we don't need to deal with "knownPlugins"
+      # and can simply pass `null`.
+      depsOfOptionalPlugins = lib.subtractLists opt (findDependenciesRecursively opt);
+      startWithDeps = findDependenciesRecursively start;
+    in
+      [ "mkdir -p $out/pack/${packageName}/start" ]
+      # To avoid confusion, even dependencies of optional plugins are added
+      # to `start` (except if they are explicitly listed as optional plugins).
+      ++ (builtins.map (link packageName "start") (lib.unique (startWithDeps ++ depsOfOptionalPlugins)))
+      ++ ["mkdir -p $out/pack/${packageName}/opt"]
+      ++ (builtins.map (link packageName "opt") opt)
+    );
+    packDir = (packages:
+      stdenv.mkDerivation {
+        name = "vim-pack-dir";
+        src = ./.;
+        installPhase = lib.concatStringsSep "\n" (lib.flatten (lib.mapAttrsToList packageLinks packages));
+        preferLocalBuild = true;
+      }
+    );
+  in
+  ''
+    set packpath^=${packDir packages}
+    set runtimepath^=${packDir packages}
+  '');
+
   vimrcContent = {
     packages ? null,
     vam ? null,
     pathogen ? null,
     plug ? null,
-    beforePlugins ? "",
-    customRC ? ""
+    beforePlugins ? ''
+      " configuration generated by NIX
+      set nocompatible
+    '',
+    customRC ? null
   }:
 
     let
···
         call vam#Scripts(l, {})
       '');
 
-      nativeImpl = lib.optionalString (packages != null)
-      (let
-        link = (packageName: dir: pluginPath: "ln -sf ${pluginPath}/share/vim-plugins/* $out/pack/${packageName}/${dir}");
-        packageLinks = (packageName: {start ? [], opt ? []}:
-        let
-          # `nativeImpl` expects packages to be derivations, not strings (as
-          # opposed to older implementations that have to maintain backwards
-          # compatibility). Therefore we don't need to deal with "knownPlugins"
-          # and can simply pass `null`.
-          depsOfOptionalPlugins = lib.subtractLists opt (findDependenciesRecursively opt);
-          startWithDeps = findDependenciesRecursively start;
-        in
-          ["mkdir -p $out/pack/${packageName}/start"]
-          # To avoid confusion, even dependencies of optional plugins are added
-          # to `start` (except if they are explicitly listed as optional plugins).
-          ++ (builtins.map (link packageName "start") (lib.unique (startWithDeps ++ depsOfOptionalPlugins)))
-          ++ ["mkdir -p $out/pack/${packageName}/opt"]
-          ++ (builtins.map (link packageName "opt") opt)
-        );
-        packDir = (packages:
-          stdenv.mkDerivation {
-            name = "vim-pack-dir";
-            src = ./.;
-            installPhase = lib.concatStringsSep
-                             "\n"
-                             (lib.flatten (lib.mapAttrsToList packageLinks packages));
-            preferLocalBuild = true;
-          }
-        );
-      in
-      ''
-        set packpath^=${packDir packages}
-        set runtimepath^=${packDir packages}
-
-        filetype indent plugin on | syn on
-      '');
+      entries = [
+        beforePlugins
+        vamImpl pathogenImpl plugImpl
+        (nativeImpl packages)
+        customRC
+      ];
 
-  in ''
-  " configuration generated by NIX
-  set nocompatible
+    in
+      lib.concatStringsSep "\n" (lib.filter (x: x != null && x != "") entries);
 
-  ${beforePlugins}
-
-  ${vamImpl}
-  ${pathogenImpl}
-  ${plugImpl}
-  ${nativeImpl}
-
-  ${customRC}
-  '';
   vimrcFile = settings: writeText "vimrc" (vimrcContent settings);
 
 in
···
     '';
   };
 
-  vim_with_vim2nix = vim_configurable.customize { name = "vim"; vimrcConfig.vam.pluginDictionaries = [ "vim-addon-vim2nix" ]; };
-
   inherit (import ./build-vim-plugin.nix { inherit lib stdenv rtpPath vim; }) buildVimPlugin buildVimPluginFrom2Nix;
 
   # used to figure out which python dependencies etc. neovim needs
···
       nativePlugins = lib.concatMap ({start?[], opt?[], knownPlugins?vimPlugins}: start++opt) nativePluginsConfigs;
     in
       nativePlugins ++ nonNativePlugins;
-
-
-  # test cases:
-  test_vim_with_vim_nix_using_vam = vim_configurable.customize {
-   name = "vim-with-vim-addon-nix-using-vam";
-    vimrcConfig.vam.pluginDictionaries = [{name = "vim-nix"; }];
-  };
-
-  test_vim_with_vim_nix_using_pathogen = vim_configurable.customize {
-    name = "vim-with-vim-addon-nix-using-pathogen";
-    vimrcConfig.pathogen.pluginNames = [ "vim-nix" ];
-  };
-
-  test_vim_with_vim_nix_using_plug = vim_configurable.customize {
-    name = "vim-with-vim-addon-nix-using-plug";
-    vimrcConfig.plug.plugins = with vimPlugins; [ vim-nix ];
-  };
-
-  test_vim_with_vim_nix = vim_configurable.customize {
-    name = "vim-with-vim-addon-nix";
-    vimrcConfig.packages.myVimPackage.start = with vimPlugins; [ vim-nix ];
-  };
-
-  # only neovim makes use of `requiredPlugins`, test this here
-  test_nvim_with_vim_nix_using_pathogen = neovim.override {
-    configure.pathogen.pluginNames = [ "vim-nix" ];
-  };
-
-  # regression test for https://github.com/NixOS/nixpkgs/issues/53112
-  # The user may have specified their own plugins which may not be formatted
-  # exactly as the generated ones. In particular, they may not have the `pname`
-  # attribute.
-  test_vim_with_custom_plugin = vim_configurable.customize {
-    name = "vim_with_custom_plugin";
-    vimrcConfig.vam.knownPlugins =
-      vimPlugins // ({
-        vim-trailing-whitespace = buildVimPluginFrom2Nix {
-          name = "vim-trailing-whitespace";
-          src = fetchFromGitHub {
-            owner = "bronson";
-            repo = "vim-trailing-whitespace";
-            rev = "4c596548216b7c19971f8fc94e38ef1a2b55fee6";
-            sha256 = "0f1cpnp1nxb4i5hgymjn2yn3k1jwkqmlgw1g02sq270lavp2dzs9";
-          };
-          # make sure string dependencies are handled
-          dependencies = [ "vim-nix" ];
-        };
-      });
-    vimrcConfig.vam.pluginDictionaries = [ { names = [ "vim-trailing-whitespace" ]; } ];
-  };
-
-  # system remote plugin manifest should be generated, deoplete should be usable
-  # without the user having to do `UpdateRemotePlugins`. To test, launch neovim
-  # and do `:call deoplete#enable()`. It will print an error if the remote
-  # plugin is not registered.
-  test_nvim_with_remote_plugin = neovim.override {
-    configure.pathogen.pluginNames = with vimPlugins; [ deoplete-nvim ];
-  };
 }

pkgs/os-specific/linux/dropwatch/default.nix

···
-{ lib, stdenv, fetchFromGitHub, autoreconfHook, pkg-config
-, libnl, readline, libbfd, ncurses, zlib }:
+{ lib
+, stdenv
+, fetchFromGitHub
+, autoreconfHook
+, pkg-config
+, libbfd
+, libnl
+, libpcap
+, ncurses
+, readline
+, zlib
+}:
 
 stdenv.mkDerivation rec {
   pname = "dropwatch";
-  version = "1.5.1";
+  version = "1.5.3";
 
   src = fetchFromGitHub {
     owner = "nhorman";
     repo = pname;
     rev = "v${version}";
-    sha256 = "1qmax0l7z1qik42c949fnvjh5r6awk4gpgzdsny8iwnmwzjyp8b8";
+    sha256 = "0axx0zzrs7apqnl0r70jyvmgk7cs5wk185id479mapgngibwkyxy";
   };
 
-  nativeBuildInputs = [ autoreconfHook pkg-config ];
-  buildInputs = [ libbfd libnl ncurses readline zlib ];
-
-  # To avoid running into https://sourceware.org/bugzilla/show_bug.cgi?id=14243 we need to define:
-  NIX_CFLAGS_COMPILE = "-DPACKAGE=${pname} -DPACKAGE_VERSION=${version}";
+  nativeBuildInputs = [
+    autoreconfHook
+    pkg-config
+  ];
+  buildInputs = [
+    libbfd
+    libnl
+    libpcap
+    ncurses
+    readline
+    zlib
+  ];
 
   enableParallelBuilding = true;
 
   meta = with lib; {
     description = "Linux kernel dropped packet monitor";
     homepage = "https://github.com/nhorman/dropwatch";
-    license = licenses.gpl2;
+    license = licenses.gpl2Plus;
     platforms = platforms.linux;
-    maintainers = [ maintainers.c0bw3b ];
+    maintainers = with maintainers; [ c0bw3b ];
   };
 }

pkgs/os-specific/linux/rtw88/default.nix

···
 in
 stdenv.mkDerivation {
   pname = "rtw88";
-  version = "unstable-2021-04-01";
+  version = "unstable-2021-04-19";
 
   src = fetchFromGitHub {
     owner = "lwfinger";
     repo = "rtw88";
-    rev = "689ce370b0c2da207bb092065697f6cb455a00dc";
-    hash = "sha256-gdfQxpzYJ9bEObc2iEapA0TPMZuXndBvEu6qwKqdhyo=";
+    rev = "0f3cc6a5973bc386d9cb542fc85a6ba027edff5d";
+    hash = "sha256-PRzWXC1lre8gt1GfVdnaG836f5YK57P9a8tG20yef0w=";
   };
 
   makeFlags = [ "KSRC=${kernel.dev}/lib/modules/${kernel.modDirVersion}/build" ];

pkgs/test/default.nix

···
   rustCustomSysroot = callPackage ./rust-sysroot {};
   buildRustCrate = callPackage ../build-support/rust/build-rust-crate/test { };
 
+  vim = callPackage ./vim {};
+
   nixos-functions = callPackage ./nixos-functions {};
 
   patch-shebangs = callPackage ./patch-shebangs {};

pkgs/test/vim/default.nix

···
+{ vimUtils, vim_configurable, neovim, vimPlugins
+, lib, fetchFromGitHub,
+}:
+let
+  inherit (vimUtils) buildVimPluginFrom2Nix;
+
+  packages.myVimPackage.start = with vimPlugins; [ vim-nix ];
+in
+{
+  vim_empty_config = vimUtils.vimrcFile { beforePlugins = ""; customRC = ""; };
+
+  vim_with_vim2nix = vim_configurable.customize {
+    name = "vim"; vimrcConfig.vam.pluginDictionaries = [ "vim-addon-vim2nix" ];
+  };
+
+  # test cases:
+  test_vim_with_vim_nix_using_vam = vim_configurable.customize {
+   name = "vim-with-vim-addon-nix-using-vam";
+    vimrcConfig.vam.pluginDictionaries = [{name = "vim-nix"; }];
+  };
+
+  test_vim_with_vim_nix_using_pathogen = vim_configurable.customize {
+    name = "vim-with-vim-addon-nix-using-pathogen";
+    vimrcConfig.pathogen.pluginNames = [ "vim-nix" ];
+  };
+
+  test_vim_with_vim_nix_using_plug = vim_configurable.customize {
+    name = "vim-with-vim-addon-nix-using-plug";
+    vimrcConfig.plug.plugins = with vimPlugins; [ vim-nix ];
+  };
+
+  test_vim_with_vim_nix = vim_configurable.customize {
+    name = "vim-with-vim-addon-nix";
+    vimrcConfig.packages.myVimPackage.start = with vimPlugins; [ vim-nix ];
+  };
+
+  # only neovim makes use of `requiredPlugins`, test this here
+  test_nvim_with_vim_nix_using_pathogen = neovim.override {
+    configure.pathogen.pluginNames = [ "vim-nix" ];
+  };
+
+  # regression test for https://github.com/NixOS/nixpkgs/issues/53112
+  # The user may have specified their own plugins which may not be formatted
+  # exactly as the generated ones. In particular, they may not have the `pname`
+  # attribute.
+  test_vim_with_custom_plugin = vim_configurable.customize {
+    name = "vim_with_custom_plugin";
+    vimrcConfig.vam.knownPlugins =
+      vimPlugins // ({
+        vim-trailing-whitespace = buildVimPluginFrom2Nix {
+          name = "vim-trailing-whitespace";
+          src = fetchFromGitHub {
+            owner = "bronson";
+            repo = "vim-trailing-whitespace";
+            rev = "4c596548216b7c19971f8fc94e38ef1a2b55fee6";
+            sha256 = "0f1cpnp1nxb4i5hgymjn2yn3k1jwkqmlgw1g02sq270lavp2dzs9";
+          };
+          # make sure string dependencies are handled
+          dependencies = [ "vim-nix" ];
+        };
+      });
+    vimrcConfig.vam.pluginDictionaries = [ { names = [ "vim-trailing-whitespace" ]; } ];
+  };
+
+  # system remote plugin manifest should be generated, deoplete should be usable
+  # without the user having to do `UpdateRemotePlugins`. To test, launch neovim
+  # and do `:call deoplete#enable()`. It will print an error if the remote
+  # plugin is not registered.
+  test_nvim_with_remote_plugin = neovim.override {
+    configure.pathogen.pluginNames = with vimPlugins; [ deoplete-nvim ];
+  };
+}

pkgs/tools/misc/websocat/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "websocat";
-  version = "1.6.0";
+  version = "1.8.0";
 
   src = fetchFromGitHub {
     owner = "vi";
-    repo = "websocat";
+    repo = pname;
     rev = "v${version}";
-    sha256 = "0iilq96bxcb2fsljvlgy47pg514w0jf72ckz39yy3k0gwc1yfcja";
+    sha256 = "sha256-jwoWxK4phBqhIeo3+oRnpGsfvtn9gTR1ryd4N+0Lmbw=";
   };
 
   cargoBuildFlags = [ "--features=ssl" ];
-  cargoSha256 = "1hsms8rlnds8npr8m0dm21h04ci5ljda09pqb598v7ny3j2dldiq";
+  cargoSha256 = "sha256-+3SG1maarY4DJ4+QiYGwltGLksOoOhKtcqstRwgzi2k=";
 
   nativeBuildInputs = [ pkg-config makeWrapper ];
   buildInputs = [ openssl ] ++ lib.optional stdenv.isDarwin Security;
+
+  # Needed to get openssl-sys to use pkg-config.
+  OPENSSL_NO_VENDOR=1;
 
   # The wrapping is required so that the "sh-c" option of websocat works even
   # if sh is not in the PATH (as can happen, for instance, when websocat is
···
   '';
 
   meta = with lib; {
+    homepage = "https://github.com/vi/websocat";
     description = "Command-line client for WebSockets (like netcat/socat)";
-    homepage = "https://github.com/vi/websocat";
+    changelog = "https://github.com/vi/websocat/releases/tag/v${version}";
     license = licenses.mit;
     maintainers = with maintainers; [ thoughtpolice Br1ght0ne ];
   };

pkgs/tools/networking/sish/default.nix

···
+{ lib
+, buildGoModule
+, fetchFromGitHub
+}:
+
+buildGoModule rec {
+  pname = "sish";
+  version = "1.1.5";
+
+  src = fetchFromGitHub {
+    owner = "antoniomika";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "06ckgxhnijs7yrj0hhwh1vk2fvapwn6wb44w3g6qs6n6fmqh92mb";
+  };
+
+  vendorSha256 = "0vfazbaiaqka5nd7imh5ls7k3asf1c17y081nzkban98svg3l3sj";
+
+  meta = with lib; {
+    description = "HTTP(S)/WS(S)/TCP Tunnels to localhost";
+    homepage = "https://github.com/antoniomika/sish";
+    license = with licenses; [ mit ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

pkgs/tools/nix/manix/default.nix

···
-{ lib, stdenv, fetchFromGitHub, rustPlatform, darwin }:
+{ lib, stdenv, fetchFromGitHub, rustPlatform, darwin, Security }:
 
 rustPlatform.buildRustPackage rec {
   pname = "manix";
-  version = "0.6.2";
+  version = "0.6.3";
 
   src = fetchFromGitHub {
     owner = "mlvzk";
     repo  = pname;
     rev = "v${version}";
-    sha256 = "0fv3sgzwjsgq2h1177r8r1cl5zrfja4ll801sd0bzj3nzmkyww7p";
+    sha256 = "1b7xi8c2drbwzfz70czddc4j33s7g1alirv12dwl91hbqxifx8qs";
   };
 
-  buildInputs = lib.optional stdenv.isDarwin [ darwin.Security ];
+  buildInputs = lib.optionals stdenv.isDarwin [ Security ];
 
-  cargoSha256 = "0f2q3bj1cmpbma0fjhc2lc92j4al78fhrx3yc37kmbgzaza0yan5";
+  cargoSha256 = "1yivx9vzk2fvncvlkwq5v11hb9llr1zlcmy69y12q6xnd9rd8x1b";
 
   meta = with lib; {
     description = "A Fast Documentation Searcher for Nix";

pkgs/tools/security/cosign/default.nix

···
-{ lib, buildGoModule, fetchFromGitHub }:
+{ stdenv, lib, buildGoModule, fetchFromGitHub, pcsclite, pkg-config, PCSC }:
 
 buildGoModule rec {
   pname = "cosign";
-  version = "0.2.0";
+  version = "0.3.1";
 
   src = fetchFromGitHub {
     owner = "sigstore";
     repo = pname;
     rev = "v${version}";
-    sha256 = "1zwb2q62ngb2zh1hasvq7r7pmrjlpgfhs5raibbhkxbk5kayvmii";
+    sha256 = "1gfzard6bh78xxgjk14c9zmdplppkcjqxhvfazcbv8qppjl2pbbd";
   };
 
-  vendorSha256 = "0nwbjaps4z5fhiknbj9pybxb6kgwb1vf2qhy0mzpycprf04q6g0v";
+  buildInputs =
+    lib.optional stdenv.isLinux (lib.getDev pcsclite)
+    ++ lib.optionals stdenv.isDarwin [ PCSC ];
+
+  nativeBuildInputs = [ pkg-config ];
+
+  vendorSha256 = "15163v484rv08rn439y38r9spyqn3lf4q4ly8xr18nnf4bs3h6y2";
 
   subPackages = [ "cmd/cosign" ];
 
+  preBuild = ''
+    buildFlagsArray+=("-ldflags" "-s -w -X github.com/sigstore/cosign/cmd/cosign/cli.gitVersion=v${version}")
+  '';
+
   meta = with lib; {
     homepage = "https://github.com/sigstore/cosign";
     changelog = "https://github.com/sigstore/cosign/releases/tag/v${version}";
     description = "Container Signing CLI with support for ephemeral keys and Sigstore signing";
     license = licenses.asl20;
-    maintainers = with maintainers; [ lesuisse ];
+    maintainers = with maintainers; [ lesuisse jk ];
   };
 }

pkgs/tools/security/hfinger/default.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "hfinger";
-  version = "0.2.0";
+  version = "0.2.1";
   disabled = python3.pythonOlder "3.3";
 
   src = fetchFromGitHub {
     owner = "CERT-Polska";
     repo = pname;
     rev = "v${version}";
-    sha256 = "1vz8mf572qyng684fvb9gdwaaiybk7mjmikbymvjvy24d10raak1";
+    sha256 = "sha256-QKnrprDDBq+D8N1brkqgcfK4E+6ssvgPtRaSxkF0C84=";
   };
 
   propagatedBuildInputs = with python3.pkgs; [

pkgs/tools/security/ldeep/default.nix

···
 
 buildPythonApplication rec {
   pname = "ldeep";
-  version = "1.0.10";
+  version = "1.0.11";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-/7mcmAj69NmuiK+xlQijAk39sMLDX8kHatmSI6XYbwE=";
+    sha256 = "sha256-MYVC8fxLW85n8uZVMhb2Zml1lQ8vW9gw/eRLcmemQx4=";
   };
 
   propagatedBuildInputs = [

pkgs/tools/wayland/ydotool/default.nix

···
-{ lib, stdenv, fetchFromGitHub, pkg-config, cmake, boost, libevdevplus, libuinputplus }:
+{ lib, stdenv, fetchFromGitHub, pkg-config, cmake, boost, libevdevplus, libuinputplus, iodash, cxxopts}:
 
 stdenv.mkDerivation rec {
   pname = "ydotool";
-  version = "0.1.8";
+  version = "unstable-2021-01-20";
 
   src = fetchFromGitHub {
     owner = "ReimuNotMoe";
     repo = "ydotool";
-    rev = "v${version}";
-    sha256 = "0mx3636p0f8pznmwm4rlbwq7wrmjb2ygkf8b3a6ps96a7j1fw39l";
+    rev = "b1d041f52f7bac364d6539b1251d29c3b77c0f37";
+    sha256 = "1gzdbx6fv0dbcyia3yyzhv93az2gf90aszb9kcj5cnxywfpv9w9g";
   };
 
-  # disable static linking
+  # upstream decided to use a cpp package manager called cpm.
+  # we need to disable that because it wants networking, furthermore,
+  # it does some system folder creating which also needs to be disabled.
+  # Both changes are to respect the sandbox.
+  patches = [ ./fixup-cmakelists.patch ];
+
+
+  # cxxopts is a header only library.
+  # See pull request: https://github.com/ReimuNotMoe/ydotool/pull/105
   postPatch = ''
     substituteInPlace CMakeLists.txt --replace \
-      "-static" \
-      ""
+      "PUBLIC cxxopts" \
+      "PUBLIC"
   '';
 
   nativeBuildInputs = [ cmake pkg-config ];
   buildInputs = [
-    boost libevdevplus libuinputplus
+    boost libevdevplus libuinputplus iodash cxxopts
   ];
 
   meta = with lib; {

pkgs/tools/wayland/ydotool/fixup-cmakelists.patch

···
+From bb8bc44d22060cd1215712117cf30eae09f4f6ba Mon Sep 17 00:00:00 2001
+From: Jappie Klooster <[e-mail]>
+Date: Fri, 2 Apr 2021 14:04:14 -0400
+Subject: [PATCH] Fixup cmaklists
+
+We remove cpm, which is a package manager for c++,
+which requires networking, so it's better just deleted.
+
+Furthermore we delete the adddirectory statements.
+These want to modify directories outside of the sandbox.
+---
+ CMakeLists.txt | 26 --------------------------
+ 1 file changed, 26 deletions(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index b5e8789..b797538 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -13,30 +13,6 @@ endif()
+ 
+ include(${CPM_DOWNLOAD_LOCATION})
+ 
+-CPMAddPackage(
+-        NAME IODash
+-        GITHUB_REPOSITORY YukiWorkshop/IODash
+-        VERSION 0.1.0
+-)
+-
+-CPMAddPackage(
+-        NAME libevdevPlus
+-        GITHUB_REPOSITORY YukiWorkshop/libevdevPlus
+-        VERSION 0.2.1
+-)
+-
+-CPMAddPackage(
+-        NAME libuInputPlus
+-        GITHUB_REPOSITORY YukiWorkshop/libuInputPlus
+-        VERSION 0.2.1
+-)
+-
+-CPMAddPackage(
+-        NAME cxxopts
+-        GITHUB_REPOSITORY jarro2783/cxxopts
+-        VERSION 3.0.0
+-        GIT_TAG 2d8e17c4f88efce80e274cb03eeb902e055a91d3
+-)
+ 
+ set(SOURCE_FILES_LIBRARY
+         CommonIncludes.hpp
+@@ -74,5 +50,3 @@ add_executable(ydotool ${SOURCE_FILES_CLIENT})
+ target_link_libraries(ydotool ydotool_library dl pthread uInputPlus evdevPlus)
+ install(TARGETS ydotool DESTINATION ${CMAKE_INSTALL_BINDIR})
+ 
+-add_subdirectory(Daemon)
+-add_subdirectory(manpage)
+-- 
+2.29.2
+

pkgs/top-level/all-packages.nix

···
 
   corsmisc = callPackage ../tools/security/corsmisc { };
 
-  cosign = callPackage ../tools/security/cosign { };
+  cosign = callPackage ../tools/security/cosign {
+    inherit (darwin.apple_sdk.frameworks) PCSC;
+  };
 
   cozy = callPackage ../applications/audio/cozy-audiobooks { };
 
···
 
   jq = callPackage ../development/tools/jq { };
 
+  jql = callPackage ../development/tools/jql { };
+
   jo = callPackage ../development/tools/jo { };
 
   jrnl = python3Packages.callPackage ../applications/misc/jrnl { };
···
   nodejs-slim-15_x = callPackage ../development/web/nodejs/v15.nix {
     enableNpm = false;
   };
+  nodejs-16_x = callPackage ../development/web/nodejs/v16.nix { };
+  nodejs-slim-16_x = callPackage ../development/web/nodejs/v16.nix {
+    enableNpm = false;
+  };
   # Update this when adding the newest nodejs major version!
-  nodejs_latest = nodejs-15_x;
-  nodejs-slim_latest = nodejs-slim-15_x;
+  nodejs_latest = nodejs-16_x;
+  nodejs-slim_latest = nodejs-slim-16_x;
 
   nodePackages_latest = dontRecurseIntoAttrs (callPackage ../development/node-packages/default.nix {
     nodejs = pkgs.nodejs_latest;
···
 
   ispell = callPackage ../tools/text/ispell {};
 
+  iodash = callPackage ../development/libraries/iodash { };
   jumanpp = callPackage ../tools/text/jumanpp {};
 
   jump = callPackage ../tools/system/jump {};
···
 
   mandoc = callPackage ../tools/misc/mandoc { };
 
-  manix = callPackage ../tools/nix/manix {};
+  manix = callPackage ../tools/nix/manix {
+    inherit (darwin.apple_sdk.frameworks) Security;
+  };
 
   marktext = callPackage ../applications/misc/marktext { };
 
···
   openresolv = callPackage ../tools/networking/openresolv { };
 
   openrgb = libsForQt5.callPackage ../applications/misc/openrgb { };
+
+  openrussian-cli = callPackage ../misc/openrussian-cli { };
 
   opensc = callPackage ../tools/security/opensc {
     inherit (darwin.apple_sdk.frameworks) Carbon PCSC;
···
 
   gxplugins-lv2 = callPackage ../applications/audio/gxplugins-lv2 { };
 
+  hachoir = with python3Packages; toPythonApplication hachoir;
+
   hackrf = callPackage ../applications/radio/hackrf { };
 
   hacksaw = callPackage ../tools/misc/hacksaw {};
···
   hexdino = callPackage ../applications/editors/hexdino { };
 
   hexedit = callPackage ../applications/editors/hexedit { };
+
+  himalaya = callPackage ../applications/networking/mailreaders/himalaya {
+    inherit (darwin.apple_sdk.frameworks) Security;
+  };
 
   hipchat = callPackage ../applications/networking/instant-messengers/hipchat { };
 
···
   simple-scan = gnome3.simple-scan;
 
   siproxd = callPackage ../applications/networking/siproxd { };
+
+  sish = callPackage ../tools/networking/sish { };
 
   skypeforlinux = callPackage ../applications/networking/instant-messengers/skypeforlinux { };
 

pkgs/top-level/python-packages.nix

···
 
   habanero = callPackage ../development/python-modules/habanero { };
 
+  hachoir = callPackage ../development/python-modules/hachoir { };
+
   ha-ffmpeg = callPackage ../development/python-modules/ha-ffmpeg { };
 
   halo = callPackage ../development/python-modules/halo { };

pkgs/top-level/ruby-packages.nix

···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0clfsmkdqviwrjdc0fjqx3qs7xkq06bdl24f2qdyk4p2f0aszdw9";
+      sha256 = "0dr6w3h7i7xyqd04aw66x2ddm7xinvlw02pkk1sxczi8x21z16hf";
       type = "gem";
     };
-    version = "6.1.0";
+    version = "6.1.3.1";
   };
   actionmailbox = {
     dependencies = ["actionpack" "activejob" "activerecord" "activestorage" "activesupport" "mail"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "14qcia1l2yjga3azgc381mk75xrddspkpxxvswrr6rg9453i70wf";
+      sha256 = "0w3cq2m1qbmxp7yv3qs82ffn9y46vq5q04vqwxak6ln0ki0v4hn4";
       type = "gem";
     };
-    version = "6.1.0";
+    version = "6.1.3.1";
   };
   actionmailer = {
     dependencies = ["actionpack" "actionview" "activejob" "activesupport" "mail" "rails-dom-testing"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "17cnw2pi5gbll6wqqmp40wdxbg3v0kz1jmfdbg7kwdk8b4mkfqmw";
+      sha256 = "1wsa6kcgjx5am9hn44q2afg174m2gda4n8bfk5na17nj48s9g1ii";
       type = "gem";
     };
-    version = "6.1.0";
+    version = "6.1.3.1";
   };
   actionpack = {
     dependencies = ["actionview" "activesupport" "rack" "rack-test" "rails-dom-testing" "rails-html-sanitizer"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1mbmizxyl2k6z386zqvvzg3i8b91g7ag4hfjmm7fpbc8p6j4kjmb";
+      sha256 = "0brr9kbmmc4fr2x8a7kj88yv8whfjfvalik3h82ypxlbg5b1c9iz";
       type = "gem";
     };
-    version = "6.1.0";
+    version = "6.1.3.1";
   };
   actiontext = {
     dependencies = ["actionpack" "activerecord" "activestorage" "activesupport" "nokogiri"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "19dgv0zcq7k0wps7gbaiprrardqm74ija9zjydkv93anqqfw3rwd";
+      sha256 = "04f7x7ycg73zc2v3lhvrnl072f7nl0nhp0sspfa2sqq14v4akmmb";
       type = "gem";
     };
-    version = "6.1.0";
+    version = "6.1.3.1";
   };
   actionview = {
     dependencies = ["activesupport" "builder" "erubi" "rails-dom-testing" "rails-html-sanitizer"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1d68p974w96b3mg8q45cmwy2629dl615fm9in56fgb0k7vcrpazk";
+      sha256 = "0m009iki20hhwwj713bqdw57hmz650l7drfbajw32xn2qnawf294";
       type = "gem";
     };
-    version = "6.1.0";
+    version = "6.1.3.1";
   };
   activejob = {
     dependencies = ["activesupport" "globalid"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0pkiy5jy5xjgh4diw5wyc72w1r9s07p1qp1kpwv50a5q1ca12aw0";
+      sha256 = "0zjwcfr4qyff9ln4hhjb1csbjpvr3z4pdgvg8axvhcs86h4xpy2n";
       type = "gem";
     };
-    version = "6.1.0";
+    version = "6.1.3.1";
   };
   activemodel = {
     dependencies = ["activesupport"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "019gwxrbki4fr3n2c6g7qyyjw94z5qxjwalh2n69hh1anpcbrd98";
+      sha256 = "118slj94hif5g1maaijlxsywrq75h7qdz20bq62303pkrzabjaxm";
       type = "gem";
     };
-    version = "6.1.0";
+    version = "6.1.3.1";
   };
   activerecord = {
     dependencies = ["activemodel" "activesupport"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1ag8wpfayzbv8n9gf9ca2k8rm9yndsxybvf7jv451j9r822mxzm8";
+      sha256 = "1jva5iqnjmj76mhhxcvx6xzda071cy80bhxn3r79f76pvgwwyymg";
       type = "gem";
     };
-    version = "6.1.0";
+    version = "6.1.3.1";
   };
   activestorage = {
-    dependencies = ["actionpack" "activejob" "activerecord" "activesupport" "marcel" "mimemagic"];
+    dependencies = ["actionpack" "activejob" "activerecord" "activesupport" "marcel" "mini_mime"];
     groups = ["default"];
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0kzslp0990fjyxvlsxb7kdysx28mc3zvay4q3zp2wbfnpl1ik41j";
+      sha256 = "1800ski0619mzyk2p2xcmy4xlym18g3lbqw8wb3ss06jhvn5dl5p";
       type = "gem";
     };
-    version = "6.1.0";
+    version = "6.1.3.1";
   };
   activesupport = {
     dependencies = ["concurrent-ruby" "i18n" "minitest" "tzinfo" "zeitwerk"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1pflc2fch1bbgzk1rqgj21l6mgx025l92kd9arxjls98nf5am44v";
+      sha256 = "0l0khgrb7zn611xjnmygv5wdxh7wq645f613wldn5397q5w3l9lc";
       type = "gem";
     };
-    version = "6.1.0";
+    version = "6.1.3.1";
   };
   addressable = {
     dependencies = ["public_suffix"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1l3468czzjmxl93ap40hp7z94yxp4nbag0bxqs789bm30md90m2a";
+      sha256 = "04nc8x27hlzlrr5c2gn7mar4vdr0apw5xg22wp6m8dx3wqr04a0y";
       type = "gem";
     };
-    version = "2.4.1";
+    version = "2.4.2";
   };
   atk = {
     dependencies = ["glib2"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "14arh1ixfsd6j5md0agyzvksm5svfkvchb90fp32nn7y3avcmc2h";
+      sha256 = "0vkq6c8y2jvaw03ynds5vjzl1v9wg608cimkd3bidzxc0jvk56z9";
       type = "gem";
     };
-    version = "1.8.0";
+    version = "1.9.2";
   };
   bacon = {
     groups = ["default"];
···
     version = "11.1.3";
   };
   cairo = {
-    dependencies = ["native-package-installer" "pkg-config"];
+    dependencies = ["native-package-installer" "pkg-config" "red-colors"];
     groups = ["default"];
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "00hiy6anibkjq9w77hg0lpgnkkbcxrfbz8wxv44jfzqbab8910wb";
+      sha256 = "0vbj9szp2xbnxqan8hppip8vm9fxpcmpx745y5fvg2scdh9f0p7s";
       type = "gem";
     };
-    version = "1.16.6";
+    version = "1.17.5";
   };
   cairo-gobject = {
     dependencies = ["cairo" "glib2"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1jvpxf32l5y2ayj0jp9mv9n7vn61zingzd0s5f7490n584lwmvmg";
+      sha256 = "1y04ig8p9rparhff5dh3781pwf1xlirgq8p0fzvggjjpx761bvra";
       type = "gem";
     };
-    version = "3.4.1";
+    version = "3.4.2";
   };
   cocoapods = {
     dependencies = ["activesupport" "claide" "cocoapods-core" "cocoapods-deintegrate" "cocoapods-downloader" "cocoapods-plugins" "cocoapods-search" "cocoapods-stats" "cocoapods-trunk" "cocoapods-try" "colored" "escape" "fourflusher" "molinillo" "nap" "xcodeproj"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1b91sfsriizsr08m1vn9j4sf9sb8vgsyr6xjnw18bpy66bpwsqca";
+      sha256 = "0syya8l1kz36069y7cx4f37aihpmbm4yd5wvifs3j8qzz8bpxpfi";
       type = "gem";
     };
-    version = "0.0.2";
+    version = "0.0.3";
   };
   cocoapods-core = {
     dependencies = ["activesupport" "fuzzy_match" "nap"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1pwzrwp3sys5ad23lc49r3ja2ijzhzjfrq4bbrpbz1x5z7jsa77v";
+      sha256 = "0vpn0y2r91cv9kr2kh6rwh51ipi90iyjfya8ir9grxh1ngv179ck";
       type = "gem";
     };
-    version = "2.2.0";
+    version = "2.2.2";
   };
   cocoapods-git_url_rewriter = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1ln4kywj4bx32qyqvr0byi3g4fk8yj026n00xch782x0147f8lka";
+      sha256 = "1z50v9y66kl0s9s84syd8vai77hhysdaymmgbdmpaq54bra6xk72";
       type = "gem";
     };
-    version = "0.0.11";
+    version = "0.2.0";
   };
   cocoapods-wholemodule = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1vnxrbhi7cq3p4y2v9iwd10v1c7l15is4var14hwnb2jip4fyjzz";
+      sha256 = "0mr23wq0szj52xnj0zcn1k0c7j4v79wlwbijkpfcscqww3l6jlg3";
       type = "gem";
     };
-    version = "1.1.7";
+    version = "1.1.8";
   };
   crass = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0wi81lynfdvbwhrc4ws746g3j8761vian4m9gxamdj9rjwj9jhls";
+      sha256 = "1bpdrsdqwv80qqc3f4xxzpii13lx9mlx3zay4bnmmscrx8c0p63z";
       type = "gem";
     };
-    version = "1.3.4";
+    version = "1.3.5";
   };
   domain_name = {
     dependencies = ["unf"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0gggrgkcq839mamx7a8jbnp2h7x2ykfn34ixwskwb0lzx2ak17g9";
+      sha256 = "1cql2cxl9bg8gbmmlzl4kvpq7y0gjldgarsnxq35vpd7ga3h54w2";
       type = "gem";
     };
-    version = "0.12.0";
+    version = "0.13.0";
   };
   eventmachine = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "16ij8617v3js03yj1zd32mmrf7kpi9l96bid5mpqk30c4mzai55r";
+      sha256 = "0jn8s74nxsh0vmxv2fjrrrc3b2cgp8d267dyn206hbw5ki4pkd85";
       type = "gem";
     };
-    version = "0.78.1";
+    version = "0.80.1";
   };
   faraday = {
-    dependencies = ["faraday-net_http" "multipart-post" "ruby2_keywords"];
+    dependencies = ["faraday-excon" "faraday-net_http" "faraday-net_http_persistent" "multipart-post" "ruby2_keywords"];
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0q646m07lfahakx5jdq77j004rcgfj6lkg13c0f84993gi78dhvi";
+      type = "gem";
+    };
+    version = "1.4.1";
+  };
+  faraday-excon = {
     groups = ["default"];
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1hmssd8pj4n7yq4kz834ylkla8ryyvhaap6q9nzymp93m1xq21kz";
+      sha256 = "0h09wkb0k0bhm6dqsd47ac601qiaah8qdzjh8gvxfd376x1chmdh";
       type = "gem";
     };
-    version = "1.3.0";
+    version = "1.1.0";
   };
   faraday-net_http = {
     groups = ["default"];
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1kk5d1c5nxbmwawl5gcznwiscjz24nz3vdhxrlzvj7748c1qqr6d";
+      sha256 = "1fi8sda5hc54v1w3mqfl5yz09nhx35kglyx72w7b8xxvdr0cwi9j";
+      type = "gem";
+    };
+    version = "1.0.1";
+  };
+  faraday-net_http_persistent = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0l2c835wl7gv34xp49fhd1bl4czkpw2g3ahqsak2251iqv5589ka";
       type = "gem";
     };
-    version = "1.0.0";
+    version = "1.1.0";
   };
   ffi = {
     groups = ["default"];
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "15hgiy09i8ywjihyzyvjvk42ivi3kmy6dm21s5sgg9j7y3h3zkkx";
+      sha256 = "0nq1fb3vbfylccwba64zblxy96qznxbys5900wd7gm9bpplmf432";
       type = "gem";
     };
-    version = "1.14.2";
+    version = "1.15.0";
   };
   ffi-compiler = {
     dependencies = ["ffi" "rake"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1kr0bx9323fv5ys6nlhsy05kmwcbs94h6ac7ka9qqywy0vbdvrrv";
+      sha256 = "0g2fnag935zn2ggm5cn6k4s4xvv53v2givj1j90szmvavlpya96a";
       type = "gem";
     };
-    version = "1.8.7";
+    version = "1.8.10";
   };
   iconv = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "02llgsg30jz9kpxs8jzv6rvzaylw7948xj2grp4vsfg54z20cwbm";
+      sha256 = "1vz0vp5lbp1bz2samyn8nk49vyh6zhvcqz35faq4i3kgsd4xlnhp";
       type = "gem";
     };
-    version = "2.10.1";
+    version = "2.11.2";
   };
   jekyll = {
     dependencies = ["addressable" "colorator" "em-websocket" "i18n" "jekyll-sass-converter" "jekyll-watch" "kramdown" "kramdown-parser-gfm" "liquid" "mercenary" "pathutil" "rouge" "safe_yaml" "terminal-table"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "14ynyq1q483spj20ffl4xayfqx1a8qr761mqjfxczf8lwlap392n";
+      sha256 = "036i5fc09275ms49mw43mh4i9pwaap778ra2pmx06ipzyyjl6bfs";
       type = "gem";
     };
-    version = "2.2.2";
+    version = "2.2.3";
   };
   kramdown = {
     dependencies = ["rexml"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1nw1gscax8zsv1m682h9f8vys26385nrwpkbigiifs5bsz6272rk";
+      sha256 = "0h2sc2la6dd808pfnd7vh66fqwc7xg3nd2jqr4pdqymxspk9zcsq";
       type = "gem";
     };
-    version = "1.4.2";
+    version = "1.4.3";
   };
   libv8 = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "06hkw6mssx39fg3jqyq57czr5acd11nqs5631k0xs50lr2y2pv8p";
+      sha256 = "0h2v34xhi30w0d9gfzds2w6v89grq2gkpgvmdj9m8x1ld1845xnj";
       type = "gem";
     };
-    version = "3.4.0";
+    version = "3.5.1";
   };
   loofah = {
     dependencies = ["crass" "nokogiri"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0ndimir6k3kfrh8qrb7ir1j836l4r3qlwyclwjh88b86clblhszh";
+      sha256 = "1w9mbii8515p28xd4k72f3ab2g6xiyq15497ys5r8jn6m355lgi7";
       type = "gem";
     };
-    version = "2.8.0";
+    version = "2.9.1";
   };
   mab = {
     groups = ["default"];
···
     version = "2.7.1";
   };
   marcel = {
-    dependencies = ["mimemagic"];
     groups = ["default"];
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1nxbjmcyg8vlw6zwagf17l9y2mwkagmmkg95xybpn4bmf3rfnksx";
+      sha256 = "0bp001p687nsa4a8sp3q1iv8pfhs24w7s3avychjp64sdkg6jxq3";
       type = "gem";
     };
-    version = "0.3.3";
+    version = "1.0.1";
   };
   markaby = {
     dependencies = ["builder"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0ipjyfwn9nlvpcl8knq3jk4g5f12cflwdbaiqxcq1s7vwfwfxcag";
-      type = "gem";
-    };
-    version = "3.2020.1104";
-  };
-  mimemagic = {
-    groups = ["default"];
-    platforms = [];
-    source = {
-      remotes = ["https://rubygems.org"];
-      sha256 = "1qfqb9w76kmpb48frbzbyvjc0dfxh5qiw1kxdbv2y2kp6fxpa1kf";
+      sha256 = "1phcq7z0zpipwd7y4fbqmlaqghv07fjjgrx99mwq3z3n0yvy7fmi";
       type = "gem";
     };
-    version = "0.3.5";
+    version = "3.2021.0225";
   };
   mini_magick = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1axm0rxyx3ss93wbmfkm78a6x03l8y4qy60rhkkiq0aza0vwq3ha";
+      sha256 = "1np6srnyagghhh2w4nyv09sz47v0i6ri3q6blicj94vgxqp12c94";
       type = "gem";
     };
-    version = "1.0.2";
+    version = "1.0.3";
   };
   mini_portile2 = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0ipjhdw8ds6q9h7bs3iw28bjrwkwp215hr4l3xf6215fsl80ky5j";
+      sha256 = "19z7wkhg59y8abginfrm2wzplz7py3va8fyngiigngqvsws6cwgl";
       type = "gem";
     };
-    version = "5.14.3";
+    version = "5.14.4";
   };
   molinillo = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1lva6bkvb4mfa0m3bqn4lm4s4gi81c40jvdcsrxr6vng49q9daih";
+      sha256 = "06iajjyhx0rvpn4yr3h1hc4w4w3k59bdmfhxnjzzh76wsrdxxrc6";
       type = "gem";
     };
-    version = "1.3.3";
+    version = "1.4.2";
   };
   multi_json = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0piclgf6pw7hr10x57x0hn675djyna4sb3xc97yb9vh66wkx1fl0";
+      sha256 = "1ww1mq41q7rda975byjmq5dk8k13v8dawvm33370pbkrymd8syp8";
       type = "gem";
     };
-    version = "1.0.9";
+    version = "1.1.1";
   };
   ncursesw = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1cbwp1kbv6b2qfxv8sarv0d0ilb257jihlvdqj8f5pdm0ksq1sgk";
+      sha256 = "00fwz0qq7agd2xkdz02i8li236qvwhma3p0jdn5bdvc21b7ydzd5";
       type = "gem";
     };
-    version = "2.5.4";
+    version = "2.5.7";
   };
   nokogiri = {
     dependencies = ["mini_portile2" "racc"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1ajwkqr28hwqbyl1l3czx4a34c88acxywyqp8cjyy0zgsd6sbhj2";
+      sha256 = "19d78mdg2lbz9jb4ph6nk783c9jbsdm8rnllwhga6pd53xffp6x0";
       type = "gem";
     };
-    version = "1.11.1";
+    version = "1.11.3";
   };
   opus-ruby = {
     dependencies = ["ffi"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1zlk3bksiwrdvb7j0r5av7w280kigl7947wa7w4kbwqz3snaxl3m";
+      sha256 = "0m2acfd6l6k9xvqxvwivcnwji9974ac7498znydxh69z1x3rr8nm";
       type = "gem";
     };
-    version = "4.4.0";
+    version = "4.4.1";
   };
   pango = {
     dependencies = ["cairo-gobject" "gobject-introspection"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1jixakyzmy0j5c1rb0fjrrdhgnyryvrr6vgcybs14jfw09akv5ml";
+      sha256 = "04ri489irbbx6sbkclpgri7j7p99v2qib5g2i70xx5fay12ilny8";
       type = "gem";
     };
-    version = "3.0.0.0";
+    version = "3.0.1.0";
   };
   pathutil = {
     dependencies = ["forwardable-extended"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "068sf963n2zk47kqcckj624g5pxmk68mm76h02piphfyh9x4zmi3";
+      sha256 = "1mjjy1grxr64znkffxsvprcckbrrnm40b6gbllnbm7jxslbr3gjl";
       type = "gem";
     };
-    version = "1.4.4";
+    version = "1.4.6";
   };
   polyglot = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0iyw4q4an2wmk8v5rn2ghfy2jaz9vmw2nk8415nnpx2s866934qk";
+      sha256 = "0m445x8fwcjdyv2bc0glzss2nbm1ll51bq45knixapc7cl3dzdlr";
       type = "gem";
     };
-    version = "0.13.1";
+    version = "0.14.1";
   };
   pry-byebug = {
     dependencies = ["byebug" "pry"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "096y5vmzpyy4x9h4ky4cs4y7d19vdq9vbwwrqafbh5gagzwhifiv";
+      sha256 = "07cv2hddswb334777pjgc9avxn0x9qhrdr191g7windvnjk3scvg";
       type = "gem";
     };
-    version = "3.9.0";
+    version = "3.8.0";
   };
   pry-doc = {
     dependencies = ["pry" "yard"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "13640p5fk19705ygp8j6p07lccag3d80bx8bmjgpd5zsxxsdc50b";
+      sha256 = "0wiprd0v4mjqv5p1vqaidr9ci2xm08lcxdz1k50mb1b6nrw6r74k";
       type = "gem";
     };
-    version = "5.1.1";
+    version = "5.2.2";
   };
   racc = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "179r2qymrh16ih5x563wqv3zpka9fvby5czqf47d24zm7zw1bwla";
+      sha256 = "1m3ckisji9n3li2700jpkyncsrh5b2z20zb0b4jl5x16cwsymr7b";
       type = "gem";
     };
-    version = "6.1.0";
+    version = "6.1.3.1";
   };
   rainbow = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "16q71cc9wx342c697q18pkz19ym4ncjd97hcw4v6f1mgflkdv400";
+      sha256 = "13za43xb5xfg1xb1vwlvwx14jlmnk7jal5dqw8q9a5g13csx41sw";
+      type = "gem";
+    };
+    version = "1.4.0";
+  };
+  red-colors = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0ar2k7zvhr1215jx5di29hkg5h1798f1gypmq6v0sy9v35w6ijca";
       type = "gem";
     };
-    version = "1.2.0";
+    version = "0.1.1";
   };
   redcarpet = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0zm86k9q8m5jkcnpb1f93wsvc57saldfj8czxkx1aw031i95inip";
+      sha256 = "0vg7imjnfcqjx7kw94ccj5r78j4g190cqzi1i59sh4a0l940b9cr";
       type = "gem";
     };
-    version = "2.0.3";
+    version = "2.1.1";
   };
   rest-client = {
     dependencies = ["http-accept" "http-cookie" "mime-types" "netrc"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1mkvkcw9fhpaizrhca0pdgjcrbns48rlz4g6lavl5gjjq3rk2sq3";
+      sha256 = "08ximcyfjy94pm1rhcx04ny1vx2sk0x4y185gzn86yfsbzwkng53";
       type = "gem";
     };
-    version = "3.2.4";
+    version = "3.2.5";
   };
   rmagick = {
     groups = ["default"];
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0ajn6aisf9hh3x5zrs7n02pg5xy3m8x38gh9cn7b3klzgp3djla5";
+      sha256 = "04ahv5gwfwdmwx6b7c0z91rrsfklvnqichgnqk1f9b9n6md3b8yw";
       type = "gem";
     };
-    version = "4.1.2";
+    version = "4.2.2";
   };
   rouge = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1x4aks5qq489iikb4ir11ppy1dg83l4dw3s34jlwvc90mj2fjrql";
+      sha256 = "1d13g6kipqqc9lmwz5b244pdwc97z15vcbnbq6n9rlf32bipdz4k";
       type = "gem";
     };
-    version = "3.10.1";
+    version = "3.10.2";
   };
   rspec-support = {
     groups = ["default"];
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1lw9qdrff4dfdz62ww8cmv33rddmadr92k2lrvc042aajvk6x886";
+      sha256 = "15j52parvb8cgvl6s0pbxi2ywxrv6x0764g222kz5flz0s4mycbl";
       type = "gem";
     };
-    version = "3.10.1";
+    version = "3.10.2";
   };
   rubocop = {
     dependencies = ["parallel" "parser" "rainbow" "regexp_parser" "rexml" "rubocop-ast" "ruby-progressbar" "unicode-display_width"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "12kkyzyzh30mi9xs52lc1pjki1al4x9acdaikj40wslhpwp1ng1l";
+      sha256 = "0cgrj670wrdw202pddiawcx2jbkcp7ja8zbc646by7nrg9ax492d";
       type = "gem";
     };
-    version = "1.7.0";
+    version = "1.13.0";
   };
   rubocop-ast = {
     dependencies = ["parser"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1qvfp567aprjgcwj757p55ynj0dx2b3c3hd76za9z3c43sphprcj";
+      sha256 = "0gkf1p8yal38nlvdb39qaiy0gr85fxfr09j5dxh8qvrgpncpnk78";
       type = "gem";
     };
-    version = "1.4.0";
+    version = "1.4.1";
   };
   rubocop-performance = {
     dependencies = ["rubocop" "rubocop-ast"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "01aahh54r9mwhdj7v2s6kmkdm1k1n1z27dlknlbgm281ny1aswrk";
+      sha256 = "07c3kymvsid9aajwmmwr3n6apxgyjcbzbl2n6r5lpzkyz28jqn15";
       type = "gem";
     };
-    version = "1.9.2";
+    version = "1.10.2";
   };
   ruby-graphviz = {
     dependencies = ["rexml"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0lk124dixshf8mmrjpsy9avnaygni3cwki25g8nm5py4d2f5fwwa";
+      sha256 = "1wy58f9qijwvkmw1j40ak2v5nsr3wcwsa1nilfw047liwyi06yad";
       type = "gem";
     };
-    version = "2.0.17";
+    version = "2.1.0";
   };
   ruby2_keywords = {
     groups = ["default"];
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "17pcc0wgvh3ikrkr7bm3nx0qhyiqwidd13ij0fa50k7gsbnr2p0l";
+      sha256 = "15wfcqxyfgka05v2a7kpg64x57gl1y4xzvnc9lh60bqx5sf1iqrs";
       type = "gem";
     };
-    version = "0.0.2";
+    version = "0.0.4";
   };
   RubyInline = {
     dependencies = ["ZenTest"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1lanqba97ncv88m9r5a3i12n938j5hnpn06q55fxhayfls4fsgdn";
+      sha256 = "13mlccf70slrjpxvpvmnk2cls39nkpgksa7sd90jlnm0s0z7lhdd";
       type = "gem";
     };
-    version = "0.11.1";
+    version = "0.11.4";
   };
   sequel = {
     groups = ["default"];
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0ym43w8alp65fl8j7792i1l44laq9pm91zj97x0r340xkmaii9hp";
+      sha256 = "0i2zbx3zkrppvf7zmk5hpiji9kj18c0yavcr2c3i0gaqskhzvaj9";
       type = "gem";
     };
-    version = "5.40.0";
+    version = "5.43.0";
   };
   sequel_pg = {
     dependencies = ["pg" "sequel"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0vv68r61crcnyr5i2qi3h220xbwndsfzwcfzzdr6cmhcdczyr9n2";
+      sha256 = "1hrv046jll6ad1s964gsmcq4hvkr3zzr6jc7z1mns22mvfpbc3cr";
       type = "gem";
     };
-    version = "0.21.1";
+    version = "0.21.2";
   };
   simplecov-html = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0nqyam74izmbczwb406bsmgdzjz5r91d4lywlvdbxx5sl4g4256a";
+      sha256 = "0516kmcypysgf2lw8zm8n9yghv6igqgphhfgmgyzgiin388xw4gj";
       type = "gem";
     };
-    version = "2.6.0";
+    version = "2.7.0";
   };
   slop = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1g7398sn8syybz3nbf3dqwa8q8v3s3s444i24xl5q9pzx4g4nkf1";
+      sha256 = "1nkwmlx0ja35gs4lkh7hmshlwsqk5wm1wqrc2p45icnjmrh0x5cw";
       type = "gem";
     };
-    version = "1.0.1";
+    version = "1.1.0";
   };
   terminal-table = {
     dependencies = ["unicode-display_width"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1xbhkmyhlxwzshaqa7swy2bx6vd64mm0wrr8g3jywvxy7hg0cwkm";
+      sha256 = "18yhlvmfya23cs3pvhr1qy38y41b6mhr5q9vwv5lrgk16wmf3jna";
       type = "gem";
     };
-    version = "1.0.1";
+    version = "1.1.0";
   };
   thrift = {
     groups = ["default"];
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "08076cmdx0g51yrkd7dlxlr45nflink3jhdiq7006ljc2pc3212q";
+      sha256 = "1sfa4120a7yl3gxjcx990gyawsshfr22gfv5rvgpk72l2p9j2420";
       type = "gem";
     };
-    version = "0.13.0";
+    version = "0.14.1";
   };
   tilt = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0ch19amq0spj5dc240mv6s8hh245w7nis2h070qr3jm15r4jb21m";
+      sha256 = "092y84kak86ds2as9kwn5a9m2yzqwqcz4wx31jk3kin32c3hwcrn";
       type = "gem";
     };
-    version = "5.0.1";
+    version = "5.0.2";
   };
   xcodeproj = {
     dependencies = ["CFPropertyList" "atomos" "claide" "colored2" "nanaimo"];