From ec1453728770dc8b8877f7aef888c7ccca5a3d05 Mon Sep 17 00:00:00 2001
From: Joris Roovers <joris.roovers@gmail.com>
Date: Sat, 31 Oct 2020 12:04:37 +0100
Subject: Replace format() with f-strings

Replaces most occurences for format() with f-strings (supported since
Python 3.6) - this makes for more readable code in most cases.

Relates to #151
---
 docs/user_defined_rules.md                  |  5 ++-
 examples/my_commit_rules.py                 |  4 +--
 examples/my_line_rules.py                   |  2 +-
 gitlint/cli.py                              | 16 ++++-----
 gitlint/config.py                           | 56 ++++++++++++++---------------
 gitlint/git.py                              |  8 ++---
 gitlint/hooks.py                            | 10 +++---
 gitlint/lint.py                             | 13 ++++---
 gitlint/options.py                          | 21 ++++++-----
 gitlint/rule_finder.py                      | 48 ++++++++++++-------------
 gitlint/rules.py                            | 26 +++++++-------
 gitlint/tests/base.py                       |  8 ++---
 gitlint/tests/cli/test_cli.py               | 20 +++++------
 gitlint/tests/cli/test_cli_hooks.py         |  7 ++--
 gitlint/tests/config/test_config.py         |  6 ++--
 gitlint/tests/config/test_config_builder.py |  8 ++---
 gitlint/tests/contrib/test_contrib_rules.py |  3 +-
 gitlint/tests/git/test_git.py               |  2 +-
 gitlint/tests/git/test_git_commit.py        |  6 ++--
 gitlint/tests/rules/test_title_rules.py     |  2 +-
 gitlint/tests/rules/test_user_rules.py      |  5 +--
 gitlint/tests/test_hooks.py                 | 10 +++---
 gitlint/tests/test_lint.py                  |  4 +--
 gitlint/tests/test_options.py               |  9 +++--
 qa/base.py                                  |  3 +-
 qa/samples/user_rules/extra/extra_rules.py  | 16 ++++-----
 qa/test_commits.py                          |  2 +-
 qa/test_gitlint.py                          |  7 ++--
 qa/test_hooks.py                            |  6 ++--
 29 files changed, 160 insertions(+), 173 deletions(-)

diff --git a/docs/user_defined_rules.md b/docs/user_defined_rules.md
index 88d1dd8..fd944d1 100644
--- a/docs/user_defined_rules.md
+++ b/docs/user_defined_rules.md
@@ -152,7 +152,7 @@ class SpecialChars(LineRule):
         # options can be accessed by looking them up by their name in self.options
         for char in self.options['special-chars'].value:
             if char in line:
-                msg = "Title contains the special character '{0}'".format(char)
+                msg = f"Title contains the special character '{char}'"
                 violation = RuleViolation(self.id, msg, line)
                 violations.append(violation)
 
@@ -262,8 +262,7 @@ class BodyMaxLineCount(CommitRule):
         line_count = len(commit.message.body)
         max_line_count = self.options['max-line-count'].value
         if line_count > max_line_count:
-            message = "Body contains too many lines ({0} > {1})".format(line_count, 
-                                                                        max_line_count)
+            message = f"Body contains too many lines ({line_count} > {max_line_count})"
             return [RuleViolation(self.id, message, line_nr=1)]
 ```
 
diff --git a/examples/my_commit_rules.py b/examples/my_commit_rules.py
index 5e8ce08..5a66c94 100644
--- a/examples/my_commit_rules.py
+++ b/examples/my_commit_rules.py
@@ -35,7 +35,7 @@ class BodyMaxLineCount(CommitRule):
         line_count = len(commit.message.body)
         max_line_count = self.options['max-line-count'].value
         if line_count > max_line_count:
-            message = "Body contains too many lines ({0} > {1})".format(line_count, max_line_count)
+            message = f"Body contains too many lines ({line_count} > {max_line_count})"
             return [RuleViolation(self.id, message, line_nr=1)]
 
 
@@ -88,7 +88,7 @@ class BranchNamingConventions(CommitRule):
                     break
 
             if not valid_branch_name:
-                msg = "Branch name '{0}' does not start with one of {1}".format(branch, allowed_branch_prefixes)
+                msg = f"Branch name '{branch}' does not start with one of {allowed_branch_prefixes}"
                 violations.append(RuleViolation(self.id, msg, line_nr=1))
 
         return violations
diff --git a/examples/my_line_rules.py b/examples/my_line_rules.py
index 820024a..3a1ef36 100644
--- a/examples/my_line_rules.py
+++ b/examples/my_line_rules.py
@@ -45,7 +45,7 @@ class SpecialChars(LineRule):
         # options can be accessed by looking them up by their name in self.options
         for char in self.options['special-chars'].value:
             if char in line:
-                msg = "Title contains the special character '{0}'".format(char)
+                msg = f"Title contains the special character '{char}'"
                 violation = RuleViolation(self.id, msg, line)
                 violations.append(violation)
 
diff --git a/gitlint/cli.py b/gitlint/cli.py
index a42d4c6..76a9734 100644
--- a/gitlint/cli.py
+++ b/gitlint/cli.py
@@ -187,7 +187,7 @@ class ContextObj:
               type=click.Path(exists=True, resolve_path=True, file_okay=False, readable=True),
               help="Path of the target git repository. [default: current working directory]")
 @click.option('-C', '--config', type=click.Path(exists=True, dir_okay=False, readable=True, resolve_path=True),
-              help="Config file location [default: {0}]".format(DEFAULT_CONFIG_FILE))
+              help=f"Config file location [default: {DEFAULT_CONFIG_FILE}]")
 @click.option('-c', multiple=True,
               help="Config flags in format <rule>.<option>=<value> (e.g.: -c T1.line-length=80). " +
                    "Flag can be used multiple times to set multiple config values.")  # pylint: disable=bad-continuation
@@ -242,10 +242,10 @@ def cli(  # pylint: disable=too-many-arguments
         click.echo(e)
         ctx.exit(GIT_CONTEXT_ERROR_CODE)
     except GitLintUsageError as e:
-        click.echo("Error: {0}".format(e))
+        click.echo(f"Error: {e}")
         ctx.exit(USAGE_ERROR_CODE)
     except LintConfigError as e:
-        click.echo("Config Error: {0}".format(e))
+        click.echo(f"Config Error: {e}")
         ctx.exit(CONFIG_ERROR_CODE)
 
 
@@ -315,7 +315,7 @@ def install_hook(ctx):
     try:
         hooks.GitHookInstaller.install_commit_msg_hook(ctx.obj.config)
         hook_path = hooks.GitHookInstaller.commit_msg_hook_path(ctx.obj.config)
-        click.echo("Successfully installed gitlint commit-msg hook in {0}".format(hook_path))
+        click.echo(f"Successfully installed gitlint commit-msg hook in {hook_path}")
         ctx.exit(0)
     except hooks.GitHookInstallerError as e:
         click.echo(e, err=True)
@@ -329,7 +329,7 @@ def uninstall_hook(ctx):
     try:
         hooks.GitHookInstaller.uninstall_commit_msg_hook(ctx.obj.config)
         hook_path = hooks.GitHookInstaller.commit_msg_hook_path(ctx.obj.config)
-        click.echo("Successfully uninstalled gitlint commit-msg hook from {0}".format(hook_path))
+        click.echo(f"Successfully uninstalled gitlint commit-msg hook from {hook_path}")
         ctx.exit(0)
     except hooks.GitHookInstallerError as e:
         click.echo(e, err=True)
@@ -411,14 +411,14 @@ def generate_config(ctx):
     path = os.path.realpath(path)
     dir_name = os.path.dirname(path)
     if not os.path.exists(dir_name):
-        click.echo("Error: Directory '{0}' does not exist.".format(dir_name), err=True)
+        click.echo(f"Error: Directory '{dir_name}' does not exist.", err=True)
         ctx.exit(USAGE_ERROR_CODE)
     elif os.path.exists(path):
-        click.echo("Error: File \"{0}\" already exists.".format(path), err=True)
+        click.echo(f"Error: File \"{path}\" already exists.", err=True)
         ctx.exit(USAGE_ERROR_CODE)
 
     LintConfigGenerator.generate_config(path)
-    click.echo("Successfully generated {0}".format(path))
+    click.echo(f"Successfully generated {path}")
     ctx.exit(0)
 
 
diff --git a/gitlint/config.py b/gitlint/config.py
index 2e50046..91179c9 100644
--- a/gitlint/config.py
+++ b/gitlint/config.py
@@ -220,7 +220,7 @@ class LintConfig:
                 if rule_class:
                     self.rules.add_rule(rule_class, rule_class.id, {'is_contrib': True})
                 else:
-                    raise LintConfigError("No contrib rule with id or name '{0}' found.".format(rule_id_or_name))
+                    raise LintConfigError(f"No contrib rule with id or name '{rule_id_or_name}' found.")
 
         except (options.RuleOptionError, rules.UserRuleError) as e:
             raise LintConfigError(str(e))
@@ -228,11 +228,11 @@ class LintConfig:
     def _get_option(self, rule_name_or_id, option_name):
         rule = self.rules.find_rule(rule_name_or_id)
         if not rule:
-            raise LintConfigError("No such rule '{0}'".format(rule_name_or_id))
+            raise LintConfigError(f"No such rule '{rule_name_or_id}'")
 
         option = rule.options.get(option_name)
         if not option:
-            raise LintConfigError("Rule '{0}' has no option '{1}'".format(rule_name_or_id, option_name))
+            raise LintConfigError(f"Rule '{rule_name_or_id}' has no option '{option_name}'")
 
         return option
 
@@ -249,14 +249,14 @@ class LintConfig:
         try:
             option.set(option_value)
         except options.RuleOptionError as e:
-            msg = "'{0}' is not a valid value for option '{1}.{2}'. {3}."
-            raise LintConfigError(msg.format(option_value, rule_name_or_id, option_name, e))
+            msg = f"'{option_value}' is not a valid value for option '{rule_name_or_id}.{option_name}'. {e}."
+            raise LintConfigError(msg)
 
     def set_general_option(self, option_name, option_value):
         attr_name = option_name.replace("-", "_")
         # only allow setting general options that exist and don't start with an underscore
         if not hasattr(self, attr_name) or attr_name[0] == "_":
-            raise LintConfigError("'{0}' is not a valid gitlint option".format(option_name))
+            raise LintConfigError(f"'{option_name}' is not a valid gitlint option")
 
         # else:
         setattr(self, attr_name, option_value)
@@ -280,21 +280,21 @@ class LintConfig:
 
     def __str__(self):
         # config-path is not a user exposed variable, so don't print it under the general section
-        return_str = "config-path: {0}\n".format(self._config_path)
-        return_str += "[GENERAL]\n"
-        return_str += "extra-path: {0}\n".format(self.extra_path)
-        return_str += "contrib: {0}\n".format(self.contrib)
+        return_str = f"config-path: {self._config_path}\n"
+        return_str += f"[GENERAL]\n"
+        return_str += f"extra-path: {self.extra_path}\n"
+        return_str += f"contrib: {self.contrib}\n"
         return_str += "ignore: {0}\n".format(",".join(self.ignore))
-        return_str += "ignore-merge-commits: {0}\n".format(self.ignore_merge_commits)
-        return_str += "ignore-fixup-commits: {0}\n".format(self.ignore_fixup_commits)
-        return_str += "ignore-squash-commits: {0}\n".format(self.ignore_squash_commits)
-        return_str += "ignore-revert-commits: {0}\n".format(self.ignore_revert_commits)
-        return_str += "ignore-stdin: {0}\n".format(self.ignore_stdin)
-        return_str += "staged: {0}\n".format(self.staged)
-        return_str += "verbosity: {0}\n".format(self.verbosity)
-        return_str += "debug: {0}\n".format(self.debug)
-        return_str += "target: {0}\n".format(self.target)
-        return_str += "[RULES]\n{0}".format(self.rules)
+        return_str += f"ignore-merge-commits: {self.ignore_merge_commits}\n"
+        return_str += f"ignore-fixup-commits: {self.ignore_fixup_commits}\n"
+        return_str += f"ignore-squash-commits: {self.ignore_squash_commits}\n"
+        return_str += f"ignore-revert-commits: {self.ignore_revert_commits}\n"
+        return_str += f"ignore-stdin: {self.ignore_stdin}\n"
+        return_str += f"staged: {self.staged}\n"
+        return_str += f"verbosity: {self.verbosity}\n"
+        return_str += f"debug: {self.debug}\n"
+        return_str += f"target: {self.target}\n"
+        return_str += f"[RULES]\n{self.rules}"
         return return_str
 
 
@@ -359,7 +359,7 @@ class RuleCollection:
     def __unicode__(self):
         return_str = ""
         for rule in self._rules.values():
-            return_str += "  {0}: {1}\n".format(rule.id, rule.name)
+            return_str += f"  {rule.id}: {rule.name}\n"
             for option_name, option_value in sorted(rule.options.items()):
                 if option_value.value is None:
                     option_val_repr = None
@@ -369,7 +369,7 @@ class RuleCollection:
                     option_val_repr = option_value.value.pattern
                 else:
                     option_val_repr = option_value.value
-                return_str += "     {0}={1}\n".format(option_name, option_val_repr)
+                return_str += f"     {option_name}={option_val_repr}\n"
         return return_str
 
 
@@ -414,12 +414,12 @@ class LintConfigBuilder:
                 self.set_option(rule_name, option_name, option_value)
             except ValueError:  # raised if the config string is invalid
                 raise LintConfigError(
-                    "'{0}' is an invalid configuration option. Use '<rule>.<option>=<value>'".format(config_option))
+                    f"'{config_option}' is an invalid configuration option. Use '<rule>.<option>=<value>'")
 
     def set_from_config_file(self, filename):
         """ Loads lint config from a ini-style config file """
         if not os.path.exists(filename):
-            raise LintConfigError("Invalid file path: {0}".format(filename))
+            raise LintConfigError(f"Invalid file path: {filename}")
         self._config_path = os.path.realpath(filename)
         try:
             parser = ConfigParser()
@@ -449,14 +449,14 @@ class LintConfigBuilder:
         # - not empty
         # - no whitespace or colons
         if rule_name == "" or bool(re.search("\\s|:", rule_name, re.UNICODE)):
-            msg = "The rule-name part in '{0}' cannot contain whitespace, colons or be empty"
-            raise LintConfigError(msg.format(qualified_rule_name))
+            msg = f"The rule-name part in '{qualified_rule_name}' cannot contain whitespace, colons or be empty"
+            raise LintConfigError(msg)
 
         # find parent rule
         parent_rule = config.rules.find_rule(parent_rule_specifier)
         if not parent_rule:
-            msg = "No such rule '{0}' (named rule: '{1}')"
-            raise LintConfigError(msg.format(parent_rule_specifier, qualified_rule_name))
+            msg = f"No such rule '{parent_rule_specifier}' (named rule: '{qualified_rule_name}')"
+            raise LintConfigError(msg)
 
         # Determine canonical id and name by recombining the parent id/name and instance name parts.
         canonical_id = parent_rule.__class__.id + self.RULE_QUALIFIER_SYMBOL + rule_name
diff --git a/gitlint/git.py b/gitlint/git.py
index 59f1af0..8f239bf 100644
--- a/gitlint/git.py
+++ b/gitlint/git.py
@@ -32,8 +32,7 @@ class GitExitCodeError(GitContextError):
     def __init__(self, command, stderr):
         self.command = command
         self.stderr = stderr
-        super(GitExitCodeError, self).__init__(
-            "An error occurred while executing '{0}': {1}".format(command, stderr))
+        super(GitExitCodeError, self).__init__(f"An error occurred while executing '{command}': {stderr}")
 
 
 def _git(*command_parts, **kwargs):
@@ -55,8 +54,7 @@ def _git(*command_parts, **kwargs):
         error_msg = e.stderr.strip()
         error_msg_lower = error_msg.lower()
         if '_cwd' in git_kwargs and b"not a git repository" in error_msg_lower:
-            error_msg = "{0} is not a git repository.".format(git_kwargs['_cwd'])
-            raise GitContextError(error_msg)
+            raise GitContextError(f"{git_kwargs['_cwd']} is not a git repository.")
 
         if (b"does not have any commits yet" in error_msg_lower or
                 b"ambiguous argument 'head': unknown revision" in error_msg_lower):
@@ -105,7 +103,7 @@ class GitCommitMessage:
     def from_full_message(context, commit_msg_str):
         """  Parses a full git commit message by parsing a given string into the different parts of a commit message """
         all_lines = commit_msg_str.splitlines()
-        cutline = "{0} ------------------------ >8 ------------------------".format(context.commentchar)
+        cutline = f"{context.commentchar} ------------------------ >8 ------------------------"
         try:
             cutline_index = all_lines.index(cutline)
         except ValueError:
diff --git a/gitlint/hooks.py b/gitlint/hooks.py
index f13acf6..aa3766a 100644
--- a/gitlint/hooks.py
+++ b/gitlint/hooks.py
@@ -27,7 +27,7 @@ class GitHookInstaller:
         """ Asserts that a given target directory is a git repository """
         hooks_dir = git_hooks_dir(target)
         if not os.path.isdir(hooks_dir):
-            raise GitHookInstallerError("{0} is not a git repository.".format(target))
+            raise GitHookInstallerError(f"{target} is not a git repository.")
 
     @staticmethod
     def install_commit_msg_hook(lint_config):
@@ -35,7 +35,7 @@ class GitHookInstaller:
         dest_path = GitHookInstaller.commit_msg_hook_path(lint_config)
         if os.path.exists(dest_path):
             raise GitHookInstallerError(
-                "There is already a commit-msg hook file present in {0}.\n".format(dest_path) +
+                f"There is already a commit-msg hook file present in {dest_path}.\n" +
                 "gitlint currently does not support appending to an existing commit-msg file.")
 
         # copy hook file
@@ -49,14 +49,14 @@ class GitHookInstaller:
         GitHookInstaller._assert_git_repo(lint_config.target)
         dest_path = GitHookInstaller.commit_msg_hook_path(lint_config)
         if not os.path.exists(dest_path):
-            raise GitHookInstallerError("There is no commit-msg hook present in {0}.".format(dest_path))
+            raise GitHookInstallerError(f"There is no commit-msg hook present in {dest_path}.")
 
         with io.open(dest_path, encoding=DEFAULT_ENCODING) as fp:
             lines = fp.readlines()
             if len(lines) < 2 or lines[1] != GITLINT_HOOK_IDENTIFIER:
-                msg = "The commit-msg hook in {0} was not installed by gitlint (or it was modified).\n" + \
+                msg = f"The commit-msg hook in {dest_path} was not installed by gitlint (or it was modified).\n" + \
                       "Uninstallation of 3th party or modified gitlint hooks is not supported."
-                raise GitHookInstallerError(msg.format(dest_path))
+                raise GitHookInstallerError(msg)
 
         # If we are sure it's a gitlint hook, go ahead and remove it
         os.remove(dest_path)
diff --git a/gitlint/lint.py b/gitlint/lint.py
index f9e1e1a..4b6c8a3 100644
--- a/gitlint/lint.py
+++ b/gitlint/lint.py
@@ -78,8 +78,8 @@ class GitLinter:
         # Skip linting if this is a special commit type that is configured to be ignored
         ignore_commit_types = ["merge", "squash", "fixup", "revert"]
         for commit_type in ignore_commit_types:
-            if getattr(commit, "is_{0}_commit".format(commit_type)) and \
-               getattr(self.config, "ignore_{0}_commits".format(commit_type)):
+            if getattr(commit, f"is_{commit_type}_commit") and \
+               getattr(self.config, f"ignore_{commit_type}_commits"):
                 return []
 
         violations = []
@@ -98,10 +98,9 @@ class GitLinter:
         """ Print a given set of violations to the standard error output """
         for v in violations:
             line_nr = v.line_nr if v.line_nr else "-"
-            self.display.e("{0}: {1}".format(line_nr, v.rule_id), exact=True)
-            self.display.ee("{0}: {1} {2}".format(line_nr, v.rule_id, v.message), exact=True)
+            self.display.e(f"{line_nr}: {v.rule_id}", exact=True)
+            self.display.ee(f"{line_nr}: {v.rule_id} {v.message}", exact=True)
             if v.content:
-                self.display.eee("{0}: {1} {2}: \"{3}\"".format(line_nr, v.rule_id, v.message, v.content),
-                                 exact=True)
+                self.display.eee(f"{line_nr}: {v.rule_id} {v.message}: \"{v.content}\"", exact=True)
             else:
-                self.display.eee("{0}: {1} {2}".format(line_nr, v.rule_id, v.message), exact=True)
+                self.display.eee(f"{line_nr}: {v.rule_id} {v.message}", exact=True)
diff --git a/gitlint/options.py b/gitlint/options.py
index a4981bc..f9e1071 100644
--- a/gitlint/options.py
+++ b/gitlint/options.py
@@ -41,7 +41,7 @@ class RuleOption:
         return self  # pragma: no cover
 
     def __unicode__(self):
-        return "({0}: {1} ({2}))".format(self.name, self.value, self.description)  # pragma: no cover
+        return f"({self.name}: {self.value} ({self.description}))"  # pragma: no cover
 
     def __repr__(self):
         return self.__str__()  # pragma: no cover
@@ -63,9 +63,9 @@ class IntOption(RuleOption):
 
     def _raise_exception(self, value):
         if self.allow_negative:
-            error_msg = "Option '{0}' must be an integer (current value: '{1}')".format(self.name, value)
+            error_msg = f"Option '{self.name}' must be an integer (current value: '{value}')"
         else:
-            error_msg = "Option '{0}' must be a positive integer (current value: '{1}')".format(self.name, value)
+            error_msg = f"Option '{self.name}' must be a positive integer (current value: '{value}')"
         raise RuleOptionError(error_msg)
 
     @allow_none
@@ -85,7 +85,7 @@ class BoolOption(RuleOption):
     def set(self, value):
         value = str(value).strip().lower()
         if value not in ['true', 'false']:
-            raise RuleOptionError("Option '{0}' must be either 'true' or 'false'".format(self.name))
+            raise RuleOptionError(f"Option '{self.name}' must be either 'true' or 'false'")
         self.value = value == 'true'
 
 
@@ -118,17 +118,16 @@ class PathOption(RuleOption):
 
         if self.type == 'dir':
             if not os.path.isdir(value):
-                error_msg = "Option {0} must be an existing directory (current value: '{1}')".format(self.name, value)
+                error_msg = f"Option {self.name} must be an existing directory (current value: '{value}')"
         elif self.type == 'file':
             if not os.path.isfile(value):
-                error_msg = "Option {0} must be an existing file (current value: '{1}')".format(self.name, value)
+                error_msg = f"Option {self.name} must be an existing file (current value: '{value}')"
         elif self.type == 'both':
             if not os.path.isdir(value) and not os.path.isfile(value):
-                error_msg = ("Option {0} must be either an existing directory or file "
-                             "(current value: '{1}')").format(self.name, value)
+                error_msg = (f"Option {self.name} must be either an existing directory or file "
+                             f"(current value: '{value}')")
         else:
-            error_msg = "Option {0} type must be one of: 'file', 'dir', 'both' (current: '{1}')".format(self.name,
-                                                                                                        self.type)
+            error_msg = f"Option {self.name} type must be one of: 'file', 'dir', 'both' (current: '{self.type}')"
 
         if error_msg:
             raise RuleOptionError(error_msg)
@@ -143,7 +142,7 @@ class RegexOption(RuleOption):
         try:
             self.value = re.compile(value, re.UNICODE)
         except (re.error, TypeError) as exc:
-            raise RuleOptionError("Invalid regular expression: '{0}'".format(exc))
+            raise RuleOptionError(f"Invalid regular expression: '{exc}'")
 
     def __deepcopy__(self, _):
         # copy.deepcopy() - used in rules.py - doesn't support copying regex objects prior to Python 3.7
diff --git a/gitlint/rule_finder.py b/gitlint/rule_finder.py
index c1528df..e1c5e77 100644
--- a/gitlint/rule_finder.py
+++ b/gitlint/rule_finder.py
@@ -27,7 +27,7 @@ def find_rule_classes(extra_path):
         files = os.listdir(extra_path)
         directory = extra_path
     else:
-        raise rules.UserRuleError("Invalid extra-path: {0}".format(extra_path))
+        raise rules.UserRuleError(f"Invalid extra-path: {extra_path}")
 
     # Filter out files that are not python modules
     for filename in files:
@@ -55,7 +55,7 @@ def find_rule_classes(extra_path):
             importlib.import_module(module)
 
         except Exception as e:
-            raise rules.UserRuleError("Error while importing extra-path module '{0}': {1}".format(module, e))
+            raise rules.UserRuleError(f"Error while importing extra-path module '{module}': {e}")
 
         # Find all rule classes in the module. We do this my inspecting all members of the module and checking
         # 1) is it a class, if not, skip
@@ -93,55 +93,53 @@ def assert_valid_rule_class(clazz, rule_type="User-defined"):  # pylint: disable
     # Rules must extend from LineRule, CommitRule or ConfigurationRule
     if not (issubclass(clazz, rules.LineRule) or issubclass(clazz, rules.CommitRule)
             or issubclass(clazz, rules.ConfigurationRule)):
-        msg = "{0} rule class '{1}' must extend from {2}.{3}, {2}.{4} or {2}.{5}"
-        raise rules.UserRuleError(msg.format(rule_type, clazz.__name__, rules.CommitRule.__module__,
-                                             rules.LineRule.__name__, rules.CommitRule.__name__,
-                                             rules.ConfigurationRule.__name__))
+        msg = f"{rule_type} rule class '{clazz.__name__}' " + \
+              f"must extend from {rules.CommitRule.__module__}.{rules.LineRule.__name__}, " + \
+              f"{rules.CommitRule.__module__}.{rules.CommitRule.__name__} or " + \
+              f"{rules.CommitRule.__module__}.{rules.ConfigurationRule.__name__}"
+        raise rules.UserRuleError(msg)
 
     # Rules must have an id attribute
     if not hasattr(clazz, 'id') or clazz.id is None or not clazz.id:
-        msg = "{0} rule class '{1}' must have an 'id' attribute"
-        raise rules.UserRuleError(msg.format(rule_type, clazz.__name__))
+        raise rules.UserRuleError(f"{rule_type} rule class '{clazz.__name__}' must have an 'id' attribute")
 
     # Rule id's cannot start with gitlint reserved letters
     if clazz.id[0].upper() in ['R', 'T', 'B', 'M', 'I']:
-        msg = "The id '{1}' of '{0}' is invalid. Gitlint reserves ids starting with R,T,B,M,I"
-        raise rules.UserRuleError(msg.format(clazz.__name__, clazz.id[0]))
+        msg = f"The id '{clazz.id[0]}' of '{clazz.__name__}' is invalid. Gitlint reserves ids starting with R,T,B,M,I"
+        raise rules.UserRuleError(msg)
 
     # Rules must have a name attribute
     if not hasattr(clazz, 'name') or clazz.name is None or not clazz.name:
-        msg = "{0} rule class '{1}' must have a 'name' attribute"
-        raise rules.UserRuleError(msg.format(rule_type, clazz.__name__))
+        raise rules.UserRuleError(f"{rule_type} rule class '{clazz.__name__}' must have a 'name' attribute")
 
     # if set, options_spec must be a list of RuleOption
     if not isinstance(clazz.options_spec, list):
-        msg = "The options_spec attribute of {0} rule class '{1}' must be a list of {2}.{3}"
-        raise rules.UserRuleError(msg.format(rule_type.lower(), clazz.__name__,
-                                             options.RuleOption.__module__, options.RuleOption.__name__))
+        msg = f"The options_spec attribute of {rule_type.lower()} rule class '{clazz.__name__}' " + \
+              f"must be a list of {options.RuleOption.__module__}.{options.RuleOption.__name__}"
+        raise rules.UserRuleError(msg)
 
     # check that all items in options_spec are actual gitlint options
     for option in clazz.options_spec:
         if not isinstance(option, options.RuleOption):
-            msg = "The options_spec attribute of {0} rule class '{1}' must be a list of {2}.{3}"
-            raise rules.UserRuleError(msg.format(rule_type.lower(), clazz.__name__,
-                                                 options.RuleOption.__module__, options.RuleOption.__name__))
+            msg = f"The options_spec attribute of {rule_type.lower()} rule class '{clazz.__name__}' " + \
+                  f"must be a list of {options.RuleOption.__module__}.{options.RuleOption.__name__}"
+            raise rules.UserRuleError(msg)
 
     # Line/Commit rules must have a `validate` method
     # We use isroutine() as it's both python 2 and 3 compatible. Details: http://stackoverflow.com/a/17019998/381010
     if (issubclass(clazz, rules.LineRule) or issubclass(clazz, rules.CommitRule)):
         if not hasattr(clazz, 'validate') or not inspect.isroutine(clazz.validate):
-            msg = "{0} rule class '{1}' must have a 'validate' method"
-            raise rules.UserRuleError(msg.format(rule_type, clazz.__name__))
+            raise rules.UserRuleError(f"{rule_type} rule class '{clazz.__name__}' must have a 'validate' method")
     # Configuration rules must have an `apply` method
     elif issubclass(clazz, rules.ConfigurationRule):
         if not hasattr(clazz, 'apply') or not inspect.isroutine(clazz.apply):
-            msg = "{0} Configuration rule class '{1}' must have an 'apply' method"
-            raise rules.UserRuleError(msg.format(rule_type, clazz.__name__))
+            msg = f"{rule_type} Configuration rule class '{clazz.__name__}' must have an 'apply' method"
+            raise rules.UserRuleError(msg)
 
     # LineRules must have a valid target: rules.CommitMessageTitle or rules.CommitMessageBody
     if issubclass(clazz, rules.LineRule):
         if clazz.target not in [rules.CommitMessageTitle, rules.CommitMessageBody]:
-            msg = "The target attribute of the {0} LineRule class '{1}' must be either {2}.{3} or {2}.{4}"
-            msg = msg.format(rule_type.lower(), clazz.__name__, rules.CommitMessageTitle.__module__,
-                             rules.CommitMessageTitle.__name__, rules.CommitMessageBody.__name__)
+            msg = f"The target attribute of the {rule_type.lower()} LineRule class '{clazz.__name__}' " + \
+                  f"must be either {rules.CommitMessageTitle.__module__}.{rules.CommitMessageTitle.__name__} " + \
+                  f"or {rules.CommitMessageTitle.__module__}.{rules.CommitMessageBody.__name__}"
             raise rules.UserRuleError(msg)
diff --git a/gitlint/rules.py b/gitlint/rules.py
index e944ce0..32e0327 100644
--- a/gitlint/rules.py
+++ b/gitlint/rules.py
@@ -39,7 +39,7 @@ class Rule:
         return self  # pragma: no cover
 
     def __unicode__(self):
-        return "{0} {1}".format(self.id, self.name)  # pragma: no cover
+        return f"{self.id} {self.name}"  # pragma: no cover
 
     def __repr__(self):
         return self.__str__()  # pragma: no cover
@@ -96,8 +96,7 @@ class RuleViolation:
         return self  # pragma: no cover
 
     def __unicode__(self):
-        return f"{0}: {1} {2}: \"{3}\"".format(self.line_nr, self.rule_id, self.message,
-                                               self.content)  # pragma: no cover
+        return f"{self.line_nr}: {self.rule_id} {self.message}: \"{self.content}\""  # pragma: no cover
 
     def __repr__(self):
         return self.__unicode__()  # pragma: no cover
@@ -195,7 +194,7 @@ class TitleTrailingPunctuation(LineRule):
         punctuation_marks = '?:!.,;'
         for punctuation_mark in punctuation_marks:
             if title.endswith(punctuation_mark):
-                return [RuleViolation(self.id, "Title has trailing punctuation ({0})".format(punctuation_mark), title)]
+                return [RuleViolation(self.id, f"Title has trailing punctuation ({punctuation_mark})", title)]
 
 
 class TitleHardTab(HardTab):
@@ -232,7 +231,7 @@ class TitleRegexMatches(LineRule):
             return
 
         if not self.options['regex'].value.search(title):
-            violation_msg = "Title does not match regex ({0})".format(self.options['regex'].value.pattern)
+            violation_msg = f"Title does not match regex ({self.options['regex'].value.pattern})"
             return [RuleViolation(self.id, violation_msg, title)]
 
 
@@ -246,7 +245,7 @@ class TitleMinLength(LineRule):
         min_length = self.options['min-length'].value
         actual_length = len(title)
         if actual_length < min_length:
-            violation_message = "Title is too short ({0}<{1})".format(actual_length, min_length)
+            violation_message = f"Title is too short ({actual_length}<{min_length})"
             return [RuleViolation(self.id, violation_message, title, 1)]
 
 
@@ -289,7 +288,7 @@ class BodyMinLength(CommitRule):
         body_message_no_newline = "".join([line for line in commit.message.body if line is not None])
         actual_length = len(body_message_no_newline)
         if 0 < actual_length < min_length:
-            violation_message = "Body message is too short ({0}<{1})".format(actual_length, min_length)
+            violation_message = f"Body message is too short ({actual_length}<{min_length})"
             return [RuleViolation(self.id, violation_message, body_message_no_newline, 3)]
 
 
@@ -318,7 +317,7 @@ class BodyChangedFileMention(CommitRule):
             # in the commit msg body
             if needs_mentioned_file in commit.changed_files:
                 if needs_mentioned_file not in " ".join(commit.message.body):
-                    violation_message = "Body does not mention changed file '{0}'".format(needs_mentioned_file)
+                    violation_message = f"Body does not mention changed file '{needs_mentioned_file}'"
                     violations.append(RuleViolation(self.id, violation_message, None, len(commit.message.body) + 1))
         return violations if violations else None
 
@@ -347,7 +346,7 @@ class BodyRegexMatches(CommitRule):
         full_body = "\n".join(body_lines)
 
         if not self.options['regex'].value.search(full_body):
-            violation_msg = "Body does not match regex ({0})".format(self.options['regex'].value.pattern)
+            violation_msg = f"Body does not match regex ({self.options['regex'].value.pattern})"
             return [RuleViolation(self.id, violation_msg, None, len(commit.message.body) + 1)]
 
 
@@ -379,9 +378,8 @@ class IgnoreByTitle(ConfigurationRule):
         if self.options['regex'].value.match(commit.message.title):
             config.ignore = self.options['ignore'].value
 
-            message = "Commit title '{0}' matches the regex '{1}', ignoring rules: {2}"
-            message = message.format(commit.message.title, self.options['regex'].value.pattern,
-                                     self.options['ignore'].value)
+            message = f"Commit title '{commit.message.title}' matches the regex " + \
+                      f"'{self.options['regex'].value.pattern}', ignoring rules: {self.options['ignore'].value}"
 
             self.log.debug("Ignoring commit because of rule '%s': %s", self.id, message)
 
@@ -401,8 +399,8 @@ class IgnoreByBody(ConfigurationRule):
             if self.options['regex'].value.match(line):
                 config.ignore = self.options['ignore'].value
 
-                message = "Commit message line '{0}' matches the regex '{1}', ignoring rules: {2}"
-                message = message.format(line, self.options['regex'].value.pattern, self.options['ignore'].value)
+                message = f"Commit message line '{line}' matches the regex '{self.options['regex'].value.pattern}'," + \
+                          f" ignoring rules: {self.options['ignore'].value}"
 
                 self.log.debug("Ignoring commit because of rule '%s': %s", self.id, message)
                 # No need to check other lines if we found a match
diff --git a/gitlint/tests/base.py b/gitlint/tests/base.py
index 111ba3d..cc92a92 100644
--- a/gitlint/tests/base.py
+++ b/gitlint/tests/base.py
@@ -135,15 +135,15 @@ class BaseTestCase(unittest.TestCase):
         except expected_exception as exc:
             exception_msg = str(exc)
             if exception_msg != expected_msg:
-                error = "Right exception, wrong message:\n      got: {0}\n expected: {1}"
-                raise self.fail(error.format(exception_msg, expected_msg))
+                error = f"Right exception, wrong message:\n      got: {exception_msg}\n expected: {expected_msg}"
+                raise self.fail(error)
             # else: everything is fine, just return
             return
         except Exception as exc:
-            raise self.fail("Expected '{0}' got '{1}'".format(expected_exception.__name__, exc.__class__.__name__))
+            raise self.fail(f"Expected '{expected_exception.__name__}' got '{exc.__class__.__name__}'")
 
         # No exception raised while we expected one
-        raise self.fail("Expected to raise {0}, didn't get an exception at all".format(expected_exception.__name__))
+        raise self.fail(f"Expected to raise {expected_exception.__name__}, didn't get an exception at all")
 
     def object_equality_test(self, obj, attr_list, ctor_kwargs=None):
         """ Helper function to easily implement object equality tests.
diff --git a/gitlint/tests/cli/test_cli.py b/gitlint/tests/cli/test_cli.py
index cf738d6..5283071 100644
--- a/gitlint/tests/cli/test_cli.py
+++ b/gitlint/tests/cli/test_cli.py
@@ -49,7 +49,7 @@ class CLITests(BaseTestCase):
     def test_version(self):
         """ Test for --version option """
         result = self.cli.invoke(cli.cli, ["--version"])
-        self.assertEqual(result.output.split("\n")[0], "cli, version {0}".format(__version__))
+        self.assertEqual(result.output.split("\n")[0], f"cli, version {__version__}")
 
     @patch('gitlint.cli.get_stdin_data', return_value=False)
     @patch('gitlint.git.sh')
@@ -428,16 +428,14 @@ class CLITests(BaseTestCase):
         # Directory as config file
         config_path = self.get_sample_path("config")
         result = self.cli.invoke(cli.cli, ["--config", config_path])
-        expected_string = "Error: Invalid value for \"-C\" / \"--config\": File \"{0}\" is a directory.".format(
-            config_path)
+        expected_string = f"Error: Invalid value for \"-C\" / \"--config\": File \"{config_path}\" is a directory."
         self.assertEqual(result.output.split("\n")[3], expected_string)
         self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE)
 
         # Non existing file
         config_path = self.get_sample_path("föo")
         result = self.cli.invoke(cli.cli, ["--config", config_path])
-        expected_string = "Error: Invalid value for \"-C\" / \"--config\": File \"{0}\" does not exist.".format(
-            config_path)
+        expected_string = f"Error: Invalid value for \"-C\" / \"--config\": File \"{config_path}\" does not exist."
         self.assertEqual(result.output.split("\n")[3], expected_string)
         self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE)
 
@@ -470,7 +468,7 @@ class CLITests(BaseTestCase):
         target_path = self.get_sample_path(os.path.join("config", "gitlintconfig"))
         result = self.cli.invoke(cli.cli, ["--target", target_path])
         self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE)
-        expected_msg = "Error: Invalid value for \"--target\": Directory \"{0}\" is a file.".format(target_path)
+        expected_msg = f"Error: Invalid value for \"--target\": Directory \"{target_path}\" is a file."
         self.assertEqual(result.output.split("\n")[3], expected_msg)
 
     @patch('gitlint.config.LintConfigGenerator.generate_config')
@@ -479,7 +477,7 @@ class CLITests(BaseTestCase):
         result = self.cli.invoke(cli.cli, ["generate-config"], input="tëstfile\n")
         self.assertEqual(result.exit_code, 0)
         expected_msg = "Please specify a location for the sample gitlint config file [.gitlint]: tëstfile\n" + \
-                       "Successfully generated {0}\n".format(os.path.realpath("tëstfile"))
+                       f"Successfully generated {os.path.realpath('tëstfile')}\n"
         self.assertEqual(result.output, expected_msg)
         generate_config.assert_called_once_with(os.path.realpath("tëstfile"))
 
@@ -490,8 +488,8 @@ class CLITests(BaseTestCase):
         fake_path = os.path.join(fake_dir, "bar")
         result = self.cli.invoke(cli.cli, ["generate-config"], input=fake_path)
         self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE)
-        expected_msg = ("Please specify a location for the sample gitlint config file [.gitlint]: {0}\n"
-                        + "Error: Directory '{1}' does not exist.\n").format(fake_path, fake_dir)
+        expected_msg = f"Please specify a location for the sample gitlint config file [.gitlint]: {fake_path}\n" + \
+                       f"Error: Directory '{fake_dir}' does not exist.\n"
         self.assertEqual(result.output, expected_msg)
 
         # Existing file
@@ -499,8 +497,8 @@ class CLITests(BaseTestCase):
         result = self.cli.invoke(cli.cli, ["generate-config"], input=sample_path)
         self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE)
         expected_msg = "Please specify a location for the sample gitlint " + \
-                       "config file [.gitlint]: {0}\n".format(sample_path) + \
-                       "Error: File \"{0}\" already exists.\n".format(sample_path)
+                       f"config file [.gitlint]: {sample_path}\n" + \
+                       f"Error: File \"{sample_path}\" already exists.\n"
         self.assertEqual(result.output, expected_msg)
 
     @patch('gitlint.cli.get_stdin_data', return_value=False)
diff --git a/gitlint/tests/cli/test_cli_hooks.py b/gitlint/tests/cli/test_cli_hooks.py
index 8abd7fa..6d6d2ef 100644
--- a/gitlint/tests/cli/test_cli_hooks.py
+++ b/gitlint/tests/cli/test_cli_hooks.py
@@ -39,7 +39,7 @@ class CLIHookTests(BaseTestCase):
         """ Test for install-hook subcommand """
         result = self.cli.invoke(cli.cli, ["install-hook"])
         expected_path = os.path.join("/hür", "dur", hooks.COMMIT_MSG_HOOK_DST_PATH)
-        expected = "Successfully installed gitlint commit-msg hook in {0}\n".format(expected_path)
+        expected = f"Successfully installed gitlint commit-msg hook in {expected_path}\n"
         self.assertEqual(result.output, expected)
         self.assertEqual(result.exit_code, 0)
         expected_config = config.LintConfig()
@@ -77,7 +77,7 @@ class CLIHookTests(BaseTestCase):
         """ Test for uninstall-hook subcommand """
         result = self.cli.invoke(cli.cli, ["uninstall-hook"])
         expected_path = os.path.join("/hür", "dur", hooks.COMMIT_MSG_HOOK_DST_PATH)
-        expected = "Successfully uninstalled gitlint commit-msg hook from {0}\n".format(expected_path)
+        expected = f"Successfully uninstalled gitlint commit-msg hook from {expected_path}\n"
         self.assertEqual(result.exit_code, 0)
         self.assertEqual(result.output, expected)
         expected_config = config.LintConfig()
@@ -151,8 +151,7 @@ class CLIHookTests(BaseTestCase):
 
                         shell.assert_called_with(expected_editors[i] + " " + msg_filename)
                         self.assert_log_contains("DEBUG: gitlint.cli run-hook: editing commit message")
-                        self.assert_log_contains("DEBUG: gitlint.cli run-hook: {0} {1}".format(expected_editors[i],
-                                                                                               msg_filename))
+                        self.assert_log_contains(f"DEBUG: gitlint.cli run-hook: {expected_editors[i]} {msg_filename}")
 
     def test_hook_no(self):
         """ Test for run-hook subcommand, answering 'n(o)' after commit-hook """
diff --git a/gitlint/tests/config/test_config.py b/gitlint/tests/config/test_config.py
index a7e3845..93e35de 100644
--- a/gitlint/tests/config/test_config.py
+++ b/gitlint/tests/config/test_config.py
@@ -203,7 +203,7 @@ class LintConfigTests(BaseTestCase):
         # invalid verbosity
         incorrect_values = [-1, "föo"]
         for value in incorrect_values:
-            expected_msg = "Option 'verbosity' must be a positive integer (current value: '{0}')".format(value)
+            expected_msg = f"Option 'verbosity' must be a positive integer (current value: '{value}')"
             with self.assertRaisesMessage(LintConfigError, expected_msg):
                 config.verbosity = value
 
@@ -220,7 +220,7 @@ class LintConfigTests(BaseTestCase):
             for value in incorrect_values:
                 option_name = attribute.replace("_", "-")
                 with self.assertRaisesMessage(LintConfigError,
-                                              "Option '{0}' must be either 'true' or 'false'".format(option_name)):
+                                              f"Option '{option_name}' must be either 'true' or 'false'"):
                     setattr(config, attribute, value)
 
         # invalid ignore -> not here because ignore is a ListOption which converts everything to a string before
@@ -230,7 +230,7 @@ class LintConfigTests(BaseTestCase):
         for attribute in ['debug', 'staged', 'ignore_stdin']:
             option_name = attribute.replace("_", "-")
             with self.assertRaisesMessage(LintConfigError,
-                                          "Option '{0}' must be either 'true' or 'false'".format(option_name)):
+                                          f"Option '{option_name}' must be either 'true' or 'false'"):
                 setattr(config, attribute, "föobar")
 
         # extra-path has its own negative test
diff --git a/gitlint/tests/config/test_config_builder.py b/gitlint/tests/config/test_config_builder.py
index 069e7a1..e0d7f9b 100644
--- a/gitlint/tests/config/test_config_builder.py
+++ b/gitlint/tests/config/test_config_builder.py
@@ -90,7 +90,7 @@ class LintConfigBuilderTests(BaseTestCase):
 
         # bad config file load
         foo_path = self.get_sample_path("föo")
-        expected_error_msg = "Invalid file path: {0}".format(foo_path)
+        expected_error_msg = f"Invalid file path: {foo_path}"
         with self.assertRaisesMessage(LintConfigError, expected_error_msg):
             config_builder.set_from_config_file(foo_path)
 
@@ -246,9 +246,9 @@ class LintConfigBuilderTests(BaseTestCase):
         # Invalid rule name
         for invalid_name in ["", " ", "    ", "\t", "\n", "å b", "å:b", "åb:", ":åb"]:
             config_builder = LintConfigBuilder()
-            config_builder.set_option("T7:{0}".format(invalid_name), 'regex', "tëst")
-            expected_msg = "The rule-name part in 'T7:{0}' cannot contain whitespace, colons or be empty"
-            with self.assertRaisesMessage(LintConfigError, expected_msg.format(invalid_name)):
+            config_builder.set_option(f"T7:{invalid_name}", 'regex', "tëst")
+            expected_msg = f"The rule-name part in 'T7:{invalid_name}' cannot contain whitespace, colons or be empty"
+            with self.assertRaisesMessage(LintConfigError, expected_msg):
                 config_builder.build()
 
         # Invalid parent rule name
diff --git a/gitlint/tests/contrib/test_contrib_rules.py b/gitlint/tests/contrib/test_contrib_rules.py
index 9c6419d..8ab6539 100644
--- a/gitlint/tests/contrib/test_contrib_rules.py
+++ b/gitlint/tests/contrib/test_contrib_rules.py
@@ -24,8 +24,7 @@ class ContribRuleTests(BaseTestCase):
             if filename.endswith(".py") and filename not in ["__init__.py"]:
                 expected_test_file = "test_" + filename
                 error_msg = "Every Contrib Rule must have associated tests. " + \
-                            "Expected test file {0} not found.".format(os.path.join(contrib_tests_dir,
-                                                                                    expected_test_file))
+                            f"Expected test file {os.path.join(contrib_tests_dir, expected_test_file)} not found."
                 self.assertIn(expected_test_file, contrib_test_files, error_msg)
 
     def test_contrib_rule_naming_conventions(self):
diff --git a/gitlint/tests/git/test_git.py b/gitlint/tests/git/test_git.py
index 81f0fd5..7b9b7c6 100644
--- a/gitlint/tests/git/test_git.py
+++ b/gitlint/tests/git/test_git.py
@@ -44,7 +44,7 @@ class GitTests(BaseTestCase):
         err = b"fatal: Random git error"
         sh.git.side_effect = ErrorReturnCode("git log -1 --pretty=%H", b"", err)
 
-        expected_msg = "An error occurred while executing 'git log -1 --pretty=%H': {0}".format(err)
+        expected_msg = f"An error occurred while executing 'git log -1 --pretty=%H': {err}"
         with self.assertRaisesMessage(GitContextError, expected_msg):
             GitContext.from_local_repository("fåke/path")
 
diff --git a/gitlint/tests/git/test_git_commit.py b/gitlint/tests/git/test_git_commit.py
index da93c4a..6bb545a 100644
--- a/gitlint/tests/git/test_git_commit.py
+++ b/gitlint/tests/git/test_git_commit.py
@@ -189,7 +189,7 @@ class GitCommitTests(BaseTestCase):
             sh.git.side_effect = [
                 sample_sha,
                 "test åuthor\x00test-emåil@foo.com\x002016-12-03 15:28:15 +0100\x00åbc\n"
-                "{0}! \"foo bår commit\"".format(commit_type),
+                f"{commit_type}! \"foo bår commit\"",
                 "#",  # git config --get core.commentchar
                 "file1.txt\npåth/to/file2.txt\n",
                 "foöbar\n* hürdur\n"
@@ -212,7 +212,7 @@ class GitCommitTests(BaseTestCase):
             last_commit = context.commits[-1]
             self.assertIsInstance(last_commit, LocalGitCommit)
             self.assertEqual(last_commit.sha, sample_sha)
-            self.assertEqual(last_commit.message.title, "{0}! \"foo bår commit\"".format(commit_type))
+            self.assertEqual(last_commit.message.title, f"{commit_type}! \"foo bår commit\"")
             self.assertEqual(last_commit.message.body, [])
             self.assertEqual(last_commit.author_name, "test åuthor")
             self.assertEqual(last_commit.author_email, "test-emåil@foo.com")
@@ -396,7 +396,7 @@ class GitCommitTests(BaseTestCase):
     def test_from_commit_msg_fixup_squash_commit(self):
         commit_types = ["fixup", "squash"]
         for commit_type in commit_types:
-            commit_msg = "{0}! Test message".format(commit_type)
+            commit_msg = f"{commit_type}! Test message"
             gitcontext = GitContext.from_commit_msg(commit_msg)
             commit = gitcontext.commits[-1]
 
diff --git a/gitlint/tests/rules/test_title_rules.py b/gitlint/tests/rules/test_title_rules.py
index 8d8d756..e1be857 100644
--- a/gitlint/tests/rules/test_title_rules.py
+++ b/gitlint/tests/rules/test_title_rules.py
@@ -68,7 +68,7 @@ class TitleRuleTests(BaseTestCase):
         for char in punctuation:
             line = "This is å test" + char  # note that make sure to include some unicode!
             gitcontext = self.gitcontext(line)
-            expected_violation = RuleViolation("T3", "Title has trailing punctuation ({0})".format(char), line)
+            expected_violation = RuleViolation("T3", f"Title has trailing punctuation ({char})", line)
             violations = rule.validate(line, gitcontext)
             self.assertListEqual(violations, [expected_violation])
 
diff --git a/gitlint/tests/rules/test_user_rules.py b/gitlint/tests/rules/test_user_rules.py
index c9de194..510a829 100644
--- a/gitlint/tests/rules/test_user_rules.py
+++ b/gitlint/tests/rules/test_user_rules.py
@@ -159,8 +159,9 @@ class UserRuleTests(BaseTestCase):
             # Rule ids must not start with one of the reserved id letters
             for letter in ["T", "R", "B", "M", "I"]:
                 MyRuleClass.id = letter + "1"
-                expected_msg = "The id '{0}' of 'MyRuleClass' is invalid. Gitlint reserves ids starting with R,T,B,M,I"
-                with self.assertRaisesMessage(UserRuleError, expected_msg.format(letter)):
+                expected_msg = f"The id '{letter}' of 'MyRuleClass' is invalid. " + \
+                               "Gitlint reserves ids starting with R,T,B,M,I"
+                with self.assertRaisesMessage(UserRuleError, expected_msg):
                     assert_valid_rule_class(MyRuleClass)
 
     def test_assert_valid_rule_class_negative_name(self):
diff --git a/gitlint/tests/test_hooks.py b/gitlint/tests/test_hooks.py
index 56f4379..0ce5040 100644
--- a/gitlint/tests/test_hooks.py
+++ b/gitlint/tests/test_hooks.py
@@ -53,7 +53,7 @@ class HookTests(BaseTestCase):
         git_hooks_dir.return_value = os.path.join("/föo", "bar", ".git", "hooks")
         # mock that current dir is not a git repo
         isdir.return_value = False
-        expected_msg = "{0} is not a git repository.".format(lint_config.target)
+        expected_msg = f"{lint_config.target} is not a git repository."
         with self.assertRaisesMessage(GitHookInstallerError, expected_msg):
             GitHookInstaller.install_commit_msg_hook(lint_config)
             isdir.assert_called_with(git_hooks_dir.return_value)
@@ -64,7 +64,7 @@ class HookTests(BaseTestCase):
         isdir.return_value = True
         path_exists.return_value = True
         expected_dst = os.path.join(git_hooks_dir.return_value, COMMIT_MSG_HOOK_DST_PATH)
-        expected_msg = "There is already a commit-msg hook file present in {0}.\n".format(expected_dst) + \
+        expected_msg = f"There is already a commit-msg hook file present in {expected_dst}.\n" + \
                        "gitlint currently does not support appending to an existing commit-msg file."
         with self.assertRaisesMessage(GitHookInstallerError, expected_msg):
             GitHookInstaller.install_commit_msg_hook(lint_config)
@@ -99,7 +99,7 @@ class HookTests(BaseTestCase):
 
         # mock that the current directory is not a git repo
         isdir.return_value = False
-        expected_msg = "{0} is not a git repository.".format(lint_config.target)
+        expected_msg = f"{lint_config.target} is not a git repository."
         with self.assertRaisesMessage(GitHookInstallerError, expected_msg):
             GitHookInstaller.uninstall_commit_msg_hook(lint_config)
             isdir.assert_called_with(git_hooks_dir.return_value)
@@ -110,7 +110,7 @@ class HookTests(BaseTestCase):
         isdir.return_value = True
         path_exists.return_value = False
         expected_dst = os.path.join(git_hooks_dir.return_value, COMMIT_MSG_HOOK_DST_PATH)
-        expected_msg = "There is no commit-msg hook present in {0}.".format(expected_dst)
+        expected_msg = f"There is no commit-msg hook present in {expected_dst}."
         with self.assertRaisesMessage(GitHookInstallerError, expected_msg):
             GitHookInstaller.uninstall_commit_msg_hook(lint_config)
             isdir.assert_called_with(git_hooks_dir.return_value)
@@ -122,7 +122,7 @@ class HookTests(BaseTestCase):
         path_exists.return_value = True
         read_data = "#!/bin/sh\nfoo"
         expected_dst = os.path.join(git_hooks_dir.return_value, COMMIT_MSG_HOOK_DST_PATH)
-        expected_msg = "The commit-msg hook in {0} was not installed by gitlint ".format(expected_dst) + \
+        expected_msg = f"The commit-msg hook in {expected_dst} was not installed by gitlint " + \
                        "(or it was modified).\nUninstallation of 3th party or modified gitlint hooks " + \
                        "is not supported."
         with patch('gitlint.hooks.io.open', mock_open(read_data=read_data), create=True):
diff --git a/gitlint/tests/test_lint.py b/gitlint/tests/test_lint.py
index 9114d95..b743389 100644
--- a/gitlint/tests/test_lint.py
+++ b/gitlint/tests/test_lint.py
@@ -161,7 +161,7 @@ class LintTests(BaseTestCase):
 
     def test_lint_special_commit(self):
         for commit_type in ["merge", "revert", "squash", "fixup"]:
-            commit = self.gitcommit(self.get_sample("commit_message/{0}".format(commit_type)))
+            commit = self.gitcommit(self.get_sample(f"commit_message/{commit_type}"))
             lintconfig = LintConfig()
             linter = GitLinter(lintconfig)
             violations = linter.lint(commit)
@@ -170,7 +170,7 @@ class LintTests(BaseTestCase):
             self.assertListEqual(violations, [])
 
             # Check that we do see violations if we disable 'ignore-merge-commits'
-            setattr(lintconfig, "ignore_{0}_commits".format(commit_type), False)
+            setattr(lintconfig, f"ignore_{commit_type}_commits", False)
             linter = GitLinter(lintconfig)
             violations = linter.lint(commit)
             self.assertTrue(len(violations) > 0)
diff --git a/gitlint/tests/test_options.py b/gitlint/tests/test_options.py
index a1f9b7f..fc3ccc1 100644
--- a/gitlint/tests/test_options.py
+++ b/gitlint/tests/test_options.py
@@ -171,13 +171,13 @@ class RuleOptionTests(BaseTestCase):
 
         # set to non-existing directory
         non_existing_path = os.path.join("/föo", "bar")
-        expected = "Option tëst-directory must be an existing directory (current value: '{0}')"
-        with self.assertRaisesMessage(RuleOptionError, expected.format(non_existing_path)):
+        expected = f"Option tëst-directory must be an existing directory (current value: '{non_existing_path}')"
+        with self.assertRaisesMessage(RuleOptionError, expected):
             option.set(non_existing_path)
 
         # set to a file, should raise exception since option.type = dir
         sample_path = self.get_sample_path(os.path.join("commit_message", "sample1"))
-        expected = "Option tëst-directory must be an existing directory (current value: '{0}')".format(sample_path)
+        expected = f"Option tëst-directory must be an existing directory (current value: '{sample_path}')"
         with self.assertRaisesMessage(RuleOptionError, expected):
             option.set(sample_path)
 
@@ -185,8 +185,7 @@ class RuleOptionTests(BaseTestCase):
         option.type = "file"
         option.set(sample_path)
         self.assertEqual(option.value, sample_path)
-        expected = "Option tëst-directory must be an existing file (current value: '{0}')".format(
-            self.get_sample_path())
+        expected = f"Option tëst-directory must be an existing file (current value: '{self.get_sample_path()}')"
         with self.assertRaisesMessage(RuleOptionError, expected):
             option.set(self.get_sample_path())
 
diff --git a/qa/base.py b/qa/base.py
index 02118d7..2dd2715 100644
--- a/qa/base.py
+++ b/qa/base.py
@@ -57,7 +57,8 @@ class BaseTestCase(TestCase):
 
     @classmethod
     def generate_temp_path(cls):
-        return os.path.realpath("/tmp/gitlint-test-{0}".format(datetime.now().strftime("%Y%m%d-%H%M%S-%f")))
+        timestamp = datetime.now().strftime("%Y%m%d-%H%M%S-%f")
+        return os.path.realpath(f"/tmp/gitlint-test-{timestamp}")
 
     @classmethod
     def create_tmp_git_repo(cls):
diff --git a/qa/samples/user_rules/extra/extra_rules.py b/qa/samples/user_rules/extra/extra_rules.py
index 64c6528..9a0ae6d 100644
--- a/qa/samples/user_rules/extra/extra_rules.py
+++ b/qa/samples/user_rules/extra/extra_rules.py
@@ -11,8 +11,8 @@ class GitContextRule(CommitRule):
 
     def validate(self, commit):
         violations = [
-            RuleViolation(self.id, "GitContext.current_branch: {0}".format(commit.context.current_branch), line_nr=1),
-            RuleViolation(self.id, "GitContext.commentchar: {0}".format(commit.context.commentchar), line_nr=1)
+            RuleViolation(self.id, f"GitContext.current_branch: {commit.context.current_branch}", line_nr=1),
+            RuleViolation(self.id, f"GitContext.commentchar: {commit.context.commentchar}", line_nr=1)
         ]
 
         return violations
@@ -25,8 +25,8 @@ class GitCommitRule(CommitRule):
 
     def validate(self, commit):
         violations = [
-            RuleViolation(self.id, "GitCommit.branches: {0}".format(commit.branches), line_nr=1),
-            RuleViolation(self.id, "GitCommit.custom_prop: {0}".format(commit.custom_prop), line_nr=1),
+            RuleViolation(self.id, f"GitCommit.branches: {commit.branches}", line_nr=1),
+            RuleViolation(self.id, f"GitCommit.custom_prop: {commit.custom_prop}", line_nr=1),
         ]
 
         return violations
@@ -40,7 +40,7 @@ class GitlintConfigurationRule(ConfigurationRule):
     def apply(self, config, commit):
         # We add a line to the commit message body that pulls a value from config, this proves we can modify the body
         # and read the config contents
-        commit.message.body.append("{0} ".format(config.target))  # trailing whitespace deliberate to trigger violation
+        commit.message.body.append(f"{config.target} ")  # trailing whitespace deliberate to trigger violation
 
         # We set a custom property that we access in CommitRule, to prove we can add extra properties to the commit
         commit.custom_prop = "foöbar"
@@ -60,9 +60,9 @@ class ConfigurableCommitRule(CommitRule):
 
     def validate(self, _):
         violations = [
-            RuleViolation(self.id, "int-öption: {0}".format(self.options[u'int-öption'].value), line_nr=1),
-            RuleViolation(self.id, "str-öption: {0}".format(self.options[u'str-öption'].value), line_nr=1),
-            RuleViolation(self.id, "list-öption: {0}".format(self.options[u'list-öption'].value), line_nr=1),
+            RuleViolation(self.id, f"int-öption: {self.options[u'int-öption'].value}", line_nr=1),
+            RuleViolation(self.id, f"str-öption: {self.options[u'str-öption'].value}", line_nr=1),
+            RuleViolation(self.id, f"list-öption: {self.options[u'list-öption'].value}", line_nr=1),
         ]
 
         return violations
diff --git a/qa/test_commits.py b/qa/test_commits.py
index eace0b6..389ad66 100644
--- a/qa/test_commits.py
+++ b/qa/test_commits.py
@@ -45,7 +45,7 @@ class CommitsTests(BaseTestCase):
         self.create_simple_commit("Sïmple title.\n")
         self.create_simple_commit("Sïmple title2.\n")
         commit_sha = self.get_last_commit_hash()
-        refspec = "{0}^...{0}".format(commit_sha)
+        refspec = f"{commit_sha}^...{commit_sha}"
         self.create_simple_commit("Sïmple title3.\n")
         output = gitlint("--commits", refspec, _cwd=self.tmp_git_repo, _tty_in=True, _ok_code=[2])
         expected = ("1: T3 Title has trailing punctuation (.): \"Sïmple title2.\"\n" +
diff --git a/qa/test_gitlint.py b/qa/test_gitlint.py
index 0f17c77..0200d76 100644
--- a/qa/test_gitlint.py
+++ b/qa/test_gitlint.py
@@ -34,14 +34,14 @@ class IntegrationTests(BaseTestCase):
         git("checkout", "-b", "test-branch", _cwd=self.tmp_git_repo)
         git("checkout", "test-branch", _cwd=self.tmp_git_repo)
         commit_title = "Commit on test-brånch with a pretty long title that will cause issues when merging"
-        self.create_simple_commit("{0}\n\nSïmple body".format(commit_title))
+        self.create_simple_commit(f"{commit_title}\n\nSïmple body")
         hash = self.get_last_commit_hash()
 
         # Checkout master and merge the commit
         # We explicitly set the title of the merge commit to the title of the previous commit as this or similar
         # behavior is what many tools do that handle merges (like github, gerrit, etc).
         git("checkout", "master", _cwd=self.tmp_git_repo)
-        git("merge", "--no-ff", "-m", "Merge '{0}'".format(commit_title), hash, _cwd=self.tmp_git_repo)
+        git("merge", "--no-ff", "-m", f"Merge '{commit_title}'", hash, _cwd=self.tmp_git_repo)
 
         # Run gitlint and assert output is empty
         output = gitlint(_cwd=self.tmp_git_repo, _tty_in=True)
@@ -50,8 +50,7 @@ class IntegrationTests(BaseTestCase):
         # Assert that we do see the error if we disable the ignore-merge-commits option
         output = gitlint("-c", "general.ignore-merge-commits=false", _cwd=self.tmp_git_repo, _tty_in=True, _ok_code=[1])
         self.assertEqual(output.exit_code, 1)
-        self.assertEqualStdout(output,
-                               "1: T1 Title exceeds max length (90>72): \"Merge '{0}'\"\n".format(commit_title))
+        self.assertEqualStdout(output, f"1: T1 Title exceeds max length (90>72): \"Merge '{commit_title}'\"\n")
 
     def test_fixup_commit(self):
         # Create a normal commit and assert that it has a violation
diff --git a/qa/test_hooks.py b/qa/test_hooks.py
index 28b47a8..0ad3491 100644
--- a/qa/test_hooks.py
+++ b/qa/test_hooks.py
@@ -50,7 +50,7 @@ class HookTests(BaseTestCase):
         # Ans