chore: remove all API code

flake.lock

@@ -49,60 +49,10 @@
         "type": "github"
       }
     },
-    "nixpkgs-lib_2": {
-      "locked": {
-        "lastModified": 1754788789,
-        "narHash": "sha256-x2rJ+Ovzq0sCMpgfgGaaqgBSwY+LST+WbZ6TytnT9Rk=",
-        "owner": "nix-community",
-        "repo": "nixpkgs.lib",
-        "rev": "a73b9c743612e4244d865a2fdee11865283c04e6",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "repo": "nixpkgs.lib",
-        "type": "github"
-      }
-    },
-    "nixpkgs_2": {
-      "locked": {
-        "lastModified": 1660438583,
-        "narHash": "sha256-rJUTYxFKlWUJI3njAwEc1pKAVooAViZGJvsgqfh/q/E=",
-        "owner": "nix-community",
-        "repo": "nixpkgs.lib",
-        "rev": "bbd8f7cd87d0b29294ef3072ffdbd61d60f05da4",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "repo": "nixpkgs.lib",
-        "type": "github"
-      }
-    },
     "root": {
       "inputs": {
         "flake-parts": "flake-parts",
-        "nixpkgs": "nixpkgs",
+        "nixpkgs": "nixpkgs"
-        "nixpkgs-lib": "nixpkgs-lib_2",
-        "yants": "yants"
-      }
-    },
-    "yants": {
-      "inputs": {
-        "nixpkgs": "nixpkgs_2"
-      },
-      "locked": {
-        "lastModified": 1686863218,
-        "narHash": "sha256-kooxYm3/3ornWtVBNHM3Zh020gACUyFX2G0VQXnB+mk=",
-        "owner": "divnix",
-        "repo": "yants",
-        "rev": "8f0da0dba57149676aa4817ec0c880fbde7a648d",
-        "type": "github"
-      },
-      "original": {
-        "owner": "divnix",
-        "repo": "yants",
-        "type": "github"
       }
     }
   },

flake.nix

