Git Open Source Weekend London 11th/12th November

Hi,

Bloomberg is hosting an Open Source Weekend in London on the 11th & 12th November 2017 to contribute to the Git project. We have also confirmed that Peff will be amongst the mentors on hand to guide attendees through their efforts!

Some of you may notice that we tried to organize this earlier in the year, but unfortunately had to postpone it. For this time around we are further along in planning, and it's definitely happening :)

For those unfamiliar with Bloomberg Open Source weekends: These events provide a great way for those who love working on code to give back to the community. Come and help make difference to a great project!

There will be tasks provided by the mentors, or bring your own if you already have a great idea. Also if you can't attend the weekend and can think of a project which you would like tackled at this event please let me know. Obviously the projects should be completable inside a weekend.

Normally attendees work in small groups on a specific task to prevent anyone from getting stuck. Per usual, Bloomberg will provide the venue, mentors, snacks and drinks. Bring your enthusiasm (and your laptop!) and come share in the fun! The event is also open to everyone, so feel free to pass on the invite!

The event is free of charge, but please ensure that you are able to attend the event before registering. That will greatly help us with accurate numbers for catering so that we don't create unwanted waste!

You can register for the event here:

https://go.bloomberg.com/attend/invite/git-sprint-hosted-bloomberg/

Whether you already are a contributor (as probably most people on this list are) or interested in starting to contribute to git or have some friends that you'd like to get to contribute to git, it would be great to see you at the event.

If you have any further questions feel free to get in touch.

- Thomas

I think it will help if the experienced members of the community (both those who will be at the event and not) can come up with some possible topics to work on (though of course I'd be glad for participants to come with their own itch to scratch).

We've started using the #leftoverbits tag to allow searching in the archive:

https://public-inbox.org/git/?q=leftoverbits

Some of those have since been completed, but others are left open. There's not really a master list, but it's a potential source for digging for gold (well, if you want to call leftover bugs gold :) ).

I started a list over the summer of larger items that people might want to pick up. Here it is in no particular order:

- the pager.<cmd> config is mis-designed, because our config keys cannot represent all possible command names (e.g., case folding and illegal characters). This should be pager.<cmd>.enable or similar. Some discussion in (this message and the surrounding thread):

     https://public-inbox.org/git/[email protected]/

But I think you could find more by searching the archive.

- ditto for alias.* config, which has the same syntax problems.

- auto-gc is sometimes over-anxious to run if you have a lot of unreachable loose objects. We should pack unreachables into a single pack. That solves the --auto problem, and is also way more efficient. The catch is expiration. Some discussion here (and especially down-thread):

     https://public-inbox.org/git/[email protected]/

- git-config's "--get-color" is unlike all the other types in that it takes a "default" value if the config key isn't set. This makes it annoyingly inconsistent, but there's also no way to ask Git to interpret other values (e.g., you might want it to expand "--path" or an "--int"). It would be nice to have a general "--default" option so you could do:

     # same as git config --get-color color.diff.old red
     git config --default red --color color.diff.old

or

     # not currently possible to ask git to interpret "10k"
     git config --default 10k --int some.integer.key

- git's internal config can parse expiration dates (see parse_expiry_date()), but you can't do so from git-config. It should probably have a type for "--expiry-date" (which would of course be more useful with the --default option above).

- there's no efficient way to ask git-config for several keys with a specific type (or even multiple different types). You can use "--list" to get their strings, but you can't get any interpretation (like colors, integers, etc). Invoking git-config many times can have a noticeable speed impact for a script. There should probably be a "--stdin" mode (or maybe "--get-stdin" if we would one day want to have a "--set-stdin") that takes a list of keys, optional types, and optional defaults (that "--default" again!) and outputs them to stdout.

Those were just sitting on my ideas list. I'm happy to go into more detail if anybody's interested in discussing any of them. Some of them may be half-baked.

And of course I'd be happy if people wanted to contribute more items to the list.

-Peff

From: "Jeff King" <[email protected]>

A few I've seen recently are:

* The provison of a git resolve -X <ours|theirs> -- <pathspec> command to simplify the manual resolution of remaining conflicts.
https://public-inbox.org/git/[email protected]/ Sergey Organov: How to re-merge paths differently?

* (Git for Windows/HFS): Detect directory capitalisation changes when switching branches, and rename them correctly on case preserving, case insensitive file systems. Optimisation: If the underlying tree is identical then do not update the modified dates.
https://github.com/git-for-windows/git/issues/1333 Chuck Lu: Folder name should be case sensitive when switch branches.

