Ignore certain lines in Git messages

[rettenbs]

We came across this issue when using Github's "suggestion" feature in pull requests.

The commit message look like this:

Apply suggestions from code review

<custom message>

Co-Authored-By: <user> <email>

The last line is automatically appended by Github and may exceed the max line length if the user name and/or the email is very long.

We would like to ignore the max line length rule for Co-Authored-By: <user> <email> but still check <custom message>.

[jorisroovers]

Interesting use-case.

To support this, we'd probably need to do make some changes to the linting code, to check whether a given line should be linted or not.

Ideally I think gitlint should offer some flexibility in how it determines whether a line should be ignored or not. So not just supporting ignoring lines based on matching a given string/regex, but providing a generic mechanism that checks whether a line should be ignored or not. A LineIgnoreRule or something like that.

This requires some more thought on my end, I've had a quick look and this doesn't look very easy to do right.

I'm interested to eventually implement this, but I don't think that will be soon given I just released 0.13.x and am planning a bit of a break now :)

In the meantime, a blunt work-around would be to ignore the body line-length for any commit that contains the Co-Authored-By line.
You can do that using the ignore-by-body rule:

[ignore-by-body]
regex=^Co\-Authored\-By(.*)
ignore=body-max-length

[jorisroovers]

Ok, so I gave this more thought and came up with a much more elegant solution and temporary workaround that are both easy to implement.

Gitlint already has the concept of ConfigurationRules: ignore-by-body and ignore-by-title are currently the only 2 examples we have of those.

Configuration rules are executed before all other rules, and can modify both the lint configuration as well as the commit message on the fly. This last part is important for this use-case. This didn't occur to me before since we don't have a rules as of now that actually modify the commit message. I guess I had some foresight when initially implementing ConfigurationRule rules though :-)

All of this means that supporting this use-case is just a matter of implementing a new rule in gitlint - not that much work (75% of the work is writing tests and docs). I'll do it, but probably not near-term.

Meanwhile, you'll be able to work around this by using the user-defined rule below. Note that this rule pulls some tricks/hacks that are not really supported in general. This is needed because gitlint doesn't yet support user-defined ConfigurationRules, that's still on the wish-list...

# filename: ignore_lines.py
import gitlint
from gitlint.rules import CommitRule, ConfigurationRule

# Monkey patch gitlint so it allows us to define a user-defined ConfigurationRule (workaround)
gitlint.rule_finder.assert_valid_rule_class = lambda *_: True

# For now we'll need to extend from CommitRule for gitlint to find our rule (workaround)
class RemoveBodyLines(ConfigurationRule, CommitRule):

    name = "remove-body-lines"
    id = "CR1"

    def apply(self, config, commit):
        # modify commit message body, drop all lines starting with "Co-Authored-By: "
        commit.message.body = [l for l in commit.message.body if not l.startswith("Co-Authored-By:")]

    # This is needed because we extend from CommitRule (workaround)
    def validate(self, commit):
        return

Execute this like so:

gitlint -e mydir/ignore_lines.py

Or using a .gitlint file with following config:

[general]
extra-path=mydir/ignore_lines.py

Hope this helps!

[nioncode]

Will the new ConfigurationRule also support the following commit message:

add support for xyz

Closes #234.

At the moment, this triggers B5 Body message is too short, but it would be great to ignore the Closes #{num} / Fixes #{num} etc. from linting.

[jorisroovers]

@nioncode Should already be supported by ignore-by-body, see https://jorisroovers.github.io/gitlint/#ignoring-commits

[jorisroovers]

@nioncode, just reread your message and realized you probably meant ignoring only the Closes #{num} / Fixes #{num} while still linting the rest of the message. So not ignoring the entire commit (which is what ignore-by-title and ignore-by-body allow you to do).

In that case, yes, this is the exact same use-case IMO and would be covered by this issue. The lines to ignore would be configurable through a regex.

[nioncode]

Exactly, I want to only ignore the specific lines. Thanks for the fast response, I'm eagerly awaiting this feature and for now just disable the body-min-length check.

[jorisroovers]

Actually @nioncode, thinking about your specific example once more, ignoring that line won't actually make the B5 violation go away. It will just ignore that particular line, but still apply all the rules as usual. In fact, ignoring this line will likely also trigger an B6 body-is-missing violation since other than that line, the commit message body is empty.

I think what you want is to ignore certain rules when the body contains certain lines. Not necessarily ignoring the matching lines themselves - although I can see that you probably also want to do that (that would fit this issue's use-case).

With this in mind, I think the do actually want to use ignore-by-body as of now, but just only ignore specific rules.

[ignore-by-body]
regex=^Closes(.*) # I'll leave the actual regex to you
ignore=B5,B6 # You can specify which rules to ignore

Limitation: It's currently not possible to specify multiple of the same rules (see #113), which means that you wouldn't be able to ignore different rules for different matching regexes. But if the rules you want to ignore are always the same, this should work.

[nioncode]

Thanks, I already ignore body-is-missing by default, so I did not think of that particular problem.
Your ignore-by-body method looks nice and i think this would already cover my use case, thanks!