diff --git a/users/daniel/configs/system/default.nix b/users/daniel/configs/system/default.nix
index 3763353..d3ffe90 100644
--- a/users/daniel/configs/system/default.nix
+++ b/users/daniel/configs/system/default.nix
@@ -3,6 +3,6 @@
./alacritty
./helix
./kitty
- ./neovim
+ ./nvim
];
}
diff --git a/users/daniel/configs/system/nvim/default.nix b/users/daniel/configs/system/nvim/default.nix
new file mode 100644
index 0000000..3b2780c
--- /dev/null
+++ b/users/daniel/configs/system/nvim/default.nix
@@ -0,0 +1,11 @@
+{...}:
+
+{
+ programs.neovim.enable = true;
+
+ home.file = {
+ ".config/nvim" = {
+ source = ./nvim;
+ };
+ };
+}
diff --git a/users/daniel/configs/system/nvim/nvim/.gitignore b/users/daniel/configs/system/nvim/nvim/.gitignore
new file mode 100644
index 0000000..11b67c8
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/.gitignore
@@ -0,0 +1,9 @@
+!colors/astronvim.lua
+colors/*
+docs
+ginit.vim
+lua/user
+plugin
+ftplugin
+spell
+.luarc.json
diff --git a/users/daniel/configs/system/nvim/nvim/.luacheckrc b/users/daniel/configs/system/nvim/nvim/.luacheckrc
new file mode 100644
index 0000000..809581e
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/.luacheckrc
@@ -0,0 +1,21 @@
+-- Global objects
+globals = {
+ "PACKER_BOOTSTRAP",
+ "astronvim",
+ "astronvim_installation",
+ "vim",
+ "bit",
+ "C",
+ "packer_plugins",
+}
+
+-- Rerun tests only if their modification time changed
+cache = true
+
+-- Don't report unused self arguments of methods
+self = false
+
+ignore = {
+ "631", -- max_line_length
+ "212/_.*", -- unused argument, for vars with "_" prefix
+}
diff --git a/users/daniel/configs/system/nvim/nvim/.stylua.toml b/users/daniel/configs/system/nvim/nvim/.stylua.toml
new file mode 100644
index 0000000..bfcffff
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/.stylua.toml
@@ -0,0 +1,7 @@
+column_width = 120
+line_endings = "Unix"
+indent_type = "Spaces"
+indent_width = 2
+quote_style = "AutoPreferDouble"
+call_parentheses = "None"
+collapse_simple_statement = "Always"
diff --git a/users/daniel/configs/system/nvim/nvim/.styluaignore b/users/daniel/configs/system/nvim/nvim/.styluaignore
new file mode 100644
index 0000000..52ccbc0
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/.styluaignore
@@ -0,0 +1 @@
+lua/lazy_snapshot.lua
diff --git a/users/daniel/configs/system/nvim/nvim/LICENSE b/users/daniel/configs/system/nvim/nvim/LICENSE
new file mode 100644
index 0000000..f288702
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/LICENSE
@@ -0,0 +1,674 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc.
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+ To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+ Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+ For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+ Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so. This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software. The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable. Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products. If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+ Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary. To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ TERMS AND CONDITIONS
+
+ 0. Definitions.
+
+ "This License" refers to version 3 of the GNU General Public License.
+
+ "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+ "The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+ To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+ A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+ To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+ To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+ An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+ 1. Source Code.
+
+ The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+ A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+ The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+ The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+ The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+ The Corresponding Source for a work in source code form is that
+same work.
+
+ 2. Basic Permissions.
+
+ All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+ You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+ Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+ No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+ When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+ 4. Conveying Verbatim Copies.
+
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+ You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+ 5. Conveying Modified Source Versions.
+
+ You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+ a) The work must carry prominent notices stating that you modified
+ it, and giving a relevant date.
+
+ b) The work must carry prominent notices stating that it is
+ released under this License and any conditions added under section
+ 7. This requirement modifies the requirement in section 4 to
+ "keep intact all notices".
+
+ c) You must license the entire work, as a whole, under this
+ License to anyone who comes into possession of a copy. This
+ License will therefore apply, along with any applicable section 7
+ additional terms, to the whole of the work, and all its parts,
+ regardless of how they are packaged. This License gives no
+ permission to license the work in any other way, but it does not
+ invalidate such permission if you have separately received it.
+
+ d) If the work has interactive user interfaces, each must display
+ Appropriate Legal Notices; however, if the Program has interactive
+ interfaces that do not display Appropriate Legal Notices, your
+ work need not make them do so.
+
+ A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+ 6. Conveying Non-Source Forms.
+
+ You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+ a) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by the
+ Corresponding Source fixed on a durable physical medium
+ customarily used for software interchange.
+
+ b) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by a
+ written offer, valid for at least three years and valid for as
+ long as you offer spare parts or customer support for that product
+ model, to give anyone who possesses the object code either (1) a
+ copy of the Corresponding Source for all the software in the
+ product that is covered by this License, on a durable physical
+ medium customarily used for software interchange, for a price no
+ more than your reasonable cost of physically performing this
+ conveying of source, or (2) access to copy the
+ Corresponding Source from a network server at no charge.
+
+ c) Convey individual copies of the object code with a copy of the
+ written offer to provide the Corresponding Source. This
+ alternative is allowed only occasionally and noncommercially, and
+ only if you received the object code with such an offer, in accord
+ with subsection 6b.
+
+ d) Convey the object code by offering access from a designated
+ place (gratis or for a charge), and offer equivalent access to the
+ Corresponding Source in the same way through the same place at no
+ further charge. You need not require recipients to copy the
+ Corresponding Source along with the object code. If the place to
+ copy the object code is a network server, the Corresponding Source
+ may be on a different server (operated by you or a third party)
+ that supports equivalent copying facilities, provided you maintain
+ clear directions next to the object code saying where to find the
+ Corresponding Source. Regardless of what server hosts the
+ Corresponding Source, you remain obligated to ensure that it is
+ available for as long as needed to satisfy these requirements.
+
+ e) Convey the object code using peer-to-peer transmission, provided
+ you inform other peers where the object code and Corresponding
+ Source of the work are being offered to the general public at no
+ charge under subsection 6d.
+
+ A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+ A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+ "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+ If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+ The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+ Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+ 7. Additional Terms.
+
+ "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+ When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+ Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+ a) Disclaiming warranty or limiting liability differently from the
+ terms of sections 15 and 16 of this License; or
+
+ b) Requiring preservation of specified reasonable legal notices or
+ author attributions in that material or in the Appropriate Legal
+ Notices displayed by works containing it; or
+
+ c) Prohibiting misrepresentation of the origin of that material, or
+ requiring that modified versions of such material be marked in
+ reasonable ways as different from the original version; or
+
+ d) Limiting the use for publicity purposes of names of licensors or
+ authors of the material; or
+
+ e) Declining to grant rights under trademark law for use of some
+ trade names, trademarks, or service marks; or
+
+ f) Requiring indemnification of licensors and authors of that
+ material by anyone who conveys the material (or modified versions of
+ it) with contractual assumptions of liability to the recipient, for
+ any liability that these contractual assumptions directly impose on
+ those licensors and authors.
+
+ All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+ If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+ Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+ 8. Termination.
+
+ You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+ However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+ Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+ Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+ 9. Acceptance Not Required for Having Copies.
+
+ You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+ 10. Automatic Licensing of Downstream Recipients.
+
+ Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+ An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+ You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+ 11. Patents.
+
+ A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+ A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+ Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+ In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+ If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+ If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+ A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+ Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+ 12. No Surrender of Others' Freedom.
+
+ If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+ 13. Use with the GNU Affero General Public License.
+
+ Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+ If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+ Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+ 15. Disclaimer of Warranty.
+
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+
+ Copyright (C)
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+ Copyright (C)
+ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+ You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+.
+
+ The GNU General Public License does not permit incorporating your program
+into proprietary programs. If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License. But first, please read
+.
diff --git a/users/daniel/configs/system/nvim/nvim/config.ld b/users/daniel/configs/system/nvim/nvim/config.ld
new file mode 100644
index 0000000..61784df
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/config.ld
@@ -0,0 +1,7 @@
+project='AstroNvim'
+title='AstroNvim API'
+description='Documentation of AstroNvim\'s core API'
+format = 'markdown'
+file='lua'
+dir='docs'
+no_space_before_args=true
diff --git a/users/daniel/configs/system/nvim/nvim/init.lua b/users/daniel/configs/system/nvim/nvim/init.lua
new file mode 100644
index 0000000..a887f21
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/init.lua
@@ -0,0 +1,18 @@
+for _, source in ipairs {
+ "astronvim.bootstrap",
+ "astronvim.options",
+ "astronvim.lazy",
+ "astronvim.autocmds",
+ "astronvim.mappings",
+} do
+ local status_ok, fault = pcall(require, source)
+ if not status_ok then vim.api.nvim_err_writeln("Failed to load " .. source .. "\n\n" .. fault) end
+end
+
+if astronvim.default_colorscheme then
+ if not pcall(vim.cmd.colorscheme, astronvim.default_colorscheme) then
+ require("astronvim.utils").notify("Error setting up colorscheme: " .. astronvim.default_colorscheme, "error")
+ end
+end
+
+require("astronvim.utils").conditional_func(astronvim.user_opts("polish", nil, false), true)
diff --git a/users/daniel/configs/system/nvim/nvim/lua/astronvim/autocmds.lua b/users/daniel/configs/system/nvim/nvim/lua/astronvim/autocmds.lua
new file mode 100644
index 0000000..fff6dc3
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/lua/astronvim/autocmds.lua
@@ -0,0 +1,235 @@
+local augroup = vim.api.nvim_create_augroup
+local autocmd = vim.api.nvim_create_autocmd
+local cmd = vim.api.nvim_create_user_command
+local namespace = vim.api.nvim_create_namespace
+
+local utils = require "astronvim.utils"
+local is_available = utils.is_available
+local astroevent = utils.event
+
+vim.on_key(function(char)
+ if vim.fn.mode() == "n" then
+ local new_hlsearch = vim.tbl_contains({ "", "n", "N", "*", "#", "?", "/" }, vim.fn.keytrans(char))
+ if vim.opt.hlsearch:get() ~= new_hlsearch then vim.opt.hlsearch = new_hlsearch end
+ end
+end, namespace "auto_hlsearch")
+
+local bufferline_group = augroup("bufferline", { clear = true })
+autocmd({ "BufAdd", "BufEnter" }, {
+ desc = "Update buffers when adding new buffers",
+ group = bufferline_group,
+ callback = function(args)
+ if not vim.t.bufs then vim.t.bufs = {} end
+ local bufs = vim.t.bufs
+ if not vim.tbl_contains(bufs, args.buf) then
+ table.insert(bufs, args.buf)
+ vim.t.bufs = bufs
+ end
+ vim.t.bufs = vim.tbl_filter(require("astronvim.utils.buffer").is_valid, vim.t.bufs)
+ astroevent "BufsUpdated"
+ end,
+})
+autocmd("BufDelete", {
+ desc = "Update buffers when deleting buffers",
+ group = bufferline_group,
+ callback = function(args)
+ for _, tab in ipairs(vim.api.nvim_list_tabpages()) do
+ local bufs = vim.t[tab].bufs
+ if bufs then
+ for i, bufnr in ipairs(bufs) do
+ if bufnr == args.buf then
+ table.remove(bufs, i)
+ vim.t[tab].bufs = bufs
+ break
+ end
+ end
+ end
+ end
+ vim.t.bufs = vim.tbl_filter(require("astronvim.utils.buffer").is_valid, vim.t.bufs)
+ astroevent "BufsUpdated"
+ vim.cmd.redrawtabline()
+ end,
+})
+
+autocmd({ "VimEnter", "FileType", "BufEnter", "WinEnter" }, {
+ desc = "URL Highlighting",
+ group = augroup("highlighturl", { clear = true }),
+ pattern = "*",
+ callback = function() utils.set_url_match() end,
+})
+
+local view_group = augroup("auto_view", { clear = true })
+autocmd("BufWinLeave", {
+ desc = "Save view with mkview for real files",
+ group = view_group,
+ callback = function(event)
+ if vim.b[event.buf].view_activated then vim.cmd.mkview { mods = { emsg_silent = true } } end
+ end,
+})
+autocmd("BufWinEnter", {
+ desc = "Try to load file view if available and enable view saving for real files",
+ group = view_group,
+ callback = function(event)
+ if not vim.b[event.buf].view_activated then
+ local filetype = vim.api.nvim_get_option_value("filetype", { buf = event.buf })
+ local buftype = vim.api.nvim_get_option_value("buftype", { buf = event.buf })
+ local ignore_filetypes = { "gitcommit", "gitrebase", "svg", "hgcommit" }
+ if buftype == "" and filetype and filetype ~= "" and not vim.tbl_contains(ignore_filetypes, filetype) then
+ vim.b[event.buf].view_activated = true
+ vim.cmd.loadview { mods = { emsg_silent = true } }
+ end
+ end
+ end,
+})
+
+autocmd("FileType", {
+ desc = "Make q close help, man, quickfix, dap floats",
+ group = augroup("q_close_windows", { clear = true }),
+ pattern = { "qf", "help", "man", "dap-float" },
+ callback = function(event)
+ vim.keymap.set("n", "q", "close", { buffer = event.buf, silent = true, nowait = true })
+ end,
+})
+
+autocmd("TextYankPost", {
+ desc = "Highlight yanked text",
+ group = augroup("highlightyank", { clear = true }),
+ pattern = "*",
+ callback = function() vim.highlight.on_yank() end,
+})
+
+autocmd("FileType", {
+ desc = "Unlist quickfist buffers",
+ group = augroup("unlist_quickfist", { clear = true }),
+ pattern = "qf",
+ callback = function() vim.opt_local.buflisted = false end,
+})
+
+autocmd("BufEnter", {
+ desc = "Quit AstroNvim if more than one window is open and only sidebar windows are list",
+ group = augroup("auto_quit", { clear = true }),
+ callback = function()
+ local wins = vim.api.nvim_tabpage_list_wins(0)
+ -- Both neo-tree and aerial will auto-quit if there is only a single window left
+ if #wins <= 1 then return end
+ local sidebar_fts = { aerial = true, ["neo-tree"] = true }
+ for _, winid in ipairs(wins) do
+ if vim.api.nvim_win_is_valid(winid) then
+ local bufnr = vim.api.nvim_win_get_buf(winid)
+ local filetype = vim.api.nvim_get_option_value("filetype", { buf = bufnr })
+ -- If any visible windows are not sidebars, early return
+ if not sidebar_fts[filetype] then
+ return
+ -- If the visible window is a sidebar
+ else
+ -- only count filetypes once, so remove a found sidebar from the detection
+ sidebar_fts[filetype] = nil
+ end
+ end
+ end
+ if #vim.api.nvim_list_tabpages() > 1 then
+ vim.cmd.tabclose()
+ else
+ vim.cmd.qall()
+ end
+ end,
+})
+
+if is_available "alpha-nvim" then
+ local group_name = augroup("alpha_settings", { clear = true })
+ autocmd("User", {
+ desc = "Disable status and tablines for alpha",
+ group = group_name,
+ pattern = "AlphaReady",
+ callback = function()
+ local prev_showtabline = vim.opt.showtabline
+ local prev_status = vim.opt.laststatus
+ vim.opt.laststatus = 0
+ vim.opt.showtabline = 0
+ vim.opt_local.winbar = nil
+ autocmd("BufUnload", {
+ pattern = "",
+ callback = function()
+ vim.opt.laststatus = prev_status
+ vim.opt.showtabline = prev_showtabline
+ end,
+ })
+ end,
+ })
+ autocmd("VimEnter", {
+ desc = "Start Alpha when vim is opened with no arguments",
+ group = group_name,
+ callback = function()
+ local should_skip = false
+ if vim.fn.argc() > 0 or vim.fn.line2byte "$" ~= -1 or not vim.o.modifiable then
+ should_skip = true
+ else
+ for _, arg in pairs(vim.v.argv) do
+ if arg == "-b" or arg == "-c" or vim.startswith(arg, "+") or arg == "-S" then
+ should_skip = true
+ break
+ end
+ end
+ end
+ if not should_skip then require("alpha").start(true, require("alpha").default_config) end
+ end,
+ })
+end
+
+if is_available "neo-tree.nvim" then
+ autocmd("BufEnter", {
+ desc = "Open Neo-Tree on startup with directory",
+ group = augroup("neotree_start", { clear = true }),
+ callback = function()
+ if package.loaded["neo-tree"] then
+ vim.api.nvim_del_augroup_by_name "neotree_start"
+ else
+ local stats = vim.loop.fs_stat(vim.api.nvim_buf_get_name(0))
+ if stats and stats.type == "directory" then
+ require "neo-tree"
+ vim.api.nvim_del_augroup_by_name "neotree_start"
+ vim.api.nvim_exec_autocmds("BufEnter", {})
+ end
+ end
+ end,
+ })
+end
+
+autocmd({ "VimEnter", "ColorScheme" }, {
+ desc = "Load custom highlights from user configuration",
+ group = augroup("astronvim_highlights", { clear = true }),
+ callback = function()
+ if vim.g.colors_name then
+ for _, module in ipairs { "init", vim.g.colors_name } do
+ for group, spec in pairs(astronvim.user_opts("highlights." .. module)) do
+ vim.api.nvim_set_hl(0, group, spec)
+ end
+ end
+ end
+ astroevent "ColorScheme"
+ end,
+})
+
+autocmd({ "BufReadPost", "BufNewFile" }, {
+ group = augroup("file_user_events", { clear = true }),
+ callback = function(args)
+ if not (vim.fn.expand "%" == "" or vim.api.nvim_get_option_value("buftype", { buf = args.buf }) == "nofile") then
+ utils.event "File"
+ if utils.cmd('git -C "' .. vim.fn.expand "%:p:h" .. '" rev-parse', false) then utils.event "GitFile" end
+ end
+ end,
+})
+
+cmd(
+ "AstroChangelog",
+ function() require("astronvim.utils.updater").changelog() end,
+ { desc = "Check AstroNvim Changelog" }
+)
+cmd(
+ "AstroUpdatePackages",
+ function() require("astronvim.utils.updater").update_packages() end,
+ { desc = "Update Plugins and Mason" }
+)
+cmd("AstroRollback", function() require("astronvim.utils.updater").rollback() end, { desc = "Rollback AstroNvim" })
+cmd("AstroUpdate", function() require("astronvim.utils.updater").update() end, { desc = "Update AstroNvim" })
+cmd("AstroVersion", function() require("astronvim.utils.updater").version() end, { desc = "Check AstroNvim Version" })
diff --git a/users/daniel/configs/system/nvim/nvim/lua/astronvim/bootstrap.lua b/users/daniel/configs/system/nvim/nvim/lua/astronvim/bootstrap.lua
new file mode 100644
index 0000000..b06b25d
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/lua/astronvim/bootstrap.lua
@@ -0,0 +1,131 @@
+--- ### AstroNvim Core Bootstrap
+--
+-- This module simply sets up the global `astronvim` module.
+-- This is automatically loaded and should not be resourced, everything is accessible through the global `astronvim` variable.
+--
+-- @module astronvim.bootstrap
+-- @copyright 2022
+-- @license GNU General Public License v3.0
+
+_G.astronvim = {}
+
+--- installation details from external installers
+astronvim.install = _G["astronvim_installation"] or { home = vim.fn.stdpath "config" }
+astronvim.supported_configs = { astronvim.install.home }
+--- external astronvim configuration folder
+astronvim.install.config = vim.fn.stdpath("config"):gsub("nvim$", "astronvim")
+-- check if they are the same, protects against NVIM_APPNAME use for isolated install
+if astronvim.install.home ~= astronvim.install.config then
+ vim.opt.rtp:append(astronvim.install.config)
+ --- supported astronvim user conifg folders
+ table.insert(astronvim.supported_configs, astronvim.install.config)
+end
+
+--- Looks to see if a module path references a lua file in a configuration folder and tries to load it. If there is an error loading the file, write an error and continue
+-- @param module the module path to try and load
+-- @return the loaded module if successful or nil
+local function load_module_file(module)
+ -- placeholder for final return value
+ local found_module = nil
+ -- search through each of the supported configuration locations
+ for _, config_path in ipairs(astronvim.supported_configs) do
+ -- convert the module path to a file path (example user.init -> user/init.lua)
+ local module_path = config_path .. "/lua/" .. module:gsub("%.", "/") .. ".lua"
+ -- check if there is a readable file, if so, set it as found
+ if vim.fn.filereadable(module_path) == 1 then found_module = module_path end
+ end
+ -- if we found a readable lua file, try to load it
+ if found_module then
+ -- try to load the file
+ local status_ok, loaded_module = pcall(require, module)
+ -- if successful at loading, set the return variable
+ if status_ok then
+ found_module = loaded_module
+ -- if unsuccessful, throw an error
+ else
+ vim.api.nvim_err_writeln("Error loading file: " .. found_module .. "\n\n" .. loaded_module)
+ end
+ end
+ -- return the loaded module or nil if no file found
+ return found_module
+end
+
+--- Main configuration engine logic for extending a default configuration table with either a function override or a table to merge into the default option
+-- @param overrides the override definition, either a table or a function that takes a single parameter of the original table
+-- @param default the default configuration table
+-- @param extend boolean value to either extend the default or simply overwrite it if an override is provided
+-- @return the new configuration table
+local function func_or_extend(overrides, default, extend)
+ -- if we want to extend the default with the provided override
+ if extend then
+ -- if the override is a table, use vim.tbl_deep_extend
+ if type(overrides) == "table" then
+ local opts = overrides or {}
+ default = default and vim.tbl_deep_extend("force", default, opts) or opts
+ -- if the override is a function, call it with the default and overwrite default with the return value
+ elseif type(overrides) == "function" then
+ default = overrides(default)
+ end
+ -- if extend is set to false and we have a provided override, simply override the default
+ elseif overrides ~= nil then
+ default = overrides
+ end
+ -- return the modified default table
+ return default
+end
+
+--- user settings from the base `user/init.lua` file
+local user_settings = load_module_file "user.init"
+
+--- Search the user settings (user/init.lua table) for a table with a module like path string
+-- @param module the module path like string to look up in the user settings table
+-- @return the value of the table entry if exists or nil
+local function user_setting_table(module)
+ -- get the user settings table
+ local settings = user_settings or {}
+ -- iterate over the path string split by '.' to look up the table value
+ for tbl in string.gmatch(module, "([^%.]+)") do
+ settings = settings[tbl]
+ -- if key doesn't exist, keep the nil value and stop searching
+ if settings == nil then break end
+ end
+ -- return the found settings
+ return settings
+end
+
+--- User configuration entry point to override the default options of a configuration table with a user configuration file or table in the user/init.lua user settings
+-- @param module the module path of the override setting
+-- @param default the default settings that will be overridden
+-- @param extend boolean value to either extend the default settings or overwrite them with the user settings entirely (default: true)
+-- @return the new configuration settings with the user overrides applied
+function astronvim.user_opts(module, default, extend)
+ -- default to extend = true
+ if extend == nil then extend = true end
+ -- if no default table is provided set it to an empty table
+ if default == nil then default = {} end
+ -- try to load a module file if it exists
+ local user_module_settings = load_module_file("user." .. module)
+ -- if no user module file is found, try to load an override from the user settings table from user/init.lua
+ if user_module_settings == nil then user_module_settings = user_setting_table(module) end
+ -- if a user override was found call the configuration engine
+ if user_module_settings ~= nil then default = func_or_extend(user_module_settings, default, extend) end
+ -- return the final configuration table with any overrides applied
+ return default
+end
+
+--- Updater settings overridden with any user provided configuration
+astronvim.updater = {
+ options = astronvim.user_opts("updater", { remote = "origin", channel = "stable" }),
+ snapshot = { module = "lazy_snapshot", path = vim.fn.stdpath "config" .. "/lua/lazy_snapshot.lua" },
+ rollback_file = vim.fn.stdpath "cache" .. "/astronvim_rollback.lua",
+}
+local options = astronvim.updater.options
+if astronvim.install.is_stable ~= nil then options.channel = astronvim.install.is_stable and "stable" or "nightly" end
+if options.pin_plugins == nil then options.pin_plugins = options.channel == "stable" end
+
+--- table of user created terminals
+astronvim.user_terminals = {}
+--- table of language servers to ignore the setup of, configured through lsp.skip_setup in the user configuration
+astronvim.lsp = { skip_setup = astronvim.user_opts("lsp.skip_setup", {}) }
+--- the default colorscheme to apply on startup
+astronvim.default_colorscheme = astronvim.user_opts("colorscheme", "astrotheme", false)
diff --git a/users/daniel/configs/system/nvim/nvim/lua/astronvim/health.lua b/users/daniel/configs/system/nvim/nvim/lua/astronvim/health.lua
new file mode 100644
index 0000000..9e48adf
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/lua/astronvim/health.lua
@@ -0,0 +1,51 @@
+local M = {}
+
+function M.check()
+ vim.health.report_start "AstroNvim"
+
+ vim.health.report_info("AstroNvim Version: " .. require("astronvim.utils.updater").version(true))
+ vim.health.report_info("Neovim Version: v" .. vim.fn.matchstr(vim.fn.execute "version", "NVIM v\\zs[^\n]*"))
+
+ if vim.version().prerelease then
+ vim.health.report_warn "Neovim nightly is not officially supported and may have breaking changes"
+ elseif vim.fn.has "nvim-0.8" == 1 then
+ vim.health.report_ok "Using stable Neovim >= 0.8.0"
+ else
+ vim.health.report_error "Neovim >= 0.8.0 is required"
+ end
+
+ local programs = {
+ { cmd = "git", type = "error", msg = "Used for core functionality such as updater and plugin management" },
+ {
+ cmd = { "xdg-open", "open", "explorer" },
+ type = "warn",
+ msg = "Used for `gx` mapping for opening files with system opener (Optional)",
+ },
+ { cmd = "lazygit", type = "warn", msg = "Used for mappings to pull up git TUI (Optional)" },
+ { cmd = "node", type = "warn", msg = "Used for mappings to pull up node REPL (Optional)" },
+ { cmd = "gdu", type = "warn", msg = "Used for mappings to pull up disk usage analyzer (Optional)" },
+ { cmd = "btm", type = "warn", msg = "Used for mappings to pull up system monitor (Optional)" },
+ { cmd = { "python", "python3" }, type = "warn", msg = "Used for mappings to pull up python REPL (Optional)" },
+ }
+
+ for _, program in ipairs(programs) do
+ if type(program.cmd) == "string" then program.cmd = { program.cmd } end
+ local name = table.concat(program.cmd, "/")
+ local found = false
+ for _, cmd in ipairs(program.cmd) do
+ if vim.fn.executable(cmd) == 1 then
+ name = cmd
+ found = true
+ break
+ end
+ end
+
+ if found then
+ vim.health.report_ok(("`%s` is installed: %s"):format(name, program.msg))
+ else
+ vim.health["report_" .. program.type](("`%s` is not installed: %s"):format(name, program.msg))
+ end
+ end
+end
+
+return M
diff --git a/users/daniel/configs/system/nvim/nvim/lua/astronvim/icons/nerd_font.lua b/users/daniel/configs/system/nvim/nvim/lua/astronvim/icons/nerd_font.lua
new file mode 100644
index 0000000..d6f7f47
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/lua/astronvim/icons/nerd_font.lua
@@ -0,0 +1,48 @@
+return {
+ ActiveLSP = "",
+ ActiveTS = "",
+ ArrowLeft = "",
+ ArrowRight = "",
+ BufferClose = "",
+ DapBreakpoint = "",
+ DapBreakpointCondition = "",
+ DapBreakpointRejected = "",
+ DapLogPoint = ".>",
+ DapStopped = "",
+ DefaultFile = "",
+ Diagnostic = "裂",
+ DiagnosticError = "",
+ DiagnosticHint = "",
+ DiagnosticInfo = "",
+ DiagnosticWarn = "",
+ Ellipsis = "…",
+ FileModified = "",
+ FileReadOnly = "",
+ FoldClosed = "",
+ FoldOpened = "",
+ FoldSeparator = " ",
+ FolderClosed = "",
+ FolderEmpty = "",
+ FolderOpen = "",
+ Git = "",
+ GitAdd = "",
+ GitBranch = "",
+ GitChange = "",
+ GitConflict = "",
+ GitDelete = "",
+ GitIgnored = "◌",
+ GitRenamed = "➜",
+ GitStaged = "✓",
+ GitUnstaged = "✗",
+ GitUntracked = "★",
+ LSPLoaded = "",
+ LSPLoading1 = "",
+ LSPLoading2 = "",
+ LSPLoading3 = "",
+ MacroRecording = "",
+ Paste = "",
+ Search = "",
+ Selected = "❯",
+ Spellcheck = "暈",
+ TabClose = "",
+}
diff --git a/users/daniel/configs/system/nvim/nvim/lua/astronvim/icons/text.lua b/users/daniel/configs/system/nvim/nvim/lua/astronvim/icons/text.lua
new file mode 100644
index 0000000..a8b4e0a
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/lua/astronvim/icons/text.lua
@@ -0,0 +1,40 @@
+return {
+ ActiveLSP = "LSP:",
+ ArrowLeft = "<",
+ ArrowRight = ">",
+ BufferClose = "x",
+ DapBreakpoint = "B",
+ DapBreakpointCondition = "C",
+ DapBreakpointRejected = "R",
+ DapLogPoint = "L",
+ DapStopped = ">",
+ DefaultFile = "[F]",
+ DiagnosticError = "X",
+ DiagnosticHint = "?",
+ DiagnosticInfo = "i",
+ DiagnosticWarn = "!",
+ Ellipsis = "...",
+ FileModified = "*",
+ FileReadOnly = "[lock]",
+ FoldClosed = "+",
+ FoldOpened = "-",
+ FoldSeparator = " ",
+ FolderClosed = "[D]",
+ FolderEmpty = "[E]",
+ FolderOpen = "[O]",
+ GitAdd = "[+]",
+ GitChange = "[/]",
+ GitConflict = "[!]",
+ GitDelete = "[-]",
+ GitIgnored = "[I]",
+ GitRenamed = "[R]",
+ GitStaged = "[S]",
+ GitUnstaged = "[U]",
+ GitUntracked = "[?]",
+ MacroRecording = "Recording:",
+ Paste = "[PASTE]",
+ Search = "?",
+ Selected = "*",
+ Spellcheck = "[SPELL]",
+ TabClose = "X",
+}
diff --git a/users/daniel/configs/system/nvim/nvim/lua/astronvim/lazy.lua b/users/daniel/configs/system/nvim/nvim/lua/astronvim/lazy.lua
new file mode 100644
index 0000000..0a7ef70
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/lua/astronvim/lazy.lua
@@ -0,0 +1,41 @@
+local lazypath = vim.fn.stdpath "data" .. "/lazy/lazy.nvim"
+if not vim.loop.fs_stat(lazypath) then
+ vim.fn.system { "git", "clone", "https://github.com/folke/lazy.nvim.git", "--branch=stable", lazypath }
+ local oldcmdheight = vim.opt.cmdheight:get()
+ vim.opt.cmdheight = 1
+ vim.notify "Please wait while plugins are installed..."
+ vim.api.nvim_create_autocmd("User", {
+ once = true,
+ pattern = "LazyInstall",
+ callback = function()
+ vim.cmd.bw()
+ vim.opt.cmdheight = oldcmdheight
+ vim.tbl_map(function(module) pcall(require, module) end, { "nvim-treesitter", "mason" })
+ require("astronvim.utils").notify "Mason is installing packages if configured, check status with :Mason"
+ end,
+ })
+end
+vim.opt.rtp:prepend(lazypath)
+
+local user_plugins = astronvim.user_opts "plugins"
+for _, config_dir in ipairs(astronvim.supported_configs) do
+ if vim.fn.isdirectory(config_dir .. "/lua/user/plugins") == 1 then user_plugins = { import = "user.plugins" } end
+end
+
+local spec = astronvim.updater.options.pin_plugins and { { import = astronvim.updater.snapshot.module } } or {}
+vim.list_extend(spec, { { import = "plugins" }, user_plugins })
+
+local colorscheme = astronvim.default_colorscheme and { astronvim.default_colorscheme } or nil
+
+require("lazy").setup(astronvim.user_opts("lazy", {
+ spec = spec,
+ defaults = { lazy = true },
+ install = { colorscheme = colorscheme },
+ performance = {
+ rtp = {
+ paths = astronvim.supported_configs,
+ disabled_plugins = { "tohtml", "gzip", "matchit", "zipPlugin", "netrwPlugin", "tarPlugin" },
+ },
+ },
+ lockfile = vim.fn.stdpath "data" .. "/lazy-lock.json",
+}))
diff --git a/users/daniel/configs/system/nvim/nvim/lua/astronvim/mappings.lua b/users/daniel/configs/system/nvim/nvim/lua/astronvim/mappings.lua
new file mode 100644
index 0000000..029e46b
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/lua/astronvim/mappings.lua
@@ -0,0 +1,379 @@
+local utils = require "astronvim.utils"
+local is_available = utils.is_available
+local ui = require "astronvim.utils.ui"
+
+local maps = { i = {}, n = {}, v = {}, t = {} }
+
+local sections = {
+ f = { name = " Find" },
+ p = { name = " Packages" },
+ l = { name = " LSP" },
+ u = { name = " UI" },
+ b = { name = " Buffers" },
+ d = { name = " Debugger" },
+ g = { name = " Git" },
+ S = { name = " Session" },
+ t = { name = " Terminal" },
+}
+if not vim.g.icons_enabled then vim.tbl_map(function(opts) opts.name = opts.name:gsub("^.* ", "") end, sections) end
+
+-- Normal --
+-- Standard Operations
+maps.n["j"] = { "v:count ? 'j' : 'gj'", expr = true, desc = "Move cursor down" }
+maps.n["k"] = { "v:count ? 'k' : 'gk'", expr = true, desc = "Move cursor up" }
+maps.v["j"] = maps.n.j
+maps.v["k"] = maps.n.k
+maps.n["w"] = { "w", desc = "Save" }
+maps.n["q"] = { "confirm q", desc = "Quit" }
+maps.n["n"] = { "enew", desc = "New File" }
+maps.n["gx"] = { utils.system_open, desc = "Open the file under cursor with system app" }
+maps.n[""] = { "w!", desc = "Force write" }
+maps.n[""] = { "q!", desc = "Force quit" }
+maps.n["|"] = { "vsplit", desc = "Vertical Split" }
+maps.n["\\"] = { "split", desc = "Horizontal Split" }
+
+-- Plugin Manager
+maps.n["p"] = sections.p
+maps.n["pi"] = { function() require("lazy").install() end, desc = "Plugins Install" }
+maps.n["ps"] = { function() require("lazy").home() end, desc = "Plugins Status" }
+maps.n["pS"] = { function() require("lazy").sync() end, desc = "Plugins Sync" }
+maps.n["pu"] = { function() require("lazy").check() end, desc = "Plugins Check Updates" }
+maps.n["pU"] = { function() require("lazy").update() end, desc = "Plugins Update" }
+
+-- AstroNvim
+maps.n["pa"] = { "AstroUpdatePackages", desc = "Update Plugins and Mason" }
+maps.n["pA"] = { "AstroUpdate", desc = "AstroNvim Update" }
+maps.n["pv"] = { "AstroVersion", desc = "AstroNvim Version" }
+maps.n["pl"] = { "AstroChangelog", desc = "AstroNvim Changelog" }
+
+-- Manage Buffers
+maps.n["c"] = { function() require("astronvim.utils.buffer").close() end, desc = "Close buffer" }
+maps.n["C"] = { function() require("astronvim.utils.buffer").close(0, true) end, desc = "Force close buffer" }
+maps.n["]b"] =
+ { function() require("astronvim.utils.buffer").nav(vim.v.count > 0 and vim.v.count or 1) end, desc = "Next buffer" }
+maps.n["[b"] = {
+ function() require("astronvim.utils.buffer").nav(-(vim.v.count > 0 and vim.v.count or 1)) end,
+ desc = "Previous buffer",
+}
+maps.n[">b"] = {
+ function() require("astronvim.utils.buffer").move(vim.v.count > 0 and vim.v.count or 1) end,
+ desc = "Move buffer tab right",
+}
+maps.n[" 0 and vim.v.count or 1)) end,
+ desc = "Move buffer tab left",
+}
+
+maps.n["b"] = sections.b
+maps.n["bc"] =
+ { function() require("astronvim.utils.buffer").close_all(true) end, desc = "Close all buffers except current" }
+maps.n["bC"] = { function() require("astronvim.utils.buffer").close_all() end, desc = "Close all buffers" }
+maps.n["bb"] = {
+ function()
+ require("astronvim.utils.status").heirline.buffer_picker(function(bufnr) vim.api.nvim_win_set_buf(0, bufnr) end)
+ end,
+ desc = "Select buffer from tabline",
+}
+maps.n["bd"] = {
+ function()
+ require("astronvim.utils.status").heirline.buffer_picker(
+ function(bufnr) require("astronvim.utils.buffer").close(bufnr) end
+ )
+ end,
+ desc = "Delete buffer from tabline",
+}
+maps.n["b\\"] = {
+ function()
+ require("astronvim.utils.status").heirline.buffer_picker(function(bufnr)
+ vim.cmd.split()
+ vim.api.nvim_win_set_buf(0, bufnr)
+ end)
+ end,
+ desc = "Horizontal split buffer from tabline",
+}
+maps.n["b|"] = {
+ function()
+ require("astronvim.utils.status").heirline.buffer_picker(function(bufnr)
+ vim.cmd.vsplit()
+ vim.api.nvim_win_set_buf(0, bufnr)
+ end)
+ end,
+ desc = "Vertical split buffer from tabline",
+}
+
+-- Navigate tabs
+maps.n["]t"] = { function() vim.cmd.tabnext() end, desc = "Next tab" }
+maps.n["[t"] = { function() vim.cmd.tabprevious() end, desc = "Previous tab" }
+
+-- Alpha
+if is_available "alpha-nvim" then
+ maps.n["h"] = {
+ function()
+ local wins = vim.api.nvim_tabpage_list_wins(0)
+ if #wins > 1 and vim.api.nvim_get_option_value("filetype", { win = wins[1] }) == "neo-tree" then
+ vim.fn.win_gotoid(wins[2]) -- go to non-neo-tree window to toggle alpha
+ end
+ require("alpha").start(false, require("alpha").default_config)
+ end,
+ desc = "Home Screen",
+ }
+end
+
+-- Comment
+if is_available "Comment.nvim" then
+ maps.n["/"] = {
+ function() require("Comment.api").toggle.linewise.count(vim.v.count > 0 and vim.v.count or 1) end,
+ desc = "Comment line",
+ }
+ maps.v["/"] =
+ { "lua require('Comment.api').toggle.linewise(vim.fn.visualmode())", desc = "Toggle comment line" }
+end
+
+-- GitSigns
+if is_available "gitsigns.nvim" then
+ maps.n["g"] = sections.g
+ maps.n["]g"] = { function() require("gitsigns").next_hunk() end, desc = "Next Git hunk" }
+ maps.n["[g"] = { function() require("gitsigns").prev_hunk() end, desc = "Previous Git hunk" }
+ maps.n["gl"] = { function() require("gitsigns").blame_line() end, desc = "View Git blame" }
+ maps.n["gp"] = { function() require("gitsigns").preview_hunk() end, desc = "Preview Git hunk" }
+ maps.n["gh"] = { function() require("gitsigns").reset_hunk() end, desc = "Reset Git hunk" }
+ maps.n["gr"] = { function() require("gitsigns").reset_buffer() end, desc = "Reset Git buffer" }
+ maps.n["gs"] = { function() require("gitsigns").stage_hunk() end, desc = "Stage Git hunk" }
+ maps.n["gS"] = { function() require("gitsigns").stage_buffer() end, desc = "Stage Git buffer" }
+ maps.n["gu"] = { function() require("gitsigns").undo_stage_hunk() end, desc = "Unstage Git hunk" }
+ maps.n["gd"] = { function() require("gitsigns").diffthis() end, desc = "View Git diff" }
+end
+
+-- NeoTree
+if is_available "neo-tree.nvim" then
+ maps.n["e"] = { "Neotree toggle", desc = "Toggle Explorer" }
+ maps.n["o"] = {
+ function()
+ if vim.bo.filetype == "neo-tree" then
+ vim.cmd.wincmd "p"
+ else
+ vim.cmd.Neotree "focus"
+ end
+ end,
+ desc = "Toggle Explorer Focus",
+ }
+end
+
+-- Session Manager
+if is_available "neovim-session-manager" then
+ maps.n["S"] = sections.S
+ maps.n["Sl"] = { "SessionManager! load_last_session", desc = "Load last session" }
+ maps.n["Ss"] = { "SessionManager! save_current_session", desc = "Save this session" }
+ maps.n["Sd"] = { "SessionManager! delete_session", desc = "Delete session" }
+ maps.n["Sf"] = { "SessionManager! load_session", desc = "Search sessions" }
+ maps.n["S."] =
+ { "SessionManager! load_current_dir_session", desc = "Load current directory session" }
+end
+
+-- Package Manager
+if is_available "mason.nvim" then
+ maps.n["pm"] = { "Mason", desc = "Mason Installer" }
+ maps.n["pM"] = { "MasonUpdateAll", desc = "Mason Update" }
+end
+
+-- Smart Splits
+if is_available "smart-splits.nvim" then
+ maps.n[""] = { function() require("smart-splits").move_cursor_left() end, desc = "Move to left split" }
+ maps.n[""] = { function() require("smart-splits").move_cursor_down() end, desc = "Move to below split" }
+ maps.n[""] = { function() require("smart-splits").move_cursor_up() end, desc = "Move to above split" }
+ maps.n[""] = { function() require("smart-splits").move_cursor_right() end, desc = "Move to right split" }
+ maps.n[""] = { function() require("smart-splits").resize_up() end, desc = "Resize split up" }
+ maps.n[""] = { function() require("smart-splits").resize_down() end, desc = "Resize split down" }
+ maps.n[""] = { function() require("smart-splits").resize_left() end, desc = "Resize split left" }
+ maps.n[""] = { function() require("smart-splits").resize_right() end, desc = "Resize split right" }
+else
+ maps.n[""] = { "h", desc = "Move to left split" }
+ maps.n[""] = { "j", desc = "Move to below split" }
+ maps.n[""] = { "k", desc = "Move to above split" }
+ maps.n[""] = { "l", desc = "Move to right split" }
+ maps.n[""] = { "resize -2", desc = "Resize split up" }
+ maps.n[""] = { "resize +2", desc = "Resize split down" }
+ maps.n[""] = { "vertical resize -2", desc = "Resize split left" }
+ maps.n[""] = { "vertical resize +2", desc = "Resize split right" }
+end
+
+-- SymbolsOutline
+if is_available "aerial.nvim" then
+ maps.n["l"] = sections.l
+ maps.n["lS"] = { function() require("aerial").toggle() end, desc = "Symbols outline" }
+end
+
+-- Telescope
+if is_available "telescope.nvim" then
+ maps.n["f"] = sections.f
+ maps.n["g"] = sections.g
+ maps.n["gb"] = { function() require("telescope.builtin").git_branches() end, desc = "Git branches" }
+ maps.n["gc"] = { function() require("telescope.builtin").git_commits() end, desc = "Git commits" }
+ maps.n["gt"] = { function() require("telescope.builtin").git_status() end, desc = "Git status" }
+ maps.n["f"] = { function() require("telescope.builtin").resume() end, desc = "Resume previous search" }
+ maps.n["f'"] = { function() require("telescope.builtin").marks() end, desc = "Find marks" }
+ maps.n["fa"] = {
+ function()
+ local cwd = vim.fn.stdpath "config" .. "/.."
+ local search_dirs = {}
+ for _, dir in ipairs(astronvim.supported_configs) do -- search all supported config locations
+ if dir == astronvim.install.home then dir = dir .. "/lua/user" end -- don't search the astronvim core files
+ if vim.fn.isdirectory(dir) == 1 then table.insert(search_dirs, dir) end -- add directory to search if exists
+ end
+ if vim.tbl_isempty(search_dirs) then -- if no config folders found, show warning
+ utils.notify("No user configuration files found", "warn")
+ else
+ if #search_dirs == 1 then cwd = search_dirs[1] end -- if only one directory, focus cwd
+ require("telescope.builtin").find_files {
+ prompt_title = "Config Files",
+ search_dirs = search_dirs,
+ cwd = cwd,
+ } -- call telescope
+ end
+ end,
+ desc = "Find AstroNvim config files",
+ }
+ maps.n["fb"] = { function() require("telescope.builtin").buffers() end, desc = "Find buffers" }
+ maps.n["fc"] =
+ { function() require("telescope.builtin").grep_string() end, desc = "Find for word under cursor" }
+ maps.n["fC"] = { function() require("telescope.builtin").commands() end, desc = "Find commands" }
+ maps.n["ff"] = { function() require("telescope.builtin").find_files() end, desc = "Find files" }
+ maps.n["fF"] = {
+ function() require("telescope.builtin").find_files { hidden = true, no_ignore = true } end,
+ desc = "Find all files",
+ }
+ maps.n["fh"] = { function() require("telescope.builtin").help_tags() end, desc = "Find help" }
+ maps.n["fk"] = { function() require("telescope.builtin").keymaps() end, desc = "Find keymaps" }
+ maps.n["fm"] = { function() require("telescope.builtin").man_pages() end, desc = "Find man" }
+ if is_available "nvim-notify" then
+ maps.n["fn"] =
+ { function() require("telescope").extensions.notify.notify() end, desc = "Find notifications" }
+ end
+ maps.n["fo"] = { function() require("telescope.builtin").oldfiles() end, desc = "Find history" }
+ maps.n["fr"] = { function() require("telescope.builtin").registers() end, desc = "Find registers" }
+ maps.n["ft"] =
+ { function() require("telescope.builtin").colorscheme { enable_preview = true } end, desc = "Find themes" }
+ maps.n["fw"] = { function() require("telescope.builtin").live_grep() end, desc = "Find words" }
+ maps.n["fW"] = {
+ function()
+ require("telescope.builtin").live_grep {
+ additional_args = function(args) return vim.list_extend(args, { "--hidden", "--no-ignore" }) end,
+ }
+ end,
+ desc = "Find words in all files",
+ }
+ maps.n["l"] = sections.l
+ maps.n["lD"] = { function() require("telescope.builtin").diagnostics() end, desc = "Search diagnostics" }
+ maps.n["ls"] = {
+ function()
+ local aerial_avail, _ = pcall(require, "aerial")
+ if aerial_avail then
+ require("telescope").extensions.aerial.aerial()
+ else
+ require("telescope.builtin").lsp_document_symbols()
+ end
+ end,
+ desc = "Search symbols",
+ }
+end
+
+-- Terminal
+if is_available "toggleterm.nvim" then
+ maps.n["t"] = sections.t
+ if vim.fn.executable "lazygit" == 1 then
+ maps.n["g"] = sections.g
+ maps.n["gg"] = { function() utils.toggle_term_cmd "lazygit" end, desc = "ToggleTerm lazygit" }
+ maps.n["tl"] = { function() utils.toggle_term_cmd "lazygit" end, desc = "ToggleTerm lazygit" }
+ end
+ if vim.fn.executable "node" == 1 then
+ maps.n["tn"] = { function() utils.toggle_term_cmd "node" end, desc = "ToggleTerm node" }
+ end
+ if vim.fn.executable "gdu" == 1 then
+ maps.n["tu"] = { function() utils.toggle_term_cmd "gdu" end, desc = "ToggleTerm gdu" }
+ end
+ if vim.fn.executable "btm" == 1 then
+ maps.n["tt"] = { function() utils.toggle_term_cmd "btm" end, desc = "ToggleTerm btm" }
+ end
+ local python = vim.fn.executable "python" == 1 and "python" or vim.fn.executable "python3" == 1 and "python3"
+ if python then maps.n["tp"] = { function() utils.toggle_term_cmd(python) end, desc = "ToggleTerm python" } end
+ maps.n["tf"] = { "ToggleTerm direction=float", desc = "ToggleTerm float" }
+ maps.n["th"] = { "ToggleTerm size=10 direction=horizontal", desc = "ToggleTerm horizontal split" }
+ maps.n["tv"] = { "ToggleTerm size=80 direction=vertical", desc = "ToggleTerm vertical split" }
+ maps.n[""] = { "ToggleTerm", desc = "Toggle terminal" }
+ maps.t[""] = maps.n[""]
+ maps.n[""] = maps.n[""]
+ maps.t[""] = maps.n[""]
+end
+
+if is_available "nvim-dap" then
+ maps.n["d"] = sections.d
+ -- modified function keys found with `showkey -a` in the terminal to get key code
+ -- run `nvim -V3log +quit` and search through the "Terminal info" in the `log` file for the correct keyname
+ maps.n[""] = { function() require("dap").continue() end, desc = "Debugger: Start" }
+ maps.n[""] = { function() require("dap").terminate() end, desc = "Debugger: Stop" } -- Shift+F5
+ maps.n[""] = { function() require("dap").restart_frame() end, desc = "Debugger: Restart" } -- Control+F5
+ maps.n[""] = { function() require("dap").pause() end, desc = "Debugger: Pause" }
+ maps.n[""] = { function() require("dap").toggle_breakpoint() end, desc = "Debugger: Toggle Breakpoint" }
+ maps.n[""] = { function() require("dap").step_over() end, desc = "Debugger: Step Over" }
+ maps.n[""] = { function() require("dap").step_into() end, desc = "Debugger: Step Into" }
+ maps.n[""] = { function() require("dap").step_out() end, desc = "Debugger: Step Out" } -- Shift+F11
+ maps.n["db"] = { function() require("dap").toggle_breakpoint() end, desc = "Toggle Breakpoint (F9)" }
+ maps.n["dB"] = { function() require("dap").clear_breakpoints() end, desc = "Clear Breakpoints" }
+ maps.n["dc"] = { function() require("dap").continue() end, desc = "Start/Continue (F5)" }
+ maps.n["di"] = { function() require("dap").step_into() end, desc = "Step Into (F11)" }
+ maps.n["do"] = { function() require("dap").step_over() end, desc = "Step Over (F10)" }
+ maps.n["dO"] = { function() require("dap").step_out() end, desc = "Step Out (S-F11)" }
+ maps.n["dq"] = { function() require("dap").close() end, desc = "Close Session" }
+ maps.n["dQ"] = { function() require("dap").terminate() end, desc = "Terminate Session (S-F5)" }
+ maps.n["dp"] = { function() require("dap").pause() end, desc = "Pause (F6)" }
+ maps.n["dr"] = { function() require("dap").restart_frame() end, desc = "Restart (C-F5)" }
+ maps.n["dR"] = { function() require("dap").repl.toggle() end, desc = "Toggle REPL" }
+ if is_available "nvim-dap-ui" then
+ maps.n["du"] = { function() require("dapui").toggle() end, desc = "Toggle Debugger UI" }
+ maps.n["dh"] = { function() require("dap.ui.widgets").hover() end, desc = "Debugger Hover" }
+ end
+end
+
+-- Improved Code Folding
+if is_available "nvim-ufo" then
+ maps.n["zR"] = { function() require("ufo").openAllFolds() end, desc = "Open all folds" }
+ maps.n["zM"] = { function() require("ufo").closeAllFolds() end, desc = "Close all folds" }
+ maps.n["zr"] = { function() require("ufo").openFoldsExceptKinds() end, desc = "Fold less" }
+ maps.n["zm"] = { function() require("ufo").closeFoldsWith() end, desc = "Fold more" }
+ maps.n["zp"] = { function() require("ufo").peekFoldedLinesUnderCursor() end, desc = "Peek fold" }
+end
+
+-- Stay in indent mode
+maps.v[""] = { ""] = { ">gv", desc = "indent line" }
+
+-- Improved Terminal Navigation
+maps.t[""] = { "wincmd h", desc = "Terminal left window navigation" }
+maps.t[""] = { "wincmd j", desc = "Terminal down window navigation" }
+maps.t[""] = { "wincmd k", desc = "Terminal up window navigation" }
+maps.t[""] = { "wincmd l", desc = "Terminal right window navigation" }
+
+maps.n["u"] = sections.u
+-- Custom menu for modification of the user experience
+if is_available "nvim-autopairs" then maps.n["ua"] = { ui.toggle_autopairs, desc = "Toggle autopairs" } end
+maps.n["ub"] = { ui.toggle_background, desc = "Toggle background" }
+if is_available "nvim-cmp" then maps.n["uc"] = { ui.toggle_cmp, desc = "Toggle autocompletion" } end
+if is_available "nvim-colorizer.lua" then
+ maps.n["uC"] = { "ColorizerToggle", desc = "Toggle color highlight" }
+end
+maps.n["ud"] = { ui.toggle_diagnostics, desc = "Toggle diagnostics" }
+maps.n["ug"] = { ui.toggle_signcolumn, desc = "Toggle signcolumn" }
+maps.n["ui"] = { ui.set_indent, desc = "Change indent setting" }
+maps.n["ul"] = { ui.toggle_statusline, desc = "Toggle statusline" }
+maps.n["uL"] = { ui.toggle_codelens, desc = "Toggle CodeLens refresh" }
+maps.n["un"] = { ui.change_number, desc = "Change line numbering" }
+maps.n["uN"] = { ui.toggle_ui_notifications, desc = "Toggle UI notifications" }
+maps.n["up"] = { ui.toggle_paste, desc = "Toggle paste mode" }
+maps.n["us"] = { ui.toggle_spell, desc = "Toggle spellcheck" }
+maps.n["uS"] = { ui.toggle_conceal, desc = "Toggle conceal" }
+maps.n["ut"] = { ui.toggle_tabline, desc = "Toggle tabline" }
+maps.n["uu"] = { ui.toggle_url_match, desc = "Toggle URL highlight" }
+maps.n["uw"] = { ui.toggle_wrap, desc = "Toggle wrap" }
+maps.n["uy"] = { ui.toggle_syntax, desc = "Toggle syntax highlight" }
+
+utils.set_mappings(astronvim.user_opts("mappings", maps))
diff --git a/users/daniel/configs/system/nvim/nvim/lua/astronvim/options.lua b/users/daniel/configs/system/nvim/nvim/lua/astronvim/options.lua
new file mode 100644
index 0000000..0fce646
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/lua/astronvim/options.lua
@@ -0,0 +1,71 @@
+vim.opt.viewoptions:remove "curdir" -- disable saving current directory with views
+vim.opt.shortmess:append { s = true, I = true } -- disable startup message
+vim.opt.backspace:append { "nostop" } -- Don't stop backspace at insert
+if vim.fn.has "nvim-0.9" == 1 then
+ vim.opt.diffopt:append "linematch:60" -- enable linematch diff algorithm
+end
+local options = astronvim.user_opts("options", {
+ opt = {
+ breakindent = true, -- Wrap indent to match line start
+ clipboard = "unnamedplus", -- Connection to the system clipboard
+ cmdheight = 0, -- hide command line unless needed
+ completeopt = { "menuone", "noselect" }, -- Options for insert mode completion
+ copyindent = true, -- Copy the previous indentation on autoindenting
+ cursorline = true, -- Highlight the text line of the cursor
+ expandtab = true, -- Enable the use of space in tab
+ fileencoding = "utf-8", -- File content encoding for the buffer
+ fillchars = { eob = " " }, -- Disable `~` on nonexistent lines
+ foldenable = true, -- enable fold for nvim-ufo
+ foldlevel = 99, -- set high foldlevel for nvim-ufo
+ foldlevelstart = 99, -- start with all code unfolded
+ foldcolumn = vim.fn.has "nvim-0.9" == 1 and "1" or nil, -- show foldcolumn in nvim 0.9
+ history = 100, -- Number of commands to remember in a history table
+ ignorecase = true, -- Case insensitive searching
+ infercase = true, -- Infer cases in keyword completion
+ laststatus = 3, -- globalstatus
+ linebreak = true, -- Wrap lines at 'breakat'
+ mouse = "a", -- Enable mouse support
+ number = true, -- Show numberline
+ preserveindent = true, -- Preserve indent structure as much as possible
+ pumheight = 10, -- Height of the pop up menu
+ relativenumber = true, -- Show relative numberline
+ scrolloff = 8, -- Number of lines to keep above and below the cursor
+ shiftwidth = 2, -- Number of space inserted for indentation
+ showmode = false, -- Disable showing modes in command line
+ showtabline = 2, -- always display tabline
+ sidescrolloff = 8, -- Number of columns to keep at the sides of the cursor
+ signcolumn = "yes", -- Always show the sign column
+ smartcase = true, -- Case sensitivie searching
+ smartindent = true, -- Smarter autoindentation
+ splitbelow = true, -- Splitting a new window below the current one
+ splitkeep = vim.fn.has "nvim-0.9" == 1 and "screen" or nil, -- Maintain code view when splitting
+ splitright = true, -- Splitting a new window at the right of the current one
+ tabstop = 2, -- Number of space in a tab
+ termguicolors = true, -- Enable 24-bit RGB color in the TUI
+ timeoutlen = 500, -- Shorten key timeout length a little bit for which-key
+ undofile = true, -- Enable persistent undo
+ updatetime = 300, -- Length of time to wait before triggering the plugin
+ virtualedit = "block", -- allow going past end of line in visual block mode
+ wrap = false, -- Disable wrapping of lines longer than the width of window
+ writebackup = false, -- Disable making a backup before overwriting a file
+ },
+ g = {
+ highlighturl_enabled = true, -- highlight URLs by default
+ mapleader = " ", -- set leader key
+ autoformat_enabled = true, -- enable or disable auto formatting at start (lsp.formatting.format_on_save must be enabled)
+ codelens_enabled = true, -- enable or disable automatic codelens refreshing for lsp that support it
+ lsp_handlers_enabled = true, -- enable or disable default vim.lsp.handlers (hover and signatureHelp)
+ cmp_enabled = true, -- enable completion at start
+ autopairs_enabled = true, -- enable autopairs at start
+ diagnostics_mode = 3, -- set the visibility of diagnostics in the UI (0=off, 1=only show in status line, 2=virtual text off, 3=all on)
+ icons_enabled = true, -- disable icons in the UI (disable if no nerd font is available)
+ ui_notifications_enabled = true, -- disable notifications when toggling UI elements
+ },
+ t = { bufs = vim.api.nvim_list_bufs() }, -- initialize buffers for the current tab
+})
+
+for scope, table in pairs(options) do
+ for setting, value in pairs(table) do
+ vim[scope][setting] = value
+ end
+end
diff --git a/users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/buffer.lua b/users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/buffer.lua
new file mode 100644
index 0000000..ecb37bb
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/buffer.lua
@@ -0,0 +1,103 @@
+--- ### AstroNvim Buffer Utilities
+--
+-- Buffer management related utility functions
+--
+-- This module can be loaded with `local buffer_utils = require "astronvim.utils.buffer"`
+--
+-- @module astronvim.utils.buffer
+-- @copyright 2022
+-- @license GNU General Public License v3.0
+
+local M = {}
+
+--- Check if a buffer is valid
+-- @param bufnr the buffer to check
+-- @return true if the buffer is valid or false
+function M.is_valid(bufnr)
+ if not bufnr or bufnr < 1 then return false end
+ return vim.bo[bufnr].buflisted and vim.api.nvim_buf_is_valid(bufnr)
+end
+
+--- Move the current buffer tab n places in the bufferline
+-- @param n numer of tabs to move the current buffer over by (positive = right, negative = left)
+function M.move(n)
+ if n == 0 then return end -- if n = 0 then no shifts are needed
+ local bufs = vim.t.bufs -- make temp variable
+ for i, bufnr in ipairs(bufs) do -- loop to find current buffer
+ if bufnr == vim.api.nvim_get_current_buf() then -- found index of current buffer
+ for _ = 0, (n % #bufs) - 1 do -- calculate number of right shifts
+ local new_i = i + 1 -- get next i
+ if i == #bufs then -- if at end, cycle to beginning
+ new_i = 1 -- next i is actually 1 if at the end
+ local val = bufs[i] -- save value
+ table.remove(bufs, i) -- remove from end
+ table.insert(bufs, new_i, val) -- insert at beginning
+ else -- if not at the end,then just do an in place swap
+ bufs[i], bufs[new_i] = bufs[new_i], bufs[i]
+ end
+ i = new_i -- iterate i to next value
+ end
+ break
+ end
+ end
+ vim.t.bufs = bufs -- set buffers
+ require("astronvim.utils").event "BufsUpdated"
+ vim.cmd.redrawtabline() -- redraw tabline
+end
+
+--- Navigate left and right by n places in the bufferline
+-- @param n the number of tabs to navigate to (positive = right, negative = left)
+function M.nav(n)
+ local current = vim.api.nvim_get_current_buf()
+ for i, v in ipairs(vim.t.bufs) do
+ if current == v then
+ vim.cmd.b(vim.t.bufs[(i + n - 1) % #vim.t.bufs + 1])
+ break
+ end
+ end
+end
+
+--- Navigate to a specific buffer by its position in the bufferline
+-- @param tabnr the position of the buffer to navigate to
+function M.nav_to(tabnr) vim.cmd.b(vim.t.bufs[tabnr]) end
+
+--- Close a given buffer
+-- @param bufnr? the buffer number to close or the current buffer if not provided
+-- @param force? whether or not to foce close the buffers or confirm changes (default: false)
+function M.close(bufnr, force)
+ if force == nil then force = false end
+ if require("astronvim.utils").is_available "bufdelete.nvim" then
+ require("bufdelete").bufdelete(bufnr, force)
+ else
+ vim.cmd((force and "bd!" or "confirm bd") .. bufnr)
+ end
+end
+
+--- Close all buffers
+-- @param keep_current? whether or not to keep the current buffer (default: false)
+-- @param force? whether or not to foce close the buffers or confirm changes (default: false)
+function M.close_all(keep_current, force)
+ if force == nil then force = false end
+ if keep_current == nil then keep_current = false end
+ local current = vim.api.nvim_get_current_buf()
+ for _, bufnr in ipairs(vim.t.bufs) do
+ if not keep_current or bufnr ~= current then
+ if require("astronvim.utils").is_available "bufdelete.nvim" then
+ require("bufdelete").bufdelete(bufnr, force)
+ else
+ vim.cmd((force and "bd!" or "confirm bd") .. bufnr)
+ end
+ end
+ end
+end
+
+--- Close the current tab
+function M.close_tab()
+ if #vim.api.nvim_list_tabpages() > 1 then
+ vim.t.bufs = nil
+ require("astronvim.utils").event "BufsUpdated"
+ vim.cmd.tabclose()
+ end
+end
+
+return M
diff --git a/users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/ffi.lua b/users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/ffi.lua
new file mode 100644
index 0000000..3b1487d
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/ffi.lua
@@ -0,0 +1,20 @@
+-- ### AstroNvim C Extensions
+
+local ffi = require "ffi"
+
+-- Custom C extension to get direct fold information from Neovim
+ffi.cdef [[
+ typedef struct {} Error;
+ typedef struct {} win_T;
+ typedef struct {
+ int start; // line number where deepest fold starts
+ int level; // fold level, when zero other fields are N/A
+ int llevel; // lowest level that starts in v:lnum
+ int lines; // number of lines from v:lnum to end of closed fold
+ } foldinfo_T;
+ foldinfo_T fold_info(win_T* wp, int lnum);
+ win_T *find_window_by_handle(int Window, Error *err);
+ int compute_foldcolumn(win_T *wp, int col);
+]]
+
+return ffi
diff --git a/users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/git.lua b/users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/git.lua
new file mode 100644
index 0000000..dfd9ecd
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/git.lua
@@ -0,0 +1,168 @@
+--- ### Git LUA API
+--
+-- This module can be loaded with `local git = require "astronvim.utils.git"`
+--
+-- @module astronvim.utils.git
+-- @copyright 2022
+-- @license GNU General Public License v3.0
+
+local git = { url = "https://github.com/" }
+
+local function trim_or_nil(str) return type(str) == "string" and vim.trim(str) or nil end
+
+--- Run a git command from the AstroNvim installation directory
+-- @param args the git arguments
+-- @return the result of the command or nil if unsuccessful
+function git.cmd(args, ...)
+ return require("astronvim.utils").cmd("git -C " .. astronvim.install.home .. " " .. args, ...)
+end
+
+--- Check if the AstroNvim is able to reach the `git` command
+-- @return the result of running `git --help`
+function git.available() return vim.fn.executable "git" == 1 end
+
+--- Check if the AstroNvim home is a git repo
+-- @return the result of the command
+function git.is_repo() return git.cmd("rev-parse --is-inside-work-tree", false) end
+
+--- Fetch git remote
+-- @param remote the remote to fetch
+-- @return the result of the command
+function git.fetch(remote, ...) return git.cmd("fetch " .. remote, ...) end
+
+--- Pull the git repo
+-- @return the result of the command
+function git.pull(...) return git.cmd("pull --rebase", ...) end
+
+--- Checkout git target
+-- @param dest the target to checkout
+-- @return the result of the command
+function git.checkout(dest, ...) return git.cmd("checkout " .. dest, ...) end
+
+--- Hard reset to a git target
+-- @param dest the target to hard reset to
+-- @return the result of the command
+function git.hard_reset(dest, ...) return git.cmd("reset --hard " .. dest, ...) end
+
+--- Check if a branch contains a commit
+-- @param remote the git remote to check
+-- @param branch the git branch to check
+-- @param commit the git commit to check for
+-- @return the result of the command
+function git.branch_contains(remote, branch, commit, ...)
+ return git.cmd("merge-base --is-ancestor " .. commit .. " " .. remote .. "/" .. branch, ...) ~= nil
+end
+
+--- Get the remote name for a given branch
+-- @param branch the git branch to check
+-- @return the name of the remote for the given branch
+function git.branch_remote(branch, ...) return trim_or_nil(git.cmd("config branch." .. branch .. ".remote", ...)) end
+
+--- Add a git remote
+-- @param remote the remote to add
+-- @param url the url of the remote
+-- @return the result of the command
+function git.remote_add(remote, url, ...) return git.cmd("remote add " .. remote .. " " .. url, ...) end
+
+--- Update a git remote URL
+-- @param remote the remote to update
+-- @param url the new URL of the remote
+-- @return the result of the command
+function git.remote_update(remote, url, ...) return git.cmd("remote set-url " .. remote .. " " .. url, ...) end
+
+--- Get the URL of a given git remote
+-- @param remote the remote to get the URL of
+-- @return the url of the remote
+function git.remote_url(remote, ...) return trim_or_nil(git.cmd("remote get-url " .. remote, ...)) end
+
+--- Get the current version with git describe including tags
+-- @return the current git describe string
+function git.current_version(...) return trim_or_nil(git.cmd("describe --tags", ...)) end
+
+--- Get the current branch
+-- @return the branch of the AstroNvim installation
+function git.current_branch(...) return trim_or_nil(git.cmd("rev-parse --abbrev-ref HEAD", ...)) end
+
+--- Get the current head of the git repo
+-- @return the head string
+function git.local_head(...) return trim_or_nil(git.cmd("rev-parse HEAD", ...)) end
+
+--- Get the current head of a git remote
+-- @param remote the remote to check
+-- @param branch the branch to check
+-- @return the head string of the remote branch
+function git.remote_head(remote, branch, ...)
+ return trim_or_nil(git.cmd("rev-list -n 1 " .. remote .. "/" .. branch, ...))
+end
+
+--- Get the commit hash of a given tag
+-- @param tag the tag to resolve
+-- @return the commit hash of a git tag
+function git.tag_commit(tag, ...) return trim_or_nil(git.cmd("rev-list -n 1 " .. tag, ...)) end
+
+--- Get the commit log between two commit hashes
+-- @param start_hash the start commit hash
+-- @param end_hash the end commit hash
+-- @return an array like table of commit messages
+function git.get_commit_range(start_hash, end_hash, ...)
+ local range = ""
+ if start_hash and end_hash then range = start_hash .. ".." .. end_hash end
+ local log = git.cmd('log --no-merges --pretty="format:[%h] %s" ' .. range, ...)
+ return log and vim.fn.split(log, "\n") or {}
+end
+
+--- Get a list of all tags with a regex filter
+-- @param search a regex to search the tags with (defaults to "v*" for version tags)
+-- @return an array like table of tags that match the search
+function git.get_versions(search, ...)
+ local tags = git.cmd('tag -l --sort=version:refname "' .. (search == "latest" and "v*" or search) .. '"', ...)
+ return tags and vim.fn.split(tags, "\n") or {}
+end
+
+--- Get the latest version of a list of versions
+-- @param versions a list of versions to search (defaults to all versions available)
+-- @return the latest version from the array
+function git.latest_version(versions, ...)
+ if not versions then versions = git.get_versions(...) end
+ return versions[#versions]
+end
+
+--- Parse a remote url
+-- @param str the remote to parse to a full git url
+-- @return the full git url for the given remote string
+function git.parse_remote_url(str)
+ return vim.fn.match(str, astronvim.url_matcher) == -1
+ and git.url .. str .. (vim.fn.match(str, "/") == -1 and "/AstroNvim.git" or ".git")
+ or str
+end
+
+--- Check if a Conventional Commit commit message is breaking or not
+-- @param commit a commit message
+-- @return boolean true if the message is breaking, false if the commit message is not breaking
+function git.is_breaking(commit) return vim.fn.match(commit, "\\[.*\\]\\s\\+\\w\\+\\((\\w\\+)\\)\\?!:") ~= -1 end
+
+--- Get a list of breaking commits from commit messages using Conventional Commit standard
+-- @param commits an array like table of commit messages
+-- @return an array like table of commits that are breaking
+function git.breaking_changes(commits) return vim.tbl_filter(git.is_breaking, commits) end
+
+--- Generate a table of commit messages for neovim's echo API with highlighting
+-- @param commits an array like table of commit messages
+-- @return an array like table of echo messages to provide to nvim_echo or astronvim.echo
+function git.pretty_changelog(commits)
+ local changelog = {}
+ for _, commit in ipairs(commits) do
+ local hash, type, msg = commit:match "(%[.*%])(.*:)(.*)"
+ if hash and type and msg then
+ vim.list_extend(changelog, {
+ { hash, "DiffText" },
+ { type, git.is_breaking(commit) and "DiffDelete" or "DiffChange" },
+ { msg },
+ { "\n" },
+ })
+ end
+ end
+ return changelog
+end
+
+return git
diff --git a/users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/init.lua b/users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/init.lua
new file mode 100644
index 0000000..a810a43
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/init.lua
@@ -0,0 +1,249 @@
+--- ### AstroNvim Utilities
+--
+-- Various utility functions to use within AstroNvim and user configurations.
+--
+-- This module can be loaded with `local utils = require "astronvim.utils"`
+--
+-- @module astronvim.utils
+-- @copyright 2022
+-- @license GNU General Public License v3.0
+
+local M = {}
+
+--- Merge extended options with a default table of options
+-- @param default the default table that you want to merge into
+-- @param opts the new options that should be merged with the default table
+-- @return the merged table
+function M.extend_tbl(default, opts)
+ opts = opts or {}
+ return default and vim.tbl_deep_extend("force", default, opts) or opts
+end
+
+--- Insert one or more values into a list like table and maintain that you do not insert non-unique values (THIS MODIFIES `lst`)
+-- @param lst the list like table that you want to insert into
+-- @param vals either a list like table of values to be inserted or a single value to be inserted
+-- @return the modified list like table
+function M.list_insert_unique(lst, vals)
+ assert(vim.tbl_islist(lst), "Provided table is not a list like table")
+ if not vim.tbl_islist(vals) then vals = { vals } end
+ for _, val in ipairs(vals) do
+ if not vim.tbl_contains(lst, val) then table.insert(lst, val) end
+ end
+ return lst
+end
+
+--- Call function if a condition is met
+-- @param func the function to run
+-- @param condition a boolean value of whether to run the function or not
+function M.conditional_func(func, condition, ...)
+ -- if the condition is true or no condition is provided, evaluate the function with the rest of the parameters and return the result
+ if condition and type(func) == "function" then return func(...) end
+end
+
+--- Get an icon from `lspkind` if it is available and return it
+-- @param kind the kind of icon in `lspkind` to retrieve
+-- @return the icon
+function M.get_icon(kind)
+ local icon_pack = vim.g.icons_enabled and "icons" or "text_icons"
+ if not M[icon_pack] then
+ M.icons = astronvim.user_opts("icons", require "astronvim.icons.nerd_font")
+ M.text_icons = astronvim.user_opts("text_icons", require "astronvim.icons.text")
+ end
+ return M[icon_pack] and M[icon_pack][kind] or ""
+end
+
+--- Get highlight properties for a given highlight name
+-- @param name highlight group name
+-- @return table of highlight group properties
+function M.get_hlgroup(name, fallback)
+ if vim.fn.hlexists(name) == 1 then
+ local hl = vim.api.nvim_get_hl_by_name(name, vim.o.termguicolors)
+ if not hl["foreground"] then hl["foreground"] = "NONE" end
+ if not hl["background"] then hl["background"] = "NONE" end
+ hl.fg, hl.bg, hl.sp = hl.foreground, hl.background, hl.special
+ hl.ctermfg, hl.ctermbg = hl.foreground, hl.background
+ return hl
+ end
+ return fallback
+end
+
+--- Serve a notification with a title of AstroNvim
+-- @param msg the notification body
+-- @param type the type of the notification (:help vim.log.levels)
+-- @param opts table of nvim-notify options to use (:help notify-options)
+function M.notify(msg, type, opts)
+ vim.schedule(function() vim.notify(msg, type, M.extend_tbl({ title = "AstroNvim" }, opts)) end)
+end
+
+--- Trigger an AstroNvim user event
+-- @param event the event name to be appended to Astro
+function M.event(event)
+ vim.schedule(function() vim.api.nvim_exec_autocmds("User", { pattern = "Astro" .. event }) end)
+end
+
+--- Open a URL under the cursor with the current operating system
+-- @param path the path of the file to open with the system opener
+function M.system_open(path)
+ local cmd
+ if vim.fn.has "win32" == 1 and vim.fn.executable "explorer" == 1 then
+ cmd = "explorer"
+ elseif vim.fn.has "unix" == 1 and vim.fn.executable "xdg-open" == 1 then
+ cmd = "xdg-open"
+ elseif (vim.fn.has "mac" == 1 or vim.fn.has "unix" == 1) and vim.fn.executable "open" == 1 then
+ cmd = "open"
+ end
+ if not cmd then M.notify("Available system opening tool not found!", "error") end
+ vim.fn.jobstart({ cmd, path or vim.fn.expand "" }, { detach = true })
+end
+
+-- term_details can be either a string for just a command or
+-- a complete table to provide full access to configuration when calling Terminal:new()
+
+--- Toggle a user terminal if it exists, if not then create a new one and save it
+-- @param term_details a terminal command string or a table of options for Terminal:new() (Check toggleterm.nvim documentation for table format)
+function M.toggle_term_cmd(opts)
+ local terms = astronvim.user_terminals
+ -- if a command string is provided, create a basic table for Terminal:new() options
+ if type(opts) == "string" then opts = { cmd = opts, hidden = true } end
+ local num = vim.v.count > 0 and vim.v.count or 1
+ -- if terminal doesn't exist yet, create it
+ if not terms[opts.cmd] then terms[opts.cmd] = {} end
+ if not terms[opts.cmd][num] then
+ if not opts.count then opts.count = vim.tbl_count(terms) * 100 + num end
+ if not opts.on_exit then opts.on_exit = function() terms[opts.cmd][num] = nil end end
+ terms[opts.cmd][num] = require("toggleterm.terminal").Terminal:new(opts)
+ end
+ -- toggle the terminal
+ terms[opts.cmd][num]:toggle()
+end
+
+--- Create a button entity to use with the alpha dashboard
+-- @param sc the keybinding string to convert to a button
+-- @param txt the explanation text of what the keybinding does
+-- @return a button entity table for an alpha configuration
+function M.alpha_button(sc, txt)
+ -- replace in shortcut text with LDR for nicer printing
+ local sc_ = sc:gsub("%s", ""):gsub("LDR", "")
+ -- if the leader is set, replace the text with the actual leader key for nicer printing
+ if vim.g.mapleader then sc = sc:gsub("LDR", vim.g.mapleader == " " and "SPC" or vim.g.mapleader) end
+ -- return the button entity to display the correct text and send the correct keybinding on press
+ return {
+ type = "button",
+ val = txt,
+ on_press = function()
+ local key = vim.api.nvim_replace_termcodes(sc_, true, false, true)
+ vim.api.nvim_feedkeys(key, "normal", false)
+ end,
+ opts = {
+ position = "center",
+ text = txt,
+ shortcut = sc,
+ cursor = 5,
+ width = 36,
+ align_shortcut = "right",
+ hl = "DashboardCenter",
+ hl_shortcut = "DashboardShortcut",
+ },
+ }
+end
+
+--- Check if a plugin is defined in lazy. Useful with lazy loading when a plugin is not necessarily loaded yet
+-- @param plugin the plugin string to search for
+-- @return boolean value if the plugin is available
+function M.is_available(plugin)
+ local lazy_config_avail, lazy_config = pcall(require, "lazy.core.config")
+ return lazy_config_avail and lazy_config.plugins[plugin] ~= nil
+end
+
+--- A helper function to wrap a module function to require a plugin before running
+-- @param plugin the plugin string to call `require("lazy").laod` with
+-- @param module the system module where the functions live (e.g. `vim.ui`)
+-- @param func_names a string or a list like table of strings for functions to wrap in the given moduel (e.g. `{ "ui", "select }`)
+function M.load_plugin_with_func(plugin, module, func_names)
+ if type(func_names) == "string" then func_names = { func_names } end
+ for _, func in ipairs(func_names) do
+ local old_func = module[func]
+ module[func] = function(...)
+ module[func] = old_func
+ require("lazy").load { plugins = { plugin } }
+ module[func](...)
+ end
+ end
+end
+
+--- Register queued which-key mappings
+function M.which_key_register()
+ if M.which_key_queue then
+ local wk_avail, wk = pcall(require, "which-key")
+ if wk_avail then
+ for mode, registration in pairs(M.which_key_queue) do
+ wk.register(registration, { mode = mode })
+ end
+ M.which_key_queue = nil
+ end
+ end
+end
+
+--- Table based API for setting keybindings
+-- @param map_table A nested table where the first key is the vim mode, the second key is the key to map, and the value is the function to set the mapping to
+-- @param base A base set of options to set on every keybinding
+function M.set_mappings(map_table, base)
+ -- iterate over the first keys for each mode
+ base = base or {}
+ for mode, maps in pairs(map_table) do
+ -- iterate over each keybinding set in the current mode
+ for keymap, options in pairs(maps) do
+ -- build the options for the command accordingly
+ if options then
+ local cmd = options
+ local keymap_opts = base
+ if type(options) == "table" then
+ cmd = options[1]
+ keymap_opts = vim.tbl_deep_extend("force", keymap_opts, options)
+ keymap_opts[1] = nil
+ end
+ if not cmd or keymap_opts.name then -- if which-key mapping, queue it
+ if not M.which_key_queue then M.which_key_queue = {} end
+ if not M.which_key_queue[mode] then M.which_key_queue[mode] = {} end
+ M.which_key_queue[mode][keymap] = keymap_opts
+ else -- if not which-key mapping, set it
+ vim.keymap.set(mode, keymap, cmd, keymap_opts)
+ end
+ end
+ end
+ end
+ if package.loaded["which-key"] then M.which_key_register() end -- if which-key is loaded already, register
+end
+
+--- regex used for matching a valid URL/URI string
+local url_matcher =
+ "\\v\\c%(%(h?ttps?|ftp|file|ssh|git)://|[a-z]+[@][a-z]+[.][a-z]+:)%([&:#*@~%_\\-=?!+;/0-9a-z]+%(%([.;/?]|[.][.]+)[&:#*@~%_\\-=?!+/0-9a-z]+|:\\d+|,%(%(%(h?ttps?|ftp|file|ssh|git)://|[a-z]+[@][a-z]+[.][a-z]+:)@![0-9a-z]+))*|\\([&:#*@~%_\\-=?!+;/.0-9a-z]*\\)|\\[[&:#*@~%_\\-=?!+;/.0-9a-z]*\\]|\\{%([&:#*@~%_\\-=?!+;/.0-9a-z]*|\\{[&:#*@~%_\\-=?!+;/.0-9a-z]*})\\})+"
+
+--- Delete the syntax matching rules for URLs/URIs if set
+function M.delete_url_match()
+ for _, match in ipairs(vim.fn.getmatches()) do
+ if match.group == "HighlightURL" then vim.fn.matchdelete(match.id) end
+ end
+end
+
+--- Add syntax matching rules for highlighting URLs/URIs
+function M.set_url_match()
+ M.delete_url_match()
+ if vim.g.highlighturl_enabled then vim.fn.matchadd("HighlightURL", url_matcher, 15) end
+end
+
+--- Run a shell command and capture the output and if the command succeeded or failed
+-- @param cmd the terminal command to execute
+-- @param show_error boolean of whether or not to show an unsuccessful command as an error to the user
+-- @return the result of a successfully executed command or nil
+function M.cmd(cmd, show_error)
+ if vim.fn.has "win32" == 1 then cmd = { "cmd.exe", "/C", cmd } end
+ local result = vim.fn.system(cmd)
+ local success = vim.api.nvim_get_vvar "shell_error" == 0
+ if not success and (show_error == nil or show_error) then
+ vim.api.nvim_err_writeln("Error running command: " .. cmd .. "\nError message:\n" .. result)
+ end
+ return success and result:gsub("[\27\155][][()#;?%d]*[A-PRZcf-ntqry=><~]", "") or nil
+end
+
+return M
diff --git a/users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/lsp.lua b/users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/lsp.lua
new file mode 100644
index 0000000..433238a
--- /dev/null
+++ b/users/daniel/configs/system/nvim/nvim/lua/astronvim/utils/lsp.lua
@@ -0,0 +1,377 @@
+--- ### AstroNvim LSP Utils
+--
+-- LSP related utility functions to use within AstroNvim and user configurations.
+--
+-- This module can be loaded with `local lsp_utils = require("astronvim.utils.lsp")`
+--
+-- @module astronvim.utils.lsp
+-- @see astronvim.utils
+-- @copyright 2022
+-- @license GNU General Public License v3.0
+
+local M = {}
+local tbl_contains = vim.tbl_contains
+local tbl_isempty = vim.tbl_isempty
+local user_opts = astronvim.user_opts
+
+local utils = require "astronvim.utils"
+local conditional_func = utils.conditional_func
+local is_available = utils.is_available
+
+local server_config = "lsp.config."
+local setup_handlers = user_opts("lsp.setup_handlers", {
+ function(server, opts) require("lspconfig")[server].setup(opts) end,
+})
+
+M.diagnostics = { [0] = {}, {}, {}, {} }
+
+M.setup_diagnostics = function(signs)
+ local default_diagnostics = astronvim.user_opts("diagnostics", {
+ virtual_text = true,
+ signs = { active = signs },
+ update_in_insert = true,
+ underline = true,
+ severity_sort = true,
+ float = {
+ focused = false,
+ style = "minimal",
+ border = "rounded",
+ source = "always",
+ header = "",
+ prefix = "",
+ },
+ })
+ M.diagnostics = {
+ -- diagnostics off
+ [0] = utils.extend_tbl(
+ default_diagnostics,
+ { underline = false, virtual_text = false, signs = false, update_in_insert = false }
+ ),
+ -- status only
+ utils.extend_tbl(default_diagnostics, { virtual_text = false, signs = false }),
+ -- virtual text off, signs on
+ utils.extend_tbl(default_diagnostics, { virtual_text = false }),
+ -- all diagnostics on
+ default_diagnostics,
+ }
+
+ vim.diagnostic.config(M.diagnostics[vim.g.diagnostics_mode])
+end
+
+M.formatting = user_opts("lsp.formatting", { format_on_save = { enabled = true }, disabled = {} })
+if type(M.formatting.format_on_save) == "boolean" then
+ M.formatting.format_on_save = { enabled = M.formatting.format_on_save }
+end
+
+M.format_opts = vim.deepcopy(M.formatting)
+M.format_opts.disabled = nil
+M.format_opts.format_on_save = nil
+M.format_opts.filter = function(client)
+ local filter = M.formatting.filter
+ local disabled = M.formatting.disabled or {}
+ -- check if client is fully disabled or filtered by function
+ return not (vim.tbl_contains(disabled, client.name) or (type(filter) == "function" and not filter(client)))
+end
+
+--- Helper function to set up a given server with the Neovim LSP client
+-- @param server the name of the server to be setup
+M.setup = function(server)
+ -- if server doesn't exist, set it up from user server definition
+ local config_avail, config = pcall(require, "lspconfig.server_configurations." .. server)
+ if not config_avail or not config.default_config then
+ local server_definition = user_opts(server_config .. server)
+ if server_definition.cmd then require("lspconfig.configs")[server] = { default_config = server_definition } end
+ end
+ local opts = M.config(server)
+ local setup_handler = setup_handlers[server] or setup_handlers[1]
+ if not vim.tbl_contains(astronvim.lsp.skip_setup, server) and setup_handler then setup_handler(server, opts) end
+end
+
+local function add_buffer_autocmd(augroup, bufnr, autocmds)
+ if not vim.tbl_islist(autocmds) then autocmds = { autocmds } end
+ local cmds_found, cmds = pcall(vim.api.nvim_get_autocmds, { group = augroup, buffer = bufnr })
+ if not cmds_found or vim.tbl_isempty(cmds) then
+ vim.api.nvim_create_augroup(augroup, { clear = false })
+ for _, autocmd in ipairs(autocmds) do
+ local events = autocmd.events
+ autocmd.events = nil
+ autocmd.group = augroup
+ autocmd.buffer = bufnr
+ vim.api.nvim_create_autocmd(events, autocmd)
+ end
+ end
+end
+
+--- The `on_attach` function used by AstroNvim
+-- @param client the LSP client details when attaching
+-- @param bufnr the number of the buffer that the LSP client is attaching to
+M.on_attach = function(client, bufnr)
+ local capabilities = client.server_capabilities
+ local lsp_mappings = {
+ n = {
+ ["ld"] = {
+ function() vim.diagnostic.open_float() end,
+ desc = "Hover diagnostics",
+ },
+ ["[d"] = {
+ function() vim.diagnostic.goto_prev() end,
+ desc = "Previous diagnostic",
+ },
+ ["]d"] = {
+ function() vim.diagnostic.goto_next() end,
+ desc = "Next diagnostic",
+ },
+ ["gl"] = {
+ function() vim.diagnostic.open_float() end,
+ desc = "Hover diagnostics",
+ },
+ },
+ v = {},
+ }
+
+ if is_available "mason-lspconfig.nvim" then
+ lsp_mappings.n["li"] = { "LspInfo", desc = "LSP information" }
+ end
+
+ if is_available "null-ls.nvim" then
+ lsp_mappings.n["lI"] = { "NullLsInfo", desc = "Null-ls information" }
+ end
+
+ if capabilities.codeActionProvider then
+ lsp_mappings.n["la"] = {
+ function() vim.lsp.buf.code_action() end,
+ desc = "LSP code action",
+ }
+ lsp_mappings.v["la"] = lsp_mappings.n["la"]
+ end
+
+ if capabilities.codeLensProvider then
+ add_buffer_autocmd("lsp_codelens_refresh", bufnr, {
+ events = { "InsertLeave", "BufEnter" },
+ desc = "Refresh codelens",
+ callback = function()
+ if vim.g.codelens_enabled then vim.lsp.codelens.refresh() end
+ end,
+ })
+ vim.lsp.codelens.refresh()
+ lsp_mappings.n["ll"] = {
+ function() vim.lsp.codelens.refresh() end,
+ desc = "LSP CodeLens refresh",
+ }
+ lsp_mappings.n["lL"] = {
+ function() vim.lsp.codelens.run() end,
+ desc = "LSP CodeLens run",
+ }
+ end
+
+ if capabilities.declarationProvider then
+ lsp_mappings.n["gD"] = {
+ function() vim.lsp.buf.declaration() end,
+ desc = "Declaration of current symbol",
+ }
+ end
+
+ if capabilities.definitionProvider then
+ lsp_mappings.n["gd"] = {
+ function() vim.lsp.buf.definition() end,
+ desc = "Show the definition of current symbol",
+ }
+ end
+
+ if capabilities.documentFormattingProvider and not tbl_contains(M.formatting.disabled, client.name) then
+ lsp_mappings.n["