busser-behave 0.1.3

data/vendor/behave/behave/textutil.py

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+"""
+Provides some utility functions related to text processing.
+"""
+
+from __future__ import absolute_import, print_function
+import codecs
+import os
+import sys
+import six
+
+# -----------------------------------------------------------------------------
+# CONSTANTS:
+# -----------------------------------------------------------------------------
+# DEFAULT STRATEGY: For error handling when unicode-strings are converted.
+BEHAVE_UNICODE_ERRORS = os.environ.get("BEHAVE_UNICODE_ERRORS", "replace")
+
+
+# -----------------------------------------------------------------------------
+# FUNCTIONS:
+# -----------------------------------------------------------------------------
+def make_indentation(indent_size, part=u" "):
+    """Creates an indentation prefix string of the given size."""
+    return indent_size * part
+
+
+def indent(text, prefix):   # pylint: disable=redefined-outer-name
+    """Indent text or a number of text lines (with newline).
+
+    :param lines:  Text lines to indent (as string or list of strings).
+    :param prefix: Line prefix to use (as string).
+    :return: Indented text (as unicode string).
+    """
+    lines = text
+    newline = u""
+    if isinstance(text, six.string_types):
+        lines = text.splitlines(True)
+    elif lines and not lines[0].endswith("\n"):
+        # -- TEXT LINES: Without trailing new-line.
+        newline = u"\n"
+    # MAYBE: return newline.join([prefix + six.text_type(line, errors="replace")
+    return newline.join([prefix + six.text_type(line)  for line in lines])
+
+
+def compute_words_maxsize(words):
+    """Compute the maximum word size from a list of words (or strings).
+
+    :param words: List of words (or strings) to use.
+    :return: Maximum size of all words.
+    """
+    max_size = 0
+    for word in words:
+        if len(word) > max_size:
+            max_size = len(word)
+    return max_size
+
+
+def is_ascii_encoding(encoding):
+    """Checks if a given encoding is ASCII."""
+    try:
+        return codecs.lookup(encoding).name == "ascii"
+    except LookupError:
+        return False
+
+def select_best_encoding(outstream=None):
+    """Select the *best* encoding for an output stream/file.
+    Uses:
+    * ``outstream.encoding`` (if available)
+    * ``sys.getdefaultencoding()`` (otherwise)
+
+    Note: If encoding=ascii, uses encoding=UTF-8
+
+    :param outstream:  Output stream to select encoding for (or: stdout)
+    :return: Unicode encoding name (as string) to use (for output stream).
+    """
+    outstream = outstream or sys.stdout
+    encoding = getattr(outstream, "encoding", None) or sys.getdefaultencoding()
+    if is_ascii_encoding(encoding):
+        # -- REQUIRED-FOR: Python2
+        # MAYBE: locale.getpreferredencoding()
+        return "utf-8"
+    return encoding
+
+
+def text(value, encoding=None, errors=None):
+    """Convert into a unicode string.
+
+    :param value:  Value to convert into a unicode string (bytes, str, object).
+    :return: Unicode string
+
+    SYNDROMES:
+      * Convert object to unicode: Has only __str__() method (Python2)
+      * Windows: exception-traceback and encoding=unicode-escape are BAD
+      * exception-traceback w/ weird encoding or bytes
+
+    ALTERNATIVES:
+      * Use traceback2 for Python2: Provides unicode tracebacks
+    """
+    if encoding is None:
+        encoding = select_best_encoding()
+    if errors is None:
+        errors = BEHAVE_UNICODE_ERRORS
+
+    if isinstance(value, six.text_type):
+        # -- CASE: ALREADY UNICODE (pass-through, efficiency):
+        return value
+    elif isinstance(value, six.binary_type):
+        # -- CASE: bytes/binary_type (Python2: str)
+        try:
+            return six.text_type(value, encoding, errors)
+        except UnicodeError:
+            # -- BEST-EFFORT:
+            return six.u(value)
+    # elif isinstance(value, bytes):
+    #     # -- MAYBE: filename, path, etc.
+    #     try:
+    #         return value.decode(sys.getfilesystemencoding())
+    #     except UnicodeError:
+    #         return value.decode("utf-8", "replace") # MAYBE: "ignore"
+    else:
+        # -- CASE: CONVERT/CAST OBJECT TO TEXT/STRING
+        try:
+            if six.PY2:
+                try:
+                    text2 = six.text_type(value)
+                except UnicodeError as e:
+                    # -- NOTE: value has no sane unicode conversion
+                    #  encoding=unicode-escape helps recover from errors.
+                    data = str(value)
+                    text2 = six.text_type(data, "unicode-escape", "replace")
+            else:
+                # PY3: Cast to string/unicode
+                text2 = six.text_type(value)
+        except UnicodeError as e:
+            # Python3: multi-arg call supports only string-like object: str, bytes
+            text2 = six.text_type(e)
+        return text2

