Re: [PATCH v3 1/2] fsck.c: modify fsck_ident() and fsck_commit()

On Mon, Mar 24, 2014 at 8:08 AM, Ashwin Jha ajha@gmail.com wrote: Subject: fsck.c: modify fsck_ident() and fsck_commit() The subject should summarize the change while being concise and expressive. The above is a bit lacking. A better subject might be: Subject: fsck: add missing 'const's

Re: [PATCH v3 2/2] fsck.c:fsck_commit replace memcmp by skip_prefix

On Mon, Mar 24, 2014 at 8:09 AM, Ashwin Jha ajha@gmail.com wrote: Replace memcmp by skip_prefix as it serves the dual purpose of checking the string for a prefix as well as skipping that prefix. Signed-off-by: Ashwin Jha ajha@gmail.com --- fsck_commit(): After the first patch in

[PATCH 007/144] git-web--browse.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 013/144] t0026-eol-config.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 009/144] t0001-init.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 008/144] unimplemented.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 001/144] check-builtins.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 012/144] t0025-crlf-auto.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 053/144] t5100-mailinfo.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 049/144] t4119-apply-config.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 018/144] t1001-read-tree-m-2way.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 095/144] t7602-merge-octopus-many.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 030/144] t3030-merge-recursive.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 072/144] t5550-http-fetch-dumb.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 048/144] t4116-apply-reverse.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 090/144] t7103-reset-bare.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 093/144] t7504-commit-msg-hook.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 097/144] t8003-blame-corner-cases.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 040/144] t4006-diff-mode.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 075/144] t5601-clone.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 058/144] t5304-prune.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 015/144] t0204-gettext-reencode-sanity.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 038/144] t3905-stash-include-untracked.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 041/144] t4010-diff-pathspec.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 056/144] t5302-pack-index.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 099/144] t9101-git-svn-props.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 079/144] t6001-rev-list-graft.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 084/144] t6111-rev-list-treesame.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 034/144] t3403-rebase-skip.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 064/144] t5515-fetch-merge-logic.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 085/144] t6132-pathspec-exclude.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 074/144] t5570-git-daemon.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 104/144] t9109-git-svn-multi-glob.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 096/144] t7700-repack.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 103/144] t9108-git-svn-glob.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 088/144] t7004-tag.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 094/144] t7505-prepare-commit-msg-hook.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 076/144] t5700-clone-reference.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 082/144] t6032-merge-large-rename.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 086/144] t7001-mv.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 098/144] t9001-send-email.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 101/144] t9105-git-svn-commit-diff.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 083/144] t6034-merge-rename-nocruft.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 080/144] t6002-rev-list-bisect.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 081/144] t6015-rev-list-show-all-parents.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 071/144] t5538-push-shallow.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 092/144] t7408-submodule-reference.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 070/144] t5537-fetch-shallow.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 087/144] t7003-filter-branch.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 089/144] t7006-pager.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 105/144] t9110-git-svn-use-svm-props.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 100/144] t9104-git-svn-follow-parent.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 067/144] t5520-pull.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 055/144] t5301-sliding-window.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 060/144] t5500-fetch-pack.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 068/144] t5522-pull-symlink.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 077/144] t5710-info-alternate.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 061/144] t5505-remote.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 057/144] t5303-pack-corruption-resilience.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 062/144] t5506-remote-groups.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 066/144] t5517-push-mirror.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 059/144] t5305-include-tag.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 073/144] t5551-http-fetch-smart.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 054/144] t5300-pack-object.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 065/144] t5516-fetch-push.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 063/144] t5510-fetch.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 078/144] t5900-repo-selection.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 025/144] t1401-symbolic-ref.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 042/144] t4012-diff-binary.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 033/144] t3210-pack-refs.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 021/144] t1004-read-tree-m-u-wf.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

Re: [PATCH 015/144] t0204-gettext-reencode-sanity.sh: use the $( ... ) construct for command substitution

Elia Pinto gitter.spi...@gmail.com writes: --- a/t/t0204-gettext-reencode-sanity.sh +++ b/t/t0204-gettext-reencode-sanity.sh @@ -58,7 +58,7 @@ test_expect_success GETTEXT_LOCALE 'gettext: Fetching a UTF-8 msgid - UTF-8' ' # How these quotes get transliterated depends on the gettext

[PATCH 050/144] t4204-patch-id.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 031/144] t3100-ls-tree-restrict.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 028/144] t1512-rev-parse-disambiguation.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 016/144] t0300-credentials.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

Re: [PATCH 001/144] check-builtins.sh: use the $( ... ) construct for command substitution

Elia Pinto gitter.spi...@gmail.com writes: and is supported by POSIX. However,all but the simplest uses become Missing space after comma. complicated quickly. In particular,embedded command substitutions Ditto. (neither should block merging, but they would be worth fixing if you need a

[PATCH 027/144] t1511-rev-parse-caret.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 032/144] t3101-ls-tree-dirname.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 026/144] t1410-reflog.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 035/144] t3511-cherry-pick-x.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 017/144] t1000-read-tree-m-3way.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 020/144] t1003-read-tree-prefix.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 046/144] t4038-diff-combined.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 045/144] t4036-format-patch-signer-mime.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 052/144] t5003-archive-zip.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 029/144] t2102-update-index-symlinks.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 043/144] t4013-diff-various.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 047/144] t4057-diff-combined-paths.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 037/144] t3700-add.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 039/144] t3910-mac-os-precompose.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 044/144] t4014-format-patch.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 051/144] t5000-tar-tree.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 036/144] t3600-rm.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 010/144] t0010-racy-git.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 000/144] Use the $( ... ) construct for command substitution instead of using the back-quotes

This patch series changes everywhere the back-quotes construct for command substitution with the $( ... ). The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes , or grave accents (`..`). The backquoted form is the historical method

[PATCH 023/144] t1050-large.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 002/144] git-am.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 014/144] t0030-stripspace.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

[PATCH 004/144] git-rebase--merge.sh: use the $( ... ) construct for command substitution

The Git CodingGuidelines prefer the $( ... ) construct for command substitution instead of using the back-quotes, or grave accents (`..`). The backquoted form is the historical method for command substitution, and is supported by POSIX. However,all but the simplest uses become complicated

  1   2   3   >