diff options
Diffstat (limited to 'mac')
| -rw-r--r-- | mac/.config/TheSiahxyz/lua/TheSiahxyz/core/lazy.lua | 234 | ||||
| -rw-r--r-- | mac/.config/TheSiahxyz/lua/TheSiahxyz/plugins/textobject.lua | 227 | ||||
| -rw-r--r-- | mac/.config/TheSiahxyz/lua/TheSiahxyz/plugins/treesitter.lua | 80 | ||||
| -rw-r--r-- | mac/.config/git/config | 4 | ||||
| -rw-r--r-- | mac/.config/shell/profile | 8 |
5 files changed, 394 insertions, 159 deletions
diff --git a/mac/.config/TheSiahxyz/lua/TheSiahxyz/core/lazy.lua b/mac/.config/TheSiahxyz/lua/TheSiahxyz/core/lazy.lua index 52eff22..802a3a5 100644 --- a/mac/.config/TheSiahxyz/lua/TheSiahxyz/core/lazy.lua +++ b/mac/.config/TheSiahxyz/lua/TheSiahxyz/core/lazy.lua @@ -23,17 +23,235 @@ vim.opt.rtp:prepend(lazypath) -- Setup lazy.nvim require("lazy").setup({ + root = vim.fn.stdpath("data") .. "/lazy", -- directory where plugins will be installed + defaults = { + -- Set this to `true` to have all your plugins lazy-loaded by default. + -- Only do this if you know what you are doing, as it can lead to unexpected behavior. + lazy = false, -- should plugins be lazy-loaded? + -- It's recommended to leave version=false for now, since a lot the plugin that support versioning, + -- have outdated releases, which may break your Neovim install. + version = nil, -- always use the latest git commit + -- version = "*", -- try installing the latest stable version for plugins that support semver + -- default `cond` you can use to globally disable a lot of plugins + -- when running inside vscode for example + cond = nil, ---@type boolean|fun(self:LazyPlugin):boolean|nil + }, + -- leave nil when passing the spec as the first argument to setup() -- highlight-start spec = { -- import your plugins { import = "TheSiahxyz.plugins" }, }, - -- highlight-end - -- Configure any other settings here. See the documentation for more details. - -- colorscheme that will be used when installing plugins. - install = { colorscheme = { "catppuccin" } }, - -- automatically check for plugin updates - checker = { enabled = false }, - -- automatically check for config file changes and reload the ui - change_detection = { enabled = false }, + local_spec = true, -- load project specific .lazy.lua spec files. They will be added at the end of the spec. + lockfile = vim.fn.stdpath("config") .. "/lazy-lock.json", -- lockfile generated after running update. + ---@type number? limit the maximum amount of concurrent tasks + concurrency = jit.os:find("Windows") and (vim.uv.available_parallelism() * 2) or nil, + git = { + -- defaults for the `Lazy log` command + -- log = { "--since=3 days ago" }, -- show commits from the last 3 days + log = { "-8" }, -- show the last 8 commits + timeout = 120, -- kill processes that take more than 2 minutes + url_format = "https://github.com/%s.git", + -- lazy.nvim requires git >=2.19.0. If you really want to use lazy with an older version, + -- then set the below to false. This should work, but is NOT supported and will + -- increase downloads a lot. + filter = true, + -- rate of network related git operations (clone, fetch, checkout) + throttle = { + enabled = false, -- not enabled by default + -- max 2 ops every 5 seconds + rate = 2, + duration = 5 * 1000, -- in ms + }, + -- Time in seconds to wait before running fetch again for a plugin. + -- Repeated update/check operations will not run again until this + -- cooldown period has passed. + cooldown = 0, + }, + pkg = { + enabled = true, + cache = vim.fn.stdpath("state") .. "/lazy/pkg-cache.lua", + -- the first package source that is found for a plugin will be used. + sources = { + "lazy", + "rockspec", -- will only be used when rocks.enabled is true + "packspec", + }, + }, + rocks = { + enabled = true, + root = vim.fn.stdpath("data") .. "/lazy-rocks", + server = "https://lumen-oss.github.io/rocks-binaries/", + -- use hererocks to install luarocks? + -- set to `nil` to use hererocks when luarocks is not found + -- set to `true` to always use hererocks + -- set to `false` to always use luarocks + hererocks = nil, + }, + dev = { + -- Directory where you store your local plugin projects. If a function is used, + -- the plugin directory (e.g. `~/projects/plugin-name`) must be returned. + ---@type string | fun(plugin: LazyPlugin): string + path = "~/projects", + ---@type string[] plugins that match these patterns will use your local versions instead of being fetched from GitHub + patterns = {}, -- For example {"folke"} + fallback = false, -- Fallback to git when local plugin doesn't exist + }, + install = { + -- install missing plugins on startup. This doesn't increase startup time. + missing = true, + -- try to load one of these colorschemes when starting an installation during startup + colorscheme = { "catppuccin" }, + }, + ui = { + -- a number <1 is a percentage., >1 is a fixed size + size = { width = 0.8, height = 0.8 }, + wrap = true, -- wrap the lines in the ui + -- The border to use for the UI window. Accepts same border values as |nvim_open_win()|. + border = "none", + -- The backdrop opacity. 0 is fully opaque, 100 is fully transparent. + backdrop = 60, + title = nil, ---@type string only works when border is not "none" + title_pos = "center", ---@type "center" | "left" | "right" + -- Show pills on top of the Lazy window + pills = true, ---@type boolean + icons = { + cmd = " ", + config = "", + debug = "● ", + event = " ", + favorite = " ", + ft = " ", + init = " ", + import = " ", + keys = " ", + lazy = " ", + loaded = "●", + not_loaded = "○", + plugin = " ", + runtime = " ", + require = " ", + source = " ", + start = " ", + task = "✔ ", + list = { + "●", + "➜", + "★", + "‒", + }, + }, + -- leave nil, to automatically select a browser depending on your OS. + -- If you want to use a specific browser, you can define it here + browser = nil, ---@type string? + throttle = 1000 / 30, -- how frequently should the ui process render events + custom_keys = { + -- You can define custom key maps here. If present, the description will + -- be shown in the help menu. + -- To disable one of the defaults, set it to false. + + ["<leader>gL"] = { + function(plugin) + require("lazy.util").float_term({ "lazygit", "log" }, { + cwd = plugin.dir, + }) + end, + desc = "Open lazygit log", + }, + + ["<leader>is"] = { + function(plugin) + Util.notify(vim.inspect(plugin), { + title = "Inspect " .. plugin.name, + lang = "lua", + }) + end, + desc = "Inspect Plugin", + }, + + ["<leader><C-p>"] = { + function(plugin) + require("lazy.util").float_term(nil, { + cwd = plugin.dir, + }) + end, + desc = "Open terminal in plugin dir", + }, + }, + }, + -- Output options for headless mode + headless = { + -- show the output from process commands like git + process = true, + -- show log messages + log = true, + -- show task start/end + task = true, + -- use ansi colors + colors = true, + }, + diff = { + -- diff command <d> can be one of: + -- * browser: opens the github compare view. Note that this is always mapped to <K> as well, + -- so you can have a different command for diff <d> + -- * git: will run git diff and open a buffer with filetype git + -- * terminal_git: will open a pseudo terminal with git diff + -- * diffview.nvim: will open Diffview to show the diff + cmd = "git", + }, + checker = { + -- automatically check for plugin updates + enabled = false, + concurrency = nil, ---@type number? set to 1 to check for updates very slowly + notify = true, -- get a notification when new updates are found + frequency = 3600, -- check for updates every hour + check_pinned = false, -- check for pinned packages that can't be updated + }, + change_detection = { + -- automatically check for config file changes and reload the ui + enabled = false, + notify = false, -- get a notification when changes are found + }, + performance = { + cache = { + enabled = true, + }, + reset_packpath = true, -- reset the package path to improve startup time + rtp = { + reset = true, -- reset the runtime path to $VIMRUNTIME and your config directory + ---@type string[] + paths = {}, -- add any custom paths here that you want to includes in the rtp + ---@type string[] list any plugins you want to disable here + disabled_plugins = { + -- "gzip", + -- "matchit", + -- "matchparen", + -- "netrwPlugin", + -- "tarPlugin", + -- "tohtml", + -- "tutor", + -- "zipPlugin", + }, + }, + }, + -- lazy can generate helptags from the headings in markdown readme files, + -- so :help works even for plugins that don't have vim docs. + -- when the readme opens with :help it will be correctly displayed as markdown + readme = { + enabled = true, + root = vim.fn.stdpath("state") .. "/lazy/readme", + files = { "README.md", "lua/**/README.md" }, + -- only generate markdown helptags for plugins that don't have docs + skip_if_doc_exists = true, + }, + state = vim.fn.stdpath("state") .. "/lazy/state.json", -- state info for checker and other things + -- Enable profiling of lazy.nvim. This will add some overhead, + -- so only enable this when you are debugging lazy.nvim + profiling = { + -- Enables extra stats on the debug tab related to the loader cache. + -- Additionally gathers stats about all package.loaders + loader = false, + -- Track each new require in the Lazy profiling tab + require = false, + }, }) diff --git a/mac/.config/TheSiahxyz/lua/TheSiahxyz/plugins/textobject.lua b/mac/.config/TheSiahxyz/lua/TheSiahxyz/plugins/textobject.lua index 3002fc0..b82eac6 100644 --- a/mac/.config/TheSiahxyz/lua/TheSiahxyz/plugins/textobject.lua +++ b/mac/.config/TheSiahxyz/lua/TheSiahxyz/plugins/textobject.lua @@ -1,8 +1,8 @@ return { "nvim-treesitter/nvim-treesitter-textobjects", + branch = "main", dependencies = { - { "nvim-treesitter", build = ":TSUpdate" }, - { "nvim-treesitter/nvim-treesitter" }, + { "nvim-treesitter/nvim-treesitter", build = ":TSUpdate" }, { "chrisgrieser/nvim-various-textobjs", event = "UIEnter", @@ -14,6 +14,16 @@ return { }, }, init = function() + -- Disable entire built-in ftplugin mappings to avoid conflicts. + -- See https://github.com/neovim/neovim/tree/master/runtime/ftplugin for built-in ftplugins. + vim.g.no_plugin_maps = true + + -- Or, disable per filetype (add as you like) + -- vim.g.no_python_maps = true + -- vim.g.no_ruby_maps = true + -- vim.g.no_rust_maps = true + -- vim.g.no_go_maps = true + local wk = require("which-key") wk.add({ { @@ -26,115 +36,138 @@ return { }) end, config = function() - require("nvim-treesitter.configs").setup({ - textobjects = { - select = { - enable = true, - - -- Automatically jump forward to textobj, similar to targets.vim - lookahead = true, - - keymaps = { - -- You can use the capture groups defined in textobjects.scm - ["a="] = { query = "@assignment.outer", desc = "Select outer part of an assignment" }, - ["i="] = { query = "@assignment.inner", desc = "Select inner part of an assignment" }, - ["h="] = { query = "@assignment.lhs", desc = "Select left hand side of an assignment" }, - ["l="] = { query = "@assignment.rhs", desc = "Select right hand side of an assignment" }, - - -- works for javascript/typescript files (custom capture I created in after/queries/ecma/textobjects.scm) - ["a:"] = { query = "@property.outer", desc = "Select outer part of an object property" }, - ["i:"] = { query = "@property.inner", desc = "Select inner part of an object property" }, - ["h:"] = { query = "@property.lhs", desc = "Select left part of an object property" }, - ["l:"] = { query = "@property.rhs", desc = "Select right part of an object property" }, - - ["aa"] = { query = "@parameter.outer", desc = "Select outer part of a parameter/argument" }, - ["ia"] = { query = "@parameter.inner", desc = "Select inner part of a parameter/argument" }, + require("nvim-treesitter-textobjects").setup({ + select = { + -- Automatically jump forward to textobj, similar to targets.vim + lookahead = true, + -- You can choose the select mode (default is charwise 'v') + -- + -- Can also be a function which gets passed a table with the keys + -- * query_string: eg '@function.inner' + -- * method: eg 'v' or 'o' + -- and should return the mode ('v', 'V', or '<c-v>') or a table + -- mapping query_strings to modes. + selection_modes = { + ["@parameter.outer"] = "v", -- charwise + ["@function.outer"] = "V", -- linewise + ["@class.outer"] = "<c-v>", -- blockwise + }, + -- If you set this to `true` (default is `false`) then any textobject is + -- extended to include preceding or succeeding whitespace. Succeeding + -- whitespace has priority in order to act similarly to eg the built-in + -- `ap`. + -- + -- Can also be a function which gets passed a table with the keys + -- * query_string: eg '@function.inner' + -- * selection_mode: eg 'v' + -- and should return true of false + include_surrounding_whitespace = false, + }, + move = { + -- whether to set jumps in the jumplist + set_jumps = true, + }, + }) - ["an"] = { query = "@conditional.outer", desc = "Select outer part of a conditional" }, - ["in"] = { query = "@conditional.inner", desc = "Select inner part of a conditional" }, + -- keymaps + -- You can use the capture groups defined in `textobjects.scm` + vim.keymap.set({ "x", "o" }, "am", function() + require("nvim-treesitter-textobjects.select").select_textobject("@function.outer", "textobjects") + end) + vim.keymap.set({ "x", "o" }, "im", function() + require("nvim-treesitter-textobjects.select").select_textobject("@function.inner", "textobjects") + end) + vim.keymap.set({ "x", "o" }, "ac", function() + require("nvim-treesitter-textobjects.select").select_textobject("@class.outer", "textobjects") + end) + vim.keymap.set({ "x", "o" }, "ic", function() + require("nvim-treesitter-textobjects.select").select_textobject("@class.inner", "textobjects") + end) + -- You can also use captures from other query groups like `locals.scm` + vim.keymap.set({ "x", "o" }, "as", function() + require("nvim-treesitter-textobjects.select").select_textobject("@local.scope", "locals") + end) + -- keymaps + vim.keymap.set("n", "<leader>a", function() + require("nvim-treesitter-textobjects.swap").swap_next("@parameter.inner") + end) + vim.keymap.set("n", "<leader>A", function() + require("nvim-treesitter-textobjects.swap").swap_previous("@parameter.outer") + end) + -- You can use the capture groups defined in `textobjects.scm` + vim.keymap.set({ "n", "x", "o" }, "]m", function() + require("nvim-treesitter-textobjects.move").goto_next_start("@function.outer", "textobjects") + end) + vim.keymap.set({ "n", "x", "o" }, "]]", function() + require("nvim-treesitter-textobjects.move").goto_next_start("@class.outer", "textobjects") + end) + -- You can also pass a list to group multiple queries. + vim.keymap.set({ "n", "x", "o" }, "]o", function() + move.goto_next_start({ "@loop.inner", "@loop.outer" }, "textobjects") + end) + -- You can also use captures from other query groups like `locals.scm` or `folds.scm` + vim.keymap.set({ "n", "x", "o" }, "]s", function() + require("nvim-treesitter-textobjects.move").goto_next_start("@local.scope", "locals") + end) + vim.keymap.set({ "n", "x", "o" }, "]z", function() + require("nvim-treesitter-textobjects.move").goto_next_start("@fold", "folds") + end) - ["ap"] = { query = "@loop.outer", desc = "Select outer part of a loop" }, - ["ip"] = { query = "@loop.inner", desc = "Select inner part of a loop" }, + vim.keymap.set({ "n", "x", "o" }, "]M", function() + require("nvim-treesitter-textobjects.move").goto_next_end("@function.outer", "textobjects") + end) + vim.keymap.set({ "n", "x", "o" }, "][", function() + require("nvim-treesitter-textobjects.move").goto_next_end("@class.outer", "textobjects") + end) - ["af"] = { query = "@call.outer", desc = "Select outer part of a function call" }, - ["if"] = { query = "@call.inner", desc = "Select inner part of a function call" }, + vim.keymap.set({ "n", "x", "o" }, "[m", function() + require("nvim-treesitter-textobjects.move").goto_previous_start("@function.outer", "textobjects") + end) + vim.keymap.set({ "n", "x", "o" }, "[[", function() + require("nvim-treesitter-textobjects.move").goto_previous_start("@class.outer", "textobjects") + end) - ["am"] = { - query = "@function.outer", - desc = "Select outer part of a method/function definition", - }, - ["im"] = { - query = "@function.inner", - desc = "Select inner part of a method/function definition", - }, + vim.keymap.set({ "n", "x", "o" }, "[M", function() + require("nvim-treesitter-textobjects.move").goto_previous_end("@function.outer", "textobjects") + end) + vim.keymap.set({ "n", "x", "o" }, "[]", function() + require("nvim-treesitter-textobjects.move").goto_previous_end("@class.outer", "textobjects") + end) - ["ac"] = { query = "@class.outer", desc = "Select outer part of a class" }, - ["ic"] = { query = "@class.inner", desc = "Select inner part of a class" }, - }, - }, - swap = { - enable = true, - swap_next = { - ["g>a"] = { query = "@parameter.inner", desc = "swap parameters/argument with next" }, - ["g>:"] = { query = "@property.outer", desc = "swap object property with next" }, - ["g>m"] = { query = "@function.outer", desc = "swap function with next" }, - }, - swap_previous = { - ["g<a"] = { query = "@parameter.inner", desc = "swap parameters/argument with prev" }, - ["g<:"] = { query = "@property.outer", desc = "swap object property with prev" }, - ["g<m"] = { query = "@function.outer", desc = "swap function with previous" }, - }, - }, - move = { - enable = true, - set_jumps = true, -- whether to set jumps in the jumplist - goto_next_start = { - ["]f"] = { query = "@call.outer", desc = "Next function call start" }, - ["]m"] = { query = "@function.outer", desc = "Next method/function def start" }, - ["]c"] = { query = "@class.outer", desc = "Next class start" }, - ["]="] = { query = "@conditional.outer", desc = "Next conditional start" }, - ["]l"] = { query = "@loop.outer", desc = "Next loop start" }, + -- Go to either the start or the end, whichever is closer. + -- Use if you want more granular movements + vim.keymap.set({ "n", "x", "o" }, "]d", function() + require("nvim-treesitter-textobjects.move").goto_next("@conditional.outer", "textobjects") + end) + vim.keymap.set({ "n", "x", "o" }, "[d", function() + require("nvim-treesitter-textobjects.move").goto_previous("@conditional.outer", "textobjects") + end) - -- You can pass a query group to use query from `queries/<lang>/<query_group>.scm file in your runtime path. - -- Below example nvim-treesitter's `locals.scm` and `folds.scm`. They also provide highlights.scm and indent.scm. - ["]-"] = { query = "@scope", query_group = "locals", desc = "Next scope" }, - ["]z"] = { query = "@fold", query_group = "folds", desc = "Next fold" }, - }, - goto_next_end = { - ["]F"] = { query = "@call.outer", desc = "Next function call end" }, - ["]M"] = { query = "@function.outer", desc = "Next method/function def end" }, - ["]C"] = { query = "@class.outer", desc = "Next class end" }, - ["]+"] = { query = "@conditional.outer", desc = "Next conditional end" }, - ["]L"] = { query = "@loop.outer", desc = "Next loop end" }, - }, - goto_previous_start = { - ["[f"] = { query = "@call.outer", desc = "Prev function call start" }, - ["[m"] = { query = "@function.outer", desc = "Prev method/function def start" }, - ["[c"] = { query = "@class.outer", desc = "Prev class start" }, - ["[="] = { query = "@conditional.outer", desc = "Prev conditional start" }, - ["[l"] = { query = "@loop.outer", desc = "Prev loop start" }, - }, - goto_previous_end = { - ["[F"] = { query = "@call.outer", desc = "Prev function call end" }, - ["[M"] = { query = "@function.outer", desc = "Prev method/function def end" }, - ["[C"] = { query = "@class.outer", desc = "Prev class end" }, - ["[+"] = { query = "@conditional.outer", desc = "Prev conditional end" }, - ["[L"] = { query = "@loop.outer", desc = "Prev loop end" }, - }, - }, - }, - }) + local ts_repeat_move = require("nvim-treesitter-textobjects.repeatable_move") - local ts_repeat_move = require("nvim-treesitter.textobjects.repeatable_move") + -- Repeat movement with ; and , + -- ensure ; goes forward and , goes backward regardless of the last direction + vim.keymap.set({ "n", "x", "o" }, ";", ts_repeat_move.repeat_last_move_next) + vim.keymap.set({ "n", "x", "o" }, ",", ts_repeat_move.repeat_last_move_previous) -- vim way: ; goes to the direction you were moving. - vim.keymap.set({ "n", "x", "o" }, ";", ts_repeat_move.repeat_last_move) - vim.keymap.set({ "n", "x", "o" }, ",", ts_repeat_move.repeat_last_move_opposite) + -- vim.keymap.set({ "n", "x", "o" }, ";", ts_repeat_move.repeat_last_move) + -- vim.keymap.set({ "n", "x", "o" }, ",", ts_repeat_move.repeat_last_move_opposite) -- Optionally, make builtin f, F, t, T also repeatable with ; and , vim.keymap.set({ "n", "x", "o" }, "f", ts_repeat_move.builtin_f_expr, { expr = true }) vim.keymap.set({ "n", "x", "o" }, "F", ts_repeat_move.builtin_F_expr, { expr = true }) vim.keymap.set({ "n", "x", "o" }, "t", ts_repeat_move.builtin_t_expr, { expr = true }) vim.keymap.set({ "n", "x", "o" }, "T", ts_repeat_move.builtin_T_expr, { expr = true }) + + -- This repeats the last query with always previous direction and to the start of the range. + vim.keymap.set({ "n", "x", "o" }, "<home>", function() + ts_repeat_move.repeat_last_move({ forward = false, start = true }) + end) + + -- This repeats the last query with always next direction and to the end of the range. + vim.keymap.set({ "n", "x", "o" }, "<end>", function() + ts_repeat_move.repeat_last_move({ forward = true, start = false }) + end) end, } diff --git a/mac/.config/TheSiahxyz/lua/TheSiahxyz/plugins/treesitter.lua b/mac/.config/TheSiahxyz/lua/TheSiahxyz/plugins/treesitter.lua index c486343..7a9639c 100644 --- a/mac/.config/TheSiahxyz/lua/TheSiahxyz/plugins/treesitter.lua +++ b/mac/.config/TheSiahxyz/lua/TheSiahxyz/plugins/treesitter.lua @@ -1,62 +1,38 @@ return { "nvim-treesitter/nvim-treesitter", + lazy = false, build = ":TSUpdate", dependencies = { "nvim-treesitter/nvim-treesitter-textobjects" }, config = function() - require("nvim-treesitter.configs").setup({ - -- A list of parser names, or "all" - ensure_installed = { - "bash", - "c", - "cpp", - "dockerfile", - "html", - "java", - "json5", - "latex", - "lua", - "markdown", - "markdown_inline", - "python", - "sql", - "vim", - "vimdoc", - }, - - -- Install parsers synchronously (only applied to `ensure_installed`) - sync_install = true, - - -- Automatically install missing parsers when entering buffer - -- Recommendation: set to false if you don"t have `tree-sitter` CLI installed locally - auto_install = true, - - -- List of parsers to ignore installing (or "all") - ignore_install = {}, - - highlight = { - -- `false` will disable the whole extension - enable = true, - disable = { "csv" }, - -- Setting this to true will run `:h syntax` and tree-sitter at the same time. - -- Set this to `true` if you depend on "syntax" being enabled (like for indentation). - -- Using this option may slow down your editor, and you may see some duplicate highlights. - -- Instead of true it can also be a list of languages - additional_vim_regex_highlighting = { "markdown" }, - }, + require("nvim-treesitter").setup({ + install_dir = vim.fn.stdpath("data") .. "/treesitter", }) - - local treesitter_parser_config = require("nvim-treesitter.parsers").get_parser_configs() - treesitter_parser_config.templ = { - install_info = { - url = "https://github.com/vrischmann/tree-sitter-templ.git", - files = { "src/parser.c", "src/scanner.c" }, - branch = "master", - }, - } - - vim.treesitter.language.register("templ", "templ") end, keys = { - { "<leader>T", ":TSUpdate<cr>", desc = "Update treesitter" }, + { "<leader>TU", ":TSUpdate<cr>", desc = "Update treesitter" }, + { + "<leader>TI", + function() + require("nvim-treesitter").install({ + "bash", + "c", + "cpp", + "dockerfile", + "html", + "java", + "javascript", + "json5", + "latex", + "lua", + "markdown", + "markdown_inline", + "python", + "sql", + "vim", + "vimdoc", + }) + end, + desc = "Update treesitter", + }, }, } diff --git a/mac/.config/git/config b/mac/.config/git/config index 0324918..29c8585 100644 --- a/mac/.config/git/config +++ b/mac/.config/git/config @@ -10,6 +10,8 @@ branch = bold magenta changed = yellow untracked = blue +[commit] + gpgSign = false [credential] helper = cache helper = store @@ -84,5 +86,3 @@ name = TheSiahxyz email = 164138827+TheSiahxyz@users.noreply.github.com signingkey = 67BE7AD056C803BA -[commit] - gpgsign = true diff --git a/mac/.config/shell/profile b/mac/.config/shell/profile index 3e1ca79..546aafe 100644 --- a/mac/.config/shell/profile +++ b/mac/.config/shell/profile @@ -109,6 +109,12 @@ export JUPYTER_PLATFORM_DIRS="1" ### --- KODI --- ### export KODI_DATA="$XDG_DATA_HOME/kodi" +### --- LUA --- ### +export LUA_BIN="/opt/homebrew/bin/lua" +export LUA_CPATH="/usr/local/lib/lua/5.1/?.so;;" +export LUA_INTERPRETER=lua5.1 +export LUA_PATH="/usr/local/share/lua/5.1/?.lua;;" + ### --- LYNX --- ### export LYNX_CFG="$HOME/.config/lynx/lynx.cfg" export LYNX_LSS="$HOME/.config/lynx/lynx.lss" @@ -245,6 +251,7 @@ export SDCV_PAGER='less --quit-if-one-screen -RX' ### --- ENV PATH --- ### ################################################### # Add all directories in each subdirectory to $PATH +export PATH="/usr/local/bin:$PATH" [ -d ~/.local/bin ] && export PATH="$(find ~/.local/bin -path '*/.git*' -prune -o \( -type f -o -type l \) -perm -u=x -exec dirname {} \; | sort -u | paste -sd ':' -):$PATH" [ -d ~/.local/share/.password-store ] && export PATH="$(find ~/.local/share/.password-store -type d -name '.extensions' | paste -sd ':' -):$PATH" export PATH="$ASDF_DATA_DIR/shims:$PATH" @@ -252,6 +259,7 @@ export PATH="/opt/homebrew/bin:$PATH" [ -d /opt/homebrew/Caskroom ] && export PATH="$(find -L /opt/homebrew/Caskroom \( -name bin -o -name MacOS \) -type d -print 2>/dev/null | sort -u | paste -s -d ':' -):$PATH" [ -d /opt/homebrew/Cellar ] && export PATH="$(find -L /opt/homebrew/Cellar -name bin -type d -print 2>/dev/null | sort -u | paste -s -d ':' -):$PATH" [ -d /opt/homebrew/opt ] && export PATH="$(find -L /opt/homebrew/opt -name bin -type d -print 2>/dev/null | sort -u | paste -s -d ':' -):$PATH" +[ -d /opt/homebrew/opt/coreutils/libexec ] && export PATH="$(find -L /opt/homebrew/opt/coreutils/libexec -name gnubin -type d -print 2>/dev/null | sort -u | paste -s -d ':' -):$PATH" unsetopt PROMPT_SP 2>/dev/null |