githook | Github/Bitbucket Webhook Tools | REST library

Ok, so based on my suspicions and @toreks comments this is not a normal GIT usage. Add that to the fact I was new a git and it took me a while to figure out. Correct me if I'm wrong, but I think what threw me off was the idea that a file wasn't tracked if it wasn't commit in that branch, but I believe when I pull a file from master, even if its not committed in that branch its still considered "tracked".

Anyway, these two lines helped me figure things out a lot:

View files ignored:

GitHub doesn't support Git hooks (on GitHub.com at least, they are supported on GitHub Enterprise). However, you can use GitHub Actions to run arbitrary code on a push, albeit in an isolated VM and not on the actual Git server.

In .github/workflows/wiki-mirror.yml (or whatever filename you want in .github/actions), you can add an Action to do the syncing. Since GitHub wikis expect markdown files, this changes the extensions of the .txt files to match:

It seems that you have problems with peer dependencies, if you just set your npm to use legacy dependency logic to install your packages you will solve the problem.

Just add to your Dockerfile this setting before running npm install:

There is a gitlab tag in the question, so I assume you've read Gitlab Server Hooks.

From the githooks doc on pre-receive, we can see that the hook doesn't take any parameter and it reads ref info from standard input. To read from standard input in bash, you can refer to the pre-push sample, which you can also find in the local repository's .git/hooks/pre-push.sample if you haven't specified init.templateDir in gitconfig. pre-receive uses a different line format from pre-push, so modify the while read part,

The short answer is that you can't.

When git merge runs, it reads three commits into Git's index. These three commits are:

• the merge base (in slot 1);
• the --ours commit (in slot 2); and
• the --theirs commit (in slot 3).

These are stored in the usual index format: a path name including slashes, a mode (100644 or 100755 for regular files, 120000 for symbolic links, and 160000 for gitlinks), and a hash ID.

The first part of the merge then compares the modes to make sure those are suitable (if not, this is a merge conflict). Assuming normal files and suitable modes here, it goes on to compare the hash IDs:

• all three equal? file is successfully merged, drop to slot 0, erase slots 1-3
• two equal? take the third one: drop to slot 0, erase slots 1-3
• all three unequal? leave for later, for the real merge code.

There are a few more special cases (e.g., file exists in merge base and theirs/ours, but deleted in ours/theirs) that are also handled directly in the index, I think, but your particular case—file modified in theirs, but identical in ours and base—hits the middle "two equal? take third" case: the file is the same in your commit and the merge base, so Git just assumes that their updated file is the correct result.

When Git does this in the early pass, it never runs your merge driver at all. The file goes to staging slot zero—"ready to be committed"—rather than conflicted and you never get a chance to do anything. Your pre-merge-commit will get invoked, but the copy of the file in the index will be the one from the theirs commit.

We now get into the seriously dark magic part: "the index" assumes that there's a single index (.git/index) that is always used. This isn't really the case: it's mostly true, but:

• $GIT_INDEX_FILE overrides the name;
• added work-trees (from git worktree add) have their own index; and
• various Git commands read the index into memory and then work with that.

In this case, it looks like git merge has the index in-memory and just uses it as is to make the new commit. Your git add replaces the stage-zero copy in the .git/index file, but git merge does not notice this, and goes on to produce the new merge commit using the incoming copy that was there before it even ran your pre-merge-commit hook.

Assuming this is all true—and it may change from one Git version to another, depending on when and whether Git does any re-reading of the index—this would answer your question #1, and render the answer to #2 "no" and the answer to #3 be "you're trying to do something outside the range of what Git handles".

What you want to do is not inherently unreasonable, but Git just doesn't support it.

Why don't post-commit hooks work when I use git cherry-pick?

The post-commit hook is run after creating a commit.

However, cherry-pick does not really create a new commit with new information (from the user perspective) but copies another commit.

Is there a hook that cherry-pick will run?

Yes, the prepare-commit-msg should be run before commit is cherry-picked, even though the commit-msg hook is not executed.

You could simply split the grep into two, while negating the second one with the -v flag:

You have a typo in your Ruby code. In general, Unix file modes are specified in octal, which is one of the last cases where people practically use octal in programming. However, you've specified a decimal value here.

As a result, the octal mode you've specified is 1411, which makes your file have no executable permissions for the user, no read permissions for group or other, and the sticky bit set, which is probably not what you wanted.

You can fix this by writing the mode as 0777:

You're integrating Tailwind with a tool that relies on an older version of PostCSS. You can use this doc https://tailwindcss.com/docs/installation#post-css-7-compatibility-build