tasks.py

"""
Tasks for maintaining the project.

Execute 'invoke --list' for guidance on using Invoke
"""
import shutil
import platform
from os import chdir

from invoke import task
try:
    from pathlib import Path
    Path().expanduser()
except (ImportError, AttributeError):
    from pathlib2 import Path
import webbrowser


ROOT_DIR = Path(__file__).parent
SETUP_FILE = ROOT_DIR.joinpath("setup.py")
TEST_DIR = ROOT_DIR.joinpath("tests")
SOURCE_DIR = ROOT_DIR.joinpath("vagrant_debian")
TOX_DIR = ROOT_DIR.joinpath(".tox")
COVERAGE_FILE = ROOT_DIR.joinpath(".coverage")
COVERAGE_DIR = ROOT_DIR.joinpath("htmlcov")
COVERAGE_REPORT = COVERAGE_DIR.joinpath("index.html")
DOCS_DIR = ROOT_DIR.joinpath("docs")
DOCS_BUILD_DIR = DOCS_DIR.joinpath("_build")
DOCS_INDEX = DOCS_BUILD_DIR.joinpath("index.html")
PYTHON_DIRS = [str(d) for d in [SOURCE_DIR, TEST_DIR]]


def _delete_file(file):
    try:
        file.unlink(missing_ok=True)
    except TypeError:
        # missing_ok argument added in 3.8
        try:
            file.unlink()
        except FileNotFoundError:
            pass


@task(help={'check': "Checks if source is formatted without applying changes"})
def format(c, check=False):
    """
    Format code
    """
    python_dirs_string = " ".join(PYTHON_DIRS)
    # Run yapf
    yapf_options = f'--recursive {"--diff" if check else "--in-place"}'
    c.run(f"yapf {yapf_options} {python_dirs_string}")
    # Run isort
    isort_options = f'--recursive {"--check-only" if check else ""}'
    c.run(f"isort {isort_options} {python_dirs_string}")


@task
def lint(c):
    """
    Lint code
    """
    c.run(f"flake8 {SOURCE_DIR}")
    c.run(f"pylint {SOURCE_DIR}")


@task
def test(c):
    """
    Run tests
    """
    pty = platform.system() == 'Linux'
    c.run(f"python {SETUP_FILE} test", pty=pty)


@task(help={'publish': "Publish the result via coveralls"})
def coverage(c, publish=False):
    """
    Create coverage report
    """
    c.run(f"coverage run --source {SOURCE_DIR} -m pytest")
    c.run("coverage report")
    if publish:
        # Publish the results via coveralls
        c.run("coveralls")
    else:
        # Build a local report
        c.run("coverage html")
        webbrowser.open(COVERAGE_REPORT.as_uri())


@task
def docs(c):
    """
    Generate documentation
    """
    chdir(f"{DOCS_DIR}")
    c.run(f"asciidoctor --destination-dir={DOCS_BUILD_DIR} -a toc -a data-uri -a allow-uri-read -b html index.adoc")
    c.run(f"asciidoctor-pdf --destination-dir={DOCS_BUILD_DIR} -a toc -a data-uri -a allow-uri-read -d book index.adoc")
    c.run(f"asciidoctor --destination-dir={DOCS_BUILD_DIR} -a toc -a allow-uri-read -b docbook index.adoc")
    c.run(f"pandoc -f docbook --toc -t rst {DOCS_BUILD_DIR.joinpath('index.xml')} -o {DOCS_BUILD_DIR}/index.tmp")
    c.run(f"""echo '.. toctree::
:maxdepth: 2
' > {DOCS_BUILD_DIR}/index.rst""")
    c.run(f"cat {DOCS_BUILD_DIR}/index.tmp >> {DOCS_BUILD_DIR}/index.rst")
    c.run(f"rm -f {DOCS_BUILD_DIR}/index.tmp")
    c.run(f"pandoc -f docbook  --toc {DOCS_BUILD_DIR}/index.xml -o {DOCS_BUILD_DIR}/index.epub -t epub")
    chdir("..")
    webbrowser.open(DOCS_INDEX.as_uri())


@task
def clean_docs(c):
    """
    Clean up files from documentation builds
    """
    c.run(f"rm -fr {DOCS_BUILD_DIR}")


@task
def clean_build(c):
    """
    Clean up files from package building
    """
    c.run("rm -fr build/")
    c.run("rm -fr dist/")
    c.run("rm -fr .eggs/")
    c.run("find . -name '*.egg-info' -exec rm -fr {} +")
    c.run("find . -name '*.egg' -exec rm -f {} +")


@task
def clean_python(c):
    """
    Clean up python file artifacts
    """
    c.run("find . -name '*.pyc' -exec rm -f {} +")
    c.run("find . -name '*.pyo' -exec rm -f {} +")
    c.run("find . -name '*~' -exec rm -f {} +")
    c.run("find . -name '__pycache__' -exec rm -fr {} +")


@task
def clean_tests(c):
    """
    Clean up files from testing
    """
    _delete_file(COVERAGE_FILE)
    shutil.rmtree(TOX_DIR, ignore_errors=True)
    shutil.rmtree(COVERAGE_DIR, ignore_errors=True)


@task(pre=[clean_build, clean_python, clean_tests, clean_docs])
def clean(c):
    """
    Runs all clean sub-tasks
    """
    pass


@task(clean)
def dist(c):
    """
    Build source and wheel packages
    """
    c.run("python setup.py sdist")
    c.run("python setup.py bdist_wheel")

@task(pre=[clean, dist])
def test_release(c):
    """
    Make a test of release on the python package to pypi
    """
    c.run("twine upload --repository testpypi dist/*")


@task(pre=[clean, dist])
def release(c):
    """
    Make a release of the python package to pypi
    """
    c.run("twine upload dist/*")