libv8 8.4.255.0

data/vendor/depot_tools/subprocess2.py

@@ -0,0 +1,258 @@
+# coding=utf-8
+# Copyright (c) 2012 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+"""Collection of subprocess wrapper functions.
+
+In theory you shouldn't need anything else in subprocess, or this module failed.
+"""
+
+import codecs
+import errno
+import io
+import logging
+import os
+import subprocess
+import sys
+import threading
+
+# Cache the string-escape codec to ensure subprocess can find it later.
+# See crbug.com/912292#c2 for context.
+if sys.version_info.major == 2:
+  import Queue
+  codecs.lookup('string-escape')
+else:
+  import queue as Queue
+  # pylint: disable=redefined-builtin
+  basestring = (str, bytes)
+
+
+# Constants forwarded from subprocess.
+PIPE = subprocess.PIPE
+STDOUT = subprocess.STDOUT
+# Sends stdout or stderr to os.devnull.
+VOID = open(os.devnull, 'w')
+VOID_INPUT = open(os.devnull, 'r')
+
+
+class CalledProcessError(subprocess.CalledProcessError):
+  """Augment the standard exception with more data."""
+  def __init__(self, returncode, cmd, cwd, stdout, stderr):
+    super(CalledProcessError, self).__init__(returncode, cmd, output=stdout)
+    self.stdout = self.output  # for backward compatibility.
+    self.stderr = stderr
+    self.cwd = cwd
+
+  def __str__(self):
+    out = 'Command %r returned non-zero exit status %s' % (
+        ' '.join(self.cmd), self.returncode)
+    if self.cwd:
+      out += ' in ' + self.cwd
+    if self.stdout:
+      out += '\n' + self.stdout.decode('utf-8', 'ignore')
+    if self.stderr:
+      out += '\n' + self.stderr.decode('utf-8', 'ignore')
+    return out
+
+
+class CygwinRebaseError(CalledProcessError):
+  """Occurs when cygwin's fork() emulation fails due to rebased dll."""
+
+
+## Utility functions
+
+
+def kill_pid(pid):
+  """Kills a process by its process id."""
+  try:
+    # Unable to import 'module'
+    # pylint: disable=no-member,F0401
+    import signal
+    return os.kill(pid, signal.SIGTERM)
+  except ImportError:
+    pass
+
+
+def get_english_env(env):
+  """Forces LANG and/or LANGUAGE to be English.
+
+  Forces encoding to utf-8 for subprocesses.
+
+  Returns None if it is unnecessary.
+  """
+  if sys.platform == 'win32':
+    return None
+  env = env or os.environ
+
+  # Test if it is necessary at all.
+  is_english = lambda name: env.get(name, 'en').startswith('en')
+
+  if is_english('LANG') and is_english('LANGUAGE'):
+    return None
+
+  # Requires modifications.
+  env = env.copy()
+  def fix_lang(name):
+    if not is_english(name):
+      env[name] = 'en_US.UTF-8'
+  fix_lang('LANG')
+  fix_lang('LANGUAGE')
+  return env
+
+
+class Popen(subprocess.Popen):
+  """Wraps subprocess.Popen() with various workarounds.
+
+  - Forces English output since it's easier to parse the stdout if it is always
+    in English.
+  - Sets shell=True on windows by default. You can override this by forcing
+    shell parameter to a value.
+  - Adds support for VOID to not buffer when not needed.
+  - Adds self.start property.
+
+  Note: Popen() can throw OSError when cwd or args[0] doesn't exist. Translate
+  exceptions generated by cygwin when it fails trying to emulate fork().
+  """
+  # subprocess.Popen.__init__() is not threadsafe; there is a race between
+  # creating the exec-error pipe for the child and setting it to CLOEXEC during
+  # which another thread can fork and cause the pipe to be inherited by its
+  # descendents, which will cause the current Popen to hang until all those
+  # descendents exit. Protect this with a lock so that only one fork/exec can
+  # happen at a time.
+  popen_lock = threading.Lock()
+
+  def __init__(self, args, **kwargs):
+    env = get_english_env(kwargs.get('env'))
+    if env:
+      kwargs['env'] = env
+    if kwargs.get('env') is not None and sys.version_info.major != 2:
+      # Subprocess expects environment variables to be strings in Python 3.
+      def ensure_str(value):
+        if isinstance(value, bytes):
+          return value.decode()
+        return value
+
+      kwargs['env'] = {
+          ensure_str(k): ensure_str(v)
+          for k, v in kwargs['env'].items()
+      }
+    if kwargs.get('shell') is None:
+      # *Sigh*:  Windows needs shell=True, or else it won't search %PATH% for
+      # the executable, but shell=True makes subprocess on Linux fail when it's
+      # called with a list because it only tries to execute the first item in
+      # the list.
+      kwargs['shell'] = bool(sys.platform=='win32')
+
+    if isinstance(args, basestring):
+      tmp_str = args
+    elif isinstance(args, (list, tuple)):
+      tmp_str = ' '.join(args)
+    else:
+      raise CalledProcessError(None, args, kwargs.get('cwd'), None, None)
+    if kwargs.get('cwd', None):
+      tmp_str += ';  cwd=%s' % kwargs['cwd']
+    logging.debug(tmp_str)
+
+    try:
+      with self.popen_lock:
+        super(Popen, self).__init__(args, **kwargs)
+    except OSError as e:
+      if e.errno == errno.EAGAIN and sys.platform == 'cygwin':
+        # Convert fork() emulation failure into a CygwinRebaseError().
+        raise CygwinRebaseError(
+            e.errno,
+            args,
+            kwargs.get('cwd'),
+            None,
+            'Visit '
+            'http://code.google.com/p/chromium/wiki/CygwinDllRemappingFailure '
+            'to learn how to fix this error; you need to rebase your cygwin '
+            'dlls')
+      # Popen() can throw OSError when cwd or args[0] doesn't exist.
+      raise OSError('Execution failed with error: %s.\n'
+                    'Check that %s or %s exist and have execution permission.'
+                    % (str(e), kwargs.get('cwd'), args[0]))
+
+
+def communicate(args, **kwargs):
+  """Wraps subprocess.Popen().communicate().
+
+  Returns ((stdout, stderr), returncode).
+
+  - If the subprocess runs for |nag_timer| seconds without producing terminal
+    output, print a warning to stderr.
+  - Automatically passes stdin content as input so do not specify stdin=PIPE.
+  """
+  stdin = None
+  # When stdin is passed as an argument, use it as the actual input data and
+  # set the Popen() parameter accordingly.
+  if 'stdin' in kwargs and isinstance(kwargs['stdin'], basestring):
+    stdin = kwargs['stdin']
+    kwargs['stdin'] = PIPE
+
+  proc = Popen(args, **kwargs)
+  return proc.communicate(stdin), proc.returncode
+
+
+def call(args, **kwargs):
+  """Emulates subprocess.call().
+
+  Automatically convert stdout=PIPE or stderr=PIPE to VOID.
+  In no case they can be returned since no code path raises
+  subprocess2.CalledProcessError.
+
+  Returns exit code.
+  """
+  if kwargs.get('stdout') == PIPE:
+    kwargs['stdout'] = VOID
+  if kwargs.get('stderr') == PIPE:
+    kwargs['stderr'] = VOID
+  return communicate(args, **kwargs)[1]
+
+
+def check_call_out(args, **kwargs):
+  """Improved version of subprocess.check_call().
+
+  Returns (stdout, stderr), unlike subprocess.check_call().
+  """
+  out, returncode = communicate(args, **kwargs)
+  if returncode:
+    raise CalledProcessError(
+        returncode, args, kwargs.get('cwd'), out[0], out[1])
+  return out
+
+
+def check_call(args, **kwargs):
+  """Emulate subprocess.check_call()."""
+  check_call_out(args, **kwargs)
+  return 0
+
+
+def capture(args, **kwargs):
+  """Captures stdout of a process call and returns it.
+
+  Returns stdout.
+
+  - Discards returncode.
+  - Blocks stdin by default if not specified since no output will be visible.
+  """
+  kwargs.setdefault('stdin', VOID_INPUT)
+
+  # Like check_output, deny the caller from using stdout arg.
+  return communicate(args, stdout=PIPE, **kwargs)[0][0]
+
+
+def check_output(args, **kwargs):
+  """Emulates subprocess.check_output().
+
+  Captures stdout of a process call and returns stdout only.
+
+  - Throws if return code is not 0.
+  - Works even prior to python 2.7.
+  - Blocks stdin by default if not specified since no output will be visible.
+  - As per doc, "The stdout argument is not allowed as it is used internally."
+  """
+  kwargs.setdefault('stdin', VOID_INPUT)
+  if 'stdout' in kwargs:
+    raise ValueError('stdout argument not allowed, it would be overridden.')
+  return check_call_out(args, stdout=PIPE, **kwargs)[0]

