diff --git a/pkgs/applications/editors/vim/plugins/vim-utils.nix b/pkgs/applications/editors/vim/plugins/vim-utils.nix index 512b1b39cc3e..164245be176f 100644 --- a/pkgs/applications/editors/vim/plugins/vim-utils.nix +++ b/pkgs/applications/editors/vim/plugins/vim-utils.nix @@ -1,219 +1,239 @@ # tests available at pkgs/test/vim -{ lib, stdenv, vim, vimPlugins, buildEnv, writeText -, runCommand, makeWrapper -, python3 -, callPackage, makeSetupHook -, linkFarm -, config +{ + lib, + stdenv, + vim, + vimPlugins, + buildEnv, + writeText, + runCommand, + makeWrapper, + python3, + callPackage, + makeSetupHook, + linkFarm, + config, }: /* + USAGE EXAMPLE + ============= -USAGE EXAMPLE -============= + Install Vim like this eg using nixos option environment.systemPackages which will provide + vim-with-plugins in PATH: -Install Vim like this eg using nixos option environment.systemPackages which will provide -vim-with-plugins in PATH: + vim-full.customize { + name = "vim-with-plugins"; # optional - vim-full.customize { - name = "vim-with-plugins"; # optional + # add custom .vimrc lines like this: + vimrcConfig.customRC = '' + set hidden + ''; - # add custom .vimrc lines like this: - vimrcConfig.customRC = '' - set hidden - ''; - - # store your plugins in Vim packages - vimrcConfig.packages.myVimPackage = with pkgs.vimPlugins; { - # loaded on launch - start = [ youcompleteme fugitive ]; - # manually loadable by calling `:packadd $plugin-name` - opt = [ phpCompletion elm-vim ]; - # To automatically load a plugin when opening a filetype, add vimrc lines like: - # autocmd FileType php :packadd phpCompletion + # store your plugins in Vim packages + vimrcConfig.packages.myVimPackage = with pkgs.vimPlugins; { + # loaded on launch + start = [ youcompleteme fugitive ]; + # manually loadable by calling `:packadd $plugin-name` + opt = [ phpCompletion elm-vim ]; + # To automatically load a plugin when opening a filetype, add vimrc lines like: + # autocmd FileType php :packadd phpCompletion + }; }; - }; -WHAT IS A VIM PLUGIN? -===================== -Typical plugin files: + WHAT IS A VIM PLUGIN? + ===================== + Typical plugin files: - plugin/P1.vim - autoload/P1.vim - ftplugin/xyz.vim - doc/plugin-documentation.txt (traditional documentation) - README(.md) (nowadays thanks to github) + plugin/P1.vim + autoload/P1.vim + ftplugin/xyz.vim + doc/plugin-documentation.txt (traditional documentation) + README(.md) (nowadays thanks to github) + Vim offers the :h rtp setting which works for most plugins. Thus adding + this to your .vimrc should make most plugins work: -Vim offers the :h rtp setting which works for most plugins. Thus adding -this to your .vimrc should make most plugins work: + set rtp+=~/.nix-profile/share/vim-plugins/youcompleteme + " or for p in ["youcompleteme"] | exec 'set rtp+=~/.nix-profile/share/vim-plugins/'.p | endfor - set rtp+=~/.nix-profile/share/vim-plugins/youcompleteme - " or for p in ["youcompleteme"] | exec 'set rtp+=~/.nix-profile/share/vim-plugins/'.p | endfor + Learn about about plugin Vim plugin mm managers at + http://vim-wiki.mawercer.de/wiki/topic/vim%20plugin%20managment.html. -Learn about about plugin Vim plugin mm managers at -http://vim-wiki.mawercer.de/wiki/topic/vim%20plugin%20managment.html. + The documentation can be accessed by Vim's :help command if it was tagged. + See vimHelpTags sample code below. -The documentation can be accessed by Vim's :help command if it was tagged. -See vimHelpTags sample code below. + CONTRIBUTING AND CUSTOMIZING + ============================ + The example file pkgs/applications/editors/vim/plugins/default.nix provides + both: + * manually mantained plugins + * plugins created by VAM's nix#ExportPluginsForNix implementation -CONTRIBUTING AND CUSTOMIZING -============================ -The example file pkgs/applications/editors/vim/plugins/default.nix provides -both: -* manually mantained plugins -* plugins created by VAM's nix#ExportPluginsForNix implementation + I highly recommend to lookup vim plugin attribute names at the [vim-pi] project + which is a database containing all plugins from + vim.org and quite a lot of found at github and similar sources. vim-pi's documented purpose + is to associate vim.org script ids to human readable names so that dependencies + can be describe easily. -I highly recommend to lookup vim plugin attribute names at the [vim-pi] project - which is a database containing all plugins from -vim.org and quite a lot of found at github and similar sources. vim-pi's documented purpose -is to associate vim.org script ids to human readable names so that dependencies -can be describe easily. + How to find a name? + * http://vam.mawercer.de/ or VAM's + * grep vim-pi + * use VAM's completion or :AddonsInfo command -How to find a name? - * http://vam.mawercer.de/ or VAM's - * grep vim-pi - * use VAM's completion or :AddonsInfo command + It might happen than a plugin is not known by vim-pi yet. We encourage you to + contribute to vim-pi so that plugins can be updated automatically. -It might happen than a plugin is not known by vim-pi yet. We encourage you to -contribute to vim-pi so that plugins can be updated automatically. + CREATING DERIVATIONS AUTOMATICALLY BY PLUGIN NAME + ================================================== + Most convenient is to use a ~/.vim-scripts file putting a plugin name into each line + as documented by [VAM]'s README.md + It is the same format you pass to vimrcConfig.vam.pluginDictionaries from the + usage example above. + Then create a temp vim file and insert: -CREATING DERIVATIONS AUTOMATICALLY BY PLUGIN NAME -================================================== -Most convenient is to use a ~/.vim-scripts file putting a plugin name into each line -as documented by [VAM]'s README.md -It is the same format you pass to vimrcConfig.vam.pluginDictionaries from the -usage example above. + let opts = {} + let opts.path_to_nixpkgs = '/etc/nixos/nixpkgs' + let opts.cache_file = '/tmp/export-vim-plugin-for-nix-cache-file' + let opts.plugin_dictionaries = map(readfile("vim-plugins"), 'eval(v:val)') + " add more files + " let opts.plugin_dictionaries += map(.. other file ) + call nix#ExportPluginsForNix(opts) -Then create a temp vim file and insert: + Then ":source %" it. - let opts = {} - let opts.path_to_nixpkgs = '/etc/nixos/nixpkgs' - let opts.cache_file = '/tmp/export-vim-plugin-for-nix-cache-file' - let opts.plugin_dictionaries = map(readfile("vim-plugins"), 'eval(v:val)') - " add more files - " let opts.plugin_dictionaries += map(.. other file ) - call nix#ExportPluginsForNix(opts) + nix#ExportPluginsForNix is provided by ./vim2nix -Then ":source %" it. + A buffer will open containing the plugin derivation lines as well list + fitting the vimrcConfig.vam.pluginDictionaries option. -nix#ExportPluginsForNix is provided by ./vim2nix + Thus the most simple usage would be: -A buffer will open containing the plugin derivation lines as well list -fitting the vimrcConfig.vam.pluginDictionaries option. + vim_with_plugins = + let vim = vim-full; + inherit (vimUtil.override {inherit vim}) rtpPath addRtp buildVimPlugin vimHelpTags; + vimPlugins = [ + # the derivation list from the buffer created by nix#ExportPluginsForNix + # don't set which will default to pkgs.vimPlugins + ]; + in vim.customize { + name = "vim-with-plugins"; -Thus the most simple usage would be: + vimrcConfig.customRC = '' .. ''; - vim_with_plugins = - let vim = vim-full; - inherit (vimUtil.override {inherit vim}) rtpPath addRtp buildVimPlugin vimHelpTags; - vimPlugins = [ - # the derivation list from the buffer created by nix#ExportPluginsForNix - # don't set which will default to pkgs.vimPlugins + vimrcConfig.vam.knownPlugins = vimPlugins; + vimrcConfig.vam.pluginDictionaries = [ + # the plugin list form ~/.vim-scripts turned into nix format added to + # the buffer created by the nix#ExportPluginsForNix ]; - in vim.customize { - name = "vim-with-plugins"; + } - vimrcConfig.customRC = '' .. ''; + vim_with_plugins can be installed like any other application within Nix. - vimrcConfig.vam.knownPlugins = vimPlugins; - vimrcConfig.vam.pluginDictionaries = [ - # the plugin list form ~/.vim-scripts turned into nix format added to - # the buffer created by the nix#ExportPluginsForNix - ]; - } - -vim_with_plugins can be installed like any other application within Nix. - -[VAM] https://github.com/MarcWeber/vim-addon-manager -[vim-pi] https://bitbucket.org/vimcommunity/vim-pi + [VAM] https://github.com/MarcWeber/vim-addon-manager + [vim-pi] https://bitbucket.org/vimcommunity/vim-pi */ - let inherit lib; # make sure a plugin is a derivation and its dependencies are derivations. If # plugin already is a derivation, this is a no-op. If it is a string, it is # looked up in knownPlugins. - pluginToDrv = knownPlugins: plugin: - let - drv = - if builtins.isString plugin then - # make sure `pname` is set to that we are able to convert the derivation - # back to a string. - ( knownPlugins.${plugin} // { pname = plugin; }) - else - plugin; - in + pluginToDrv = + knownPlugins: plugin: + let + drv = + if builtins.isString plugin then + # make sure `pname` is set to that we are able to convert the derivation + # back to a string. + (knownPlugins.${plugin} // { pname = plugin; }) + else + plugin; + in # make sure all the dependencies of the plugin are also derivations - drv // { dependencies = map (pluginToDrv knownPlugins) (drv.dependencies or []); }; + drv // { dependencies = map (pluginToDrv knownPlugins) (drv.dependencies or [ ]); }; # transitive closure of plugin dependencies (plugin needs to be a derivation) - transitiveClosure = plugin: - [ plugin ] ++ ( - lib.unique (builtins.concatLists (map transitiveClosure plugin.dependencies or [])) - ); + transitiveClosure = + plugin: + [ plugin ] + ++ (lib.unique (builtins.concatLists (map transitiveClosure plugin.dependencies or [ ]))); findDependenciesRecursively = plugins: lib.concatMap transitiveClosure plugins; - vamDictToNames = x: - if builtins.isString x then [x] - else (lib.optional (x ? name) x.name) - ++ (x.names or []); + vamDictToNames = + x: if builtins.isString x then [ x ] else (lib.optional (x ? name) x.name) ++ (x.names or [ ]); rtpPath = "."; - vimFarm = prefix: name: drvs: - let mkEntryFromDrv = drv: { name = "${prefix}/${lib.getName drv}"; path = drv; }; - in linkFarm name (map mkEntryFromDrv drvs); - - /* Generates a packpath folder as expected by vim - Example: - packDir (myVimPackage.{ start = [ vimPlugins.vim-fugitive ]; opt = [] }) - => "/nix/store/xxxxx-pack-dir" - */ - packDir = packages: - let - packageLinks = packageName: {start ? [], opt ? []}: + vimFarm = + prefix: name: drvs: 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; - allPlugins = lib.unique (startWithDeps ++ depsOfOptionalPlugins); - allPython3Dependencies = ps: - lib.flatten (builtins.map (plugin: (plugin.python3Dependencies or (_: [])) ps) allPlugins); - python3Env = python3.withPackages allPython3Dependencies; + mkEntryFromDrv = drv: { + name = "${prefix}/${lib.getName drv}"; + path = drv; + }; + in + linkFarm name (map mkEntryFromDrv drvs); - packdirStart = vimFarm "pack/${packageName}/start" "packdir-start" allPlugins; - packdirOpt = vimFarm "pack/${packageName}/opt" "packdir-opt" opt; - # Assemble all python3 dependencies into a single `site-packages` to avoid doing recursive dependency collection - # for each plugin. - # This directory is only for python import search path, and will not slow down the startup time. - # see :help python3-directory for more details - python3link = runCommand "vim-python3-deps" {} '' - mkdir -p $out/pack/${packageName}/start/__python3_dependencies - ln -s ${python3Env}/${python3Env.sitePackages} $out/pack/${packageName}/start/__python3_dependencies/python3 - ''; + /* + Generates a packpath folder as expected by vim + Example: + packDir (myVimPackage.{ start = [ vimPlugins.vim-fugitive ]; opt = [] }) + => "/nix/store/xxxxx-pack-dir" + */ + packDir = + packages: + let + 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; + allPlugins = lib.unique (startWithDeps ++ depsOfOptionalPlugins); + allPython3Dependencies = + ps: lib.flatten (builtins.map (plugin: (plugin.python3Dependencies or (_: [ ])) ps) allPlugins); + python3Env = python3.withPackages allPython3Dependencies; + + packdirStart = vimFarm "pack/${packageName}/start" "packdir-start" allPlugins; + packdirOpt = vimFarm "pack/${packageName}/opt" "packdir-opt" opt; + # Assemble all python3 dependencies into a single `site-packages` to avoid doing recursive dependency collection + # for each plugin. + # This directory is only for python import search path, and will not slow down the startup time. + # see :help python3-directory for more details + python3link = runCommand "vim-python3-deps" { } '' + mkdir -p $out/pack/${packageName}/start/__python3_dependencies + ln -s ${python3Env}/${python3Env.sitePackages} $out/pack/${packageName}/start/__python3_dependencies/python3 + ''; + in + [ + packdirStart + packdirOpt + ] + ++ lib.optional (allPython3Dependencies python3.pkgs != [ ]) python3link; in - [ packdirStart packdirOpt ] ++ lib.optional (allPython3Dependencies python3.pkgs != []) python3link; - in buildEnv { name = "vim-pack-dir"; paths = (lib.flatten (lib.mapAttrsToList packageLinks packages)); }; - nativeImpl = packages: - '' + nativeImpl = packages: '' set packpath^=${packDir packages} set runtimepath^=${packDir packages} ''; - /* Generates a vimrc string + /* + Generates a vimrc string packages is an attrset with {name: { start = [ vim derivations ]; opt = [ vim derivations ]; } Example: @@ -224,58 +244,67 @@ let customRC = ''let mapleader = " "''; }; - */ - vimrcContent = { - packages ? null, - vam ? null, # deprecated - pathogen ? null, # deprecated - plug ? null, - beforePlugins ? '' - " configuration generated by NIX - set nocompatible - '', - customRC ? null - }: + */ + vimrcContent = + { + packages ? null, + vam ? null, # deprecated + pathogen ? null, # deprecated + plug ? null, + beforePlugins ? '' + " configuration generated by NIX + set nocompatible + '', + customRC ? null, + }: let - /* vim-plug is an extremely popular vim plugin manager. - */ + # vim-plug is an extremely popular vim plugin manager. plugImpl = - '' - source ${vimPlugins.vim-plug}/plug.vim - silent! call plug#begin('/dev/null') + '' + source ${vimPlugins.vim-plug}/plug.vim + silent! call plug#begin('/dev/null') - '' + (lib.concatMapStringsSep "\n" (pkg: "Plug '${pkg}'") plug.plugins) + '' + '' + + (lib.concatMapStringsSep "\n" (pkg: "Plug '${pkg}'") plug.plugins) + + '' - call plug#end() - ''; + call plug#end() + ''; - # vim-addon-manager = VAM (deprecated) + # vim-addon-manager = VAM (deprecated) vamImpl = - let - knownPlugins = vam.knownPlugins or vimPlugins; + let + knownPlugins = vam.knownPlugins or vimPlugins; - # plugins specified by the user - specifiedPlugins = map (pluginToDrv knownPlugins) (lib.concatMap vamDictToNames vam.pluginDictionaries); - # plugins with dependencies - plugins = findDependenciesRecursively specifiedPlugins; - vamPackages.vam = { - start = plugins; - }; - in + # plugins specified by the user + specifiedPlugins = map (pluginToDrv knownPlugins) ( + lib.concatMap vamDictToNames vam.pluginDictionaries + ); + # plugins with dependencies + plugins = findDependenciesRecursively specifiedPlugins; + vamPackages.vam = { + start = plugins; + }; + in nativeImpl vamPackages; - entries = [ - beforePlugins - ] - ++ lib.optional (vam != null) (lib.warn "'vam' attribute is deprecated. Use 'packages' instead in your vim configuration" vamImpl) - ++ lib.optional (packages != null && packages != []) (nativeImpl packages) - ++ lib.optional (pathogen != null) (throw "pathogen is now unsupported, replace `pathogen = {}` with `packages.home = { start = []; }`") - ++ lib.optional (plug != null) plugImpl - ++ [ customRC ]; + entries = + [ + beforePlugins + ] + ++ lib.optional (vam != null) ( + lib.warn "'vam' attribute is deprecated. Use 'packages' instead in your vim configuration" vamImpl + ) + ++ lib.optional (packages != null && packages != [ ]) (nativeImpl packages) + ++ lib.optional (pathogen != null) ( + throw "pathogen is now unsupported, replace `pathogen = {}` with `packages.home = { start = []; }`" + ) + ++ lib.optional (plug != null) plugImpl + ++ [ customRC ]; in - lib.concatStringsSep "\n" (lib.filter (x: x != null && x != "") entries); + lib.concatStringsSep "\n" (lib.filter (x: x != null && x != "") entries); vimrcFile = settings: writeText "vimrc" (vimrcContent settings); @@ -286,80 +315,107 @@ rec { inherit vimrcContent; inherit packDir; - makeCustomizable = let - mkVimrcFile = vimrcFile; # avoid conflict with argument name - in vim: vim // { - # Returns a customized vim that uses the specified vimrc configuration. - customize = - { # The name of the derivation. - name ? "vim" - , # A shell word used to specify the names of the customized executables. - # The shell variable $exe can be used to refer to the wrapped executable's name. - # Examples: "my-$exe", "$exe-with-plugins", "\${exe/vim/v1m}" - executableName ? - if lib.hasInfix "vim" name then - lib.replaceStrings [ "vim" ] [ "$exe" ] name - else - "\${exe/vim/${lib.escapeShellArg name}}" - , # A custom vimrc configuration, treated as an argument to vimrcContent (see the documentation in this file). - vimrcConfig ? null - , # A custom vimrc file. - vimrcFile ? null - , # A custom gvimrc file. - gvimrcFile ? null - , # If set to true, return the *vim wrappers only. - # If set to false, overlay the wrappers on top of the original vim derivation. - # This ensures that things like man pages and .desktop files are available. - standalone ? name != "vim" && wrapManual != true + makeCustomizable = + let + mkVimrcFile = vimrcFile; # avoid conflict with argument name + in + vim: + vim + // { + # Returns a customized vim that uses the specified vimrc configuration. + customize = + { + # The name of the derivation. + name ? "vim", + # A shell word used to specify the names of the customized executables. + # The shell variable $exe can be used to refer to the wrapped executable's name. + # Examples: "my-$exe", "$exe-with-plugins", "\${exe/vim/v1m}" + executableName ? + if lib.hasInfix "vim" name then + lib.replaceStrings [ "vim" ] [ "$exe" ] name + else + "\${exe/vim/${lib.escapeShellArg name}}", + # A custom vimrc configuration, treated as an argument to vimrcContent (see the documentation in this file). + vimrcConfig ? null, + # A custom vimrc file. + vimrcFile ? null, + # A custom gvimrc file. + gvimrcFile ? null, + # If set to true, return the *vim wrappers only. + # If set to false, overlay the wrappers on top of the original vim derivation. + # This ensures that things like man pages and .desktop files are available. + standalone ? name != "vim" && wrapManual != true, - , # deprecated arguments (TODO: remove eventually) - wrapManual ? null, wrapGui ? null, vimExecutableName ? null, gvimExecutableName ? null, - }: - lib.warnIf (wrapManual != null) '' - vim.customize: wrapManual is deprecated: the manual is now included by default if `name == "vim"`. - ${if wrapManual == true && name != "vim" then "Set `standalone = false` to include the manual." - else lib.optionalString (wrapManual == false && name == "vim") "Set `standalone = true` to get the *vim wrappers only." - }'' - lib.warnIf (wrapGui != null) - "vim.customize: wrapGui is deprecated: gvim is now automatically included if present" - lib.throwIfNot (vimExecutableName == null && gvimExecutableName == null) - "vim.customize: (g)vimExecutableName is deprecated: use executableName instead (see source code for examples)" - (let - vimrc = - if vimrcFile != null then vimrcFile - else if vimrcConfig != null then mkVimrcFile vimrcConfig - else throw "at least one of vimrcConfig and vimrcFile must be specified"; - bin = runCommand "${name}-bin" { nativeBuildInputs = [ makeWrapper ]; } '' - vimrc=${lib.escapeShellArg vimrc} - gvimrc=${lib.optionalString (gvimrcFile != null) (lib.escapeShellArg gvimrcFile)} + # deprecated arguments (TODO: remove eventually) + wrapManual ? null, + wrapGui ? null, + vimExecutableName ? null, + gvimExecutableName ? null, + }: + lib.warnIf (wrapManual != null) + '' + vim.customize: wrapManual is deprecated: the manual is now included by default if `name == "vim"`. + ${ + if wrapManual == true && name != "vim" then + "Set `standalone = false` to include the manual." + else + lib.optionalString ( + wrapManual == false && name == "vim" + ) "Set `standalone = true` to get the *vim wrappers only." + }'' + lib.warnIf + (wrapGui != null) + "vim.customize: wrapGui is deprecated: gvim is now automatically included if present" + lib.throwIfNot + (vimExecutableName == null && gvimExecutableName == null) + "vim.customize: (g)vimExecutableName is deprecated: use executableName instead (see source code for examples)" + ( + let + vimrc = + if vimrcFile != null then + vimrcFile + else if vimrcConfig != null then + mkVimrcFile vimrcConfig + else + throw "at least one of vimrcConfig and vimrcFile must be specified"; + bin = runCommand "${name}-bin" { nativeBuildInputs = [ makeWrapper ]; } '' + vimrc=${lib.escapeShellArg vimrc} + gvimrc=${lib.optionalString (gvimrcFile != null) (lib.escapeShellArg gvimrcFile)} - mkdir -p "$out/bin" - for exe in ${ - if standalone then "{,g,r,rg,e}vim {,g}vimdiff vi" - else "{,g,r,rg,e}{vim,view} {,g}vimdiff ex vi" - }; do - if [[ -e ${vim}/bin/$exe ]]; then - dest="$out/bin/${executableName}" - if [[ -e $dest ]]; then - echo "ambiguous executableName: ''${dest##*/} already exists" - continue - fi - makeWrapper ${vim}/bin/"$exe" "$dest" \ - --add-flags "-u ''${vimrc@Q} ''${gvimrc:+-U ''${gvimrc@Q}}" - fi - done - ''; - in if standalone then bin else - buildEnv { - inherit name; - paths = [ (lib.lowPrio vim) bin ]; - }); + mkdir -p "$out/bin" + for exe in ${ + if standalone then "{,g,r,rg,e}vim {,g}vimdiff vi" else "{,g,r,rg,e}{vim,view} {,g}vimdiff ex vi" + }; do + if [[ -e ${vim}/bin/$exe ]]; then + dest="$out/bin/${executableName}" + if [[ -e $dest ]]; then + echo "ambiguous executableName: ''${dest##*/} already exists" + continue + fi + makeWrapper ${vim}/bin/"$exe" "$dest" \ + --add-flags "-u ''${vimrc@Q} ''${gvimrc:+-U ''${gvimrc@Q}}" + fi + done + ''; + in + if standalone then + bin + else + buildEnv { + inherit name; + paths = [ + (lib.lowPrio vim) + bin + ]; + } + ); - override = f: makeCustomizable (vim.override f); - overrideAttrs = f: makeCustomizable (vim.overrideAttrs f); - }; + override = f: makeCustomizable (vim.override f); + overrideAttrs = f: makeCustomizable (vim.overrideAttrs f); + }; - vimGenDocHook = callPackage ({ vim }: + vimGenDocHook = callPackage ( + { vim }: makeSetupHook { name = "vim-gen-doc-hook"; propagatedBuildInputs = [ vim ]; @@ -367,9 +423,11 @@ rec { vimBinary = "${vim}/bin/vim"; inherit rtpPath; }; - } ./vim-gen-doc-hook.sh) {}; + } ./vim-gen-doc-hook.sh + ) { }; - vimCommandCheckHook = callPackage ({ neovim-unwrapped }: + vimCommandCheckHook = callPackage ( + { neovim-unwrapped }: makeSetupHook { name = "vim-command-check-hook"; propagatedBuildInputs = [ neovim-unwrapped ]; @@ -377,9 +435,11 @@ rec { vimBinary = "${neovim-unwrapped}/bin/nvim"; inherit rtpPath; }; - } ./vim-command-check-hook.sh) {}; + } ./vim-command-check-hook.sh + ) { }; - neovimRequireCheckHook = callPackage ({ neovim-unwrapped }: + neovimRequireCheckHook = callPackage ( + { neovim-unwrapped }: makeSetupHook { name = "neovim-require-check-hook"; propagatedBuildInputs = [ neovim-unwrapped ]; @@ -387,48 +447,69 @@ rec { nvimBinary = "${neovim-unwrapped}/bin/nvim"; inherit rtpPath; }; - } ./neovim-require-check-hook.sh) {}; + } ./neovim-require-check-hook.sh + ) { }; - inherit (import ./build-vim-plugin.nix { - inherit lib stdenv rtpPath toVimPlugin; - }) buildVimPlugin; + inherit + (import ./build-vim-plugin.nix { + inherit + lib + stdenv + rtpPath + toVimPlugin + ; + }) + buildVimPlugin + ; buildVimPluginFrom2Nix = lib.warn "buildVimPluginFrom2Nix is deprecated: use buildVimPlugin instead" buildVimPlugin; # used to figure out which python dependencies etc. neovim needs - requiredPlugins = { - packages ? {}, - plug ? null, ... - }: + requiredPlugins = + { + packages ? { }, + plug ? null, + ... + }: let nativePluginsConfigs = lib.attrsets.attrValues packages; nonNativePlugins = (lib.optionals (plug != null) plug.plugins); nativePlugins = lib.concatMap (requiredPluginsForPackage) nativePluginsConfigs; in - nativePlugins ++ nonNativePlugins; - + nativePlugins ++ nonNativePlugins; # figures out which python dependencies etc. is needed for one vim package - requiredPluginsForPackage = { start ? [], opt ? []}: + requiredPluginsForPackage = + { + start ? [ ], + opt ? [ ], + }: start ++ opt; - toVimPlugin = drv: - drv.overrideAttrs(oldAttrs: { + toVimPlugin = + drv: + drv.overrideAttrs (oldAttrs: { name = "vimplugin-${oldAttrs.name}"; # dont move the "doc" folder since vim expects it - forceShare = [ "man" "info" ]; - - nativeBuildInputs = oldAttrs.nativeBuildInputs or [] - ++ lib.optionals (stdenv.buildPlatform.canExecute stdenv.hostPlatform) [ - vimCommandCheckHook vimGenDocHook - # many neovim plugins keep using buildVimPlugin - neovimRequireCheckHook + forceShare = [ + "man" + "info" ]; - passthru = (oldAttrs.passthru or {}) // { + nativeBuildInputs = + oldAttrs.nativeBuildInputs or [ ] + ++ lib.optionals (stdenv.buildPlatform.canExecute stdenv.hostPlatform) [ + vimCommandCheckHook + vimGenDocHook + # many neovim plugins keep using buildVimPlugin + neovimRequireCheckHook + ]; + + passthru = (oldAttrs.passthru or { }) // { vimPlugin = true; }; }); -} // lib.optionalAttrs config.allowAliases { +} +// lib.optionalAttrs config.allowAliases { vimWithRC = throw "vimWithRC was removed, please use vim.customize instead"; }