* (Git for Windows/HFS) (long standing):
detect branch name capitalisation issues
- may need a struct to carry both the filename and pathname down the different parts of the code base so that the FS name of the requested ref/heads/ can be checked and warned.
e.g. https://github.com/git-for-windows/git/issues/852 "git checkout head inconsistent behavior"
- ('head' finds 'HEAD', but also 'branch' finds 'Branch');
https://github.com/git-for-windows/git/issues/852#issuecomment-239675187 -> "rambling notes" for partial analysis.

https://github.com/git-for-windows/git/issues/752 "git checkout creating tracking branch using case-insensitive match?"
- Is this part of the same problem?

* Documentation:

There's always the newby role at the hackathon of collating
all the "what does this command do/mean?" questions that could be resolved by simple updates, or capturing locally written explanations to improve the manual pages. (easy patch practice)

Perhaps see how git rerere could be better explained and integrated onto the other man pages so that more folk naturally know of it and use it. (see also the git resolve question above)

Also for case sensitivity documentation
https://github.com/git-for-windows/git/issues/908#issuecomment-325116189

--
Philip

I'm not posting this for inclusion (yet), but because I read this:

I'm posting four patches I have on this to save others from redoing my work and findings. These patches feel a bit incomplete, which is why I put them to the side some time ago (and eventually forgot about them).

In particular, they do not teach --paginate to use the pager configured by pager.foo.command. It is already now possible to use pager.foo to say "I don't want you to page, but if I later give you pager.foo=true, this is the pager I want you to use". That does not work with --paginate, but this can all be explained -- indeed, we document that --paginate overrules pager.foo.

If we teach --paginate to respect pager.foo.command, it seems that we would either 1) introduce a small (and possibly hard to understand and explain) difference between the old-style and the new-style pager-configuration or 2) knowingly change the behavior of --paginate with pager.foo or 3) knowingly change the behavior of pager.foo=false as documented in the first patch.

I think there's great value to being able to say "this is the same as this, and that is the same as that", but that might get muddied by "oh, except if you use --paginate".

If someone wants to pick these up and bring them to completion, great! If not and if I or someone else feels confident about which way to go, then I can revisit these.

Martin

Martin Ågren (4):
t7006: document that pager.foo can be partially preserved
pager: refactor pager_command_config()
pager: introduce pager.*.command and .enable
pager: make pager.foo.command imply .enable=true

 Documentation/config.txt  | 19 +++++++++
 Documentation/git-tag.txt |  3 +-
 Documentation/git.txt     |  2 +-
 t/t7006-pager.sh          | 98 +++++++++++++++++++++++++++++++++++++++++++++++
 pager.c                   | 16 +++++++-
 5 files changed, 134 insertions(+), 4 deletions(-)

2.15.0.415.gac1375d7e

Assuming a blank slate, consider the following configuration:

[pager]
foo = some-command
foo = false

Now git -c pager.foo=true foo will page using some-command. This might have been intended, or is perhaps just a side-effect of the implementation. In any case, it could be useful and someone might rely on it, either knowingly (as above) or not (if these lines are spread out across the configuration).

However, git --paginate foo will *not* use some-command. That matches the documentation (Documentation/git.txt).

Upcoming commits will expand on how paging for git foo can be configured. Those commits mustn't change how pager.foo behaves, so add tests for these two cases.

---
 t/t7006-pager.sh | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

index f0f1abd1c..e890b2f64 100755
@@ -117,6 +117,24 @@ test_expect_success TTY 'git config uses a pager if configured to' '
 	test -e paginated.out
 '
 
+test_expect_success TTY 'configuration remembers pager across boolean changes' '
+	echo paging >expected &&
+	test_unconfig pager.config &&
+	test_terminal git -c pager.config="echo paging" \
+			  -c pager.config=false \
+			  -c pager.config \
+			  config --list >actual &&
+	test_cmp expected actual
+'
+
+test_expect_success TTY '--paginate does not respect inactivated pager' '
+	rm -f paginated.out &&
+	test_terminal git -c pager.config=bad \
+			  -c pager.config=false \
+			  --paginate config --list &&
+	test -e paginated.out
+'
+
 test_expect_success TTY 'configuration can enable pager (from subdir)' '
 	rm -f paginated.out &&
 	mkdir -p subdir &&

2.15.0.415.gac1375d7e

