From a4dca9524e867ede1f31c7f760a358008eb5c274 Mon Sep 17 00:00:00 2001 From: Shelvacu Date: Tue, 26 Aug 2025 20:06:51 -0700 Subject: [PATCH] stuff --- flake.lock | 51 +++++++++++ flake.nix | 13 +-- vaculib/ip.nix | 240 ++++++++++++++++++++++--------------------------- 3 files changed, 161 insertions(+), 143 deletions(-) diff --git a/flake.lock b/flake.lock index e85b644..950af89 100644 --- a/flake.lock +++ b/flake.lock @@ -1,5 +1,21 @@ { "nodes": { + "base16-schemes": { + "flake": false, + "locked": { + "lastModified": 1696158499, + "narHash": "sha256-5yIHgDTPjoX/3oDEfLSQ0eJZdFL1SaCfb9d6M0RmOTM=", + "owner": "tinted-theming", + "repo": "base16-schemes", + "rev": "a9112eaae86d9dd8ee6bb9445b664fba2f94037a", + "type": "github" + }, + "original": { + "owner": "tinted-theming", + "repo": "base16-schemes", + "type": "github" + } + }, "disko": { "inputs": { "nixpkgs": [ @@ -426,6 +442,25 @@ "type": "github" } }, + "nix-colors": { + "inputs": { + "base16-schemes": "base16-schemes", + "nixpkgs-lib": "nixpkgs-lib" + }, + "locked": { + "lastModified": 1707825078, + "narHash": "sha256-hTfge2J2W+42SZ7VHXkf4kjU+qzFqPeC9k66jAUBMHk=", + "owner": "Misterio77", + "repo": "nix-colors", + "rev": "b01f024090d2c4fc3152cd0cf12027a7b8453ba1", + "type": "github" + }, + "original": { + "owner": "Misterio77", + "repo": "nix-colors", + "type": "github" + } + }, "nix-formatter-pack": { "inputs": { "nixpkgs": [ @@ -585,6 +620,21 @@ "type": "github" } }, + "nixpkgs-lib": { + "locked": { + "lastModified": 1697935651, + "narHash": "sha256-qOfWjQ2JQSQL15KLh6D7xQhx0qgZlYZTYlcEiRuAMMw=", + "owner": "nix-community", + "repo": "nixpkgs.lib", + "rev": "e1e11fdbb01113d85c7f41cada9d2847660e3902", + "type": "github" + }, + "original": { + "owner": "nix-community", + "repo": "nixpkgs.lib", + "type": "github" + } + }, "nixpkgs-unstable": { "locked": { "lastModified": 1755852287, @@ -765,6 +815,7 @@ "impermanence": "impermanence", "jovian-unstable": "jovian-unstable", "most-winningest": "most-winningest", + "nix-colors": "nix-colors", "nix-on-droid": "nix-on-droid", "nixos-apple-silicon-unstable": "nixos-apple-silicon-unstable", "nixos-hardware": "nixos-hardware", diff --git a/flake.nix b/flake.nix index f366ee7..2faebf1 100644 --- a/flake.nix +++ b/flake.nix @@ -96,6 +96,8 @@ lib = import "${nixpkgs}/lib"; overlays = import ./overlays; vacuModules = import ./modules; + mkVaculib = { pkgs }: import ./vaculib { inherit pkgs; nix-colors-lib = allInputs.nix-colors.lib; }; + vaculib = mkVaculib { inherit pkgs; }; defaultSuffixedInputNames = [ "nixvim" "nixpkgs" @@ -144,7 +146,7 @@ pkgsUnstable = mkPkgs { unstable = true; inherit system; }; pkgs = if unstable then pkgsUnstable else pkgsStable; inputs = mkInputs { inherit unstable inp; }; - vaculib = import ./vaculib { inherit pkgs; }; + vaculib = mkVaculib { inherit pkgs; }; in { inherit pkgs pkgsStable pkgsUnstable inputs vaculib; @@ -176,7 +178,6 @@ in inner.config.vacu.withAsserts inner; pkgs = mkPkgs x86; - vaculib = import ./vaculib { inherit lib pkgs; nix-colors-lib = allInputs.nix-colors.lib; }; mkNixosConfig = { unstable ? false, @@ -396,14 +397,6 @@ // (allInputs.flake-utils.lib.eachDefaultSystem ( system: let - # nixpkgs-args = { - # inherit system; - # config.allowUnfree = true; - # overlays = [ inputs.sm64baserom.overlays.default ]; - # }; - # pkgs-unstable = mkPkgs (nixpkgs-args // { useUnstable = true; }); - # pkgs-stable = mkPkgs (nixpkgs-args // { useUnstable = false; }); - # vaculib = import ./vaculib { pkgs = pkgs-stable; }; mkNixvim = { unstable, minimal }: let diff --git a/vaculib/ip.nix b/vaculib/ip.nix index 8c0e7ff..878cbca 100644 --- a/vaculib/ip.nix +++ b/vaculib/ip.nix @@ -18,6 +18,9 @@ let isHexDigits = str: (builtins.match ''[0-9a-fA-F]+'' str) != null; + isIPAny = + obj: + lib.isAttrs obj && (obj._type or null) == "com.shelvacu.nix.ip"; mkVersionDataCore = { segmentCount, @@ -43,6 +46,9 @@ let (ipToStringCore obj) ++ lib.optionalString obj.hasPrefix "/${builtins.toString obj.prefixSize}"; + isIP = + obj: + isIPAny obj && obj.ipVersion == versionInt; mkIPCore = { segments, prefixSize ? null, ... }@args: assert vaculib.isListWhere (seg: lib.isInt seg && seg >= 0 && seg <= this.segmentValueMax) segments; assert prefixSize != null -> (lib.isInt prefixSize && prefixSize >= 0 && prefixSize <= this.bitSize); @@ -77,7 +83,7 @@ let isValidStr = str: (this.parseStrCore str).valid; - parseStr = + parse = str: builtins.addErrorContext ''While parsing ${lib.escapeNixString str} as ${this.versionString}'' (let @@ -86,6 +92,9 @@ let lib.throwIf (!innerParse.valid) "Invalid ${this.versionString} string" mkIP innerParse.mkArgs ); + publicMethods = { + inherit (this) mkIP isIP isValidStr parse; + }; }; in this; mkVersionData = @@ -93,11 +102,11 @@ let let result = mkVersionDataCore (f result); in result; - v4Data = mkVersionData (this: rec { + v4Data = mkVersionData (this: { segmentCount = 4; segmentBitSize = 8; versionInt = 4; - mkIP = this.mkIPCore; + mkIP = args: this.mkIPCore // { zone = null; hasZone = false; }; ipToStringCore = obj: lib.pipe obj.segments [ @@ -160,11 +169,18 @@ let innerParseStrCore = addrStr: let + ip4Regex = ''([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)''; + ip4ToIP6Fragment = + ip4: + [ + ((elemAt ip4 0) * 256 + (elemAt ip4 1)) + ((elemAt ip4 2) * 256 + (elemAt ip4 3)) + ]; withoutBrackets = lib.pipe addrStr [ (lib.removePrefix "[") (lib.removeSuffix "]") ]; - matches = builtins.match ''([0-9a-fA-F:]+)(${ip4Re})?(%[a-zA-Z0-9_-]+)?'' withoutBrackets; + matches = builtins.match ''([0-9a-fA-F:]+)(${ip4Regex})?(%[a-zA-Z0-9_-]+)?'' withoutBrackets; mainMatch = elemAt matches 0; ip4Match = elemAt matches 1; @@ -197,135 +213,93 @@ let { inherit valid; } // lib.optionalAttrs valid { mkArgs = { inherit segments zone; }; }; - # ipToStringCore = - # obj: - # lib.pipe obj.segments [ - # (map nix-colors-lib.decToHex) - # (lib.concatStringSep ":") - # ] ++ lib.optionalString ((obj.zoneIndex or null) != null) "%${obj.zoneIndex}"; - # regexCore = ''([0-9a-fA-F:]+)(:${v4Data.regex})?(%[a-zA-Z0-9_-]+)?''; - # regexWithBrackets = ''\[${regexCore}\]''; - # regex = ''${regexCore}|${regexWithBrackets}''; }); - ip4Re = ''([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)''; - subnetRe = ''(/([0-9]+))?''; - # parseIP6Side = - # str: - # let - # segmentStrs = lib.splitString ":" str; - # segmentStrs' = if segmentStrs == [ "" ] then [] else segmentStrs; - # segments = map nix-colors-lib.hexToDec segmentStrs'; - # in - # segments; - # parseIP6Plain = - # { str, aaa ? 0 }: - # let - # perSegmentBits = 4 * 4; - # segmentFullCount = (128 - aaa) / perSegmentBits; - # sides = lib.splitString "::" str; - # compressed = lib.length sides == 2; - # left = parseIP6Side (lib.head sides); - # right = if compressed then parseIP6Side (elemAt sides 1) else []; - # segmentCount = (lib.length left) + (lib.length right); - # middle = lib.genList (_: 0) (segmentFullCount - segmentCount); - # in - # assert lib.length sides == 1 || lib.length sides == 2; - # assert !compressed -> segmentCount == segmentFullCount; - # assert segmentCount <= segmentFullCount; - # left ++ middle ++ right; - ip4ToIP6Fragment = - ip4: - [ - ((elemAt ip4 0) * 256 + (elemAt ip4 1)) - ((elemAt ip4 2) * 256 + (elemAt ip4 3)) - ]; - # bitsToIP4Segment = - # bits: - # if bits <= 0 then 0 - # else if bits >= 8 then 255 - # else (vaculib.pow 2 bits) - 1; - # bitsToIP6Segment = - # bits: - # if bits <= 0 then 0 - # else if bits >= 16 then 65535 - # else (vaculib.pow 2 bits) - 1; - toStringIP4 = - obj: - (lib.pipe obj.segments [ - (map builtins.toString) - (lib.concatStringSep ".") - ]) ++ lib.optionalString obj.hasPrefix "/${builtins.toString obj.prefixSize}"; + methods = { + inherit isIPAny; + v4 = v4Data.publicMethods; + v6 = v6Data.publicMethods; + } // lib.pipe [ v4Data v6Data ] [ + (map (data: { + "mkIP${toString data.versionInt}" = data.mkIP; + "isIP${toString data.versionInt}" = data.isIP; + "isValidIP${toString data.versionInt}Str" = data.isValidStr; + "parseIP${toString data.versionInt}" = data.parse; + })) + lib.mergeAttrsList + ]; in -{ ip = rec { - isIP = obj: builtins.isAttrs obj && (obj._type or null) == "com.shelvacu.nix.ip"; - isIP4 = obj: isIP obj && obj.ipVersion == 4; - isIP6 = obj: isIP obj && obj.ipVersion == 6; +{ ip = methods; } +# { ip = { +# inherit isIPAny; - mkIP4 = { segments, prefixSize ? null }@args: - assert vaculib.isListWhere (seg: lib.isInt seg && seg >= 0 && seg <= 255) segments; - assert prefixSize != null -> (lib.isInt prefixSize && prefixSize >= 0 && prefixSize <= 32); - { - _type = "com.shelvacu.nix.ip"; - ipVersion = 4; - inherit segments; - __toString = toStringIP4; - hasPrefix = false; - toSubnet = mkIP4 (args // { prefixSize = 32; }); - } // lib.optionalAttrs (prefixSize != null) { - hasPrefix = true; - toSubnet = mkIP4 args; - inherit prefixSize; - subnetMask = mkIP4 { - segments = lib.genList (idx: bitsToIP4Segment (prefixSize - 8*idx)) 4; - }; - }; - - parseIP4 = - str: - builtins.addErrorContext ''While parsing ${lib.escapeNixString str} as IP4'' - (let - m = builtins.match ''${ip4Re}${subnetRe}'' str; - prefixMatch = elemAt m 5; - in - assert m != null; - mkIP4 { - segments = lib.pipe m [ - (lib.sublist 0 4) - (map lib.toInt) - ]; - prefixSize = if prefixMatch != null then lib.toInt prefixMatch else null; - }); - - mkIP6Subnet = { segments, prefixSize, zoneIndex }: - assert vaculib.isListWhere (seg: lib.isInt seg && seg >= 0 && seg <= 256 * 256) segments; - assert lib.isInt prefixSize; - assert prefixSize >= 0; - assert prefixSize <= 128; - assert zoneIndex == null && lib.isString zoneIndex; - { - _type = "com.shelvacu.nix.ip"; - ipVersion = 6; - inherit segments; - inherit prefixSize; - inherit zoneIndex; - }; - - parseIP6 = - str: - builtins.addErrorContext ''While parsing ${lib.escapeNixString str} as IP6'' - (let - segment = ''[0-9a-fA-F]{0,4}''; - scope = ''[0-9a-zA-Z]+''; - m = builtins.match ''((${segment}:)+(${segment}))(%${scope})?${subnetRe}'' str; - mIP4 = builtins.match ''((${segment}:)+)${ip4Re}${subnetRe}'' str; - prefixMatch = if m != null then elemAt m -1 else elemAt mIP4 -1; - ip4Match = elemAt mIP4 -2; - segments = if m != null then parseIP6Plain { str = (lib.head m); } else (parseIP6Plain { str = (lib.head mIP4); aaa = 32; }) ++ ip4ToIP6Fragment (parseIP4 ip4Match); - in - assert m != null || mIP4 != null; - mkIP6Subnet { - inherit segments; - prefixSize = if prefixMatch != null then lib.toInt prefixMatch else 128; - zoneIndex = if m != null then elemAt m -2 else null; - }); -}; } + # isIP4 = obj: isIP obj && obj.ipVersion == 4; + # isIP6 = obj: isIP obj && obj.ipVersion == 6; + # + # mkIP4 = { segments, prefixSize ? null }@args: + # assert vaculib.isListWhere (seg: lib.isInt seg && seg >= 0 && seg <= 255) segments; + # assert prefixSize != null -> (lib.isInt prefixSize && prefixSize >= 0 && prefixSize <= 32); + # { + # _type = "com.shelvacu.nix.ip"; + # ipVersion = 4; + # inherit segments; + # __toString = toStringIP4; + # hasPrefix = false; + # toSubnet = mkIP4 (args // { prefixSize = 32; }); + # } // lib.optionalAttrs (prefixSize != null) { + # hasPrefix = true; + # toSubnet = mkIP4 args; + # inherit prefixSize; + # subnetMask = mkIP4 { + # segments = lib.genList (idx: bitsToIP4Segment (prefixSize - 8*idx)) 4; + # }; + # }; + # + # parseIP4 = + # str: + # builtins.addErrorContext ''While parsing ${lib.escapeNixString str} as IP4'' + # (let + # m = builtins.match ''${ip4Re}${subnetRe}'' str; + # prefixMatch = elemAt m 5; + # in + # assert m != null; + # mkIP4 { + # segments = lib.pipe m [ + # (lib.sublist 0 4) + # (map lib.toInt) + # ]; + # prefixSize = if prefixMatch != null then lib.toInt prefixMatch else null; + # }); + # + # mkIP6Subnet = { segments, prefixSize, zoneIndex }: + # assert vaculib.isListWhere (seg: lib.isInt seg && seg >= 0 && seg <= 256 * 256) segments; + # assert lib.isInt prefixSize; + # assert prefixSize >= 0; + # assert prefixSize <= 128; + # assert zoneIndex == null && lib.isString zoneIndex; + # { + # _type = "com.shelvacu.nix.ip"; + # ipVersion = 6; + # inherit segments; + # inherit prefixSize; + # inherit zoneIndex; + # }; + # + # parseIP6 = + # str: + # builtins.addErrorContext ''While parsing ${lib.escapeNixString str} as IP6'' + # (let + # segment = ''[0-9a-fA-F]{0,4}''; + # scope = ''[0-9a-zA-Z]+''; + # m = builtins.match ''((${segment}:)+(${segment}))(%${scope})?${subnetRe}'' str; + # mIP4 = builtins.match ''((${segment}:)+)${ip4Re}${subnetRe}'' str; + # prefixMatch = if m != null then elemAt m -1 else elemAt mIP4 -1; + # ip4Match = elemAt mIP4 -2; + # segments = if m != null then parseIP6Plain { str = (lib.head m); } else (parseIP6Plain { str = (lib.head mIP4); aaa = 32; }) ++ ip4ToIP6Fragment (parseIP4 ip4Match); + # in + # assert m != null || mIP4 != null; + # mkIP6Subnet { + # inherit segments; + # prefixSize = if prefixMatch != null then lib.toInt prefixMatch else 128; + # zoneIndex = if m != null then elemAt m -2 else null; + # }); +# }; }