diff --git a/PKG-INFO b/PKG-INFO
index 0018406..c80f811 100644
--- a/PKG-INFO
+++ b/PKG-INFO
@@ -1,132 +1,11 @@
 Metadata-Version: 2.1
 Name: click-man
-Version: 0.4.1
+Version: 0.4.2
 Summary: Generate man pages for click based CLI applications
 Home-page: https://github.com/click-contrib/click-man
 Author: Timo Furrer
 Author-email: tuxtimo@gmail.com
 License: MIT
-Description: # click-man
-        
-        [![Build Status](https://travis-ci.org/click-contrib/click-man.svg?branch=master)](https://travis-ci.org/click-contrib/click-man) [![PyPI Package version](https://badge.fury.io/py/click-man.svg)](https://pypi.python.org/pypi/click-man)
-        
-        Create **man pages** for [click](https://github.com/pallets/click) application as easy as this:
-        
-        ```bash
-        python3 setup.py --command-packages=click_man.commands man_pages
-        ```
-        
-        → Checkout the [debian packaging example](https://github.com/timofurrer/click-man#debian-packages)
-        
-        ## What it does
-        
-        *click-man* will generate one man page per command of your click CLI application specified in `console_scripts` in your `setup.py`.
-        
-        ## Installation
-        
-        ```bash
-        pip3 install click-man
-        ```
-        
-        **click-man** is also available for Python 2:
-        
-        ```bash
-        pip install click-man
-        ```
-        
-        ## Usage Recipes
-        
-        The following sections describe different usage example for *click-man*.
-        
-        ### Use with a previously installed package
-        
-        **click-man** provides its own command line tool which can be passed the name of
-        an installed script:
-        
-        ```bash
-        click-man commandname
-        ```
-        
-        where `commandname` is the name of an installed `console_script` entry point.
-        
-        To specify a target directory for the man pages, use the `--target` option:
-        
-        ```bash
-        click-man --target path/to/man/pages commandname
-        ```
-        
-        ### Use with setuptools
-        
-        **click-man** provides a sane setuptools command extension which can be used like the following:
-        
-        ```bash
-        python3 setup.py --command-packages=click_man.commands man_pages
-        ```
-        
-        or specify the man pages target directory:
-        
-        ```bash
-        python3 setup.py --command-packages=click_man.commands man_pages --target path/to/man/pages
-        ```
-        
-        ### Automatic man page installation with setuptools and pip
-        
-        This approach of installing man pages is problematic for various reasons:
-        
-        #### (1) Man pages are a UNIX thing
-        
-        Python in general and with that pip and setuptools are aimed to be platform independent.
-        Man pages are **not**: they are a UNIX thing which means setuptools does not provide a sane
-        solution to generate and install man pages. 
-        We should consider using automatic man page installation only with vendor specific packaging, e.g. for `*.deb` or `*.rpm` packages.
-        
-        #### (2) Man pages are not compatable with Python virtualenvs
-        
-        Even on systems that support man pages, Python packages can be installed in
-        virtualenvs via pip and setuptools, which do not make commands available
-        globally. In fact, one of the "features" of a virtualenv is the ability to
-        install a package without affecting the main system. As it is imposable to
-        ensure a man page is only generated when not installing into a virtualenv,
-        auto-generated man pages would pollute the main system and not stay contained in
-        the virtualenv. Additionally, as a user could install multiple different
-        versions of the same package into multiple different virtualenvs on the same
-        system, there is no guarantee that a globally installed man page will document
-        the version and behavior available in any given virtualenv.
-        
-        #### (3) We want to generate man pages on the fly
-        
-        First, we do not want to commit man pages to our source control.
-        We want to generate them on the fly. Either
-        during build or installation time.
-        
-        With setuptools and pip we face two problems:
-        
-        1. If we generate and install them during installation of the package pip does not know about the man pages and thus cannot uninstall it.
-        2. If we generate them in our build process and add them to your distribution we do not have a way to prevent installation to */usr/share/man* for non-UNIX-like Operating Systems or from within virtualenvs.
-        
-        ### Debian packages
-        
-        The `debhelper` packages provides a very convenient script called `dh_installman`.
-        It checks for the `debian/(pkg_name.)manpages` file and it's content which is basically a line by line list of man pages or globs:
-        
-        ```
-        debian/tmp/manpages/*
-        ```
-        
-        We override the rule provided by `dh_installman` to generate our man pages in advance, like this:
-        
-        ```Makefile
-        override_dh_installman:
-        	python3 setup.py --command-packages=click_man.commands man_pages --target debian/tmp/manpages
-        	dh_installman -O--buildsystem=pybuild
-        ```
-        
-        Now we are able to build are debian package with the tool of your choice, e.g.:
-        
-        ```debuild -us -uc```
-        
-        Checkout a working example here: [repo debian package](https://github.com/timofurrer/click-man/tree/master/examples/debian_pkg)
-        
 Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -136,3 +15,127 @@ Classifier: Programming Language :: Python :: 2
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Documentation
 Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# click-man
+
+[![Build Status](https://travis-ci.org/click-contrib/click-man.svg?branch=master)](https://travis-ci.org/click-contrib/click-man) [![PyPI Package version](https://badge.fury.io/py/click-man.svg)](https://pypi.python.org/pypi/click-man)
+
+Create **man pages** for [click](https://github.com/pallets/click) application as easy as this:
+
+```bash
+python3 setup.py --command-packages=click_man.commands man_pages
+```
+
+→ Checkout the [debian packaging example](https://github.com/timofurrer/click-man#debian-packages)
+
+## What it does
+
+*click-man* will generate one man page per command of your click CLI application specified in `console_scripts` in your `setup.py`.
+
+## Installation
+
+```bash
+pip3 install click-man
+```
+
+**click-man** is also available for Python 2:
+
+```bash
+pip install click-man
+```
+
+## Usage Recipes
+
+The following sections describe different usage example for *click-man*.
+
+### Use with a previously installed package
+
+**click-man** provides its own command line tool which can be passed the name of
+an installed script:
+
+```bash
+click-man commandname
+```
+
+where `commandname` is the name of an installed `console_script` entry point.
+
+To specify a target directory for the man pages, use the `--target` option:
+
+```bash
+click-man --target path/to/man/pages commandname
+```
+
+### Use with setuptools
+
+**click-man** provides a sane setuptools command extension which can be used like the following:
+
+```bash
+python3 setup.py --command-packages=click_man.commands man_pages
+```
+
+or specify the man pages target directory:
+
+```bash
+python3 setup.py --command-packages=click_man.commands man_pages --target path/to/man/pages
+```
+
+### Automatic man page installation with setuptools and pip
+
+This approach of installing man pages is problematic for various reasons:
+
+#### (1) Man pages are a UNIX thing
+
+Python in general and with that pip and setuptools are aimed to be platform independent.
+Man pages are **not**: they are a UNIX thing which means setuptools does not provide a sane
+solution to generate and install man pages. 
+We should consider using automatic man page installation only with vendor specific packaging, e.g. for `*.deb` or `*.rpm` packages.
+
+#### (2) Man pages are not compatable with Python virtualenvs
+
+Even on systems that support man pages, Python packages can be installed in
+virtualenvs via pip and setuptools, which do not make commands available
+globally. In fact, one of the "features" of a virtualenv is the ability to
+install a package without affecting the main system. As it is imposable to
+ensure a man page is only generated when not installing into a virtualenv,
+auto-generated man pages would pollute the main system and not stay contained in
+the virtualenv. Additionally, as a user could install multiple different
+versions of the same package into multiple different virtualenvs on the same
+system, there is no guarantee that a globally installed man page will document
+the version and behavior available in any given virtualenv.
+
+#### (3) We want to generate man pages on the fly
+
+First, we do not want to commit man pages to our source control.
+We want to generate them on the fly. Either
+during build or installation time.
+
+With setuptools and pip we face two problems:
+
+1. If we generate and install them during installation of the package pip does not know about the man pages and thus cannot uninstall it.
+2. If we generate them in our build process and add them to your distribution we do not have a way to prevent installation to */usr/share/man* for non-UNIX-like Operating Systems or from within virtualenvs.
+
+### Debian packages
+
+The `debhelper` packages provides a very convenient script called `dh_installman`.
+It checks for the `debian/(pkg_name.)manpages` file and it's content which is basically a line by line list of man pages or globs:
+
+```
+debian/tmp/manpages/*
+```
+
+We override the rule provided by `dh_installman` to generate our man pages in advance, like this:
+
+```Makefile
+override_dh_installman:
+	python3 setup.py --command-packages=click_man.commands man_pages --target debian/tmp/manpages
+	dh_installman -O--buildsystem=pybuild
+```
+
+Now we are able to build are debian package with the tool of your choice, e.g.:
+
+```debuild -us -uc```
+
+Checkout a working example here: [repo debian package](https://github.com/timofurrer/click-man/tree/master/examples/debian_pkg)
+
+
diff --git a/click_man.egg-info/PKG-INFO b/click_man.egg-info/PKG-INFO
index 0018406..c80f811 100644
--- a/click_man.egg-info/PKG-INFO
+++ b/click_man.egg-info/PKG-INFO
@@ -1,132 +1,11 @@
 Metadata-Version: 2.1
 Name: click-man
-Version: 0.4.1
+Version: 0.4.2
 Summary: Generate man pages for click based CLI applications
 Home-page: https://github.com/click-contrib/click-man
 Author: Timo Furrer
 Author-email: tuxtimo@gmail.com
 License: MIT
-Description: # click-man
-        
-        [![Build Status](https://travis-ci.org/click-contrib/click-man.svg?branch=master)](https://travis-ci.org/click-contrib/click-man) [![PyPI Package version](https://badge.fury.io/py/click-man.svg)](https://pypi.python.org/pypi/click-man)
-        
-        Create **man pages** for [click](https://github.com/pallets/click) application as easy as this:
-        
-        ```bash
-        python3 setup.py --command-packages=click_man.commands man_pages
-        ```
-        
-        → Checkout the [debian packaging example](https://github.com/timofurrer/click-man#debian-packages)
-        
-        ## What it does
-        
-        *click-man* will generate one man page per command of your click CLI application specified in `console_scripts` in your `setup.py`.
-        
-        ## Installation
-        
-        ```bash
-        pip3 install click-man
-        ```
-        
-        **click-man** is also available for Python 2:
-        
-        ```bash
-        pip install click-man
-        ```
-        
-        ## Usage Recipes
-        
-        The following sections describe different usage example for *click-man*.
-        
-        ### Use with a previously installed package
-        
-        **click-man** provides its own command line tool which can be passed the name of
-        an installed script:
-        
-        ```bash
-        click-man commandname
-        ```
-        
-        where `commandname` is the name of an installed `console_script` entry point.
-        
-        To specify a target directory for the man pages, use the `--target` option:
-        
-        ```bash
-        click-man --target path/to/man/pages commandname
-        ```
-        
-        ### Use with setuptools
-        
-        **click-man** provides a sane setuptools command extension which can be used like the following:
-        
-        ```bash
-        python3 setup.py --command-packages=click_man.commands man_pages
-        ```
-        
-        or specify the man pages target directory:
-        
-        ```bash
-        python3 setup.py --command-packages=click_man.commands man_pages --target path/to/man/pages
-        ```
-        
-        ### Automatic man page installation with setuptools and pip
-        
-        This approach of installing man pages is problematic for various reasons:
-        
-        #### (1) Man pages are a UNIX thing
-        
-        Python in general and with that pip and setuptools are aimed to be platform independent.
-        Man pages are **not**: they are a UNIX thing which means setuptools does not provide a sane
-        solution to generate and install man pages. 
-        We should consider using automatic man page installation only with vendor specific packaging, e.g. for `*.deb` or `*.rpm` packages.
-        
-        #### (2) Man pages are not compatable with Python virtualenvs
-        
-        Even on systems that support man pages, Python packages can be installed in
-        virtualenvs via pip and setuptools, which do not make commands available
-        globally. In fact, one of the "features" of a virtualenv is the ability to
-        install a package without affecting the main system. As it is imposable to
-        ensure a man page is only generated when not installing into a virtualenv,
-        auto-generated man pages would pollute the main system and not stay contained in
-        the virtualenv. Additionally, as a user could install multiple different
-        versions of the same package into multiple different virtualenvs on the same
-        system, there is no guarantee that a globally installed man page will document
-        the version and behavior available in any given virtualenv.
-        
-        #### (3) We want to generate man pages on the fly
-        
-        First, we do not want to commit man pages to our source control.
-        We want to generate them on the fly. Either
-        during build or installation time.
-        
-        With setuptools and pip we face two problems:
-        
-        1. If we generate and install them during installation of the package pip does not know about the man pages and thus cannot uninstall it.
-        2. If we generate them in our build process and add them to your distribution we do not have a way to prevent installation to */usr/share/man* for non-UNIX-like Operating Systems or from within virtualenvs.
-        
-        ### Debian packages
-        
-        The `debhelper` packages provides a very convenient script called `dh_installman`.
-        It checks for the `debian/(pkg_name.)manpages` file and it's content which is basically a line by line list of man pages or globs:
-        
-        ```
-        debian/tmp/manpages/*
-        ```
-        
-        We override the rule provided by `dh_installman` to generate our man pages in advance, like this:
-        
-        ```Makefile
-        override_dh_installman:
-        	python3 setup.py --command-packages=click_man.commands man_pages --target debian/tmp/manpages
-        	dh_installman -O--buildsystem=pybuild
-        ```
-        
-        Now we are able to build are debian package with the tool of your choice, e.g.:
-        
-        ```debuild -us -uc```
-        
-        Checkout a working example here: [repo debian package](https://github.com/timofurrer/click-man/tree/master/examples/debian_pkg)
-        
 Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -136,3 +15,127 @@ Classifier: Programming Language :: Python :: 2
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Documentation
 Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# click-man
+
+[![Build Status](https://travis-ci.org/click-contrib/click-man.svg?branch=master)](https://travis-ci.org/click-contrib/click-man) [![PyPI Package version](https://badge.fury.io/py/click-man.svg)](https://pypi.python.org/pypi/click-man)
+
+Create **man pages** for [click](https://github.com/pallets/click) application as easy as this:
+
+```bash
+python3 setup.py --command-packages=click_man.commands man_pages
+```
+
+→ Checkout the [debian packaging example](https://github.com/timofurrer/click-man#debian-packages)
+
+## What it does
+
+*click-man* will generate one man page per command of your click CLI application specified in `console_scripts` in your `setup.py`.
+
+## Installation
+
+```bash
+pip3 install click-man
+```
+
+**click-man** is also available for Python 2:
+
+```bash
+pip install click-man
+```
+
+## Usage Recipes
+
+The following sections describe different usage example for *click-man*.
+
+### Use with a previously installed package
+
+**click-man** provides its own command line tool which can be passed the name of
+an installed script:
+
+```bash
+click-man commandname
+```
+
+where `commandname` is the name of an installed `console_script` entry point.
+
+To specify a target directory for the man pages, use the `--target` option:
+
+```bash
+click-man --target path/to/man/pages commandname
+```
+
+### Use with setuptools
+
+**click-man** provides a sane setuptools command extension which can be used like the following:
+
+```bash
+python3 setup.py --command-packages=click_man.commands man_pages
+```
+
+or specify the man pages target directory:
+
+```bash
+python3 setup.py --command-packages=click_man.commands man_pages --target path/to/man/pages
+```
+
+### Automatic man page installation with setuptools and pip
+
+This approach of installing man pages is problematic for various reasons:
+
+#### (1) Man pages are a UNIX thing
+
+Python in general and with that pip and setuptools are aimed to be platform independent.
+Man pages are **not**: they are a UNIX thing which means setuptools does not provide a sane
+solution to generate and install man pages. 
+We should consider using automatic man page installation only with vendor specific packaging, e.g. for `*.deb` or `*.rpm` packages.
+
+#### (2) Man pages are not compatable with Python virtualenvs
+
+Even on systems that support man pages, Python packages can be installed in
+virtualenvs via pip and setuptools, which do not make commands available
+globally. In fact, one of the "features" of a virtualenv is the ability to
+install a package without affecting the main system. As it is imposable to
+ensure a man page is only generated when not installing into a virtualenv,
+auto-generated man pages would pollute the main system and not stay contained in
+the virtualenv. Additionally, as a user could install multiple different
+versions of the same package into multiple different virtualenvs on the same
+system, there is no guarantee that a globally installed man page will document
+the version and behavior available in any given virtualenv.
+
+#### (3) We want to generate man pages on the fly
+
+First, we do not want to commit man pages to our source control.
+We want to generate them on the fly. Either
+during build or installation time.
+
+With setuptools and pip we face two problems:
+
+1. If we generate and install them during installation of the package pip does not know about the man pages and thus cannot uninstall it.
+2. If we generate them in our build process and add them to your distribution we do not have a way to prevent installation to */usr/share/man* for non-UNIX-like Operating Systems or from within virtualenvs.
+
+### Debian packages
+
+The `debhelper` packages provides a very convenient script called `dh_installman`.
+It checks for the `debian/(pkg_name.)manpages` file and it's content which is basically a line by line list of man pages or globs:
+
+```
+debian/tmp/manpages/*
+```
+
+We override the rule provided by `dh_installman` to generate our man pages in advance, like this:
+
+```Makefile
+override_dh_installman:
+	python3 setup.py --command-packages=click_man.commands man_pages --target debian/tmp/manpages
+	dh_installman -O--buildsystem=pybuild
+```
+
+Now we are able to build are debian package with the tool of your choice, e.g.:
+
+```debuild -us -uc```
+
+Checkout a working example here: [repo debian package](https://github.com/timofurrer/click-man/tree/master/examples/debian_pkg)
+
+
diff --git a/click_man.egg-info/requires.txt b/click_man.egg-info/requires.txt
index dca9a90..ffe4b79 100644
--- a/click_man.egg-info/requires.txt
+++ b/click_man.egg-info/requires.txt
@@ -1 +1,2 @@
 click
+setuptools
diff --git a/click_man/__main__.py b/click_man/__main__.py
index b89a0c3..4424605 100644
--- a/click_man/__main__.py
+++ b/click_man/__main__.py
@@ -24,7 +24,7 @@ from click_man.core import write_man_pages
 @click.argument('name')
 def cli(target, name):
     """
-    Generate man pages for the scripts defined in the ``console_acripts`` entry point.
+    Generate man pages for the scripts defined in the ``console_scripts`` entry point.
 
     The cli application is gathered from entry points of installed packages.
 
diff --git a/click_man/core.py b/click_man/core.py
index 383938d..73b431d 100644
--- a/click_man/core.py
+++ b/click_man/core.py
@@ -16,6 +16,16 @@ import click
 
 from .man import ManPage
 
+CLICK_VERSION = tuple(int(x) for x in click.__version__.split('.'))
+
+
+def get_short_help_str(command, limit=45):
+    """
+    Gets short help for the command or makes it by shortening the long help string.
+    """
+    return command.short_help or command.help and click.utils.make_default_short_help(command.help, limit) or ''
+
+
 def generate_man_page(ctx, version=None):
     """
     Generate documentation for the given command.
@@ -29,14 +39,14 @@ def generate_man_page(ctx, version=None):
     # Create man page with the details from the given context
     man_page = ManPage(ctx.command_path)
     man_page.version = version
-    man_page.short_help = ctx.command.get_short_help_str()
+    man_page.short_help = get_short_help_str(ctx.command)
     man_page.description = ctx.command.help
     man_page.synopsis = ' '.join(ctx.command.collect_usage_pieces(ctx))
     man_page.options = [x.get_help_record(ctx) for x in ctx.command.params if isinstance(x, click.Option)]
     commands = getattr(ctx.command, 'commands', None)
     if commands:
         man_page.commands = [
-            (k, v.get_short_help_str()) for k, v in commands.items()
+            (k, get_short_help_str(v)) for k, v in commands.items()
         ]
 
     return str(man_page)
diff --git a/setup.py b/setup.py
index 2cd63e3..7369c41 100644
--- a/setup.py
+++ b/setup.py
@@ -8,7 +8,7 @@ def read(fname):
 
 setup(
     name='click-man',
-    version='0.4.1',
+    version='0.4.2',
     url='https://github.com/click-contrib/click-man',
     license='MIT',
     description='Generate man pages for click based CLI applications',
@@ -17,7 +17,8 @@ setup(
     author='Timo Furrer',
     author_email='tuxtimo@gmail.com',
     install_requires=[
-        'click'
+        'click',
+        'setuptools',
     ],
     packages=find_packages(exclude=('tests', )),
     entry_points={