data/vendor/behave/behave/userdata.py

@@ -0,0 +1,130 @@
+# -*- coding: UTF-8 -*-
+"""
+Functionality to support user-specific configuration data (userdata).
+"""
+
+from __future__ import absolute_import
+from behave._types import Unknown
+
+
+# -----------------------------------------------------------------------------
+# FUNCTIONS:
+# -----------------------------------------------------------------------------
+def parse_bool(text):
+    """Parses a boolean text and converts it into boolean value (if possible).
+    Supported truth string values:
+
+      * true:   "true", "yes", "on", "1"
+      * false:  "false", "no", "off", "0"
+
+    :raises: ValueError, if text is invalid
+    """
+    from distutils.util import strtobool
+    return bool(strtobool(text))
+
+
+def parse_user_define(text):
+    """Parse "{name}={value}" text and return parts as tuple.
+    Used for command-line definitions, like "... -D name=value".
+
+    SUPPORTED SCHEMA:
+
+      * "{name}={value}"
+      * "{name}"                (boolean flag; value="true")
+      * '"{name}={value}"'      (double-quoted name-value pair)
+      * "'{name}={value}'"      (single-quoted name-value pair)
+      * '{name}="{value}"'      (double-quoted value)
+      * "{name}='{value}'"      (single-quoted value)
+      * "  {name} = {value}  "  (whitespace padded)
+
+    .. note:: Leading/trailing Quotes are stripped.
+
+    :param text:    Text to parse (as string).
+    :return: (name, value) pair as tuple.
+    """
+    text = text.strip()
+    if "=" in text:
+        text = unqote(text)
+        name, value = text.split("=", 1)
+        name = name.strip()
+        value = unqote(value.strip())
+    else:
+        # -- ASSUMPTION: Boolean definition (as flag)
+        name = text
+        value = "true"
+    return (name, value)
+
+
+def unqote(text):
+    """Strip pair of leading and trailing quotes from text."""
+    # -- QUOTED: Strip single-quote or double-quote pair.
+    if ((text.startswith('"') and text.endswith('"')) or
+            (text.startswith("'") and text.endswith("'"))):
+        text = text[1:-1]
+    return text
+
+# -----------------------------------------------------------------------------
+# CLASSES:
+# -----------------------------------------------------------------------------
+class UserData(dict):
+    """Dictionary-like user-data with some additional features:
+
+      * type-converter methods, similar to configparser.ConfigParser.getint()
+
+    """
+
+    def getas(self, convert, name, default=None, valuetype=None):
+        """Converts the value of user-data parameter from a string into a
+        specific value type.
+
+        :param convert: Converter function to use (string to value-type).
+        :param name:    Variable name to use.
+        :param default: Default value, used if parameter is not found.
+        :param valuetype: Value type(s), needed if convert != valuetype()
+        :return: Converted textual value (type: valuetype)
+        :return: Default value, if parameter is unknown.
+        :raises ValueError: If type conversion fails.
+        """
+        if valuetype is None:
+            # -- ASSUME: Converter function is the type constructor.
+            valuetype = convert
+
+        value = self.get(name, Unknown)
+        if value is Unknown:
+            return default
+        elif isinstance(value, valuetype):
+            # -- PRESERVE: Pre-converted value if type matches.
+            return value
+        else:
+            # -- CASE: Textual value (expected)
+            # Raise ValueError if parse/conversion fails.
+            assert callable(convert)
+            return convert(value)
+
+    def getint(self, name, default=0):
+        """Convert parameter value (as string) into a integer value.
+        :return: Parameter value as integer number (on success).
+        :raises: ValueError, if type conversion fails.
+        """
+        return self.getas(int, name, default)
+
+    def getfloat(self, name, default=0.0):
+        """Convert parameter value (as string) into a float value.
+        :return: Parameter value as float number (on success).
+        :raises: ValueError, if type conversion fails.
+        """
+        return self.getas(float, name, default)
+
+    def getbool(self, name, default=False):
+        """Converts user-data string-value into boolean value (if possible).
+        Supported truth string values:
+
+          * true:   "true", "yes", "on", "1"
+          * false:  "false", "no", "off", "0"
+
+        :param name: Parameter name (as string).
+        :param default: Default value, if parameter is unknown (=False).
+        :return: Boolean value of parameter
+        :raises: ValueError, if type conversion fails.
+        """
+        return self.getas(parse_bool, name, default, valuetype=bool)

