Attribution

[simonharrer]

Why

Teams don't use mob at all or only for some commands because co-authors aren't properly attributed, and this is very important to those teams.

Scope

mob done --squash

Usually, mob next creates WIP commits and mob done --squash puts all changes in the staging area and the user creates a single commit of all changes at the end.

Approaches:

• Gather all git authors who made a WIP commit and help the user to include those users in some form in the new commit the user will create manually. What about authors that haven't made an actual commit but are still part of the mob?
• Push everything to the user. The user must include their co-authors manually in the commit the user manually creates.

mob done --no-squash without mob next

Every user won't use mob next but instead create all commits in the WIP branch themselves. In the end, mob done --no-squash merges all those commits back in main.

• Do all manual commits require co-authors here as well?

mob done --no-squash with mob next

This combination probably doesn't make a lot of sense. Because who wants a git history with strange WIP commit messages anyway.

mob done --no-squash with mob next --message

This combination might make sense. Not sure yet.

[lamalex]

fwiw our team currently uses git mob which relies on a .git-coauthors file and sets some state based on arguments passed to git mob. git mob al sh sg such that al, sh, and sg are keys on a json object defined in .git-coauthors.

Would something like `--with "<co authors, ...>" be considered?
This isn't mutually exclusive with parsing committers from mob-next commits, but does address the "member of mob did not make a change" case.

[lamalex]

I can see 2 potential flows

1. mob start --with <> ; Take the git mob approach and set state for the mob session. This would require some way of communicating the members of the mob via git, which doesn't feel right.
2. mob done --with <>; Stateless flag at finish where mob members can be listed manually

However the more I talk this out the less I like it, specially in context of automatic parsing from users of next. It would require some mental energy to remember who had not used next...

[simonharrer]

Maybe the solution is to make tools like git mob work well together with mob? They both solve different problems somehow. What do you think?

[lamalex]

Indeed. They do solve slightly different, though related, problems.
It seems that git mob writes to .git/.gitmessage which is the standard commit template location,
whereas mob ends up setting .git/COMMIT_EDITMSG (via --ff-only) which doesn't appear to respect .git/.gitmessage when git commit is finally run.

What if mob done prepended .git/.gitmessage onto .git/COMMIT_EDITMSG

I see this as not only working with git mob (kind of a secondary benefit), but also respecting teams which have a common commit template. I imagine that not many users are keeping the

mob next [ci-skip] [ci skip] [skip ci]

commits in their final history.

[lamalex]

It actually appears that git-mob provides a sample hook which sets co-authors on COMMIT_EDITMSG,
https://github.com/findmypast-oss/git-mob/blob/master/hook-examples/prepare-commit-msg-nodejs

This works, but requires set up between users. The reality is that getting shared config between devs is a hard problem. I'd prefer to see some native support in mob.

I'm almost coming back to wanting the UX to be like

1. =>
   a. mob start --with al,sh
   b. mob start --with "Alex Launi <alauni1@ford.com>, Simon Harrer <i@didntlook.com>"
2. mob next
3. ...
4. mob done # Parses authors & co-authors for final commit

the shorthand version leads to "how is that defined?" A quick search shows 2 common tools, git mob and git team which each do it differently.

In my perfect world:

• mob start --with "Alex Launi <alauni1@ford.com> as al, Simon Harrer <i@didntlook.com> as sh"
  • would only need to be run once during a mob, sets Co-authored-by on a WIP commit.
  • If someone new joins they can be added with another mob start --with "Hi Friend < ... >"
  • When mob done is run it parses authors/co-authors from the WIP commits and nicely appends everyone who worked in the mob

[lamalex]

We've started implementing the --with workflow based on @stevegt 's branch. https://github.com/lamalex/mob/tree/append-coauthors

I just now noticed, however, that the actual code to merge coauthor is not implemented.

[lamalex]

I'm not a fan of the mob next --message approach. We really like the fast handover process that mob enables. Having to set a message breaks that smooth flow.

[simonharrer]

Makes sense.

[gregorriegler]

i use mob done --no-squash with mob next and i fixup all wip commits using this script https://gist.github.com/gregorriegler/5b991f859255549bd15e3d61c3842d57

[lamalex]

Is this in lieu of mob done, or in addition to?

[simonharrer]

Hm, it could be combined with --no-squash via a parameter. But I think this might be an issue independent of attribution.

[simonharrer]

@gregorriegler what about the situation where you only have WIP commits. What does the script do in this case? I hope it doesn't merge everything in the starting commit from the main branch :-D

[lamalex]

Maybe we need to focus this on user stories and how we actually want it to work rather than how we want to implement it.

As a member of a mob
Given all members have committed code
I want all members of my mob to appear as co-authors

As a member of a mob who has not committed code
I want to appear in co-authors

[gregorriegler]

@gregorriegler what about the situation where you only have WIP commits. What does the script do in this case? I hope it doesn't merge everything in the starting commit from the main branch :-D

if there is only one wip commit, it will leave it.
if there are many, but only wip commits, it will try to squash them, setting an empty commit message, which fails the rebase, but that's all.
so i make sure that there is a manual commit in the end