@@ -1,10 +1,8 @@
 {
-  description = "My neovim configuration";
+  description = "Sloth-flake - a nix power neovim plugin manager";
 
   inputs = {
     nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
-    nixpkgs-lib.url = "github:nix-community/nixpkgs.lib";
-    yants.url = "github:divnix/yants";
     flake-parts.url = "github:hercules-ci/flake-parts";
   };
 

lib/default.nix

@@ -1,22 +1,11 @@
-{
+{self, ...}: let
-  self,
-  inputs,
-  ...
-}: let
   inherit (builtins) readFile replaceStrings;
   versionFile = replaceStrings ["\n"] [""] (readFile ../VERSION);
-  version =
+  dirty =
     if self.sourceInfo ? dirtyShortRev
-    then "${versionFile}-${self.sourceInfo.dirtyShortRev}"
+    then "-${self.sourceInfo.dirtyShortRev}"
-    else versionFile;
+    else "";
-
+  version = "${versionFile}${dirty}";
-  types = import ./types.nix {inherit (inputs) yants;};
 in {
-  flake = {
+  flake.mkLib = import ./lib.nix {inherit version;};
-    lib = {
-      mkNeovimPkg = import ./mkNeovimPkg.nix {inherit version types;};
-      mkPluginsFromInputs = import ./oldMkPluginsFromInputs.nix;
-    };
-    mkLib = import ./lib.nix {inherit version;};
-  };
 }

lib/deps.nix

@@ -1,200 +0,0 @@
-{
-  pkgs,
-  lib,
-  vimUtils,
-  dependenciesExtraArgs,
-  types,
-  ...
-}: let
-  inherit (builtins) foldl' isPath isList isString mapAttrs match elemAt;
-  inherit (lib.attrsets) attrNames optionalAttrs;
-  inherit (lib.lists) concatMap;
-  inherit (lib.strings) fileContents splitString;
-  lua = callPackage ./legacyLua.nix {};
-  callPackage = lib.callPackageWith (pkgs // dependenciesExtraArgs);
-
-  hasMatch = pattern: str: isList (match pattern str);
-  wrapArray = value:
-    if isList value
-    then value
-    else [value];
-
-  defaultPlugin = {
-    enabled = true;
-    init = null;
-    config = null;
-    dependencies = [];
-    lazy = false;
-    cmd = [];
-    ft = [];
-    events = [];
-    keymaps = [];
-  };
-
-  remotePluginToNeovimPlugin = p:
-    vimUtils.buildVimPlugin rec {
-      inherit (p) src name;
-      pname = name;
-    };
-
-  defaultKeymap = {mode = "n";};
-  normalizeKeymap = keymap: let
-    value = (
-      if isString keymap
-      then {mapping = keymap;}
-      else keymap
-    );
-  in
-    mapAttrs (_: wrapArray) (defaultKeymap // value);
-  normalizeKeymaps = keymaps:
-    if isList keymaps
-    then map normalizeKeymap keymaps
-    else [(normalizeKeymap keymaps)];
-
-  normalizeEvent = event: let
-    value =
-      if ! isString event
-      then event
-      else if ! hasMatch ".* .*" event
-      then {name = event;}
-      else let
-        part = elemAt (splitString " " event);
-      in {
-        name = part 0;
-        pattern = part 1;
-      };
-  in
-    mapAttrs (_: wrapArray) value;
-  normalizeEvents = events:
-    if isList events
-    then map normalizeEvent events
-    else [(normalizeEvent events)];
-
-  withPluginDefaults = dep: defaultPlugin // dep;
-  normalizePlugin = d: let
-    dep = types.dependency d;
-    plugin =
-      if ! dep ? plugin
-      then {plugin = dep;}
-      else let
-        inherit (dep) plugin;
-      in
-        if attrNames plugin == ["name" "src"]
-        then dep // {plugin = remotePluginToNeovimPlugin plugin;}
-        else dep;
-    p = withPluginDefaults plugin;
-  in
-    p
-    // rec {
-      hasCommands = p.cmd != [];
-      hasFileTypes = p.ft != [];
-      keymaps = normalizeKeymaps p.keymaps;
-      hasKeymaps = p.keymaps != [];
-      events = normalizeEvents p.events;
-      hasEvents = p.events != [];
-      lazy = p.lazy || hasCommands || hasFileTypes || hasEvents || hasKeymaps;
-      optional = lazy || p.init != null;
-    };
-
-  normalizeOrImportPlugin = dep:
-    if isPath dep
-    then normalizePlugins (callPackage dep {})
-    else [(normalizePlugin dep)];
-  normalizePlugins = concatMap normalizeOrImportPlugin;
-
-  mkRuntimePlugin = {
-    src,
-    version,
-    ...
-  }@opts:
-    vimUtils.buildVimPlugin ({
-        inherit src;
-      }
-      // (optionalAttrs (opts ? nvimRequireCheck) {
-        inherit (opts) nvimRequireCheck;
-      })
-      // (optionalAttrs (isNull version) {
-        name = "runtime";
-      })
-      // (optionalAttrs (! isNull version) {
-        inherit version;
-        pname = "runtime";
-      }));
-
-  mkSlothFlakePlugin = version: plugins:
-    vimUtils.buildVimPlugin {
-      inherit version;
-      pname = "sloth-flake";
-      src = with lib.fileset;
-        toSource {
-          root = ../.;
-          fileset = ../lua/sloth-flake;
-        };
-      nvimRequireCheck = "sloth-flake";
-      buildPhase = ''
-        dir=lua/sloth-flake
-
-        cat <<'LUA' > $dir/dependencies.lua
-        ${pluginsLuaDef plugins}
-        LUA
-
-        cat <<'LUA' > $dir/version.lua
-        ${versionLua version}
-        LUA
-      '';
-    };
-
-  versionLua = version: with lua; nix2lua (return (lambda [] (return version)));
-
-  textOrContent = content:
-    if isPath content
-    then fileContents content
-    else content;
-
-  pluginLuaDef = memo: plugin: let
-    mkTypeFn = type: let
-      content = textOrContent plugin.${type};
-    in
-      optionalAttrs (! isNull plugin.${type}) {
-        ${type} = with lua; lambda [] (raw content);
-      };
-    pluginName = plugin:
-      if plugin ? pname
-      then plugin.pname
-      else plugin.name;
-    name = pluginName plugin.plugin;
-  in
-    memo
-    // {
-      ${name} =
-        {
-          name = pluginName plugin.plugin;
-          dependencies = map pluginName plugin.dependencies;
-        }
-        // (mkTypeFn "init")
-        // (mkTypeFn "config")
-        // (optionalAttrs plugin.lazy {
-          lazy = true;
-        })
-        // (optionalAttrs plugin.hasCommands {
-          inherit (plugin) cmd;
-        })
-        // (optionalAttrs plugin.hasFileTypes {
-          inherit (plugin) ft;
-        })
-        // (optionalAttrs plugin.hasEvents {
-          inherit (plugin) events;
-        })
-        // (optionalAttrs plugin.hasKeymaps {
-          inherit (plugin) keymaps;
-        });
-    };
-  pluginsLuaDef = plugins:
-    with lua; nix2lua (return (foldl' pluginLuaDef {} plugins));
-in {
-  inherit normalizePlugin;
-  inherit normalizePlugins;
-  inherit mkSlothFlakePlugin;
-  inherit mkRuntimePlugin;
-  inherit textOrContent;
-}

lib/legacyLua.nix

@@ -1,92 +0,0 @@
-{...}: let
-  inherit (builtins) match isNull typeOf concatStringsSep attrNames concatMap;
-  fix = f: let x = f x; in x;
-
-  commaJoin = concatStringsSep ", ";
-  wrapNotNull' = val: value:
-    if isNull val
-    then []
-    else [value];
-  wrapNotNull = val: wrapNotNull' val val;
-
-  toLua = {
-    ast = {
-      raw = {data, ...}: data;
-      return = {data, ...}: "return ${nix2lua data}";
-      fn = {
-        data,
-        name,
-        args,
-        ...
-      }: "function ${name}(${commaJoin args})\n${nix2lua data}\nend";
-    };
-
-    type = fix (type: {
-      null = _: "nil";
-      string = data: ''"${data}"'';
-      path = type.string;
-      lambda = data: builtins.trace "Skipping function" null;
-      int = data: toString data;
-
-      bool = data:
-        if data
-        then "true"
-        else "false";
-
-      ast = data: let
-        astType = data.__ast;
-      in
-        if toLua.ast ? ${astType}
-        then toLua.ast.${astType} data
-        else abort ''Unknown ast type ${astType}'';
-
-      list = data: let
-        nix2luaList = val: wrapNotNull (nix2lua val);
-        listContent = commaJoin (concatMap nix2luaList data);
-      in "{ ${listContent} }";
-
-      set = data: let
-        mkKeyValue = key: let
-          value = data.${key};
-          luaKey =
-            if isNull (match "[a-zA-Z_][a-zA-Z_0-9]+" key)
-            then ''["${key}"]''
-            else key;
-          luaValue = nix2lua value;
-        in
-          wrapNotNull' luaValue ''
-            ${luaKey} = ${luaValue},
-          '';
-        attrsContent = concatMap mkKeyValue (attrNames data);
-      in ''
-        {
-          ${concatStringsSep "" attrsContent}}
-      '';
-    });
-  };
-
-  newAst = type: set: set // {__ast = type;};
-
-  nix2lua = data: let
-    type = typeOf data;
-  in
-    if data ? __ast
-    then toLua.type.ast data
-    else if toLua.type ? ${type}
-    then toLua.type.${type} data
-    else abort ''Type "${type}"'';
-in
-  fix (lua: {
-    inherit nix2lua;
-
-    raw = data: newAst "raw" {inherit data;};
-
-    function = name: args: data:
-      newAst "fn" {
-        inherit name data args;
-      };
-
-    lambda = lua.function "";
-
-    return = data: newAst "return" {inherit data;};
-  })

lib/mkNeovimPkg.nix

@@ -1,117 +0,0 @@
-{
-  version,
-  types,
-}: {
-  pkgs,
-  package ? pkgs.neovim-unwrapped,
-  dependencies ? [],
-  dependenciesExtraArgs ? {},
-  extraLuaPackages ? (_: []),
-  runtime ? null,
-  init ? null,
-  viAlias ? false,
-  vimAlias ? false,
-  vimdiffAlias ? false,
-  nvimdiffAlias ? false,
-  ...
-} @ config: let
-  inherit (builtins) isString isPath map;
-  inherit (pkgs) callPackage bash lib;
-  inherit (lib.strings) optionalString;
-  inherit (lib.lists) concatMap optional;
-  inherit (lib.trivial) flip;
-  inherit (lib.attrsets) optionalAttrs;
-
-  deps = callPackage ./deps.nix {inherit dependenciesExtraArgs types;};
-
-  normalizedPlugins = deps.normalizePlugins dependencies;
-  sloth-flake = deps.mkSlothFlakePlugin version normalizedPlugins;
-  runtimePlugin = deps.mkRuntimePlugin runtime;
-  plugins =
-    normalizedPlugins
-    ++ (
-      deps.normalizePlugins
-      ([sloth-flake] ++ (optional (runtime != null) runtimePlugin))
-    );
-
-  extractPlugin = p: {inherit (p) optional plugin;};
-  extractPlugins = map extractPlugin;
-
-  extractLuaPackageFn = plugin:
-    optional (plugin ? extraLuaPackages) plugin.extraLuaPackages;
-  extractLuaPackagesFn = plugins: let
-    fnList = concatMap extractLuaPackageFn plugins;
-    concatPackages = ps: fn: fn ps;
-  in
-    ps: concatMap (concatPackages ps) fnList;
-
-  buildInit = {
-    init ? null,
-    postInit ? null,
-    config ? null,
-  }: let
-    initStr = optionalString (! isNull init) ''
-      (function()
-      ${deps.textOrContent init}
-      end)();
-
-    '';
-
-    slothCall =
-      if isNull postInit
-      then "require('sloth-flake').setup {}"
-      else ''
-        require('sloth-flake').setup {
-          post_init = function()
-            ${deps.textOrContent postInit}
-          end,
-        };
-      '';
-
-    configStr = optionalString (! isNull config) ''
-
-      (function()
-      ${deps.textOrContent config}
-      end)()
-    '';
-  in ''
-    -- Generated by sloth-flake
-    ${initStr}
-    ${slothCall}
-    ${configStr}
-  '';
-
-  customRC =
-    if isString init || isPath init
-    then deps.textOrContent init
-    else buildInit (optionalAttrs (! isNull init) init);
-
-  neovimConfig = pkgs.neovimUtils.makeNeovimConfig {
-    # inherit customRC;
-    customLuaRC = customRC;
-    plugins = extractPlugins plugins;
-    extraLuaPackages = ps:
-      (extractLuaPackagesFn plugins ps) ++ (extraLuaPackages ps);
-    inherit viAlias vimAlias;
-    # autoconfigure = false;
-  };
-  # // {luaRcContent = customRC;};
-  # params =
-  #   removeAttrs neovimConfig ["neovimRcContent"]
-  #   // {inherit viAlias vimAlias;};
-  pkg = pkgs.wrapNeovimUnstable package neovimConfig;
-  mkDiffAlias = name:
-    (flip optionalString) ''
-      cat <<SH > $out/bin/${name}
-      #!${bash}/bin/bash
-      exec $out/bin/nvim -d "\''${@}"
-      SH
-      chmod 555 $out/bin/${name}
-    '';
-in
-  builtins.seq (types.mkNeovimPkgOptions config) (pkg.overrideAttrs (final: super: {
-    postBuild =
-      super.postBuild
-      + (mkDiffAlias "vimdiff" vimdiffAlias)
-      + (mkDiffAlias "nvimdiff" nvimdiffAlias);
-  }))

lib/oldMkPluginsFromInputs.nix

@@ -1,20 +0,0 @@
-{
-  pkgs,
-  inputs,
-  predicate ? pkgs.lib.strings.hasPrefix "plugin-",
-  nameMap ? builtins.substring 7 (-1),
-  buildVimPlugin ? pkgs.vimUtils.buildVimPlugin,
-}: let
-  inherit (builtins) attrNames filter foldl' mapAttrs;
-  names = filter predicate (attrNames inputs);
-  mkPlugin = m: k: let
-    name = nameMap k;
-    pluginDef = {
-      inherit name;
-      src = inputs.${k};
-    };
-  in
-    m // {${name} = pluginDef;};
-  plugins = foldl' mkPlugin {} names;
-in
-  mapAttrs (_: buildVimPlugin) plugins

lib/types.nix

@@ -1,138 +0,0 @@
-{yants, ...}: let
-  stringList = with yants; list string;
-  stringOrStringList = with yants; either string stringList;
-  stringOrStringListOr = type:
-    with yants;
-      option (eitherN [string type (list (either string type))]);
-in rec {
-  # The runtime object
-  runtimeType = with yants;
-    openStruct "runtime" {
-      # The version of the runtime
-      version = option string;
-
-      # The content of the runtime directory
-      src = any;
-    };
-
-  neovimInitType = with yants;
-    struct "neovimInit" {
-      # Lua code to call before plugins loaded
-      init = option (either string path);
-      # Lua code called after init but before import
-      postInit = option (either string path);
-      # Lua code called after all plugins are loaded
-      config = option (either string path);
-    };
-
-  # As simple remote plugin definition
-  basicPluginType = with yants;
-    struct "basicPlugin" {
-      # The name of your plugin.
-      name = string;
-      # The sources of your plugin
-      # TODO What is the type of a source ?
-      src = any;
-    };
-
-  eventType = with yants;
-    struct "event" {
-      # The name of the event
-      name = stringOrStringList;
-      # The pattern of the event
-      pattern = stringOrStringList;
-    };
-
-  keymapType = with yants;
-    struct "keymap" {
-      # The mode of the keymap
-      mode = option stringOrStringList;
-      # The mapping of the keymap
-      mapping = stringOrStringList;
-    };
-
-  # The plugin type of dependencies
-  pluginType = with yants;
-    struct "plugin" {
-      # Whether this plugin should be enabled. This option allows specific
-      # plugins to be disabled.
-      # enable = option bool;
-
-      # The init configuration of your plugin.
-      # This should be called before loading your plugin.
-      init = option (either path string);
-
-      # The configuration of your plugin.
-      # This should be called after loading your plugin.
-      config = option (either path string);
-
-      # Ensure thoses plugins are loaded before the current one
-      plugin = either drv basicPluginType;
-
-      # Ensure thoses plugins are loaded before the current one
-      dependencies = option (list drv);
-
-      # Ensure those packages are available
-      extraLuaPackages = option function;
-
-      # Should this plugin be load lazily ?
-      lazy = option bool;
-
-      # List of events on which the plugin should be loaded
-      events = option (stringOrStringListOr eventType);
-
-      # List of commands on which the plugin should be loaded
-      cmd = option stringList;
-
-      # List of filetypes on which the plugin should be loaded
-      ft = option stringList;
-
-      # List of keystrokes on which the plugin should be loaded
-      keymaps = option (stringOrStringListOr keymapType);
-
-      # Priority of the module. Influence the order of loading plugins.
-      # Highest values get loaded before.
-      # priority = option int;
-    };
-
-  # A dependency.
-  # TODO Complete doc
-  dependency = with yants; eitherN [path drv pluginType];
-
-  mkNeovimPkgOptions = with yants;
-    struct "mkNeovimPkgOptions" {
-      # The configuration of mkNeovimPkg
-      pkgs = attrs any;
-
-      # The neovim package to wrap with your conifguration.
-      # Default is pkgs.neovim-unwrapped
-      package = option drv;
-
-      # init.lua configuration
-      init = option (eitherN [string path neovimInitType]);
-
-      # An array of dependencies.
-      dependencies = option (list dependency);
-
-      # Extra argument to pass to dependencies files
-      dependenciesExtraArgs = option (attrs any);
-
-      # Ensure those packages are available
-      extraLuaPackages = option function;
-
-      # Runtime configuration
-      runtime = option runtimeType;
-
-      # Create a vi alias
-      viAlias = option bool;
-
-      # Create a vim alias
-      vimAlias = option bool;
-
-      # Create a vimdiff alias to run neovim in diff mode
-      vimdiffAlias = option bool;
-
-      # Create a nvimdiff alias to run neovim in diff mode
-      nvimdiffAlias = option bool;
-    };
-}