commitizen 1.1.0

Python commitizen client tool

Python 3 command line utility to standardize commit messages and bump version

Contents

• About

• Installation

• Features

• Commit rules

• Commitizens

• Commiting

• Usage

• Configuration

• Creating a commiter

• Python 2 support

• Contributing

About

Interactive tool to commit based on established rules (like conventional commits).

It comes with some defaults commit styles, like conventional commits and jira and it’s easily extendable.

It’s useful for teams, because it is possible to standardize the commiting style.

Also includes an automatic version bump system based on semver.

Installation

pip install -U commitizen

poetry add commitizen --dev

Global installation

sudo pip3 install -U commitizen

Features

• Prompt your commit rules to the user

• Display information about your commit rules (schema, example, info)

• Auto bump version based on semver using your rules (currently there is only support for conventionalcommits)

• Future: New documentation

• Future: Autochangelog

Commit rules

This client tool prompts the user with information about the commit.

Based on conventional commits

This is an example of how the git messages history would look like:

BREAKING CHANGE: command send has been removed
fix: minor typos in code
feat: new command update
docs: improved commitizens tab in readme
feat(cz): jira smart commits
refactor(cli): renamed all to ls command
feat: info command for angular
docs(README): added badges
docs(README): added about, installation, creating, etc
feat(config): new loads from ~/.cz and working project .cz .cz.cfg and setup.cfg

Commitizens

These are the available commiting styles by default:

• cz_conventional_commits: conventional commits

• cz_jira: jira smart commits

The installed ones can be checked with:

cz ls

Commiting

Run in your terminal

cz commit

or the shortcut

cz c

Usage

$ cz --help
usage: cz [-h] [--debug] [-n NAME] [--version]
        {ls,commit,c,example,info,schema,bump} ...

Commitizen is a cli tool to generate conventional commits.
For more information about the topic go to https://conventionalcommits.org/

optional arguments:
-h, --help            show this help message and exit
--debug               use debug mode
-n NAME, --name NAME  use the given commitizen
--version             get the version of the installed commitizen

commands:
{ls,commit,c,example,info,schema,bump}
    ls                  show available commitizens
    commit (c)          create new commit
    example             show commit example
    info                show information about the cz
    schema              show commit schema
    bump                bump semantic version based on the git log

Configuration

New!: Support for pyproject.toml

In your pyproject.toml you can add an entry like this:

[tool.commitizen]
name = cz_conventional_commits
version = "0.1.0"
files = [
    "src/__version__.py",
    "pyproject.toml"
]

Also, you can create in your project folder a file called .cz, .cz.cfg or in your setup.cfg or if you want to configure the global default in your user’s home folder a .cz file with the following information:

[commitizen]
name = cz_conventional_commits
version = 0.1.0
files = [
    "src/__version__.py",
    "pyproject.toml"
    ]

The extra tab at the end (]) is required.

Creating a commiter

Create a file starting with cz_ for example cz_jira.py. This prefix is used to detect the plugin. Same method flask uses

Inherit from BaseCommitizen and you must define questions and message. The others are optionals.

from commitizen import BaseCommitizen

class JiraCz(BaseCommitizen):

    def questions(self):
        """Questions regarding the commit message.

        :rtype: list
        """
        questions = [
            {
                'type': 'input',
                'name': 'title',
                'message': 'Commit title'
            },
            {
                'type': 'input',
                'name': 'issue',
                'message': 'Jira Issue number:'
            },
        ]
        return questions

    def message(self, answers):
        """Generate the message with the given answers.

        :type answers: dict
        :rtype: string
        """
        return '{0} (#{1})'.format(answers['title'], answers['issue'])

    def example(self):
        """Provide an example to help understand the style (OPTIONAL)
        Used by cz example.

        :rtype: string
        """
        return 'Problem with user (#321)'

    def schema(self):
        """Show the schema used (OPTIONAL)

        :rtype: string
        """
        return '<title> (<issue>)'

    def info(self):
        """Explanation of the commit rules. (OPTIONAL)
        :rtype: string
        """
        return 'We use this because is useful'


discover_this = JiraCz  # used by the plugin system

The next file required is setup.py modified from flask version

from distutils.core import setup

setup(
    name='JiraCommitizen',
    version='0.1.0',
    py_modules=['cz_jira'],
    license='MIT',
    long_description='this is a long description',
    install_requires=['commitizen']
)

So at the end we would have

.
├── cz_jira.py
└── setup.py

And that’s it, you can install it without uploading to pypi by simply doing pip install . If you feel like it should be part of the repo, create a PR.

Python 2 support

There’s no longer support for python 2. Nor planned suppport.

Contributing

Feel free to create a PR.

1. Clone the repo.

2. Add your modifications

3. Create a virtualenv

4. Run pytest -s --cov-report term-missing --cov=commitizen tests/