busser-behave 0.1.3

data/vendor/behave/tasks/clean.py

@@ -0,0 +1,246 @@
+# -*- coding: UTF-8 -*-
+"""
+Provides cleanup tasks for invoke build scripts.
+
+clean task: Add Additional Directories and Files to be removed
+-------------------------------------------------------------------------------
+
+Create an invoke configuration file (YAML of JSON) with the additional
+configuration data:
+
+.. code-block:: yaml
+
+    # -- FILE: invoke.yaml
+    # USE: clean.directories, clean.files to override current configuration.
+    clean:
+        extra_directories:
+            - **/tmp/
+        extra_files:
+            - **/*.log
+            - **/*.bak
+
+
+Registration of Cleanup Tasks
+------------------------------
+
+Other task modules often have an own cleanup task to recover the clean state.
+The :meth:`clean` task, that is provided here, supports the registration
+of additional cleanup tasks. Therefore, when the :meth:`clean` task is executed,
+all registered cleanup tasks will be executed.
+
+EXAMPLE::
+
+    # -- FILE: tasks/docs.py
+    from __future__ import absolute_import
+    from invoke import task, Collection
+    from .clean import cleanup_tasks, cleanup_dirs
+
+    @task
+    def clean(ctx, dry_run=False):
+        "Cleanup generated documentation artifacts."
+        cleanup_dirs(["build/docs"])
+
+    namespace = Collection(clean)
+    ...
+
+    # -- REGISTER CLEANUP TASK:
+    cleanup_tasks.add_task(clean, "clean_docs")
+    cleanup_tasks.configure(namespace.configuration())
+"""
+
+from __future__ import absolute_import
+from invoke import task, Collection
+from invoke.executor import Executor
+from invoke.exceptions import Failure
+import os.path
+import sys
+from path import Path
+import pathlib
+
+
+# -----------------------------------------------------------------------------
+# TASKS:
+# -----------------------------------------------------------------------------
+@task
+def clean(ctx, dry_run=False):
+    """Cleanup temporary dirs/files to regain a clean state."""
+    # -- VARIATION-POINT 1: Allow user to override in configuration-file
+    directories = ctx.clean.directories
+    files = ctx.clean.files
+
+    # -- VARIATION-POINT 2: Allow user to add more files/dirs to be removed.
+    extra_directories = ctx.clean.extra_directories or []
+    extra_files = ctx.clean.extra_files or []
+    if extra_directories:
+        directories.extend(extra_directories)
+    if extra_files:
+        files.extend(extra_files)
+
+    # -- PERFORM CLEANUP:
+    execute_cleanup_tasks(ctx, cleanup_tasks, dry_run=dry_run)
+    cleanup_dirs(directories, dry_run=dry_run)
+    cleanup_files(files, dry_run=dry_run)
+
+
+@task(name="clean-all", aliases=("distclean",))
+def clean_all(ctx, dry_run=False):
+    """Clean up everything, even the precious stuff.
+    NOTE: clean task is executed first.
+    """
+    cleanup_dirs(ctx.clean_all.directories or [], dry_run=dry_run)
+    cleanup_dirs(ctx.clean_all.extra_directories or [], dry_run=dry_run)
+    cleanup_files(ctx.clean_all.files or [], dry_run=dry_run)
+    cleanup_files(ctx.clean_all.extra_files or [], dry_run=dry_run)
+    execute_cleanup_tasks(ctx, cleanup_all_tasks, dry_run=dry_run)
+    clean(ctx, dry_run=dry_run)
+
+
+@task
+def clean_python(ctx, dry_run=False):
+    """Cleanup python related files/dirs: *.pyc, *.pyo, ..."""
+    # MAYBE NOT: "**/__pycache__"
+    cleanup_dirs(["build", "dist", "*.egg-info", "**/__pycache__"],
+                 dry_run=dry_run)
+    if not dry_run:
+        ctx.run("py.cleanup")
+    cleanup_files(["**/*.pyc", "**/*.pyo", "**/*$py.class"], dry_run=dry_run)
+
+
+# -----------------------------------------------------------------------------
+# CLEANUP UTILITIES:
+# -----------------------------------------------------------------------------
+def execute_cleanup_tasks(ctx, cleanup_tasks, dry_run=False):
+    """Execute several cleanup tasks as part of the cleanup.
+
+    REQUIRES: ``clean(ctx, dry_run=False)`` signature in cleanup tasks.
+
+    :param ctx:             Context object for the tasks.
+    :param cleanup_tasks:   Collection of cleanup tasks (as Collection).
+    :param dry_run:         Indicates dry-run mode (bool)
+    """
+    executor = Executor(cleanup_tasks, ctx.config)
+    for cleanup_task in cleanup_tasks.tasks:
+        print("CLEANUP TASK: %s" % cleanup_task)
+        executor.execute((cleanup_task, dict(dry_run=dry_run)))
+
+
+def cleanup_dirs(patterns, dry_run=False, workdir="."):
+    """Remove directories (and their contents) recursively.
+    Skips removal if directories does not exist.
+
+    :param patterns:    Directory name patterns, like "**/tmp*" (as list).
+    :param dry_run:     Dry-run mode indicator (as bool).
+    :param workdir:     Current work directory (default=".")
+    """
+    current_dir = Path(workdir)
+    python_basedir = Path(Path(sys.executable).dirname()).joinpath("..").abspath()
+    warn2_counter = 0
+    for dir_pattern in patterns:
+        for directory in path_glob(dir_pattern, current_dir):
+            directory2 = directory.abspath()
+            if sys.executable.startswith(directory2):
+                print("SKIP-SUICIDE: '%s' contains current python executable" % directory)
+                continue
+            elif directory2.startswith(python_basedir):
+                # -- PROTECT CURRENTLY USED VIRTUAL ENVIRONMENT:
+                if warn2_counter <= 4:
+                    print("SKIP-SUICIDE: '%s'" % directory)
+                warn2_counter += 1
+                continue
+
+            if dry_run:
+                print("RMTREE: %s (dry-run)" % directory)
+            else:
+                print("RMTREE: %s" % directory)
+                directory.rmtree_p()
+
+def cleanup_files(patterns, dry_run=False, workdir="."):
+    """Remove files or files selected by file patterns.
+    Skips removal if file does not exist.
+
+    :param patterns:    File patterns, like "**/*.pyc" (as list).
+    :param dry_run:     Dry-run mode indicator (as bool).
+    :param workdir:     Current work directory (default=".")
+    """
+    current_dir = Path(workdir)
+    python_basedir = Path(Path(sys.executable).dirname()).joinpath("..").abspath()
+    error_message = None
+    error_count = 0
+    for file_pattern in patterns:
+        for file_ in path_glob(file_pattern, current_dir):
+            if file_.abspath().startswith(python_basedir):
+                # -- PROTECT CURRENTLY USED VIRTUAL ENVIRONMENT:
+                continue
+
+            if dry_run:
+                print("REMOVE: %s (dry-run)" % file_)
+            else:
+                print("REMOVE: %s" % file_)
+                try:
+                    file_.remove_p()
+                except os.error as e:
+                    message = "%s: %s" % (e.__class__.__name__, e)
+                    print(message + " basedir: "+ python_basedir)
+                    error_count += 1
+                    if not error_message:
+                        error_message = message
+    if False and error_message:
+        class CleanupError(RuntimeError): pass
+        raise CleanupError(error_message)
+
+def path_glob(pattern, current_dir=None):
+    """Use pathlib for ant-like patterns, like: "**/*.py"
+
+    :param pattern:      File/directory pattern to use (as string).
+    :param current_dir:  Current working directory (as Path, pathlib.Path, str)
+    :return Resolved Path (as path.Path).
+    """
+    if not current_dir:
+        current_dir = pathlib.Path.cwd()
+    elif not isinstance(current_dir, pathlib.Path):
+        # -- CASE: string, path.Path (string-like)
+        current_dir = pathlib.Path(str(current_dir))
+
+    for p in current_dir.glob(pattern):
+        yield Path(str(p))
+
+
+# -----------------------------------------------------------------------------
+# TASK CONFIGURATION:
+# -----------------------------------------------------------------------------
+namespace = Collection(clean, clean_all)
+namespace.configure({
+    "clean": {
+        "directories": [],
+        "files": [
+            "*.bak", "*.log", "*.tmp",
+            "**/.DS_Store", "**/*.~*~",     # -- MACOSX
+        ],
+        "extra_directories": [],
+        "extra_files": [],
+    },
+    "clean_all": {
+        "directories": [".venv*", ".tox", "downloads", "tmp"],
+        "files": [],
+        "extra_directories": [],
+        "extra_files": [],
+    },
+})
+
+# -- SUPPORT ADDITIONAL CLEANUP TASKS (which are called by ``clean`` task)
+cleanup_tasks = Collection("cleanup_tasks")
+cleanup_tasks.add_task(clean_python)
+
+cleanup_all_tasks = Collection("cleanup_all_tasks")
+
+# -----------------------------------------------------------------------------
+# TASK CONFIGURATION HELPERS: Can be used from other task modules
+# -----------------------------------------------------------------------------
+def config_add_cleanup_dirs(directories):
+    cleanup_directories = namespace._configuration["clean"]["directories"]
+    cleanup_directories.extend(directories)
+
+def config_add_cleanup_files(files):
+    cleanup_files = namespace._configuration["clean"]["files"]
+    cleanup_files.extend(files)
+

