#go #python #git

Fast and powerful Git hooks manager for any type of projects: https://github.com/Arkweid/lefthook

There's also a python wrapper around it to enable pip install lefthook: https://github.com/life4/lefthook

​​#git 2.23 brings a new pair of experimental commands to the suite of existing ones: git switch and git restore. These two are meant to eventually provide a better interface for the well-known git checkout https://github.blog/2019-08-16-highlights-from-git-2-23/

​​List of awesome #git hooks!

Git hooks are custom scripts you can use to automate tasks which are triggered before or after a git command is executed. There are two groups of these hooks: client-side and server-side. Client-side hooks are triggered by operations such as committing and merging, while server-side hooks run on network operations such as receiving pushed commits. This repo contains helpful resources as well as a variety of git hook scripts that can be easily customized to serve different purposes.

https://github.com/CompSciLauren/awesome-git-hooks

Awesome #git addons: a curated list of add-ons that extend/enhance the git CLI.

https://github.com/stevemao/awesome-git-addons

#devops

​​Tig is an ncurses-based text-mode interface for git. It functions mainly as a #git repository browser, but can also assist in staging changes for commit at chunk level and act as a pager for output from various Git commands.

https://github.com/jonas/tig

#c

​​Interactive #git with the help of fzf

Features:
- You can run git add and git reset by selecting or cursoring. You can commit interactively
- You can search the diff from the query bar and the RHS diff will be highlighted accordingly
- Search the log and corresponding diff at once. Notice that when you use | the left hand side is sent to log while the right hand side is sent to diff

https://github.com/bigH/git-fuzzy

#shell

​​Query #git repositories with SQL. Uses SQLite virtual tables and go-git.

gitqlite is a tool for running SQL queries on git repositories. It implements SQLite virtual tables and uses go-git. It's meant for ad-hoc querying of git repositories on disk through a common interface (SQL), as an alternative to patching together various shell commands.

https://github.com/augmentable-dev/gitqlite

#go

​​A utility tool powered by fzf for using git interactively.

This tool is designed to help you use git more efficiently. It's lightweight and easy to use.

Also integrates with: diff-so-fancy, delta, bat, emoji-cli.

https://github.com/wfxr/forgit

#shell #git

​​Learn #git by building one in #python!

> This tutorial is different from most Git internals tutorials because we're not going to talk about Git only with words but also with code! We're going to write in Python as we go.

> This is not a tutorial on using Git! To follow along I advise that you have working knowledge of Git. If you're a newcomer to Git, this tutorial is probably not the best place to start your Git journey. I suggest coming back here after you've used Git a bit and you're comfortable with making commits, branching, merging, pushing and pulling.

> Why learn Git internals?

> For most tools that we use daily, we don't really care about their internals. We can use Firefox or Vim without understanding their inner workings.

> At first you shouldn't care about Git internals either. You can use Git as a set of CLI commands that track code history. Run git add, git commit and git push all day long and you'll do fine, as long as you're a sole developer who just commits to one branch.

> But once you start collaborating with multiple people on multiple branches and things like rebase or force push are getting involved, it's easy to become lost if you don't have a good mental model of Git internals.

> From my experience with using Git myself and teaching others, a better way to improve your effectiveness with Git is by understanding how it works behind the scenes and not by learning more "advanced" Git commands. This understanding is what will allow you to solve the kind of problems that multi-user collaborative coding sometimes produce.

> Why not learn Git by reading the real Git code?

> The real Git code is too complicated to be useful for learning basic concepts with ease. It is production quality code that is optimized for speed. It is written in C. It implements so many advanced Git features. It deals with a lot of edge cases that we don't care about for learning. In this tutorial we will focus on the bare minimum to get the point across.

https://www.leshenko.net/p/ugit

​​Bit is a modern Git CLI.

bit is an experimental modernized git CLI built on top of git that provides happy defaults and other niceties:
- command and flag suggestions to help you navigate the plethora of options git provides you
- autocompletion for files and branch names when using bit add or bit checkout
- automatic fetch and branch fast-forwarding reducing the likelihood of merge conflicts
- suggestions work with git aliases
- new commands like bit sync that vastly simplify your workflow
- commands from git-extras such as bit release & bit info
- fully compatible with git allowing you to fallback to git if need be
- get insight into how bit works using bit --debug

https://github.com/chriswalz/bit

#git #go