data/vendor/behave/behave4cmd0/__all_steps__.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+"""
+Import all step definitions of this step-library.
+Step definitions are automatically registered in "behave.step_registry".
+"""
+
+from __future__ import absolute_import
+
+# -- IMPORT STEP-LIBRARY: behave4cmd0
+import behave4cmd0.command_steps
+import behave4cmd0.note_steps
+import behave4cmd0.log.steps

data/vendor/behave/behave4cmd0/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+"""
+Predecessor of behave4cmd library.
+Currently used to provide self-tests for behave.
+"""

data/vendor/behave/behave4cmd0/__setup.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+import os.path
+
+# -----------------------------------------------------------------------------
+# CONSTANTS:
+# -----------------------------------------------------------------------------
+HERE    = os.path.dirname(__file__)
+TOP     = os.path.join(HERE, "..")
+TOPA    = os.path.abspath(TOP)

data/vendor/behave/behave4cmd0/command_shell.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Provide a behave shell to simplify creation of feature files
+and running features, etc.
+
+    context.command_result = behave_shell.behave(cmdline, cwd=context.workdir)
+    behave_shell.create_scenario(scenario_text, cwd=context.workdir)
+    behave_shell.create_step_definition(context.text, cwd=context.workdir)
+    context.command_result = behave_shell.run_feature_with_formatter(
+            context.features[0], formatter=formatter, cwd=context.workdir)
+
+"""
+
+from __future__ import absolute_import, print_function, with_statement
+from behave4cmd0.__setup import TOP
+from behave.textutil import text as _text
+import os.path
+import six
+import subprocess
+import sys
+import shlex
+if six.PY2:
+    import codecs
+
+
+# HERE = os.path.dirname(__file__)
+# TOP  = os.path.join(HERE, "..")
+
+# -----------------------------------------------------------------------------
+# CLASSES:
+# -----------------------------------------------------------------------------
+class CommandResult(object):
+    """
+    ValueObject to store the results of a subprocess command call.
+    """
+    def __init__(self, **kwargs):
+        self.command = kwargs.pop("command", None)
+        self.returncode = kwargs.pop("returncode", 0)
+        self.stdout = kwargs.pop("stdout", "")
+        self.stderr = kwargs.pop("stderr", "")
+        self._output = None
+        if kwargs:
+            names = ", ".join(kwargs.keys())
+            raise ValueError("Unexpected: %s" % names)
+
+    @property
+    def output(self):
+        if self._output is None:
+            output = self.stdout
+            if self.stderr:
+                if self.stdout:
+                    output += "\n"
+                output += self.stderr
+            self._output = output
+        return self._output
+
+    @property
+    def failed(self):
+        return self.returncode != 0
+
+    def clear(self):
+        self.command = None
+        self.returncode = 0
+        self.stdout = ""
+        self.stderr = ""
+        self._output = None
+
+
+class Command(object):
+    """
+    Helper class to run commands as subprocess,
+    collect their output and subprocess returncode.
+    """
+    DEBUG = False
+    COMMAND_MAP = {
+        "behave": os.path.normpath("{0}/bin/behave".format(TOP))
+    }
+    PREPROCESSOR_MAP = {}
+    POSTPROCESSOR_MAP = {}
+    USE_SHELL = sys.platform.startswith("win")
+
+    @staticmethod
+    def preprocess_command(preprocessors, cmdargs, command=None, cwd="."):
+        if not os.path.isdir(cwd):
+            return cmdargs
+        elif not command:
+            command = " ".join(cmdargs)
+
+        for preprocess in preprocessors:
+            cmdargs = preprocess(command, cmdargs, cwd)
+        return cmdargs
+
+    @staticmethod
+    def postprocess_command(postprocessors, command_result):
+        for postprocess in postprocessors:
+            command_result = postprocess(command_result)
+        return command_result
+
+    @classmethod
+    def run(cls, command, cwd=".", **kwargs):
+        """
+        Make a subprocess call, collect its output and returncode.
+        Returns CommandResult instance as ValueObject.
+        """
+        assert isinstance(command, six.string_types)
+        command_result = CommandResult()
+        command_result.command = command
+        use_shell = cls.USE_SHELL
+        if "shell" in kwargs:
+            use_shell = kwargs.pop("shell")
+
+        # -- BUILD COMMAND ARGS:
+        if six.PY2 and isinstance(command, six.text_type):
+            # -- PREPARE-FOR: shlex.split()
+            # In PY2, shlex.split() requires bytes string (non-unicode).
+            # In PY3, shlex.split() accepts unicode string.
+            command = codecs.encode(command, "utf-8")
+        cmdargs = shlex.split(command)
+
+        # -- TRANSFORM COMMAND (optional)
+        command0 = cmdargs[0]
+        real_command = cls.COMMAND_MAP.get(command0, None)
+        if real_command:
+            cmdargs0 = real_command.split()
+            cmdargs = cmdargs0 + cmdargs[1:]
+        preprocessors = cls.PREPROCESSOR_MAP.get(command0)
+        if preprocessors:
+            cmdargs = cls.preprocess_command(preprocessors, cmdargs, command, cwd)
+
+
+        # -- RUN COMMAND:
+        try:
+            process = subprocess.Popen(cmdargs,
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE,
+                            universal_newlines=True,
+                            shell=use_shell,
+                            cwd=cwd, **kwargs)
+            out, err = process.communicate()
+            if six.PY2: # py3: we get unicode strings, py2 not
+                # default_encoding = "UTF-8"
+                out = _text(out, process.stdout.encoding)
+                err = _text(err, process.stderr.encoding)
+            process.poll()
+            assert process.returncode is not None
+            command_result.stdout = out
+            command_result.stderr = err
+            command_result.returncode = process.returncode
+            if cls.DEBUG:
+                print("shell.cwd={0}".format(kwargs.get("cwd", None)))
+                print("shell.command: {0}".format(" ".join(cmdargs)))
+                print("shell.command.output:\n{0};".format(command_result.output))
+        except OSError as e:
+            command_result.stderr = u"OSError: %s" % e
+            command_result.returncode = e.errno
+            assert e.errno != 0
+
+        postprocessors = cls.POSTPROCESSOR_MAP.get(command0)
+        if postprocessors:
+            command_result = cls.postprocess_command(postprocessors, command_result)
+        return command_result
+
+
+# -----------------------------------------------------------------------------
+# PREPROCESSOR:
+# -----------------------------------------------------------------------------
+def path_glob(command, cmdargs, cwd="."):
+    import glob
+    if not glob.has_magic(command):
+        return cmdargs
+
+    assert os.path.isdir(cwd)
+    try:
+        current_cwd = os.getcwd()
+        os.chdir(cwd)
+        new_cmdargs = []
+        for cmdarg in cmdargs:
+            if not glob.has_magic(cmdarg):
+                new_cmdargs.append(cmdarg)
+                continue
+
+            more_args = glob.glob(cmdarg)
+            if more_args:
+                new_cmdargs.extend(more_args)
+            else:
+                # -- BAD-CASE: Require at least one match.
+                # Otherwise, restore original arg.
+                new_cmdargs.append(cmdarg)
+
+        cmdargs = new_cmdargs
+    finally:
+        os.chdir(current_cwd)
+    return cmdargs
+
+# -----------------------------------------------------------------------------
+# FUNCTIONS:
+# -----------------------------------------------------------------------------
+def run(command, cwd=".", **kwargs):
+    return Command.run(command, cwd=cwd, **kwargs)
+
+def behave(cmdline, cwd=".", **kwargs):
+    """
+    Run behave as subprocess command and return process/shell instance
+    with results (collected output, returncode).
+    """
+    assert isinstance(cmdline, six.string_types)
+    return run("behave " + cmdline, cwd=cwd, **kwargs)
+
+# -----------------------------------------------------------------------------
+# TEST MAIN:
+# -----------------------------------------------------------------------------
+if __name__ == "__main__":
+    command = " ".join(sys.argv[1:])
+    output = Command.run(sys.argv[1:])
+    print("command: {0}\n{1}\n".format(command, output))