pager_command_config() checks for the config pager.<cmd>. In the next commit, we will want to also look for some strings on the form pager.<cmd>.foo.

Refactor the code to verify upfront that the string starts with "pager.<cmd>" and then check that the remainder is the empty string. This makes it easy to look for other remainders in the next patch.

While at it, before assigning to value, free any old value we might already have picked up.

---
 pager.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

index 92b23e6cd..8968f26f1 100644
@@ -191,14 +191,19 @@ struct pager_command_config_data {
 static int pager_command_config(const char *var, const char *value, void *vdata)
 {
 	struct pager_command_config_data *data = vdata;
-	const char *cmd;
+	const char *cmd, *remainder;
+
+	if (!skip_prefix(var, "pager.", &cmd) ||
+	    !skip_prefix(cmd, data->cmd, &remainder))
+		return 0;
 
-	if (skip_prefix(var, "pager.", &cmd) && !strcmp(cmd, data->cmd)) {
+	if (!*remainder) {
 		int b = git_parse_maybe_bool(value);
 		if (b >= 0)
 			data->want = b;
 		else {
 			data->want = 1;
+			free(data->value);
 			data->value = xstrdup(value);
 		}
 	}

2.15.0.415.gac1375d7e

pager.foo conflates two concepts: how and whether git foo should page. In particular, it can not be used to change *how* to page without possibly also affecting *whether*.

Teach Git about two new config items, pager.foo.command and pager.foo.enable.

Make this interact sanely with the existing pager.foo. For example, make sure that pager.foo=false does not cause us to forget about a command already configured through pager.foo.command, so that the given pager command can be "re-activated" using pager.foo[.enable]=true.

Where Documentation/ refers to pager.tag, write "the pager.tag[.*] configuration options". In config.txt, pager.blame is mentioned more as an example and it describes precisely the situation where one will want to use the old mechanism, so leave that instance unchanged.

For symmetry with how --paginate disrespects any pager that might have been configured with pager.foo, do the same for pager.foo.command.

---
 Documentation/config.txt  | 17 +++++++++++
 Documentation/git-tag.txt |  3 +-
 Documentation/git.txt     |  2 +-
 t/t7006-pager.sh          | 73 +++++++++++++++++++++++++++++++++++++++++++++++
 pager.c                   |  5 ++++
 5 files changed, 98 insertions(+), 2 deletions(-)

index 1ac0ae6ad..72558cc74 100644
@@ -2460,6 +2460,23 @@ pager.<cmd>::
 	or `--no-pager` is specified on the command line, it takes
 	precedence over this option.  To disable pagination for all
 	commands, set `core.pager` or `GIT_PAGER` to `cat`.
++
+This is a less flexible alternative to `pager.<cmd>.command` and
+`pager.<cmd>.enable`. Using it with a boolean does the same as using
+`pager.<cmd>.enable`. Using it with a command does the same as using
+`pager.<cmd>.command` and `pager.<cmd>.enable=true`.
+
+pager.<cmd>.command::
+	Specifies the pager to use for the subcommand.
+	Whether the pager should be used is configured using
+	`pager.<cmd>.enable` or `pager.<cmd>=<boolean>`.
+
+pager.<cmd>.enable::
+	A boolean which turns on or off pagination of the output of a
+	particular Git subcommand when writing to a tty. If `--paginate`
+	or `--no-pager` is specified on the command line, it takes
+	precedence over this option.  To disable pagination for all
+	commands, set `core.pager` or `GIT_PAGER` to `cat`.
 
 pretty.<name>::
 	Alias for a --pretty= format string, as specified in

index 956fc019f..9f9f33409 100644
@@ -210,7 +210,8 @@ it in the repository configuration as follows:
     signingKey = <gpg-keyid>
 -------------------------------------
 
-`pager.tag` is only respected when listing tags, i.e., when `-l` is
+The `pager.tag[.*]` configuration options are only
+respected when listing tags, i.e., when `-l` is
 used or implied. The default is to use a pager.
 See linkgit:git-config[1].
 

index 7a1d629ca..0a2eff7a6 100644
@@ -99,7 +99,7 @@ foo.bar= ...`) sets `foo.bar` to the empty string which `git config
 -p::
 --paginate::
 	Pipe all output into 'less' (or if set, $PAGER) if standard
-	output is a terminal.  This overrides the `pager.<cmd>`
+	output is a terminal.  This overrides the `pager.<cmd>[.*]`
 	configuration options (see the "Configuration Mechanism" section
 	below).
 

index 8968f26f1..c8a6a01d8 100644
@@ -206,6 +206,11 @@ static int pager_command_config(const char *var, const char *value, void *vdata)
 			free(data->value);
 			data->value = xstrdup(value);
 		}
+	} else if (!strcmp(remainder, ".command")) {
+		free(data->value);
+		data->value = xstrdup(value);
+	} else if (!strcmp(remainder, ".enable")) {
+		data->want = git_config_bool(var, value);
 	}
 
 	return 0;

2.15.0.415.gac1375d7e

If pager.foo.command gets configured and there is no configuration (yet) saying whether we should page, act as if pager.foo.enable=true.

This means that a lone pager.foo can always be written as a lone pager.foo.command or pager.foo.enable.

---
 Documentation/config.txt | 2 ++
 t/t7006-pager.sh         | 7 +++++++
 pager.c                  | 2 ++
 3 files changed, 11 insertions(+)

index 72558cc74..91cc8b110 100644
@@ -2470,6 +2470,8 @@ pager.<cmd>.command::
 	Specifies the pager to use for the subcommand.
 	Whether the pager should be used is configured using
 	`pager.<cmd>.enable` or `pager.<cmd>=<boolean>`.
+	Implies `pager.<cmd>.enable=true` unless `pager.<cmd>.enable`
+	or `pager.<cmd>` have already been given.
 
 pager.<cmd>.enable::
 	A boolean which turns on or off pagination of the output of a

index 6966627dd..c5246a57d 100755
@@ -625,6 +625,13 @@ test_expect_success TTY '.enable discards non-boolean' '
 	test_must_fail git -c pager.log.enable=bad log
 '
 
+test_expect_success TTY 'configuration with .command turns on paging' '
+	>actual &&
+	test_terminal git -c pager.rev-list.command="sed s/^/foo:/ >actual" \
+			  rev-list HEAD &&
+	test_cmp expect actual
+'
+
 test_expect_success TTY 'configuration remembers .command as .enable flips' '
 	>actual &&
 	test_terminal git -c pager.rev-list.command="sed s/^/foo:/ >actual" \

index c8a6a01d8..0e037abf4 100644
@@ -209,6 +209,8 @@ static int pager_command_config(const char *var, const char *value, void *vdata)
 	} else if (!strcmp(remainder, ".command")) {
 		free(data->value);
 		data->value = xstrdup(value);
+		if (data->want == -1)
+			data->want = 1;
 	} else if (!strcmp(remainder, ".enable")) {
 		data->want = git_config_bool(var, value);
 	}

