Add a comment. Active Oldest Votes. Improve this answer. Raul Rene Raul Rene 9, 9 9 gold badges 50 50 silver badges 73 73 bronze badges. Steve Folly Steve Folly 7, 8 8 gold badges 46 46 silver badges 56 56 bronze badges. VonC VonC 1. Start the Windows Modules Installer service in services. Frigo Frigo 1, 1 1 gold badge 14 14 silver badges 31 31 bronze badges.
It does not need. NET framework — linquize. I faced the same problem. The problem is quite common. Hope this helps. Nikita Nikita 61 1 1 silver badge 2 2 bronze badges. Sign up or log in Sign up using Google. Sign up using Facebook. Sign up using Email and Password. Report abuse. Details required :. Cancel Submit. Diana D. In reply to krolike's post on June 18, Hi Krolike, Step 1 : Remove all components or products of acrobat and then try installing.
By marking a post as Answered, or Helpful you help others find the answer faster. How satisfied are you with this reply? Thanks for your feedback, it helps us improve the site. In reply to SUBY. You can customize the rules that git diff --word-diff uses to split words in a line, by specifying an appropriate regular expression in the "diff.
For example, in TeX a backslash followed by a sequence of letters forms a command, but several such commands can be run together without intervening whitespace.
Sometimes it is desirable to see the diff of a text-converted version of some binary files. For example, a word processor document can be converted to an ASCII text representation, and the diff of the text shown. Even though this conversion loses some information, the resulting diff is useful for human viewing but cannot be applied directly.
The textconv config option is used to define a program for performing such a conversion. The program should take a single argument, the name of a file to convert, and produce the resulting text on stdout. The text conversion is generally a one-way conversion; in this example, we lose the actual image contents and focus just on the text data.
This means that diffs generated by textconv are not suitable for applying. For this reason, only git diff and the git log family of commands i. If you want to send somebody a text-converted diff of a binary file e. Because text conversion can be slow, especially when doing a large number of them with git log -p , Git provides a mechanism to cache the output and use it in future diffs.
To enable caching, set the "cachetextconv" variable in your diff driver's config. This will cache the result of running "exif" on each blob indefinitely. If you change the textconv config variable for a diff driver, Git will automatically invalidate the cache entries and re-run the textconv filter. If you want to invalidate the cache manually e. If you want to show differences between binary or specially-formatted blobs in your repository, you can choose to use either an external diff command, or to use textconv to convert them to a diff-able text format.
Which method you choose depends on your exact situation. The advantage of using an external diff command is flexibility. You are not bound to find line-oriented changes, nor is it necessary for the output to resemble unified diff. You are free to locate and report changes in the most appropriate way for your data format.
A textconv, by comparison, is much more limiting. You provide a transformation of the data into a line-oriented text format, and Git uses its regular diff tools to generate the output.
There are several advantages to choosing this method:. Git usually guesses correctly whether a blob contains text or binary data by examining the beginning of the contents. However, sometimes you may want to override its decision, either because a blob contains binary data later in the file, or because the content, while technically composed of text characters, is opaque to a human reader.
For example, many postscript files contain only ASCII characters, but produce noisy and meaningless diffs. The simplest way to mark a file as binary is to unset the diff attribute in the. This will cause Git to generate Binary files differ or a binary patch, if binary patches are enabled instead of a regular diff. However, one may also want to specify other diff driver attributes. For example, you might want to use textconv to convert postscript files to an ASCII representation for human viewing, but otherwise treat them as binary files.
The solution is to use the diff. The attribute merge affects how three versions of a file are merged when a file-level merge is necessary during git merge , and other commands such as git revert and git cherry-pick.
There are a few built-in low-level merge drivers defined that can be asked for via the merge attribute. The definition of a merge driver is done in the.
The merge. These three tokens are replaced with the names of temporary files that hold the contents of these versions when the command line is built. When left unspecified, the driver itself is used for both internal merge and the final merge.
This attribute controls the length of conflict markers left in the work tree file during a conflicted merge. Only setting to the value to a positive integer has any meaningful effect. For example, this line in. The core. This attribute gives you finer control per path. Files and directories with the attribute export-ignore won't be added to archive files.
If the attribute export-subst is set for a file then Git will expand several placeholders when adding this file to an archive. The expansion depends on the availability of a commit ID, i. Delta compression will not be attempted for blobs for paths with the attribute delta set to false.
The value of this attribute specifies the character encoding that should be used by GUI tools e. If this attribute is not set or has an invalid value, the value of the gui. You do not want any end-of-line conversions applied to, nor textual diffs produced for, any binary file you track.
You would need to specify e. Using macro attributes, you can define an attribute that, when set, also sets or unsets a number of other attributes at the same time. The system knows a built-in macro attribute, binary :.
Setting the "binary" attribute also unsets the "text" and "diff" attributes as above. Note that macro attributes can only be "Set", though setting one might have the effect of setting or unsetting other attributes or even returning other attributes to the "Unspecified" state. The built-in macro attribute "binary" is equivalent to:. Git does not follow symbolic links when accessing a. This keeps behavior consistent when the file is accessed from the index or a tree versus from the filesystem.
Git will sometimes need credentials from the user in order to perform operations; for example, it may need to ask for a username and password in order to access a remote repository over HTTP. This manual describes the mechanisms Git uses to request these credentials, as well as some features to avoid inputting these credentials repeatedly. Without any credential helpers defined, Git will try the following strategies to ask the user for usernames and passwords:. It can be cumbersome to input the same credentials over and over.
Git provides two methods to reduce this annoyance:. The first is simple and appropriate if you do not have secure storage available for a password. It is generally configured by adding this to your config:. Credential helpers, on the other hand, are external programs from which Git can request both usernames and passwords; they typically interface with secure storage provided by the OS or other programs.
Once you have selected a helper, you can tell Git to use it by putting its name into the credential. Git considers each credential to have a context defined by a URL.
This context is used to look up context-specific configuration, and is passed to any helpers, which may use it as an index into secure storage.
When Git looks into a config file to see if a section matches this context, it will consider the two a match if the context is a more-specific subset of the pattern in the config file. For example, if you have this in your config file:. However, this context would not match:. Nor would it match foo. However, you may use wildcards in the domain name and other pattern matching techniques as with the http. Options for a credential context can be configured either in credential.
The name of an external credential helper, and any associated options. If the helper name is not an absolute path, then the string git credential- is prepended. See the manual of specific helpers for examples of their use.
If there are multiple instances of the credential. Once Git has acquired both a username and a password, no more helpers will be tried. If credential. You can write your own custom helpers to interface with any system in which you keep credentials. Credential helpers are programs executed by Git to fetch or save credentials from and to long-term storage where "long-term" is simply longer than a single Git process; e.
Each helper is specified by a single string in the configuration variable credential. The string is transformed by Git into a command to be executed using these rules:.
The resulting command then has an "operation" argument appended to it see below for details , and the result is executed by the shell. Generally speaking, rule 3 above is the simplest for users to specify. When a helper is executed, it will have one "operation" argument appended to its command line, which is one of:.
The details of the credential will be provided on the helper's stdin stream. A helper is free to produce a subset, or even no values at all if it has nothing useful to provide. Any provided attributes will overwrite those already known about by Git's credential subsystem.
While it is possible to override all attributes, well behaving helpers should refrain from doing so for any attribute other than username and password. If a helper outputs a quit attribute with a value of true or 1 , no further helpers will be consulted, nor will the user be prompted if no credential has been provided, the operation will then fail.
For a store or erase operation, the helper's output is ignored. If a helper fails to perform the requested operation or needs to notify the user of a potential issue, it may write to stderr. If it does not support the requested operation e. If a helper receives any other operation, it should silently ignore the request.
This leaves room for future operations to be added older helpers will just ignore the new requests. The diff commands git diff-index , git diff-files , and git diff-tree can be told to manipulate differences they find in unconventional ways before showing diff output.
The manipulation is collectively called "diffcore transformation". This short note describes what they are and how to use them to produce diff output that is easier to understand than the conventional kind. In all of these cases, the commands themselves first optionally limit the two sets of files by any pathspecs given on their command-lines, and compare corresponding paths in the two resulting sets of files.
The pathspecs are used to limit the world diff operates in. They remove the filepairs outside the specified sets of pathnames. If the input set of filepairs included:. The result of comparison is passed from these commands to what is internally called "diffcore", in a format similar to what is output when the -p option is not used.
The diffcore mechanism is fed a list of such comparison results each of which is called "filepair", although at this point each of them talks about a single file , and transforms such a list into another list. There are currently 5 such transformations:.
These are applied in sequence. This is used to detect a filepair that represents "complete rewrite" and break such filepair into two filepairs that represent delete and create.
If the input contained this filepair:. For the purpose of breaking a filepair, diffcore-break examines the extent of changes between the contents of the files before and after modification i.
The amount of deletion of original contents and insertion of new material are added together, and if it exceeds the "break score", the filepair is broken into two.
If the input contained these filepairs:. If the input were like these filepairs, that talk about a modified file fileY and a newly created file file Note that when rename detection is on but both copy and break detection are off, rename detection adds a preliminary step that first checks if files are moved across directories while keeping their filename the same.
If there is a file added to a directory whose contents is sufficiently similar to a file with the same name that got deleted from a different directory, it will mark them as renames and exclude them from the later quadratic step the one that pairwise compares all unmatched files to find the "best" matches, determined by the highest content similarity. For this reason, the preliminary "match same filename" step uses a bit higher threshold to mark a file pair as a rename and stop considering other candidates for better matches.
At most, one comparison is done per file in this preliminary pass; so if there are several remaining ext. This lets the copy detector consider unmodified files as copy source candidates at the expense of making it slower.
This always runs when diffcore-break is used. For the purpose of merging broken filepairs back, it uses a different "extent of changes" computation from the ones used by diffcore-break and diffcore-rename.
It counts only the deletion from the original, and does not count insertion. If you removed only 10 lines from a line document, even if you added new lines to make a new line document, you did not do a complete rewrite. Note that earlier implementation left a broken pair as a separate creation and deletion patches. This transformation limits the set of filepairs to those that change specified strings between the preimage and the postimage in a certain way.
By definition, it will not detect in-file moves. Also, when a changeset moves a file wholesale without affecting the interesting string, diffcore-rename kicks in as usual, and -S omits the filepair since the number of occurrences of that string didn't change in that rename-detected filepair.
This means that it will detect in-file or what rename-detection considers the same file moves, which is noise. The implementation runs diff twice and greps, and this can be quite expensive. To speed things up binary files without textconv filters will be ignored. When -S or -G are used without --pickaxe-all , only filepairs that match their respective criterion are kept in the output.
When --pickaxe-all is used, if even one filepair matches their respective criterion in a changeset, the entire changeset is kept. This behavior is designed to make reviewing changes in the context of the whole changeset easier. This takes a text file each of whose lines is a shell glob pattern.
Filepairs that match a glob pattern on an earlier line in the file are output before ones that match a later line, and filepairs that do not match any glob pattern are output last.
This transformation takes one pathname, and rotates the set of filepairs so that the filepair for the given pathname comes first, optionally discarding the paths that come before it. This is used to implement the --skip-to and the --rotate-to options. It is an error when the specified pathname is not in the set of filepairs, but it is not useful to error out when used with "git log" family of commands, because it is unreasonable to expect that a given path would be modified by each and every commit shown by the "git log" command.
For this reason, when used with "git log", the filepair that sorts the same as, or the first one that sorts after, the given pathname is where the output starts. Use of this transformation combined with diffcore-order will produce unexpected results, as the input to this transformation is likely not sorted when diffcore-order is in effect. A gitignore file specifies intentionally untracked files that Git should ignore. Each line in a gitignore file specifies a pattern.
When deciding whether to ignore a path, Git normally checks gitignore patterns from multiple sources, with the following order of precedence, from highest to lowest within one level of precedence, the last matching pattern decides the outcome :.
The underlying Git plumbing tools, such as git ls-files and git read-tree , read gitignore patterns specified by command-line options, or from files specified by command-line options. Higher-level Git tools, such as git status and git add , use patterns from the sources specified above.
The optional configuration variable core. The purpose of gitignore files is to ensure that certain files not tracked by Git remain untracked.
To stop tracking a file that is currently tracked, use git rm --cached. The second. You should put your personal name, generally a form using a given name and family name. For example, the current maintainer of Git uses "Junio C Hamano". This will be the name portion that is stored in every commit you make.
This configuration doesn't have any effect on authenticating to remote services; for that, see credential. If the data is larger than this size, libcurl, which handles the HTTP support for Git, will use chunked transfer encoding since it isn't known ahead of time what the size of the pushed data will be. Note that increasing this value will increase the memory used on every relevant push that Git does over HTTP or HTTPS, since the entire buffer is allocated regardless of whether or not it is all used.
Thus, it's best to leave it at the default unless you are sure you need a different value. Since some people find vi difficult to use or prefer a different editor, it may be desirable to change the editor used.
If you want to configure a general editor for most programs which need one, you can edit your shell configuration e. For example, if you prefer the editor nano , then you could write the following:. If you want to configure an editor specifically for Git, you can either set the core. Note that in all cases, the editor value will be passed to the shell, so any arguments containing spaces should be appropriately quoted.
Additionally, if your editor normally detaches from the terminal when invoked, you should specify it with an argument that makes it not do that, or else Git will not see any changes. The easiest way to do this is to use a credential helper via the credential.
Most systems provide a standard choice to integrate with the system credential manager. For example, Git for Windows provides the wincred credential manager, macOS has the osxkeychain credential manager, and Unix systems with a standard desktop environment can use the libsecret credential manager.
All of these store credentials in an encrypted store to keep your passwords or tokens secure. In addition, you can use the store credential manager which stores in a file in your home directory, or the cache credential manager, which does not permanently store your credentials, but does prevent you from being prompted for them for a certain period of time.
You can also just enter your password when prompted. While it is possible to place the password which must be percent-encoded in the URL, this is not particularly secure and can lead to accidental exposure of credentials, so it is not recommended. The credential. This is useful when passing credentials into a container, for example. Such a shell command can be specified by starting the option value with an exclamation point. Usually, if the password or token is invalid, Git will erase it and prompt for a new one.
However, there are times when this doesn't always happen. To change the password or token, you can erase the existing credentials and then Git will prompt for new ones. To erase credentials, use a syntax like the following substituting your username and the hostname :.
With most hosting providers that support SSH, a single key pair uniquely identifies a user. Therefore, to use multiple accounts, it's necessary to create a key pair for each account. Most hosting providers use a single SSH account for pushing; that is, all users push to the git account e. If that's the case for your provider, you can set up multiple aliases in SSH to make it clear which key pair to use.
Git doesn't provide a way to do this. The reason is that if Git needs to overwrite this file, such as during a checkout, it doesn't know whether the changes to the file are precious and should be kept, or whether they are irrelevant and can safely be destroyed.
Therefore, it has to take the safe route and always preserve them. It's tempting to try to use certain features of git update-index , namely the assume-unchanged and skip-worktree bits, but these don't work properly for this purpose and shouldn't be used this way. If your goal is to modify a configuration file, it can often be helpful to have a file checked into the repository which is a template or set of defaults which can then be copied alongside and modified as appropriate.
This second, modified file is usually ignored to prevent accidentally committing it. In general, there are a variety of problems that can occur when using squash merges to merge two branches multiple times.
These can include seeing extra commits in git log output, with a GUI, or when using the When Git does a normal merge between two branches, it considers exactly three points: the two branches and a third commit, called the merge base , which is usually the common ancestor of the commits. The result of the merge is the sum of the changes between the merge base and each head.
When you merge two branches with a regular merge commit, this results in a new commit which will end up as a merge base when they're merged again, because there is now a new common ancestor. Git doesn't have to consider changes that occurred before the merge base, so you don't have to re-resolve any conflicts you resolved before. When you perform a squash merge, a merge commit isn't created; instead, the changes from one side are applied as a regular commit to the other side.
This means that the merge base for these branches won't have changed, and so when Git goes to perform its next merge, it considers all of the changes that it considered the last time plus the new changes. That means any conflicts may need to be re-resolved. Similarly, anything using the As a consequence, if you want to merge two long-lived branches repeatedly, it's best to always use a regular merge commit. By default, when Git does a merge, it uses a strategy called the recursive strategy, which does a fancy three-way merge.
In such a case, when Git performs the merge, it considers exactly three points: the two heads and a third point, called the merge base , which is usually the common ancestor of those commits. Git does not consider the history or the individual commits that have happened on those branches at all. As a result, if both sides have a change and one side has reverted that change, the result is to include the change. This is because the code has changed on one side and there is no net change on the other, and in this scenario, Git adopts the change.
If this is a problem for you, you can do a rebase instead, rebasing the branch with the revert onto the other branch. A rebase in this scenario will revert the change, because a rebase applies each individual commit, including the revert. Note that rebases rewrite history, so you should avoid rebasing published branches unless you're sure you're comfortable with that.
The only safe place to make these changes is on the remote repository i. These are the locations in which policy can be enforced effectively. It's common to try to use pre-commit hooks or, for commit messages, commit-msg hooks to check these things, which is great if you're working as a solo developer and want the tooling to help you.
However, using hooks on a developer machine is not effective as a policy control because a user can bypass these hooks with --no-verify without being noticed among various other ways. Git assumes that the user is in control of their local repositories and doesn't try to prevent this or tattle on the user.
In addition, some advanced users find pre-commit hooks to be an impediment to workflows that use temporary commits to stage work in progress or that create fixup commits, so it's better to push these kinds of checks to the server anyway. Git works best when you store text files as UTF If you can't use UTF-8 with your programs, you can specify a working tree encoding that indicates which encoding your files should be checked out with, while still storing these files as UTF-8 in the repository.
You will need to run git add --renormalize to have this take effect. By default, Git expects files to be stored with Unix line endings. Git defaults to showing trailing whitespace only on new lines, not existing ones.
You can store the files in the repository with Unix line endings and convert them automatically to your platform's line endings. To do that, set the configuration option core. You can also control this behavior with the core. Internally, Git always stores file names as sequences of bytes and doesn't perform any encoding or case folding. However, Windows and macOS by default both perform case folding on file names.
As a result, it's possible to end up with multiple files or directories whose names differ only in case. Git can handle this just fine, but the file system can store only one of these files, so when Git reads the other file to see its contents, it looks modified.
It's best to remove one of the files such that you only have one file. You can do this with commands like the following assuming two files AFile. This avoids touching the disk, but removes the additional file.
Your project may prefer to adopt a naming convention, such as all-lowercase names, to avoid this problem from occurring again; such a convention can be checked using a pre-receive hook or as part of a continuous integration CI system. It is also possible for perpetually modified files to occur on any platform if a smudge or clean filter is in use on your system but a file was previously committed without running the smudge or clean filter. To fix this, run the following on an otherwise clean working tree:.
While Git can store and handle any file of any type, there are some settings that work better than others. These are the settings that work best across platforms and with tools such as git diff and git merge.
Additionally, if you have a choice between storage formats that are text based or non-text based, we recommend storing files in the text format and, if necessary, transforming them into the other format. For example, a text-based SQL dump with one record per line will work much better for diffing and merging than an actual database file. Similarly, storing binary dependencies e. Dependencies and build products are best stored on an artifact or package server with only references, URLs, and hashes stored in the repository.
For example, the following might be appropriate in some projects:. These settings help tools pick the right format for output such as patches and result in files being checked out in the appropriate line ending for the platform. Hooks are programs you can place in a hooks directory to trigger actions at certain points in git's execution. Hooks that don't have the executable bit set are ignored.
Hooks can get their arguments via the environment, command-line arguments, and stdin. See the documentation for each hook below for details. When the rest of this document refers to "default hooks" it's talking about the default template shipped with Git.
It takes a single parameter, the name of the file that holds the proposed commit log message. Exiting with a non-zero status causes git am to abort before applying the patch. The hook is allowed to edit the message file in place, and can be used to normalize the message into some project standard format.
It can also be used to refuse the commit after inspecting the message file. The default applypatch-msg hook, when enabled, runs the commit-msg hook, if the latter is enabled.
It takes no parameter, and is invoked after the patch is applied, but before a commit is made. If it exits with non-zero status, then the working tree will not be committed after applying the patch.
It can be used to inspect the current working tree and refuse to make a commit if it does not pass certain test. The default pre-applypatch hook, when enabled, runs the pre-commit hook, if the latter is enabled. It takes no parameter, and is invoked after the patch is applied and a commit is made.
This hook is meant primarily for notification, and cannot affect the outcome of git am. It takes no parameters, and is invoked before obtaining the proposed commit log message and making a commit. Exiting with a non-zero status from this script causes the git commit command to abort before creating a commit. The default pre-commit hook, when enabled, catches introduction of lines with trailing whitespaces and aborts the commit when such a line is found.
The default pre-commit hook, when enabled--and with the hooks. It takes no parameters, and is invoked after the merge has been carried out successfully and before obtaining the proposed commit log message to make a commit. Exiting with a non-zero status from this script causes the git merge command to abort before creating a commit. The default pre-merge-commit hook, when enabled, runs the pre-commit hook, if the latter is enabled.
At that point, this hook will not be executed, but the pre-commit hook will, if it is enabled. It takes one to three parameters. The first is the name of the file that contains the commit log message. The second is the source of the commit message, and can be: message if a -m or -F option was given ; template if a -t option was given or the configuration option commit. The purpose of the hook is to edit the message file in place, and it is not suppressed by the --no-verify option.
A non-zero exit means a failure of the hook and aborts the commit. It should not be used as replacement for pre-commit hook. The sample prepare-commit-msg hook that comes with Git removes the help message found in the commented portion of the commit template. Exiting with a non-zero status causes the command to abort. The default commit-msg hook, when enabled, detects duplicate Signed-off-by trailers, and aborts the commit if one is found.
It takes no parameters, and is invoked after a commit is made. This hook is meant primarily for notification, and cannot affect the outcome of git commit. The hook may be called with one or two parameters. The first parameter is the upstream from which the series was forked. The second parameter is the branch being rebased, and is not set when rebasing the current branch. This hook cannot affect the outcome of git switch or git checkout , other than that the hook's exit status becomes the exit status of these two commands.
The first parameter given to the hook is the null-ref, the second the ref of the new HEAD and the flag is always 1. Likewise for git worktree add unless --no-checkout is used. This hook can be used to perform repository validity checks, auto-display differences from the previous HEAD if different, or set working dir metadata properties. The hook takes a single parameter, a status flag specifying whether or not the merge being done was a squash merge. This hook cannot affect the outcome of git merge and is not executed, if the merge failed due to conflicts.
This hook can be used in conjunction with a corresponding pre-commit hook to save and restore any form of metadata associated with the working tree e. The hook is called with two parameters which provide the name and location of the destination remote, if a named remote is not being used both values will be the same. Information about what is to be pushed is provided on the hook's standard input with lines of the form:. For instance, if the command git push origin master:foreign were run the hook would receive a line like the following:.
If this hook exits with a non-zero status, git push will abort without pushing anything. Information about why the push is rejected may be sent to the user by writing to standard error. Just before starting to update refs on the remote repository, the pre-receive hook is invoked. Its exit status determines the success or failure of the update.
This hook executes once for the receive operation. It takes no arguments, but for each ref to be updated it receives on standard input a line of the format:. If the hook exits with non-zero status, none of the refs will be updated. If the hook exits with zero, updating of individual refs can still be prevented by the update hook.
Both standard output and standard error output are forwarded to git send-pack on the other end, so you can simply echo messages for the user. Just before updating the ref on the remote repository, the update hook is invoked. Its exit status determines the success or failure of the ref update. A zero exit from the update hook allows the ref to be updated. Exiting with a non-zero status prevents git receive-pack from updating that ref.
This hook can be used to prevent forced update on certain refs by making sure that the object name is a commit object that is a descendant of the commit object named by the old object name. That is, to enforce a "fast-forward only" policy. It could also be used to log the old.. However, it does not know the entire set of branches, so it would end up firing one e-mail per ref when used naively, though. The post-receive hook is more suited to that. In an environment that restricts the users' access only to git commands over the wire, this hook can be used to implement access control without relying on filesystem ownership and group membership.
The default update hook, when enabled--and with hooks. If the server has set the multi-valued config variable receive. This hook is responsible for updating the relevant references and reporting the results back to receive-pack. It takes no arguments, but uses a pkt-line format protocol to communicate with receive-pack to read commands, push-options and send results.
In the following example for the protocol, the letter S stands for receive-pack and the letter H stands for this hook.
Each command for the proc-receive hook may point to a pseudo-reference and always has a zero-old as its old-oid, while the proc-receive hook may update an alternate reference and the alternate reference may exist already with a non-zero old-oid.
For this case, this hook will use "option" directives to report extended attributes for the reference given by the leading "ok" directive. The report of the commands of this hook should have the same order as the input. The exit status of the proc-receive hook only determines the success or failure of the group of commands sent to it, unless atomic push is in use.
It executes on the remote repository once after all the refs have been updated. It takes no arguments, but gets the same information as the pre-receive hook does on its standard input.
This hook does not affect the outcome of git receive-pack , as it is called after the real work is done. This supersedes the post-update hook in that it gets both old and new values of all the refs in addition to their names. It takes a variable number of parameters, each of which is the name of ref that was actually updated. This hook is meant primarily for notification, and cannot affect the outcome of git receive-pack. The post-update hook can tell what are the heads that were pushed, but it does not know what their original and updated values are, so it is a poor place to do log old..
The post-receive hook does get both original and updated values of the refs. You might consider it instead if you need them. When enabled, the default post-update hook runs git update-server-info to keep the information used by dumb transports e. If you are publishing a Git repository that is accessible via HTTP, you should probably enable this hook.
This hook is invoked by any Git command that performs reference updates. It executes whenever a reference transaction is prepared, committed or aborted and may thus get called multiple times. The hook does not cover symbolic references but that may change in the future. The hook takes exactly one argument, which is the current state the given reference transaction is in:. For each reference update that was added to the transaction, the hook receives on standard input a line of the format:.
The exit status of the hook is ignored for any state except for the "prepared" state. In the "prepared" state, a non-zero exit status will cause the transaction to be aborted.
The hook will not be called with "aborted" state in that case.
0コメント