semver.nix

{ lib, ireplace }:
let
  inherit (builtins) elemAt match;
  operators =
    let
      matchWildCard = s: match "([^*])(\\.[*])" s;
      mkComparison = ret: version: v: builtins.compareVersions version v == ret;
      mkIdxComparison = idx: version: v:
        let
          ver = builtins.splitVersion v;
          minor = builtins.toString (lib.toInt (elemAt ver idx) + 1);
          upper = builtins.concatStringsSep "." (ireplace idx minor ver);
        in
        operators.">=" version v && operators."<" version upper;
      dropWildcardPrecision = f: version: constraint:
        let
          m = matchWildCard constraint;
          hasWildcard = m != null;
          c = if hasWildcard then (elemAt m 0) else constraint;
          v =
            if hasWildcard then (builtins.substring 0 (builtins.stringLength c) version)
            else version;
        in
        f v c;
    in
    {
      # Prefix operators
      "==" = dropWildcardPrecision (mkComparison 0);
      ">" = dropWildcardPrecision (mkComparison 1);
      "<" = dropWildcardPrecision (mkComparison (-1));
      "!=" = v: c: ! operators."==" v c;
      ">=" = v: c: operators."==" v c || operators.">" v c;
      "<=" = v: c: operators."==" v c || operators."<" v c;
      # Semver specific operators
      "~" = mkIdxComparison 1;
      "^" = mkIdxComparison 0;
      "~=" = v: c:
        let
          # Prune constraint
          parts = builtins.splitVersion c;
          pruned = lib.take ((builtins.length parts) - 1) parts;
          upper = builtins.toString (
            (lib.toInt (builtins.elemAt pruned (builtins.length pruned - 1))) + 1
          );
          upperConstraint = builtins.concatStringsSep "." (ireplace (builtins.length pruned - 1) upper pruned);
        in
        operators.">=" v c && operators."<" v upperConstraint;
      # Infix operators
      "-" = version: v: operators.">=" version v.vl && operators."<=" version v.vu;
      # Arbitrary equality clause, just run simple comparison
      "===" = v: c: v == c;
      #
    };
  re = {
    operators = "([=><!~^]+)";
    version = "([0-9.*x]+)";
  };
  parseConstraint = constraint:
    let
      constraintStr = builtins.replaceStrings [ " " ] [ "" ] constraint;
      # The common prefix operators
      mPre = match "${re.operators} *${re.version}" constraintStr;
      # There is also an infix operator to match ranges
      mIn = match "${re.version} *(-) *${re.version}" constraintStr;
    in
    (
      if mPre != null then {
        op = elemAt mPre 0;
        v = elemAt mPre 1;
      }
      # Infix operators are range matches
      else if mIn != null then {
        op = elemAt mIn 1;
        v = {
          vl = (elemAt mIn 0);
          vu = (elemAt mIn 2);
        };
      }
      else throw "Constraint \"${constraintStr}\" could not be parsed"
    );
  satisfiesSemver = version: constraint:
    let
      inherit (parseConstraint constraint) op v;
    in
    if constraint == "*" then true else operators."${op}" version v;
in
{ inherit satisfiesSemver; }