Move tracing/third_party/tvcm -> third_party/py_vulcanize.

tracing/third_party/tvcm/third_party/rcssmin/rcssmin.py

Index: tracing/third_party/tvcm/third_party/rcssmin/rcssmin.py
diff --git a/tracing/third_party/tvcm/third_party/rcssmin/rcssmin.py b/tracing/third_party/tvcm/third_party/rcssmin/rcssmin.py
deleted file mode 100644
index ae1cefc3396be21ef861d9bda163c69b3be50433..0000000000000000000000000000000000000000
--- a/tracing/third_party/tvcm/third_party/rcssmin/rcssmin.py
+++ /dev/null
@@ -1,374 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: ascii -*-
-r"""
-==============
- CSS Minifier
-==============
-
-CSS Minifier.
-
-The minifier is based on the semantics of the `YUI compressor`_\\, which
-itself is based on `the rule list by Isaac Schlueter`_\\.
-
-:Copyright:
-
- Copyright 2011 - 2014
- Andr\xe9 Malo or his licensors, as applicable
-
-:License:
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
-
-This module is a re-implementation aiming for speed instead of maximum
-compression, so it can be used at runtime (rather than during a preprocessing
-step). RCSSmin does syntactical compression only (removing spaces, comments
-and possibly semicolons). It does not provide semantic compression (like
-removing empty blocks, collapsing redundant properties etc). It does, however,
-support various CSS hacks (by keeping them working as intended).
-
-Here's a feature list:
-
-- Strings are kept, except that escaped newlines are stripped
-- Space/Comments before the very end or before various characters are
-  stripped: ``:{});=>+],!`` (The colon (``:``) is a special case, a single
-  space is kept if it's outside a ruleset.)
-- Space/Comments at the very beginning or after various characters are
-  stripped: ``{}(=:>+[,!``
-- Optional space after unicode escapes is kept, resp. replaced by a simple
-  space
-- whitespaces inside ``url()`` definitions are stripped
-- Comments starting with an exclamation mark (``!``) can be kept optionally.
-- All other comments and/or whitespace characters are replaced by a single
-  space.
-- Multiple consecutive semicolons are reduced to one
-- The last semicolon within a ruleset is stripped
-- CSS Hacks supported:
-
-  - IE7 hack (``>/**/``)
-  - Mac-IE5 hack (``/*\\*/.../**/``)
-  - The boxmodelhack is supported naturally because it relies on valid CSS2
-    strings
-  - Between ``:first-line`` and the following comma or curly brace a space is
-    inserted. (apparently it's needed for IE6)
-  - Same for ``:first-letter``
-
-rcssmin.c is a reimplementation of rcssmin.py in C and improves runtime up to
-factor 100 or so (depending on the input). docs/BENCHMARKS in the source
-distribution contains the details.
-
-Both python 2 (>= 2.4) and python 3 are supported.
-
-.. _YUI compressor: https://github.com/yui/yuicompressor/
-
-.. _the rule list by Isaac Schlueter: https://github.com/isaacs/cssmin/
-"""
-if __doc__:
-    # pylint: disable = W0622
-    __doc__ = __doc__.encode('ascii').decode('unicode_escape')
-__author__ = r"Andr\xe9 Malo".encode('ascii').decode('unicode_escape')
-__docformat__ = "restructuredtext en"
-__license__ = "Apache License, Version 2.0"
-__version__ = '1.0.5'
-__all__ = ['cssmin']
-
-import re as _re
-
-
-def _make_cssmin(python_only=False):
-    """
-    Generate CSS minifier.
-
-    :Parameters:
-      `python_only` : ``bool``
-        Use only the python variant. If true, the c extension is not even
-        tried to be loaded.
-
-    :Return: Minifier
-    :Rtype: ``callable``
-    """
-    # pylint: disable = R0912, R0914, W0612
-
-    if not python_only:
-        try:
-            import _rcssmin
-        except ImportError:
-            pass
-        else:
-            return _rcssmin.cssmin
-
-    nl = r'(?:[\n\f]|\r\n?)'  # pylint: disable = C0103
-    spacechar = r'[\r\n\f\040\t]'
-
-    unicoded = r'[0-9a-fA-F]{1,6}(?:[\040\n\t\f]|\r\n?)?'
-    escaped = r'[^\n\r\f0-9a-fA-F]'
-    escape = r'(?:\\(?:%(unicoded)s|%(escaped)s))' % locals()
-
-    nmchar = r'[^\000-\054\056\057\072-\100\133-\136\140\173-\177]'
-    #nmstart = r'[^\000-\100\133-\136\140\173-\177]'
-    #ident = (r'(?:'
-    #    r'-?(?:%(nmstart)s|%(escape)s)%(nmchar)s*(?:%(escape)s%(nmchar)s*)*'
-    #r')') % locals()
-
-    comment = r'(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)'
-
-    # only for specific purposes. The bang is grouped:
-    _bang_comment = r'(?:/\*(!?)[^*]*\*+(?:[^/*][^*]*\*+)*/)'
-
-    string1 = \
-        r'(?:\047[^\047\\\r\n\f]*(?:\\[^\r\n\f][^\047\\\r\n\f]*)*\047)'
-    string2 = r'(?:"[^"\\\r\n\f]*(?:\\[^\r\n\f][^"\\\r\n\f]*)*")'
-    strings = r'(?:%s|%s)' % (string1, string2)
-
-    nl_string1 = \
-        r'(?:\047[^\047\\\r\n\f]*(?:\\(?:[^\r]|\r\n?)[^\047\\\r\n\f]*)*\047)'
-    nl_string2 = r'(?:"[^"\\\r\n\f]*(?:\\(?:[^\r]|\r\n?)[^"\\\r\n\f]*)*")'
-    nl_strings = r'(?:%s|%s)' % (nl_string1, nl_string2)
-
-    uri_nl_string1 = r'(?:\047[^\047\\]*(?:\\(?:[^\r]|\r\n?)[^\047\\]*)*\047)'
-    uri_nl_string2 = r'(?:"[^"\\]*(?:\\(?:[^\r]|\r\n?)[^"\\]*)*")'
-    uri_nl_strings = r'(?:%s|%s)' % (uri_nl_string1, uri_nl_string2)
-
-    nl_escaped = r'(?:\\%(nl)s)' % locals()
-
-    space = r'(?:%(spacechar)s|%(comment)s)' % locals()
-
-    ie7hack = r'(?:>/\*\*/)'
-
-    uri = (r'(?:'
-        # noqa pylint: disable = C0330
-        r'(?:[^\000-\040"\047()\\\177]*'
-            r'(?:%(escape)s[^\000-\040"\047()\\\177]*)*)'
-        r'(?:'
-            r'(?:%(spacechar)s+|%(nl_escaped)s+)'
-            r'(?:'
-                r'(?:[^\000-\040"\047()\\\177]|%(escape)s|%(nl_escaped)s)'
-                r'[^\000-\040"\047()\\\177]*'
-                r'(?:%(escape)s[^\000-\040"\047()\\\177]*)*'
-            r')+'
-        r')*'
-    r')') % locals()
-
-    nl_unesc_sub = _re.compile(nl_escaped).sub
-
-    uri_space_sub = _re.compile((
-        r'(%(escape)s+)|%(spacechar)s+|%(nl_escaped)s+'
-    ) % locals()).sub
-    uri_space_subber = lambda m: m.groups()[0] or ''
-
-    space_sub_simple = _re.compile((
-        r'[\r\n\f\040\t;]+|(%(comment)s+)'
-    ) % locals()).sub
-    space_sub_banged = _re.compile((
-        r'[\r\n\f\040\t;]+|(%(_bang_comment)s+)'
-    ) % locals()).sub
-
-    post_esc_sub = _re.compile(r'[\r\n\f\t]+').sub
-
-    main_sub = _re.compile((
-        # noqa pylint: disable = C0330
-        r'([^\\"\047u>@\r\n\f\040\t/;:{}]+)'
-        r'|(?<=[{}(=:>+[,!])(%(space)s+)'
-        r'|^(%(space)s+)'
-        r'|(%(space)s+)(?=(([:{});=>+\],!])|$)?)'
-        r'|;(%(space)s*(?:;%(space)s*)*)(?=(\})?)'
-        r'|(\{)'
-        r'|(\})'
-        r'|(%(strings)s)'
-        r'|(?<!%(nmchar)s)url\(%(spacechar)s*('
-                r'%(uri_nl_strings)s'
-                r'|%(uri)s'
-            r')%(spacechar)s*\)'
-        r'|(@(?:'
-              r'[mM][eE][dD][iI][aA]'
-              r'|[sS][uU][pP][pP][oO][rR][tT][sS]'
-              r'|[dD][oO][cC][uU][mM][eE][nN][tT]'
-              r'|(?:-(?:'
-                  r'[wW][eE][bB][kK][iI][tT]|[mM][oO][zZ]|[oO]|[mM][sS]'
-                r')-)?'
-                r'[kK][eE][yY][fF][rR][aA][mM][eE][sS]'
-            r'))(?!%(nmchar)s)'
-        r'|(%(ie7hack)s)(%(space)s*)'
-        r'|(:[fF][iI][rR][sS][tT]-[lL]'
-            r'(?:[iI][nN][eE]|[eE][tT][tT][eE][rR]))'
-            r'(%(space)s*)(?=[{,])'
-        r'|(%(nl_strings)s)'
-        r'|(%(escape)s[^\\"\047u>@\r\n\f\040\t/;:{}]*)'
-    ) % locals()).sub
-
-    #print main_sub.__self__.pattern
-
-    def main_subber(keep_bang_comments):
-        """ Make main subber """
-        in_macie5, in_rule, at_group = [0], [0], [0]
-
-        if keep_bang_comments:
-            space_sub = space_sub_banged
-
-            def space_subber(match):
-                """ Space|Comment subber """
-                if match.lastindex:
-                    group1, group2 = match.group(1, 2)
-                    if group2:
-                        if group1.endswith(r'\*/'):
-                            in_macie5[0] = 1
-                        else:
-                            in_macie5[0] = 0
-                        return group1
-                    elif group1:
-                        if group1.endswith(r'\*/'):
-                            if in_macie5[0]:
-                                return ''
-                            in_macie5[0] = 1
-                            return r'/*\*/'
-                        elif in_macie5[0]:
-                            in_macie5[0] = 0
-                            return '/**/'
-                return ''
-        else:
-            space_sub = space_sub_simple
-
-            def space_subber(match):
-                """ Space|Comment subber """
-                if match.lastindex:
-                    if match.group(1).endswith(r'\*/'):
-                        if in_macie5[0]:
-                            return ''
-                        in_macie5[0] = 1
-                        return r'/*\*/'
-                    elif in_macie5[0]:
-                        in_macie5[0] = 0
-                        return '/**/'
-                return ''
-
-        def fn_space_post(group):
-            """ space with token after """
-            if group(5) is None or (
-                    group(6) == ':' and not in_rule[0] and not at_group[0]):
-                return ' ' + space_sub(space_subber, group(4))
-            return space_sub(space_subber, group(4))
-
-        def fn_semicolon(group):
-            """ ; handler """
-            return ';' + space_sub(space_subber, group(7))
-
-        def fn_semicolon2(group):
-            """ ; handler """
-            if in_rule[0]:
-                return space_sub(space_subber, group(7))
-            return ';' + space_sub(space_subber, group(7))
-
-        def fn_open(_):
-            """ { handler """
-            if at_group[0]:
-                at_group[0] -= 1
-            else:
-                in_rule[0] = 1
-            return '{'
-
-        def fn_close(_):
-            """ } handler """
-            in_rule[0] = 0
-            return '}'
-
-        def fn_at_group(group):
-            """ @xxx group handler """
-            at_group[0] += 1
-            return group(13)
-
-        def fn_ie7hack(group):
-            """ IE7 Hack handler """
-            if not in_rule[0] and not at_group[0]:
-                in_macie5[0] = 0
-                return group(14) + space_sub(space_subber, group(15))
-            return '>' + space_sub(space_subber, group(15))
-
-        table = (
-            # noqa pylint: disable = C0330
-            None,
-            None,
-            None,
-            None,
-            fn_space_post,                       # space with token after
-            fn_space_post,                       # space with token after
-            fn_space_post,                       # space with token after
-            fn_semicolon,                        # semicolon
-            fn_semicolon2,                       # semicolon
-            fn_open,                             # {
-            fn_close,                            # }
-            lambda g: g(11),                     # string
-            lambda g: 'url(%s)' % uri_space_sub(uri_space_subber, g(12)),
-                                                 # url(...)
-            fn_at_group,                         # @xxx expecting {...}
-            None,
-            fn_ie7hack,                          # ie7hack
-            None,
-            lambda g: g(16) + ' ' + space_sub(space_subber, g(17)),
-                                                 # :first-line|letter followed
-                                                 # by [{,] (apparently space
-                                                 # needed for IE6)
-            lambda g: nl_unesc_sub('', g(18)),   # nl_string
-            lambda g: post_esc_sub(' ', g(19)),  # escape
-        )
-
-        def func(match):
-            """ Main subber """
-            idx, group = match.lastindex, match.group
-            if idx > 3:
-                return table[idx](group)
-
-            # shortcuts for frequent operations below:
-            elif idx == 1:     # not interesting
-                return group(1)
-            #else: # space with token before or at the beginning
-            return space_sub(space_subber, group(idx))
-
-        return func
-
-    def cssmin(style, keep_bang_comments=False):  # pylint: disable = W0621
-        """
-        Minify CSS.
-
-        :Parameters:
-          `style` : ``str``
-            CSS to minify
-
-          `keep_bang_comments` : ``bool``
-            Keep comments starting with an exclamation mark? (``/*!...*/``)
-
-        :Return: Minified style
-        :Rtype: ``str``
-        """
-        return main_sub(main_subber(keep_bang_comments), style)
-
-    return cssmin
-
-cssmin = _make_cssmin()
-
-
-if __name__ == '__main__':
-    def main():
-        """ Main """
-        import sys as _sys
-        keep_bang_comments = (
-            '-b' in _sys.argv[1:]
-            or '-bp' in _sys.argv[1:]
-            or '-pb' in _sys.argv[1:]
-        )
-        if '-p' in _sys.argv[1:] or '-bp' in _sys.argv[1:] \
-                or '-pb' in _sys.argv[1:]:
-            global cssmin  # pylint: disable = W0603
-            cssmin = _make_cssmin(python_only=True)
-        _sys.stdout.write(cssmin(
-            _sys.stdin.read(), keep_bang_comments=keep_bang_comments
-        ))
-    main()