busser-behave 0.1.3

data/vendor/behave/bin/invoke

@@ -0,0 +1,8 @@
+#!/bin/sh
+#!/bin/bash
+# RUN INVOKE: From bundled ZIP file.
+
+HERE=$(dirname $0)
+export INVOKE_TASKS_USE_VENDOR_BUNDLES="yes"
+
+python ${HERE}/../tasks/_vendor/invoke.zip $*

data/vendor/behave/bin/invoke.cmd

@@ -0,0 +1,9 @@
+@echo off
+REM RUN INVOKE: From bundled ZIP file.
+
+setlocal
+set HERE=%~dp0
+set INVOKE_TASKS_USE_VENDOR_BUNDLES="yes"
+if not defined PYTHON   set PYTHON=python
+
+%PYTHON% %HERE%../tasks/_vendor/invoke.zip "%*"

data/vendor/behave/bin/json.format.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Utility script to format/beautify one or more JSON files.
+
+REQUIRES: Python >= 2.6 (json module is part of Python standard library)
+LICENSE:  BSD
+"""
+
+from __future__ import absolute_import
+
+__author__    = "Jens Engel"
+__copyright__ = "(c) 2011-2013 by Jens Engel"
+VERSION = "0.2.2"
+
+# -- IMPORTS:
+import os.path
+import glob
+import logging
+from optparse import OptionParser
+import sys
+try:
+    import json
+except ImportError:
+    import simplejson as json   #< BACKWARD-COMPATIBLE: Python <= 2.5
+
+
+# ----------------------------------------------------------------------------
+# CONSTANTS:
+# ----------------------------------------------------------------------------
+DEFAULT_INDENT_SIZE = 2
+
+# ----------------------------------------------------------------------------
+# FUNCTIONS:
+# ----------------------------------------------------------------------------
+def json_format(filename, indent=DEFAULT_INDENT_SIZE, **kwargs):
+    """
+    Format/Beautify a JSON file.
+
+    :param filename:    Filename of a JSON file to process.
+    :param indent:      Number of chars to indent per level (default: 4).
+    :returns: >= 0, if successful (written=1, skipped=2). Zero(0), otherwise.
+    :raises:  ValueError,           if parsing JSON file contents fails.
+    :raises:  json.JSONDecodeError, if parsing JSON file contents fails.
+    :raises:  IOError (Error 2), if file not found.
+    """
+    console  = kwargs.get("console", logging.getLogger("console"))
+    encoding = kwargs.get("encoding", None)
+    dry_run  = kwargs.get("dry_run", False)
+    if indent is None:
+        sort_keys = False
+    else:
+        sort_keys = True
+
+    message = "%s ..." % filename
+#    if not (os.path.exists(filename) and os.path.isfile(filename)):
+#        console.error("%s ERROR: file not found.", message)
+#        return 0
+
+    contents = open(filename, "r").read()
+    data      = json.loads(contents, encoding=encoding)
+    contents2 = json.dumps(data, indent=indent, sort_keys=sort_keys)
+    contents2 = contents2.strip()
+    contents2 = "%s\n" % contents2
+    if contents == contents2:
+        console.info("%s SKIP (already pretty)", message)
+        return 2 #< SKIPPED.
+    elif not dry_run:
+        outfile = open(filename, "w")
+        outfile.write(contents2)
+        outfile.close()
+        console.warn("%s OK", message)
+        return 1 #< OK
+
+def json_formatall(filenames, indent=DEFAULT_INDENT_SIZE, dry_run=False):
+    """
+    Format/Beautify a JSON file.
+
+    :param filenames:  Format one or more JSON files.
+    :param indent:     Number of chars to indent per level (default: 4).
+    :returns:  0, if successful. Otherwise, number of errors.
+    """
+    errors = 0
+    console = logging.getLogger("console")
+    for filename in filenames:
+        try:
+            result = json_format(filename, indent=indent, console=console,
+                                 dry_run=dry_run)
+            if not result:
+                errors += 1
+#        except json.decoder.JSONDecodeError, e:
+#            console.error("ERROR: %s (filename: %s)", e, filename)
+#            errors += 1
+        except Exception as e:
+            console.error("ERROR %s: %s (filename: %s)",
+                          e.__class__.__name__, e, filename)
+            errors += 1
+    return errors
+
+# ----------------------------------------------------------------------------
+# MAIN FUNCTION:
+# ----------------------------------------------------------------------------
+def main(args=None):
+    """Boilerplate for this script."""
+    if args is None:
+        args = sys.argv[1:]
+
+    usage_ = """%prog [OPTIONS] JsonFile [MoreJsonFiles...]
+Format/Beautify one or more JSON file(s)."""
+    parser = OptionParser(usage=usage_, version=VERSION)
+    parser.add_option("-i", "--indent", dest="indent_size",
+                default=DEFAULT_INDENT_SIZE, type="int",
+                help="Indent size to use (default: %default).")
+    parser.add_option("-c", "--compact", dest="compact",
+                action="store_true", default=False,
+                help="Use compact format (default: %default).")
+    parser.add_option("-n", "--dry-run", dest="dry_run",
+                action="store_true", default=False,
+                help="Check only if JSON is well-formed (default: %default).")
+    options, filenames = parser.parse_args(args)    #< pylint: disable=W0612
+    if not filenames:
+        parser.error("OOPS, no filenames provided.")
+    if options.compact:
+        options.indent_size = None
+
+    # -- STEP: Init logging subsystem.
+    format_ = "json.format: %(message)s"
+    logging.basicConfig(level=logging.WARN, format=format_)
+    console = logging.getLogger("console")
+
+    # -- DOS-SHELL SUPPORT: Perform filename globbing w/ wildcards.
+    skipped = 0
+    filenames2 = []
+    for filename in filenames:
+        if "*" in filenames:
+            files = glob.glob(filename)
+            filenames2.extend(files)
+        elif os.path.isdir(filename):
+            # -- CONVENIENCE-SHORTCUT: Use DIR as shortcut for JSON files.
+            files = glob.glob(os.path.join(filename, "*.json"))
+            filenames2.extend(files)
+            if not files:
+                console.info("SKIP %s, no JSON files found in dir.", filename)
+                skipped += 1
+        elif not os.path.exists(filename):
+            console.warn("SKIP %s, file not found.", filename)
+            skipped += 1
+            continue
+        else:
+            assert os.path.exists(filename)
+            filenames2.append(filename)
+    filenames = filenames2
+
+    # -- NORMAL PROCESSING:
+    errors  = json_formatall(filenames, options.indent_size,
+                             dry_run=options.dry_run)
+    console.error("Processed %d files (%d with errors, skipped=%d).",
+                  len(filenames), errors, skipped)
+    if not filenames:
+        errors += 1
+    return errors
+
+# ----------------------------------------------------------------------------
+# AUTO-MAIN:
+# ----------------------------------------------------------------------------
+if __name__ == "__main__":
+    sys.exit(main())

data/vendor/behave/bin/jsonschema_validate.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+"""
+Validate a JSON file against its JSON schema.
+
+SEE ALSO:
+  * https://python-jsonschema.readthedocs.org/
+  * https://python-jsonschema.readthedocs.org/en/latest/errors.html
+
+REQUIRES:
+  Python >= 2.6
+  jsonschema >= 1.3.0
+  argparse
+"""
+
+from __future__ import absolute_import, print_function
+
+__author__  = "Jens Engel"
+__version__ = "0.1.0"
+
+from jsonschema import validate
+import argparse
+import os.path
+import sys
+import textwrap
+try:
+    import json
+except ImportError:
+    try:
+        import simplejson as json
+    except ImportError:
+        sys.exit("REQUIRE: simplejson (which is not installed)")
+
+
+# -----------------------------------------------------------------------------
+# CONSTANTS:
+# -----------------------------------------------------------------------------
+HERE = os.path.dirname(__file__)
+TOP  = os.path.normpath(os.path.join(HERE, ".."))
+SCHEMA = os.path.join(TOP, "etc", "json", "behave.json-schema")
+
+
+# -----------------------------------------------------------------------------
+# FUNCTIONS:
+# -----------------------------------------------------------------------------
+def jsonschema_validate(filename, schema, encoding=None):
+    f = open(filename, "r")
+    contents = f.read()
+    f.close()
+    data = json.loads(contents, encoding=encoding)
+    return validate(data, schema)
+
+
+def main(args=None):
+    """
+    Validate JSON files against their JSON schema.
+    NOTE: Behave's JSON-schema is used per default.
+
+    SEE ALSO:
+      * http://json-schema.org/
+      * http://tools.ietf.org/html/draft-zyp-json-schema-04
+    """
+    if args is None:
+        args = sys.argv[1:]
+    default_schema = None
+    if os.path.exists(SCHEMA):
+        default_schema = SCHEMA
+
+    parser = argparse.ArgumentParser(
+                description=textwrap.dedent(main.__doc__),
+                formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    parser.add_argument("-v", "--version",
+                        action="version", version=__version__)
+    parser.add_argument("-s", "--schema",
+                        help="JSON schema to use.")
+    parser.add_argument("-e", "--encoding",
+                        help="Encoding for JSON/JSON schema.")
+    parser.add_argument("files", nargs="+", metavar="JSON_FILE",
+                        help="JSON file to check.")
+    parser.set_defaults(
+            schema=default_schema,
+            encoding="UTF-8"
+    )
+    options = parser.parse_args(args)
+    if not options.schema:
+        parser.error("REQUIRE: JSON schema")
+    elif not os.path.isfile(options.schema):
+        parser.error("SCHEMA not found: %s" % options.schema)
+
+    try:
+        f = open(options.schema, "r")
+        contents = f.read()
+        f.close()
+        schema = json.loads(contents, encoding=options.encoding)
+    except Exception as e:
+        msg = "ERROR: %s: %s (while loading schema)" % (e.__class__.__name__, e)
+        sys.exit(msg)
+
+    error_count = 0
+    for filename in options.files:
+        validated = True
+        more_info = None
+        try:
+            print("validate:", filename, "...", end=' ')
+            jsonschema_validate(filename, schema, encoding=options.encoding)
+        except Exception as e:
+            more_info = "%s: %s" % (e.__class__.__name__, e)
+            validated = False
+            error_count += 1
+        if validated:
+            print("OK")
+        else:
+            print("FAILED\n\n%s" % more_info)
+    return error_count
+
+
+# -----------------------------------------------------------------------------
+# AUTO-MAIN
+# -----------------------------------------------------------------------------
+if __name__ == "__main__":
+    sys.exit(main())

data/vendor/behave/bin/make_localpi.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Utility script to create a pypi-like directory structure (localpi)
+from a number of Python packages in a directory of the local filesystem.
+
+  DIRECTORY STRUCTURE (before):
+      +-- downloads/
+           +-- alice-1.0.zip
+           +-- alice-1.0.tar.gz
+           +-- bob-1.3.0.tar.gz
+           +-- bob-1.4.2.tar.gz
+           +-- charly-1.0.tar.bz2
+
+  DIRECTORY STRUCTURE (afterwards):
+      +-- downloads/
+           +-- simple/
+           |      +-- alice/index.html   --> ../../alice-*.*
+           |      +-- bob/index.html     --> ../../bob-*.*
+           |      +-- charly/index.html  --> ../../charly-*.*
+           |      +-- index.html  --> alice/, bob/, ...
+           +-- alice-1.0.zip
+           +-- alice-1.0.tar.gz
+           +-- bob-1.3.0.tar.gz
+           +-- bob-1.4.2.tar.gz
+           +-- charly-1.0.tar.bz2
+
+USAGE EXAMPLE:
+
+    mkdir -p /tmp/downloads
+    pip install --download=/tmp/downloads argparse Jinja2
+    make_localpi.py /tmp/downloads
+    pip install --index-url=file:///tmp/downloads/simple argparse Jinja2
+
+ALTERNATIVE:
+
+    pip install --download=/tmp/downloads argparse Jinja2
+    pip install --find-links=/tmp/downloads --no-index argparse Jinja2
+"""
+
+from __future__ import absolute_import, print_function, with_statement
+from fnmatch import fnmatch
+import os.path
+import shutil
+import sys
+
+
+__author__  = "Jens Engel"
+__version__ = "0.2"
+__license__ = "BSD"
+__copyright__ = "(c) 2013 by Jens Engel"
+
+
+class Package(object):
+    """
+    Package entity that keeps track of:
+      * one or more versions of this package
+      * one or more archive types
+    """
+    PATTERNS = [
+        "*.egg", "*.exe", "*.whl", "*.zip", "*.tar.gz", "*.tar.bz2", "*.7z"
+    ]
+
+    def __init__(self, filename, name=None):
+        if not name and filename:
+            name = self.get_pkgname(filename)
+        self.name  = name
+        self.files = []
+        if filename:
+            self.files.append(filename)
+
+    @property
+    def versions(self):
+        versions_info = [ self.get_pkgversion(p) for p in self.files ]
+        return versions_info
+
+    @classmethod
+    def split_pkgname_parts(cls, filename):
+        basename = cls.splitext(os.path.basename(filename))
+        if basename.startswith("http") and r"%2F" in basename:
+            # -- PIP DOWNLOAD-CACHE PACKAGE FILE NAME SCHEMA:
+            pos = basename.rfind("%2F")
+            basename = basename[pos+3:]
+
+        version_part_index = 0
+        parts = basename.split("-")
+        for index, part in enumerate(parts):
+            if index == 0:
+                continue
+            elif part and part[0].isdigit() and len(part) >= 3:
+                version_part_index = index
+                break
+        name = "-".join(parts[:version_part_index])
+        version = "0.0"
+        remainder = None
+        if version_part_index > 0:
+            version = parts[version_part_index]
+            if version_part_index+1 < len(parts):
+                remainder = "-".join(parts[version_part_index+1:])
+        assert name, "OOPS: basename=%s, name='%s'" % (basename, name)
+        return (name, version, remainder)
+
+
+    @classmethod
+    def get_pkgname(cls, filename):
+        return cls.split_pkgname_parts(filename)[0]
+
+    @classmethod
+    def get_pkgversion(cls, filename):
+        return cls.split_pkgname_parts(filename)[1]
+
+    @classmethod
+    def make_pkgname_with_version(cls, filename):
+        pkg_name = cls.get_pkgname(filename)
+        pkg_version = cls.get_pkgversion(filename)
+        return "%s-%s" % (pkg_name, pkg_version)
+
+    @staticmethod
+    def splitext(filename):
+        fname = os.path.splitext(filename)[0]
+        if fname.endswith(".tar"):
+            fname = os.path.splitext(fname)[0]
+        return fname
+
+    @classmethod
+    def isa(cls, filename):
+        basename = os.path.basename(filename)
+        if basename.startswith("."):
+            return False
+        for pattern in cls.PATTERNS:
+            if fnmatch(filename, pattern):
+                return True
+        return False
+
+def collect_packages(package_dir, package_map=None):
+    if package_map is None:
+        package_map = {}
+    packages = []
+    for filename in sorted(os.listdir(package_dir)):
+        if not Package.isa(filename):
+            continue
+        pkg_filepath = os.path.join(package_dir, filename)
+        package_name = Package.get_pkgname(pkg_filepath)
+        package = package_map.get(package_name, None)
+        if not package:
+            # -- NEW PACKAGE DETECTED: Store/register package.
+            package = Package(pkg_filepath)
+            package_map[package.name] = package
+            packages.append(package)
+        else:
+            # -- SAME PACKAGE: Collect other variant/version.
+            package.files.append(pkg_filepath)
+    return packages
+
+def make_index_for(package, index_dir, verbose=True):
+    """
+    Create an 'index.html' for one package.
+
+    :param package:   Package object to use.
+    :param index_dir: Where 'index.html' should be created.
+    """
+    index_template = """\
+<html>
+<head><title>{title}</title></head>
+<body>
+<h1>{title}</h1>
+<ul>
+{packages}
+</ul>
+</body>
+</html>
+"""
+    item_template = '<li><a href="{1}">{0}</a></li>'
+    index_filename = os.path.join(index_dir, "index.html")
+    if not os.path.isdir(index_dir):
+        os.makedirs(index_dir)
+
+    parts = []
+    for pkg_filename in package.files:
+        pkg_name = os.path.basename(pkg_filename)
+        if pkg_name == "index.html":
+            # -- ROOT-INDEX:
+            pkg_name = os.path.basename(os.path.dirname(pkg_filename))
+        else:
+            # pkg_name = package.splitext(pkg_name)
+            pkg_name = package.make_pkgname_with_version(pkg_filename)
+        pkg_relpath_to = os.path.relpath(pkg_filename, index_dir)
+        parts.append(item_template.format(pkg_name, pkg_relpath_to))
+
+    if not parts:
+        print("OOPS: Package %s has no files" % package.name)
+        return
+
+    if verbose:
+        root_index = not Package.isa(package.files[0])
+        if root_index:
+            info = "with %d package(s)" % len(package.files)
+        else:
+            package_versions = sorted(set(package.versions))
+            info = ", ".join(reversed(package_versions))
+        message = "%-30s  %s" % (package.name, info)
+        print(message)
+
+    with open(index_filename, "w") as f:
+        packages = "\n".join(parts)
+        text = index_template.format(title=package.name, packages=packages)
+        f.write(text.strip())
+        f.close()
+
+
+def make_package_index(download_dir):
+    """
+    Create a pypi server like file structure below download directory.
+
+    :param download_dir:    Download directory with packages.
+
+    EXAMPLE BEFORE:
+      +-- downloads/
+           +-- wheelhouse/bob-1.4.2-*.whl
+           +-- alice-1.0.zip
+           +-- alice-1.0.tar.gz
+           +-- bob-1.3.0.tar.gz
+           +-- bob-1.4.2.tar.gz
+           +-- charly-1.0.tar.bz2
+
+    EXAMPLE AFTERWARDS:
+      +-- downloads/
+           +-- simple/
+           |      +-- alice/index.html   --> ../../alice-*.*
+           |      +-- bob/index.html     --> ../../bob-*.*
+           |      +-- charly/index.html  --> ../../charly-*.*
+           |      +-- index.html  --> alice/index.html, bob/index.html, ...
+           +-- wheelhouse/bob-1.4.2-*.whl
+           +-- alice-1.0.zip
+           +-- alice-1.0.tar.gz
+           +-- bob-1.3.0.tar.gz
+           +-- bob-1.4.2.tar.gz
+           +-- charly-1.0.tar.bz2
+    """
+    if not os.path.isdir(download_dir):
+        raise ValueError("No such directory: %r" % download_dir)
+
+    pkg_rootdir = os.path.join(download_dir, "simple")
+    if os.path.isdir(pkg_rootdir):
+        shutil.rmtree(pkg_rootdir, ignore_errors=True)
+    os.mkdir(pkg_rootdir)
+
+    package_dirs = [download_dir]
+    wheelhouse_dir = os.path.join(download_dir, "wheelhouse")
+    if os.path.isdir(wheelhouse_dir):
+        print("Using wheelhouse: %s" % wheelhouse_dir)
+        package_dirs.append(wheelhouse_dir)
+
+    # -- STEP: Collect all packages.
+    package_map = {}
+    packages = []
+    for package_dir in package_dirs:
+        new_packages = collect_packages(package_dir, package_map)
+        packages.extend(new_packages)
+
+    # -- STEP: Make local PYTHON PACKAGE INDEX.
+    root_package = Package(None, "Python Package Index")
+    root_package.files = [ os.path.join(pkg_rootdir, pkg.name, "index.html")
+                           for pkg in packages ]
+    make_index_for(root_package, pkg_rootdir)
+    for package in packages:
+        index_dir = os.path.join(pkg_rootdir, package.name)
+        make_index_for(package, index_dir)
+
+
+# -----------------------------------------------------------------------------
+# MAIN:
+# -----------------------------------------------------------------------------
+if __name__ == "__main__":
+    if (len(sys.argv) != 2) or "-h" in sys.argv[1:] or "--help" in sys.argv[1:]:
+        print("USAGE: %s DOWNLOAD_DIR" % os.path.basename(sys.argv[0]))
+        print(__doc__)
+        sys.exit(1)
+    make_package_index(sys.argv[1])