2.15.0.415.gac1375d7e

Thanks for sharing these; it's nice if we can avoid duplicating work. We'll see if somebody at the event wants to pick up this topic.

Hmm. I think the current behavior is actually buggy. I assume the documentation you mean is from git.txt:

--paginate::
Pipe all output into 'less' (or if set, $PAGER) if standard output is a terminal. This overrides the pager.<cmd> configuration options (see the "Configuration Mechanism" section below).

That comes from 06300d9753 (git.1: Clarify the behavior of the --paginate option, 2010-02-14). But I think that commit was just trying to clarify that "--paginate" overrides the defaults and config, but not does say "always paginate".

I suspect nobody really noticed it in practice because once you've configured "pager.foo", there's basically no need to ever use "--paginate".

I think I'm suggesting (2), then.

-Peff

Yes, that's what I meant.

Thanks for digging.

You're probably right that this was not intended. I think I put way too much weight on the "s" in "options". I understood it as "both ways pager.foo can be used". From the commit message you point to, it seems that only the boolean-ness was intended. (The "s" probably refers to pager.foo, pager.bar, ...)

I think you're right. If this topic doesn't get picked up in the near future (in London or elsewhere), I'll get back to this.

A final thought for whoever tackles this: Playing with something like git -c pager.log=$foo --paginate log vs git -c core.pager=$foo --paginate log might be helpful. Possibly $foo=cat could be particularly interesting, I haven't thought hard about it.

Martin

Hi,

nice to hear, thanks for organizing. Due to having moved to London just that week I'd love to take part.

As I'm a core contributor of libgit2, I am interested in bringing forward libgit2 at that occasion. Would that be welcome or should participants keep strictly to the core git project? Just asking as I'd like to take part but have a rather long list of topics for libgit2 on my backlog which I'd like to tackle myself.

Regards
Patrick