data/vendor/behave/tasks/docs.py

@@ -0,0 +1,97 @@
+# -*- coding: UTF-8 -*-
+"""
+Provides tasks to build documentation with sphinx, etc.
+"""
+
+from __future__ import absolute_import, print_function
+from invoke import task, Collection
+from invoke.util import cd
+from path import Path
+import os.path
+import sys
+
+# -- TASK-LIBRARY:
+from .clean import cleanup_tasks, cleanup_dirs
+
+# -----------------------------------------------------------------------------
+# TASKS:
+# -----------------------------------------------------------------------------
+@task
+def clean(ctx, dry_run=False):
+    """Cleanup generated document artifacts."""
+    basedir = ctx.sphinx.destdir or "build/docs"
+    cleanup_dirs([basedir], dry_run=dry_run)
+
+
+@task(help={
+    "builder": "Builder to use (html, ...)",
+    "options": "Additional options for sphinx-build",
+})
+def build(ctx, builder="html", options=""):
+    """Build docs with sphinx-build"""
+    sourcedir = ctx.config.sphinx.sourcedir
+    destdir = Path(ctx.config.sphinx.destdir or "build")/builder
+    destdir = destdir.abspath()
+    with cd(sourcedir):
+        destdir_relative = Path(".").relpathto(destdir)
+        command = "sphinx-build {opts} -b {builder} {sourcedir} {destdir}" \
+                    .format(builder=builder, sourcedir=".",
+                            destdir=destdir_relative, opts=options)
+        ctx.run(command)
+
+@task
+def linkcheck(ctx):
+    """Check if all links are corect."""
+    build(ctx, builder="linkcheck")
+
+@task
+def browse(ctx):
+    """Open documentation in web browser."""
+    page_html = Path(ctx.config.sphinx.destdir)/"html"/"index.html"
+    if not page_html.exists():
+        build(ctx, builder="html")
+    assert page_html.exists()
+    open_cmd = "open"   # -- WORKS ON: MACOSX
+    if sys.platform.startswith("win"):
+        open_cmd = "start"
+    ctx.run("{open} {page_html}".format(open=open_cmd, page_html=page_html))
+    # ctx.run('python -m webbrowser -t {page_html}'.format(page_html=page_html))
+    # -- DISABLED:
+    # import webbrowser
+    # print("Starting webbrowser with page=%s" % page_html)
+    # webbrowser.open(str(page_html))
+
+@task(help = {"dest": "Destination directory to save docs"})
+def save(ctx, dest="docs.html", format="html"):
+    """Save/update docs under destination directory."""
+    print("STEP: Generate docs in HTML format")
+    build(ctx, builder=format)
+
+    print("STEP: Save docs under %s/" % dest)
+    source_dir = Path(ctx.config.sphinx.destdir)/format
+    Path(dest).rmtree_p()
+    source_dir.copytree(dest)
+
+    # -- POST-PROCESSING: Polish up.
+    for part in [ ".buildinfo", ".doctrees" ]:
+        partpath = Path(dest)/part
+        if partpath.isdir():
+            partpath.rmtree_p()
+        elif partpath.exists():
+            partpath.remove_p()
+
+# -----------------------------------------------------------------------------
+# TASK CONFIGURATION:
+# -----------------------------------------------------------------------------
+namespace = Collection(clean, linkcheck, browse, save)
+namespace.add_task(build, default=True)
+namespace.configure({
+    "sphinx": {
+        "sourcedir": "docs",
+        "destdir": "build/docs"
+    }
+})
+
+# -- ADD CLEANUP TASK:
+cleanup_tasks.add_task(clean, "clean_docs")
+cleanup_tasks.configure(namespace.configuration())