data/vendor/depot_tools/third_party/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) 2010 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""File to enable importing from third_party."""

data/vendor/depot_tools/third_party/colorama/LICENSE.txt

@@ -0,0 +1,27 @@
+Copyright (c) 2010 Jonathan Hartley
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holders, nor those of its contributors
+  may be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/vendor/depot_tools/third_party/colorama/README.chromium

@@ -0,0 +1,12 @@
+Name: colorama
+URL: https://github.com/tartley/colorama
+Version: b71bec90d4770d4124ad95d70cc6a4c9289bbadf (0.4.1)
+Revision: b71bec90d4770d4124ad95d70cc6a4c9289bbadf
+
+Description:
+Provides a simple cross-platform API to print colored terminal text from Python
+applications.
+
+Additional changes:
+- Kept colorama/ but removed colorama/tests/.
+- Copied LICENSE.txt and README.rst.

data/vendor/depot_tools/third_party/colorama/README.rst

@@ -0,0 +1,346 @@
+.. image:: https://img.shields.io/pypi/v/colorama.svg
+    :target: https://pypi.org/project/colorama/
+    :alt: Latest Version
+
+.. image:: https://img.shields.io/pypi/pyversions/colorama.svg
+    :target: https://pypi.org/project/colorama/
+    :alt: Supported Python versions
+
+.. image:: https://travis-ci.org/tartley/colorama.svg?branch=master
+    :target: https://travis-ci.org/tartley/colorama
+    :alt: Build Status
+
+Download and docs:
+    https://pypi.org/project/colorama/
+Source code & Development:
+    https://github.com/tartley/colorama
+
+Description
+===========
+
+Makes ANSI escape character sequences (for producing colored terminal text and
+cursor positioning) work under MS Windows.
+
+ANSI escape character sequences have long been used to produce colored terminal
+text and cursor positioning on Unix and Macs. Colorama makes this work on
+Windows, too, by wrapping ``stdout``, stripping ANSI sequences it finds (which
+would appear as gobbledygook in the output), and converting them into the
+appropriate win32 calls to modify the state of the terminal. On other platforms,
+Colorama does nothing.
+
+Colorama also provides some shortcuts to help generate ANSI sequences
+but works fine in conjunction with any other ANSI sequence generation library,
+such as the venerable Termcolor (https://pypi.org/project/termcolor/)
+or the fabulous Blessings (https://pypi.org/project/blessings/).
+
+This has the upshot of providing a simple cross-platform API for printing
+colored terminal text from Python, and has the happy side-effect that existing
+applications or libraries which use ANSI sequences to produce colored output on
+Linux or Macs can now also work on Windows, simply by calling
+``colorama.init()``.
+
+An alternative approach is to install ``ansi.sys`` on Windows machines, which
+provides the same behaviour for all applications running in terminals. Colorama
+is intended for situations where that isn't easy (e.g., maybe your app doesn't
+have an installer.)
+
+Demo scripts in the source code repository print some colored text using
+ANSI sequences. Compare their output under Gnome-terminal's built in ANSI
+handling, versus on Windows Command-Prompt using Colorama:
+
+.. image:: https://github.com/tartley/colorama/raw/master/screenshots/ubuntu-demo.png
+    :width: 661
+    :height: 357
+    :alt: ANSI sequences on Ubuntu under gnome-terminal.
+
+.. image:: https://github.com/tartley/colorama/raw/master/screenshots/windows-demo.png
+    :width: 668
+    :height: 325
+    :alt: Same ANSI sequences on Windows, using Colorama.
+
+These screengrabs show that, on Windows, Colorama does not support ANSI 'dim
+text'; it looks the same as 'normal text'.
+
+
+License
+=======
+
+Copyright Jonathan Hartley 2013. BSD 3-Clause license; see LICENSE file.
+
+
+Dependencies
+============
+
+None, other than Python. Tested on Python 2.7, 3.4, 3.5 and 3.6.
+
+Usage
+=====
+
+Initialisation
+--------------
+
+Applications should initialise Colorama using:
+
+.. code-block:: python
+
+    from colorama import init
+    init()
+
+On Windows, calling ``init()`` will filter ANSI escape sequences out of any
+text sent to ``stdout`` or ``stderr``, and replace them with equivalent Win32
+calls.
+
+On other platforms, calling ``init()`` has no effect (unless you request other
+optional functionality; see "Init Keyword Args", below). By design, this permits
+applications to call ``init()`` unconditionally on all platforms, after which
+ANSI output should just work.
+
+To stop using colorama before your program exits, simply call ``deinit()``.
+This will restore ``stdout`` and ``stderr`` to their original values, so that
+Colorama is disabled. To resume using Colorama again, call ``reinit()``; it is
+cheaper to calling ``init()`` again (but does the same thing).
+
+
+Colored Output
+--------------
+
+Cross-platform printing of colored text can then be done using Colorama's
+constant shorthand for ANSI escape sequences:
+
+.. code-block:: python
+
+    from colorama import Fore, Back, Style
+    print(Fore.RED + 'some red text')
+    print(Back.GREEN + 'and with a green background')
+    print(Style.DIM + 'and in dim text')
+    print(Style.RESET_ALL)
+    print('back to normal now')
+
+...or simply by manually printing ANSI sequences from your own code:
+
+.. code-block:: python
+
+    print('\033[31m' + 'some red text')
+    print('\033[39m') # and reset to default color
+
+...or, Colorama can be used happily in conjunction with existing ANSI libraries
+such as Termcolor:
+
+.. code-block:: python
+
+    from colorama import init
+    from termcolor import colored
+
+    # use Colorama to make Termcolor work on Windows too
+    init()
+
+    # then use Termcolor for all colored text output
+    print(colored('Hello, World!', 'green', 'on_red'))
+
+Available formatting constants are::
+
+    Fore: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
+    Back: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
+    Style: DIM, NORMAL, BRIGHT, RESET_ALL
+
+``Style.RESET_ALL`` resets foreground, background, and brightness. Colorama will
+perform this reset automatically on program exit.
+
+
+Cursor Positioning
+------------------
+
+ANSI codes to reposition the cursor are supported. See ``demos/demo06.py`` for
+an example of how to generate them.
+
+
+Init Keyword Args
+-----------------
+
+``init()`` accepts some ``**kwargs`` to override default behaviour.
+
+init(autoreset=False):
+    If you find yourself repeatedly sending reset sequences to turn off color
+    changes at the end of every print, then ``init(autoreset=True)`` will
+    automate that:
+
+    .. code-block:: python
+
+        from colorama import init
+        init(autoreset=True)
+        print(Fore.RED + 'some red text')
+        print('automatically back to default color again')
+
+init(strip=None):
+    Pass ``True`` or ``False`` to override whether ansi codes should be
+    stripped from the output. The default behaviour is to strip if on Windows
+    or if output is redirected (not a tty).
+
+init(convert=None):
+    Pass ``True`` or ``False`` to override whether to convert ANSI codes in the
+    output into win32 calls. The default behaviour is to convert if on Windows
+    and output is to a tty (terminal).
+
+init(wrap=True):
+    On Windows, colorama works by replacing ``sys.stdout`` and ``sys.stderr``
+    with proxy objects, which override the ``.write()`` method to do their work.
+    If this wrapping causes you problems, then this can be disabled by passing
+    ``init(wrap=False)``. The default behaviour is to wrap if ``autoreset`` or
+    ``strip`` or ``convert`` are True.
+
+    When wrapping is disabled, colored printing on non-Windows platforms will
+    continue to work as normal. To do cross-platform colored output, you can
+    use Colorama's ``AnsiToWin32`` proxy directly:
+
+    .. code-block:: python
+
+        import sys
+        from colorama import init, AnsiToWin32
+        init(wrap=False)
+        stream = AnsiToWin32(sys.stderr).stream
+
+        # Python 2
+        print >>stream, Fore.BLUE + 'blue text on stderr'
+
+        # Python 3
+        print(Fore.BLUE + 'blue text on stderr', file=stream)
+
+
+Status & Known Problems
+=======================
+
+I've personally only tested it on Windows XP (CMD, Console2), Ubuntu
+(gnome-terminal, xterm), and OS X.
+
+Some presumably valid ANSI sequences aren't recognised (see details below),
+but to my knowledge nobody has yet complained about this. Puzzling.
+
+See outstanding issues and wishlist:
+https://github.com/tartley/colorama/issues
+
+If anything doesn't work for you, or doesn't do what you expected or hoped for,
+I'd love to hear about it on that issues list, would be delighted by patches,
+and would be happy to grant commit access to anyone who submits a working patch
+or two.
+
+
+Recognised ANSI Sequences
+=========================
+
+ANSI sequences generally take the form:
+
+    ESC [ <param> ; <param> ... <command>
+
+Where ``<param>`` is an integer, and ``<command>`` is a single letter. Zero or
+more params are passed to a ``<command>``. If no params are passed, it is
+generally synonymous with passing a single zero. No spaces exist in the
+sequence; they have been inserted here simply to read more easily.
+
+The only ANSI sequences that colorama converts into win32 calls are::
+
+    ESC [ 0 m       # reset all (colors and brightness)
+    ESC [ 1 m       # bright
+    ESC [ 2 m       # dim (looks same as normal brightness)
+    ESC [ 22 m      # normal brightness
+
+    # FOREGROUND:
+    ESC [ 30 m      # black
+    ESC [ 31 m      # red
+    ESC [ 32 m      # green
+    ESC [ 33 m      # yellow
+    ESC [ 34 m      # blue
+    ESC [ 35 m      # magenta
+    ESC [ 36 m      # cyan
+    ESC [ 37 m      # white
+    ESC [ 39 m      # reset
+
+    # BACKGROUND
+    ESC [ 40 m      # black
+    ESC [ 41 m      # red
+    ESC [ 42 m      # green
+    ESC [ 43 m      # yellow
+    ESC [ 44 m      # blue
+    ESC [ 45 m      # magenta
+    ESC [ 46 m      # cyan
+    ESC [ 47 m      # white
+    ESC [ 49 m      # reset
+
+    # cursor positioning
+    ESC [ y;x H     # position cursor at x across, y down
+    ESC [ y;x f     # position cursor at x across, y down
+    ESC [ n A       # move cursor n lines up
+    ESC [ n B       # move cursor n lines down
+    ESC [ n C       # move cursor n characters forward
+    ESC [ n D       # move cursor n characters backward
+
+    # clear the screen
+    ESC [ mode J    # clear the screen
+
+    # clear the line
+    ESC [ mode K    # clear the line
+
+Multiple numeric params to the ``'m'`` command can be combined into a single
+sequence::
+
+    ESC [ 36 ; 45 ; 1 m     # bright cyan text on magenta background
+
+All other ANSI sequences of the form ``ESC [ <param> ; <param> ... <command>``
+are silently stripped from the output on Windows.
+
+Any other form of ANSI sequence, such as single-character codes or alternative
+initial characters, are not recognised or stripped. It would be cool to add
+them though. Let me know if it would be useful for you, via the Issues on
+GitHub.
+
+
+Development
+===========
+
+Help and fixes welcome!
+
+Running tests requires:
+
+- Michael Foord's ``mock`` module to be installed.
+- Tests are written using 2010-era updates to ``unittest``
+
+To run tests::
+
+   python -m unittest discover -p *_test.py
+
+This, like a few other handy commands, is captured in a ``Makefile``.
+
+If you use nose to run the tests, you must pass the ``-s`` flag; otherwise,
+``nosetests`` applies its own proxy to ``stdout``, which confuses the unit
+tests.
+
+
+Thanks
+======
+* Marc Schlaich (schlamar) for a ``setup.py`` fix for Python2.5.
+* Marc Abramowitz, reported & fixed a crash on exit with closed ``stdout``,
+  providing a solution to issue #7's setuptools/distutils debate,
+  and other fixes.
+* User 'eryksun', for guidance on correctly instantiating ``ctypes.windll``.
+* Matthew McCormick for politely pointing out a longstanding crash on non-Win.
+* Ben Hoyt, for a magnificent fix under 64-bit Windows.
+* Jesse at Empty Square for submitting a fix for examples in the README.
+* User 'jamessp', an observant documentation fix for cursor positioning.
+* User 'vaal1239', Dave Mckee & Lackner Kristof for a tiny but much-needed Win7
+  fix.
+* Julien Stuyck, for wisely suggesting Python3 compatible updates to README.
+* Daniel Griffith for multiple fabulous patches.
+* Oscar Lesta for a valuable fix to stop ANSI chars being sent to non-tty
+  output.
+* Roger Binns, for many suggestions, valuable feedback, & bug reports.
+* Tim Golden for thought and much appreciated feedback on the initial idea.
+* User 'Zearin' for updates to the README file.
+* John Szakmeister for adding support for light colors
+* Charles Merriam for adding documentation to demos
+* Jurko for a fix on 64-bit Windows CPython2.5 w/o ctypes
+* Florian Bruhin for a fix when stdout or stderr are None
+* Thomas Weininger for fixing ValueError on Windows
+* Remi Rampin for better Github integration and fixes to the README file
+* Simeon Visser for closing a file handle using 'with' and updating classifiers
+  to include Python 3.3 and 3.4
+* Andy Neff for fixing RESET of LIGHT_EX colors.
+* Jonathan Hartley for the initial idea and implementation.