data/vendor/behave/tasks/requirements.txt

@@ -0,0 +1,17 @@
+# ============================================================================
+# INVOKE PYTHON PACKAGE REQUIREMENTS: For tasks
+# ============================================================================
+# DESCRIPTION:
+#    pip install -r <THIS_FILE>
+#
+# SEE ALSO:
+#  * http://www.pip-installer.org/
+# ============================================================================
+
+invoke >= 0.14.0
+six >= 1.10.0
+path.py >= 8.2.1
+pathlib;    python_version <= '3.4'
+
+# For cleanup of python files: py.cleanup
+pycmd

data/vendor/behave/tasks/test.py

@@ -0,0 +1,192 @@
+# -*- coding: UTF-8 -*-
+"""
+Invoke test tasks.
+"""
+
+from __future__ import print_function
+from invoke import task, Collection
+import os.path
+import sys
+
+# -- TASK-LIBRARY:
+from .clean import cleanup_tasks, cleanup_dirs, cleanup_files
+
+
+# ---------------------------------------------------------------------------
+# TASKS
+# ---------------------------------------------------------------------------
+@task(name="all", help={
+    "args": "Command line args for test run.",
+})
+def test_all(ctx, args="", options=""):
+    """Run all tests (default)."""
+    pytest_args = select_by_prefix(args, ctx.pytest.scopes)
+    behave_args = select_by_prefix(args, ctx.behave_test.scopes)
+    pytest_should_run = not args or (args and pytest_args)
+    behave_should_run = not args or (args and behave_args)
+    if pytest_should_run:
+        pytest(ctx, pytest_args, options=options)
+    if behave_should_run:
+        behave(ctx, behave_args, options=options)
+
+
+@task
+def clean(ctx, dry_run=False):
+    """Cleanup (temporary) test artifacts."""
+    directories = ctx.test.clean.directories or []
+    files = ctx.test.clean.files or []
+    cleanup_dirs(directories, dry_run=dry_run)
+    cleanup_files(files, dry_run=dry_run)
+
+
+@task(name="unit")
+def unittest(ctx, args="", options=""):
+    """Run unit tests."""
+    pytest(ctx, args, options)
+
+
+@task
+def pytest(ctx, args="", options=""):
+    """Run unit tests."""
+    args = args or ctx.pytest.args
+    options = options or ctx.pytest.options
+    ctx.run("pytest {options} {args}".format(options=options, args=args))
+
+
+@task(help={
+    "args": "Command line args for behave",
+    "format": "Formatter to use (progress, pretty, ...)",
+})
+def behave(ctx, args="", format="", options=""):
+    """Run behave tests."""
+    format  = format or ctx.behave_test.format
+    options = options or ctx.behave_test.options
+    args = args or ctx.behave_test.args
+    if os.path.exists("bin/behave"):
+        behave = "{python} bin/behave".format(python=sys.executable)
+    else:
+        behave = "{python} -m behave".format(python=sys.executable)
+
+    for group_args in grouped_by_prefix(args, ctx.behave_test.scopes):
+        ctx.run("{behave} -f {format} {options} {args}".format(
+            behave=behave, format=format, options=options, args=group_args))
+
+
+@task(help={
+    "args":     "Tests to run (empty: all)",
+    "report":   "Coverage report format to use (report, html, xml)",
+})
+def coverage(ctx, args="", report="report", append=False):
+    """Determine test coverage (run pytest, behave)"""
+    append = append or ctx.coverage.append
+    report_formats = ctx.coverage.report_formats or []
+    if report not in report_formats:
+        report_formats.insert(0, report)
+    opts = []
+    if append:
+        opts.append("--append")
+
+    pytest_args = select_by_prefix(args, ctx.pytest.scopes)
+    behave_args = select_by_prefix(args, ctx.behave_test.scopes)
+    pytest_should_run = not args or (args and pytest_args)
+    behave_should_run = not args or (args and behave_args)
+    if not args:
+        behave_args = ctx.behave_test.args or "features"
+    if isinstance(pytest_args, list):
+        pytest_args = " ".join(pytest_args)
+    if isinstance(behave_args, list):
+        behave_args = " ".join(behave_args)
+
+    # -- RUN TESTS WITH COVERAGE:
+    if pytest_should_run:
+        ctx.run("coverage run {options} -m pytest {args}".format(
+                args=pytest_args, options=" ".join(opts)))
+    if behave_should_run:
+        behave_options = ctx.behave_test.coverage_options or ""
+        os.environ["COVERAGE_PROCESS_START"] = os.path.abspath(".coveragerc")
+        behave(ctx, args=behave_args, options=behave_options)
+        del os.environ["COVERAGE_PROCESS_START"]
+
+    # -- POST-PROCESSING:
+    ctx.run("coverage combine")
+    for report_format in report_formats:
+        ctx.run("coverage {report_format}".format(report_format=report_format))
+
+
+# ---------------------------------------------------------------------------
+# UTILITIES:
+# ---------------------------------------------------------------------------
+def select_prefix_for(arg, prefixes):
+    for prefix in prefixes:
+        if arg.startswith(prefix):
+            return prefix
+    return os.path.dirname(arg)
+
+def select_by_prefix(args, prefixes):
+    selected = []
+    for arg in args.strip().split():
+        assert not arg.startswith("-"), "REQUIRE: arg, not options"
+        scope = select_prefix_for(arg, prefixes)
+        if scope:
+            selected.append(arg)
+    return " ".join(selected)
+
+def grouped_by_prefix(args, prefixes):
+    """Group behave args by (directory) scope into multiple test-runs."""
+    group_args = []
+    current_scope = None
+    for arg in args.strip().split():
+        assert not arg.startswith("-"), "REQUIRE: arg, not options"
+        scope = select_prefix_for(arg, prefixes)
+        if scope != current_scope:
+            if group_args:
+                # -- DETECTED GROUP-END:
+                yield " ".join(group_args)
+                group_args = []
+            current_scope = scope
+        group_args.append(arg)
+    if group_args:
+        yield " ".join(group_args)
+
+
+# ---------------------------------------------------------------------------
+# TASK MANAGEMENT / CONFIGURATION
+# ---------------------------------------------------------------------------
+namespace = Collection(clean, unittest, pytest, behave, coverage)
+namespace.add_task(test_all, default=True)
+namespace.configure({
+    "test": {
+        "clean": {
+            "directories": [
+                ".cache", "assets",                         # -- TEST RUNS
+                "__WORKDIR__", "reports", "test_results",   # -- BEHAVE test
+            ],
+            "files": [
+                ".coverage", ".coverage.*",
+                "report.html",
+                "rerun*.txt", "rerun*.featureset", "testrun*.json",
+            ],
+        },
+    },
+    "pytest": {
+        "scopes":   ["test", "tests"],
+        "args":   "",
+        "options": "",  # -- NOTE:  Overide in configfile "invoke.yaml"
+    },
+    # "behave_test": behave.namespace._configuration["behave_test"],
+    "behave_test": {
+        "scopes":   ["features", "issue.features"],
+        "args":     "features issue.features",
+        "format":   "progress",
+        "options":  "",  # -- NOTE:  Overide in configfile "invoke.yaml"
+        "coverage_options": "",
+    },
+    "coverage": {
+        "append":   False,
+        "report_formats": ["report", "html"],
+    },
+})
+
+# -- ADD CLEANUP TASK:
+cleanup_tasks.add_task(clean, "clean_test")
+cleanup_tasks.configure(namespace.configuration())