├── requirements.txt
├── htmlmin
    ├── tests
    │   ├── __init__.py
    │   ├── test_escape.py
    │   └── tests.py
    ├── __init__.py
    ├── decorator.py
    ├── middleware.py
    ├── python3html
    │   ├── __init__.py
    │   ├── LICENSE
    │   └── parser.py
    ├── command.py
    ├── escape.py
    ├── main.py
    └── parser.py
├── MANIFEST.in
├── .gitignore
├── docs
    ├── tutorial.rst
    ├── reference.rst
    ├── index.rst
    ├── make.bat
    ├── Makefile
    ├── quickstart.rst
    └── conf.py
├── tox.ini
├── .travis.yml
├── README.rst
├── CHANGELOG
├── setup.py
└── LICENSE


/requirements.txt:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/htmlmin/tests/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/MANIFEST.in:
--------------------------------------------------------------------------------
1 | include README.rst
2 | include LICENSE
3 | prune htmlmin/tests
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | *~
3 | build
4 | _build
5 | *.egg-info
6 | dist
7 | .tox
8 | 


--------------------------------------------------------------------------------
/docs/tutorial.rst:
--------------------------------------------------------------------------------
1 | Tutorial & Examples
2 | ===================
3 | 
4 | Coming soon...
5 | 


--------------------------------------------------------------------------------
/tox.ini:
--------------------------------------------------------------------------------
1 | [tox]
2 | envlist=py27, py33, py34
3 | 
4 | [testenv]
5 | commands=python setup.py test
6 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: python
2 | python:
3 |   - "2.7"
4 |   - "3.5"
5 | install: "pip install -r requirements.txt"
6 | script: "python setup.py test"
7 | 


--------------------------------------------------------------------------------
/README.rst:
--------------------------------------------------------------------------------
1 | A configurable HTML Minifier with safety features.
2 | 
3 | .. image:: https://travis-ci.org/mankyd/htmlmin.png?branch=master
4 |    :target: http://travis-ci.org/mankyd/htmlmin
5 | 
6 | Documentation: https://htmlmin.readthedocs.io/en/latest/
7 | 


--------------------------------------------------------------------------------
/docs/reference.rst:
--------------------------------------------------------------------------------
 1 | API Reference
 2 | =============
 3 | 
 4 | Main Functions
 5 | --------------
 6 | .. autofunction:: htmlmin.minify
 7 | 
 8 | .. autoclass:: htmlmin.Minifier
 9 |    :members:
10 |    :member-order: bysource
11 | 
12 | WSGI Middlware
13 | --------------
14 | .. autoclass:: htmlmin.middleware.HTMLMinMiddleware
15 | 
16 | Decorator
17 | ---------
18 | .. autofunction:: htmlmin.decorator.htmlmin
19 | 


--------------------------------------------------------------------------------
/CHANGELOG:
--------------------------------------------------------------------------------
 1 | 0.1.12
 2 | ======
 3 | * Fix bug that can occur when minifying two pages in a row when the
 4 |   first page has a dangling tag.
 5 | 
 6 | 0.1.11
 7 | ======
 8 | * Fix XSS
 9 | * Add support for a 'pre' attribute prefix
10 | * Remove redundat 'lang' tags
11 |   (thanks mina86)
12 | * Fixed IndexError when data is empty
13 |   (thanks mercuree)
14 | 
15 | 0.1.10
16 | ======
17 | * Fix bug in Python 3.5 where char refs were being improperly escaped
18 |   (thanks tenzer)
19 | 
20 | 0.1.9
21 | =====
22 | * Fix bug introduced in 0.1.7 involving spaces in attribute values
23 | 
24 | 
25 | 0.1.8
26 | =====
27 | * Fix bug introduced in 0.1.7 involving repeated ampersands.
28 | 
29 | 0.1.7
30 | =====
31 | * Improved attribute escaping. Greatly improves compression.
32 | 
33 | 0.1.6
34 | =====
35 | * Always quote attributes that end in "/". (Thanks nvie)
36 | * Use StringIO to speed up string building. (Thanks nvie)
37 | * Typo fixes in documentation. (Thanks aabrahamowicz and Namibnat)
38 | * Keep Microsoft's conditional comments. (Thanks mreinhardt)
39 | * Properly handle empty comments. (Thanks Epsirom)
40 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | from setuptools import setup, find_packages
 3 | 
 4 | from htmlmin import __version__
 5 | 
 6 | here = os.path.dirname(__file__)
 7 | 
 8 | README = open(os.path.join(here, 'README.rst')).read()
 9 | LICENSE = open(os.path.join(here, 'LICENSE')).read()
10 | 
11 | setup(
12 |     name='htmlmin',
13 |     version=__version__,
14 |     license='BSD',
15 |     description='An HTML Minifier',
16 |     long_description=README,
17 |     url='https://htmlmin.readthedocs.io/en/latest/',
18 |     download_url='https://github.com/mankyd/htmlmin',
19 |     author='Dave Mankoff',
20 |     author_email='mankyd@gmail.com',
21 |     packages=find_packages(),
22 |     include_package_data=True,
23 |     zip_safe=True,
24 |     test_suite='htmlmin.tests.tests.suite',
25 |     install_requires=[],
26 |     tests_require=[],
27 |     classifiers=[
28 |         "Development Status :: 4 - Beta",
29 |         "Intended Audience :: Developers",
30 |         "License :: OSI Approved :: BSD License",
31 |         "Operating System :: OS Independent",
32 |         "Programming Language :: Python",
33 |         "Programming Language :: Python :: 2.7",
34 |         "Programming Language :: Python :: 3.2",
35 |         "Topic :: Text Processing :: Markup :: HTML",
36 |     ],
37 |     entry_points={
38 |         'console_scripts': [
39 |             'htmlmin = htmlmin.command:main',
40 |         ],
41 |     },
42 | )
43 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2013, Dave Mankoff
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without
 5 | modification, are permitted provided that the following conditions are met:
 6 |     * Redistributions of source code must retain the above copyright
 7 |       notice, this list of conditions and the following disclaimer.
 8 |     * Redistributions in binary form must reproduce the above copyright
 9 |       notice, this list of conditions and the following disclaimer in the
10 |       documentation and/or other materials provided with the distribution.
11 |     * Neither the name of Dave Mankoff nor the
12 |       names of its contributors may be used to endorse or promote products
13 |       derived from this software without specific prior written permission.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
16 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 | DISCLAIMED. IN NO EVENT SHALL DAVE MANKOFF BE LIABLE FOR ANY
19 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
22 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 | 


--------------------------------------------------------------------------------
/htmlmin/__init__.py:
--------------------------------------------------------------------------------
 1 | """
 2 | Copyright (c) 2013, Dave Mankoff
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without
 6 | modification, are permitted provided that the following conditions are met:
 7 |     * Redistributions of source code must retain the above copyright
 8 |       notice, this list of conditions and the following disclaimer.
 9 |     * Redistributions in binary form must reproduce the above copyright
10 |       notice, this list of conditions and the following disclaimer in the
11 |       documentation and/or other materials provided with the distribution.
12 |     * Neither the name of Dave Mankoff nor the
13 |       names of its contributors may be used to endorse or promote products
14 |       derived from this software without specific prior written permission.
15 | 
16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 | DISCLAIMED. IN NO EVENT SHALL DAVE MANKOFF BE LIABLE FOR ANY
20 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 | """
27 | 
28 | from .main import minify, Minifier
29 | 
30 | __version__ = '0.1.12'
31 | 


--------------------------------------------------------------------------------
/htmlmin/decorator.py:
--------------------------------------------------------------------------------
 1 | """
 2 | Copyright (c) 2013, Dave Mankoff
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without
 6 | modification, are permitted provided that the following conditions are met:
 7 |     * Redistributions of source code must retain the above copyright
 8 |       notice, this list of conditions and the following disclaimer.
 9 |     * Redistributions in binary form must reproduce the above copyright
10 |       notice, this list of conditions and the following disclaimer in the
11 |       documentation and/or other materials provided with the distribution.
12 |     * Neither the name of Dave Mankoff nor the
13 |       names of its contributors may be used to endorse or promote products
14 |       derived from this software without specific prior written permission.
15 | 
16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 | DISCLAIMED. IN NO EVENT SHALL DAVE MANKOFF BE LIABLE FOR ANY
20 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 | """
27 | 
28 | from .main import Minifier
29 | 
30 | def htmlmin(*args, **kwargs):
31 |   """Minifies HTML that is returned by a function.
32 | 
33 |   A simple decorator that minifies the HTML output of any function that it
34 |   decorates. It supports all the same options that :class:`htmlmin.minify` has.
35 |   With no options, it uses ``minify``'s default settings::
36 | 
37 |       @htmlmin
38 |       def foobar():
39 |          return '   minify me!   '
40 | 
41 |   or::
42 | 
43 |       @htmlmin(remove_comments=True)
44 |       def foobar():
45 |          return '   minify me!  <!-- and remove me! -->'
46 |   """
47 |   def _decorator(fn):
48 |     minify = Minifier(**kwargs).minify
49 |     def wrapper(*a, **kw):
50 |       return minify(fn(*a, **kw))
51 |     return wrapper
52 | 
53 |   if len(args) == 1:
54 |     if callable(args[0]) and not kwargs:
55 |       return _decorator(args[0])
56 |     else:
57 |       raise RuntimeError(
58 |           'htmlmin decorator does accept positional arguments')
59 |   elif len(args) > 1:
60 |     raise RuntimeError(
61 |       'htmlmin decorator does accept positional arguments')
62 |   else:
63 |     return _decorator
64 |         
65 | 


--------------------------------------------------------------------------------
/docs/index.rst:
--------------------------------------------------------------------------------
 1 | .. htmlmin documentation master file, created by
 2 |    sphinx-quickstart on Thu Feb 14 22:56:34 2013.
 3 |    You can adapt this file completely to your liking, but it should at least
 4 |    contain the root `toctree` directive.
 5 | 
 6 | htmlmin
 7 | ===================================
 8 | An HTML Minifier with Seatbelts
 9 | 
10 | .. toctree::
11 | 
12 |    quickstart
13 |    tutorial
14 |    reference
15 | 
16 | 
17 | htmlmin is an HTML minifier that just works. It comes with safe defaults and
18 | an easily configurable set options. It can turn this::
19 | 
20 |   <html>
21 |     <head>
22 |       <title>  Hello, World!  </title>
23 |     </head>
24 |     <body>
25 |       <p> How are <em>you</em> doing?  </p>
26 |     </body>
27 |   </html>
28 | 
29 | Into this::
30 | 
31 |   <html><head><title>Hello, World!</title><body><p> How are <em>you</em> doing? </p></body></html>
32 | 
33 | When we say that htmlmin has 'seatbelts', what we mean is that it comes with
34 | features that you can use to safely minify beyond the defaults, but you have to
35 | put them in yourself. For instance, by default, htmlmin will never minimize the
36 | content between ``<pre>``, ``<textarea>``, ``<script>``, and ``<style>`` tags.
37 | You can also  explicitly tell it to not minify additional tags either globally 
38 | by name or by adding the custom ``pre`` attribute to a tag in your HTML. htmlmin 
39 | will remove the ``pre`` attributes as it parses your HTML automatically.
40 | 
41 | It also includes a command-line tool for easy invocation and integration with
42 | existing workflows.
43 | 
44 | Install
45 | =======
46 | 
47 | To install via pip::
48 | 
49 |   pip install htmlmin 
50 | 
51 | Source Code
52 | ===========
53 | 
54 | Source code is availble on github at
55 | `https://github.com/mankyd/htmlmin <https://github.com/mankyd/htmlmin>`_::
56 | 
57 |   git clone git://github.com/mankyd/htmlmin.git
58 | 
59 | Features
60 | ========
61 | 
62 | * Safely minify HTML with either a :class:`function call <htmlmin.minify>` or
63 |   from the :ref:`command line <command_line>`.
64 | * Extend what elements can and cannot be minified.
65 | * Intelligently remove whitespace completely or reduce to single spaces.
66 | * Properly handles unclosed HTML5 tags.
67 | * Optionally remove comments while marking some comments to keep.
68 | * Simple function :class:`decorator <htmlmin.decorator.htmlmin>` to minify all
69 |   function output.
70 | * Simple :class:`WSGI middleware <htmlmin.middleware.HTMLMinMiddleware>` to
71 |   minify web app output.
72 | * `Tested <https://travis-ci.org/mankyd/htmlmin>`_ in both Python 2.7 and 3.2: 
73 |   |build_status|
74 | 
75 | .. |build_status| image:: https://travis-ci.org/mankyd/htmlmin.png?branch=master
76 | 
77 | Indices and tables
78 | ==================
79 | 
80 | * :ref:`genindex`
81 | * :ref:`search`
82 | 


--------------------------------------------------------------------------------
/htmlmin/middleware.py:
--------------------------------------------------------------------------------
 1 | """
 2 | Copyright (c) 2013, Dave Mankoff
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without
 6 | modification, are permitted provided that the following conditions are met:
 7 |     * Redistributions of source code must retain the above copyright
 8 |       notice, this list of conditions and the following disclaimer.
 9 |     * Redistributions in binary form must reproduce the above copyright
10 |       notice, this list of conditions and the following disclaimer in the
11 |       documentation and/or other materials provided with the distribution.
12 |     * Neither the name of Dave Mankoff nor the
13 |       names of its contributors may be used to endorse or promote products
14 |       derived from this software without specific prior written permission.
15 | 
16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 | DISCLAIMED. IN NO EVENT SHALL DAVE MANKOFF BE LIABLE FOR ANY
20 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 | """
27 | 
28 | from .main import Minifier
29 | 
30 | class HTMLMinMiddleware(object):
31 |   """WSGI Middleware that minifies html on the way out.
32 | 
33 |   :param by_default: Specifies if minification should be turned on or off by
34 |     default. Defaults to ``True``.
35 |   :param keep_header: The middleware recognizes one custom HTTP header that 
36 |     can be used to turn minification on or off on a per-request basis:
37 |     ``X-HTML-Min-Enable``. Setting the header to ``true`` will turn minfication
38 |     on; anything else will turn minification off. If ``by_default`` is set to 
39 |     ``False``, this header is how you would turn minification back on. The
40 |     middleware, by default, removes the header from the output. Setting this
41 |     to ``True`` leaves the header in tact.
42 |   :param debug: A quick setting to turn all minification off. The middleware
43 |     is effectively bypassed.
44 | 
45 |   This simple middleware minifies any HTML content that passes through it. Any
46 |   additional keyword arguments beyond the three settings the middleware has are
47 |   passed on to the internal minifier. The documentation for the options can
48 |   be found under :class:`htmlmin.minify`.
49 |   """
50 |   def __init__(self, app, by_default=True, keep_header=False, 
51 |                debug=False, **kwargs):
52 |     self.app = app
53 |     self.by_default = by_default
54 |     self.debug = debug
55 |     self.keep_header = keep_header
56 |     self.minifier = Minifier(**kwargs)
57 |     
58 |   def __call__(self, environ, start_response):
59 |     if self.debug:
60 |       return self.app(environ, start_response)
61 | 
62 |     should_minify = []  # need to use a mutable object so we can change it
63 |                         # in a different scope.
64 |     def minified_start_response(status, headers, exc_info=None):
65 |       should_minify.append(self.should_minify(headers))
66 |       if not self.keep_header:
67 |         headers = [(header, value) for header, value in 
68 |                    headers if header != 'X-HTML-Min-Enable']
69 |       start_response(status, headers, exc_info)
70 | 
71 |     html = [i for i in self.app(environ, minified_start_response)]
72 |     if should_minify[0]:
73 |       return [self.minifier.minify(*html)]
74 |     return html
75 |   
76 |   def should_minify(self, headers):
77 |     is_html = False
78 |     flag_header = None
79 |     for header, value in headers:
80 |       if not is_html and header == 'Content-Type' and value == 'text/html':
81 |         is_html = True
82 |         if flag_header is not None:
83 |           break
84 | 
85 |       if flag_header is None and header == 'X-HTML-Min-Enable':
86 |         flag_header = (value.lower() == 'true')
87 |         if is_html:
88 |           break
89 | 
90 |     return is_html and (
91 |       (self.by_default and flag_header != False) or 
92 |       (not self.by_default and flag_header))
93 | 


--------------------------------------------------------------------------------
/htmlmin/tests/test_escape.py:
--------------------------------------------------------------------------------
  1 | """
  2 | Copyright (c) 2015, Dave Mankoff
  3 | All rights reserved.
  4 | 
  5 | Redistribution and use in source and binary forms, with or without
  6 | modification, are permitted provided that the following conditions are met:
  7 |     * Redistributions of source code must retain the above copyright
  8 |       notice, this list of conditions and the following disclaimer.
  9 |     * Redistributions in binary form must reproduce the above copyright
 10 |       notice, this list of conditions and the following disclaimer in the
 11 |       documentation and/or other materials provided with the distribution.
 12 |     * Neither the name of Dave Mankoff nor the
 13 |       names of its contributors may be used to endorse or promote products
 14 |       derived from this software without specific prior written permission.
 15 | 
 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 19 | DISCLAIMED. IN NO EVENT SHALL DAVE MANKOFF BE LIABLE FOR ANY
 20 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 23 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 26 | """
 27 | 
 28 | from __future__ import unicode_literals
 29 | import unittest
 30 | 
 31 | from htmlmin import escape
 32 | 
 33 | class TestEscapeAttributes(unittest.TestCase):
 34 |   def assertQuotes(self, value, expected, quotes):
 35 |     result = escape.escape_attr_value(value)
 36 |     self.assertEqual((expected, quotes), result)
 37 | 
 38 |   def assertNoQuotes(self, value, expected):
 39 |     self.assertQuotes(value, expected, escape.NO_QUOTES)
 40 | 
 41 |   def assertSingleQuote(self, value, expected):
 42 |     self.assertQuotes(value, expected, escape.SINGLE_QUOTE)
 43 | 
 44 |   def assertDoubleQuote(self, value, expected):
 45 |     self.assertQuotes(value, expected, escape.DOUBLE_QUOTE)
 46 | 
 47 |   def test_simple_attribute(self):
 48 |     self.assertNoQuotes('foobar', 'foobar')
 49 | 
 50 |   def test_double_quote(self):
 51 |     self.assertDoubleQuote("foo'bar", "foo'bar")
 52 | 
 53 |   def test_single_quote(self):
 54 |     self.assertSingleQuote('foo"bar', 'foo"bar')
 55 | 
 56 |   def test_quote_space(self):
 57 |     self.assertDoubleQuote("foo bar", "foo bar")
 58 |     self.assertDoubleQuote(" foobar", " foobar")
 59 |     self.assertDoubleQuote("foobar ", "foobar ")
 60 |     self.assertDoubleQuote(" foobar ", " foobar ")
 61 |     self.assertDoubleQuote("", "")
 62 | 
 63 |   def test_quote_unsafe_chars(self):
 64 |     self.assertDoubleQuote("width=device-width", "width=device-width")
 65 |     self.assertDoubleQuote("<sinister-brackets>", "<sinister-brackets>")
 66 |     self.assertDoubleQuote("`", "`")
 67 | 
 68 |   def test_force_double_quote(self):
 69 |     result = escape.escape_attr_value("foobar", double_quote=True)
 70 |     self.assertEqual('foobar', result[0])
 71 |     self.assertEqual(escape.DOUBLE_QUOTE, result[1])
 72 | 
 73 |   def test_both_quotes(self):
 74 |     self.assertDoubleQuote("foo'\"bar", "foo'&#34;bar")
 75 |     self.assertDoubleQuote("foo''\"bar", "foo''&#34;bar")
 76 |     self.assertSingleQuote("foo'\"\"bar", 'foo&#39;""bar')
 77 | 
 78 |   def test_ampersand_char_ref(self):
 79 |     self.assertNoQuotes('foo&bar', 'foo&amp;bar')
 80 | 
 81 |   def test_multi_ampersand_char_ref(self):
 82 |     self.assertNoQuotes('foo&&bar', 'foo&&amp;bar')
 83 |     self.assertNoQuotes('foo&&&bar', 'foo&&&amp;bar')
 84 |     self.assertNoQuotes('foo&&&&bar', 'foo&&&&amp;bar')
 85 |     self.assertNoQuotes('foo&&bar&&baz', 'foo&&amp;bar&&amp;baz')
 86 | 
 87 |   def test_ampersand_decimal(self):
 88 |     self.assertNoQuotes('foo&#34', 'foo&amp;#34')
 89 | 
 90 |   def test_ampersand_non_decimal(self):
 91 |     self.assertNoQuotes('foo&#ff', 'foo&#ff')
 92 | 
 93 |   def test_ampersand_hex(self):
 94 |     self.assertNoQuotes('foo&#x34f', 'foo&amp;#x34f')
 95 | 
 96 |   def test_ampersand_nonhex(self):
 97 |     self.assertNoQuotes('foo&#xz34f', 'foo&#xz34f')
 98 | 
 99 |   def test_proper_char_refs(self):
100 |     self.assertNoQuotes('&pi;&#34;&#x34;', '&pi;&#34;&#x34;')
101 | 
102 | def suite():
103 |   return unittest.TestLoader().loadTestsFromTestCase(TestEscapeAttributes)
104 | 


--------------------------------------------------------------------------------
/htmlmin/python3html/__init__.py:
--------------------------------------------------------------------------------
  1 | """
  2 | General functions for HTML manipulation.
  3 | """
  4 | 
  5 | import re as _re
  6 | try:
  7 |     from html.entities import html5 as _html5
  8 |     unichr = chr
  9 | except ImportError:
 10 |     import htmlentitydefs
 11 |     _html5 = {'apos;':u"'"}
 12 |     for k, v in htmlentitydefs.name2codepoint.iteritems():
 13 |         _html5[k + ';'] = unichr(v)
 14 | 
 15 | 
 16 | __all__ = ['escape', 'unescape']
 17 | 
 18 | 
 19 | def escape(s, quote=True):
 20 |     """
 21 |     Replace special characters "&", "<" and ">" to HTML-safe sequences.
 22 |     If the optional flag quote is true (the default), the quotation mark
 23 |     characters, both double quote (") and single quote (') characters are also
 24 |     translated.
 25 |     """
 26 |     s = s.replace("&", "&amp;") # Must be done first!
 27 |     s = s.replace("<", "&lt;")
 28 |     s = s.replace(">", "&gt;")
 29 |     if quote:
 30 |         s = s.replace('"', "&quot;")
 31 |         s = s.replace('\'', "&#x27;")
 32 |     return s
 33 | 
 34 | 
 35 | # see http://www.w3.org/TR/html5/syntax.html#tokenizing-character-references
 36 | 
 37 | _invalid_charrefs = {
 38 |     0x00: '\ufffd',  # REPLACEMENT CHARACTER
 39 |     0x0d: '\r',      # CARRIAGE RETURN
 40 |     0x80: '\u20ac',  # EURO SIGN
 41 |     0x81: '\x81',    # <control>
 42 |     0x82: '\u201a',  # SINGLE LOW-9 QUOTATION MARK
 43 |     0x83: '\u0192',  # LATIN SMALL LETTER F WITH HOOK
 44 |     0x84: '\u201e',  # DOUBLE LOW-9 QUOTATION MARK
 45 |     0x85: '\u2026',  # HORIZONTAL ELLIPSIS
 46 |     0x86: '\u2020',  # DAGGER
 47 |     0x87: '\u2021',  # DOUBLE DAGGER
 48 |     0x88: '\u02c6',  # MODIFIER LETTER CIRCUMFLEX ACCENT
 49 |     0x89: '\u2030',  # PER MILLE SIGN
 50 |     0x8a: '\u0160',  # LATIN CAPITAL LETTER S WITH CARON
 51 |     0x8b: '\u2039',  # SINGLE LEFT-POINTING ANGLE QUOTATION MARK
 52 |     0x8c: '\u0152',  # LATIN CAPITAL LIGATURE OE
 53 |     0x8d: '\x8d',    # <control>
 54 |     0x8e: '\u017d',  # LATIN CAPITAL LETTER Z WITH CARON
 55 |     0x8f: '\x8f',    # <control>
 56 |     0x90: '\x90',    # <control>
 57 |     0x91: '\u2018',  # LEFT SINGLE QUOTATION MARK
 58 |     0x92: '\u2019',  # RIGHT SINGLE QUOTATION MARK
 59 |     0x93: '\u201c',  # LEFT DOUBLE QUOTATION MARK
 60 |     0x94: '\u201d',  # RIGHT DOUBLE QUOTATION MARK
 61 |     0x95: '\u2022',  # BULLET
 62 |     0x96: '\u2013',  # EN DASH
 63 |     0x97: '\u2014',  # EM DASH
 64 |     0x98: '\u02dc',  # SMALL TILDE
 65 |     0x99: '\u2122',  # TRADE MARK SIGN
 66 |     0x9a: '\u0161',  # LATIN SMALL LETTER S WITH CARON
 67 |     0x9b: '\u203a',  # SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
 68 |     0x9c: '\u0153',  # LATIN SMALL LIGATURE OE
 69 |     0x9d: '\x9d',    # <control>
 70 |     0x9e: '\u017e',  # LATIN SMALL LETTER Z WITH CARON
 71 |     0x9f: '\u0178',  # LATIN CAPITAL LETTER Y WITH DIAERESIS
 72 | }
 73 | 
 74 | _invalid_codepoints = {
 75 |     # 0x0001 to 0x0008
 76 |     0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8,
 77 |     # 0x000E to 0x001F
 78 |     0xe, 0xf, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
 79 |     0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 80 |     # 0x007F to 0x009F
 81 |     0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
 82 |     0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
 83 |     0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
 84 |     # 0xFDD0 to 0xFDEF
 85 |     0xfdd0, 0xfdd1, 0xfdd2, 0xfdd3, 0xfdd4, 0xfdd5, 0xfdd6, 0xfdd7, 0xfdd8,
 86 |     0xfdd9, 0xfdda, 0xfddb, 0xfddc, 0xfddd, 0xfdde, 0xfddf, 0xfde0, 0xfde1,
 87 |     0xfde2, 0xfde3, 0xfde4, 0xfde5, 0xfde6, 0xfde7, 0xfde8, 0xfde9, 0xfdea,
 88 |     0xfdeb, 0xfdec, 0xfded, 0xfdee, 0xfdef,
 89 |     # others
 90 |     0xb, 0xfffe, 0xffff, 0x1fffe, 0x1ffff, 0x2fffe, 0x2ffff, 0x3fffe, 0x3ffff,
 91 |     0x4fffe, 0x4ffff, 0x5fffe, 0x5ffff, 0x6fffe, 0x6ffff, 0x7fffe, 0x7ffff,
 92 |     0x8fffe, 0x8ffff, 0x9fffe, 0x9ffff, 0xafffe, 0xaffff, 0xbfffe, 0xbffff,
 93 |     0xcfffe, 0xcffff, 0xdfffe, 0xdffff, 0xefffe, 0xeffff, 0xffffe, 0xfffff,
 94 |     0x10fffe, 0x10ffff
 95 | }
 96 | 
 97 | 
 98 | def _replace_charref(s):
 99 |     s = s.group(1)
100 |     if s[0] == '#':
101 |         # numeric charref
102 |         if s[1] in 'xX':
103 |             num = int(s[2:].rstrip(';'), 16)
104 |         else:
105 |             num = int(s[1:].rstrip(';'))
106 |         if num in _invalid_charrefs:
107 |             return _invalid_charrefs[num]
108 |         if 0xD800 <= num <= 0xDFFF or num > 0x10FFFF:
109 |             return '\uFFFD'
110 |         if num in _invalid_codepoints:
111 |             return ''
112 |         return unichr(num)
113 |     else:
114 |         # named charref
115 |         if s in _html5:
116 |             return _html5[s]
117 |         # find the longest matching name (as defined by the standard)
118 |         for x in range(len(s)-1, 1, -1):
119 |             if s[:x] in _html5:
120 |                 return _html5[s[:x]] + s[x:]
121 |         else:
122 |             return '&' + s
123 | 
124 | 
125 | _charref = _re.compile(r'&(#[0-9]+;?'
126 |                        r'|#[xX][0-9a-fA-F]+;?'
127 |                        r'|[^\t\n\f <&#;]{1,32};?)')
128 | 
129 | def unescape(s):
130 |     """
131 |     Convert all named and numeric character references (e.g. &gt;, &#62;,
132 |     &x3e;) in the string s to the corresponding unicode characters.
133 |     This function uses the rules defined by the HTML 5 standard
134 |     for both valid and invalid character references, and the list of
135 |     HTML 5 named character references defined in html.entities.html5.
136 |     """
137 |     if '&' not in s:
138 |         return s
139 |     return _charref.sub(_replace_charref, s)
140 | 


--------------------------------------------------------------------------------
/docs/make.bat:
--------------------------------------------------------------------------------
  1 | @ECHO OFF
  2 | 
  3 | REM Command file for Sphinx documentation
  4 | 
  5 | if "%SPHINXBUILD%" == "" (
  6 | 	set SPHINXBUILD=sphinx-build
  7 | )
  8 | set BUILDDIR=_build
  9 | set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% .
 10 | set I18NSPHINXOPTS=%SPHINXOPTS% .
 11 | if NOT "%PAPER%" == "" (
 12 | 	set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS%
 13 | 	set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS%
 14 | )
 15 | 
 16 | if "%1" == "" goto help
 17 | 
 18 | if "%1" == "help" (
 19 | 	:help
 20 | 	echo.Please use `make ^<target^>` where ^<target^> is one of
 21 | 	echo.  html       to make standalone HTML files
 22 | 	echo.  dirhtml    to make HTML files named index.html in directories
 23 | 	echo.  singlehtml to make a single large HTML file
 24 | 	echo.  pickle     to make pickle files
 25 | 	echo.  json       to make JSON files
 26 | 	echo.  htmlhelp   to make HTML files and a HTML help project
 27 | 	echo.  qthelp     to make HTML files and a qthelp project
 28 | 	echo.  devhelp    to make HTML files and a Devhelp project
 29 | 	echo.  epub       to make an epub
 30 | 	echo.  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter
 31 | 	echo.  text       to make text files
 32 | 	echo.  man        to make manual pages
 33 | 	echo.  texinfo    to make Texinfo files
 34 | 	echo.  gettext    to make PO message catalogs
 35 | 	echo.  changes    to make an overview over all changed/added/deprecated items
 36 | 	echo.  linkcheck  to check all external links for integrity
 37 | 	echo.  doctest    to run all doctests embedded in the documentation if enabled
 38 | 	goto end
 39 | )
 40 | 
 41 | if "%1" == "clean" (
 42 | 	for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i
 43 | 	del /q /s %BUILDDIR%\*
 44 | 	goto end
 45 | )
 46 | 
 47 | if "%1" == "html" (
 48 | 	%SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html
 49 | 	if errorlevel 1 exit /b 1
 50 | 	echo.
 51 | 	echo.Build finished. The HTML pages are in %BUILDDIR%/html.
 52 | 	goto end
 53 | )
 54 | 
 55 | if "%1" == "dirhtml" (
 56 | 	%SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml
 57 | 	if errorlevel 1 exit /b 1
 58 | 	echo.
 59 | 	echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml.
 60 | 	goto end
 61 | )
 62 | 
 63 | if "%1" == "singlehtml" (
 64 | 	%SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml
 65 | 	if errorlevel 1 exit /b 1
 66 | 	echo.
 67 | 	echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml.
 68 | 	goto end
 69 | )
 70 | 
 71 | if "%1" == "pickle" (
 72 | 	%SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle
 73 | 	if errorlevel 1 exit /b 1
 74 | 	echo.
 75 | 	echo.Build finished; now you can process the pickle files.
 76 | 	goto end
 77 | )
 78 | 
 79 | if "%1" == "json" (
 80 | 	%SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json
 81 | 	if errorlevel 1 exit /b 1
 82 | 	echo.
 83 | 	echo.Build finished; now you can process the JSON files.
 84 | 	goto end
 85 | )
 86 | 
 87 | if "%1" == "htmlhelp" (
 88 | 	%SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp
 89 | 	if errorlevel 1 exit /b 1
 90 | 	echo.
 91 | 	echo.Build finished; now you can run HTML Help Workshop with the ^
 92 | .hhp project file in %BUILDDIR%/htmlhelp.
 93 | 	goto end
 94 | )
 95 | 
 96 | if "%1" == "qthelp" (
 97 | 	%SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp
 98 | 	if errorlevel 1 exit /b 1
 99 | 	echo.
100 | 	echo.Build finished; now you can run "qcollectiongenerator" with the ^
101 | .qhcp project file in %BUILDDIR%/qthelp, like this:
102 | 	echo.^> qcollectiongenerator %BUILDDIR%\qthelp\htmlmin.qhcp
103 | 	echo.To view the help file:
104 | 	echo.^> assistant -collectionFile %BUILDDIR%\qthelp\htmlmin.ghc
105 | 	goto end
106 | )
107 | 
108 | if "%1" == "devhelp" (
109 | 	%SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp
110 | 	if errorlevel 1 exit /b 1
111 | 	echo.
112 | 	echo.Build finished.
113 | 	goto end
114 | )
115 | 
116 | if "%1" == "epub" (
117 | 	%SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub
118 | 	if errorlevel 1 exit /b 1
119 | 	echo.
120 | 	echo.Build finished. The epub file is in %BUILDDIR%/epub.
121 | 	goto end
122 | )
123 | 
124 | if "%1" == "latex" (
125 | 	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
126 | 	if errorlevel 1 exit /b 1
127 | 	echo.
128 | 	echo.Build finished; the LaTeX files are in %BUILDDIR%/latex.
129 | 	goto end
130 | )
131 | 
132 | if "%1" == "text" (
133 | 	%SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text
134 | 	if errorlevel 1 exit /b 1
135 | 	echo.
136 | 	echo.Build finished. The text files are in %BUILDDIR%/text.
137 | 	goto end
138 | )
139 | 
140 | if "%1" == "man" (
141 | 	%SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man
142 | 	if errorlevel 1 exit /b 1
143 | 	echo.
144 | 	echo.Build finished. The manual pages are in %BUILDDIR%/man.
145 | 	goto end
146 | )
147 | 
148 | if "%1" == "texinfo" (
149 | 	%SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo
150 | 	if errorlevel 1 exit /b 1
151 | 	echo.
152 | 	echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo.
153 | 	goto end
154 | )
155 | 
156 | if "%1" == "gettext" (
157 | 	%SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale
158 | 	if errorlevel 1 exit /b 1
159 | 	echo.
160 | 	echo.Build finished. The message catalogs are in %BUILDDIR%/locale.
161 | 	goto end
162 | )
163 | 
164 | if "%1" == "changes" (
165 | 	%SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes
166 | 	if errorlevel 1 exit /b 1
167 | 	echo.
168 | 	echo.The overview file is in %BUILDDIR%/changes.
169 | 	goto end
170 | )
171 | 
172 | if "%1" == "linkcheck" (
173 | 	%SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck
174 | 	if errorlevel 1 exit /b 1
175 | 	echo.
176 | 	echo.Link check complete; look for any errors in the above output ^
177 | or in %BUILDDIR%/linkcheck/output.txt.
178 | 	goto end
179 | )
180 | 
181 | if "%1" == "doctest" (
182 | 	%SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest
183 | 	if errorlevel 1 exit /b 1
184 | 	echo.
185 | 	echo.Testing of doctests in the sources finished, look at the ^
186 | results in %BUILDDIR%/doctest/output.txt.
187 | 	goto end
188 | )
189 | 
190 | :end
191 | 


--------------------------------------------------------------------------------
/docs/Makefile:
--------------------------------------------------------------------------------
  1 | # Makefile for Sphinx documentation
  2 | #
  3 | 
  4 | # You can set these variables from the command line.
  5 | SPHINXOPTS    =
  6 | SPHINXBUILD   = sphinx-build
  7 | PAPER         =
  8 | BUILDDIR      = _build
  9 | 
 10 | # Internal variables.
 11 | PAPEROPT_a4     = -D latex_paper_size=a4
 12 | PAPEROPT_letter = -D latex_paper_size=letter
 13 | ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
 14 | # the i18n builder cannot share the environment and doctrees with the others
 15 | I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
 16 | 
 17 | .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext
 18 | 
 19 | help:
 20 | 	@echo "Please use \`make <target>' where <target> is one of"
 21 | 	@echo "  html       to make standalone HTML files"
 22 | 	@echo "  dirhtml    to make HTML files named index.html in directories"
 23 | 	@echo "  singlehtml to make a single large HTML file"
 24 | 	@echo "  pickle     to make pickle files"
 25 | 	@echo "  json       to make JSON files"
 26 | 	@echo "  htmlhelp   to make HTML files and a HTML help project"
 27 | 	@echo "  qthelp     to make HTML files and a qthelp project"
 28 | 	@echo "  devhelp    to make HTML files and a Devhelp project"
 29 | 	@echo "  epub       to make an epub"
 30 | 	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
 31 | 	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
 32 | 	@echo "  text       to make text files"
 33 | 	@echo "  man        to make manual pages"
 34 | 	@echo "  texinfo    to make Texinfo files"
 35 | 	@echo "  info       to make Texinfo files and run them through makeinfo"
 36 | 	@echo "  gettext    to make PO message catalogs"
 37 | 	@echo "  changes    to make an overview of all changed/added/deprecated items"
 38 | 	@echo "  linkcheck  to check all external links for integrity"
 39 | 	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
 40 | 
 41 | clean:
 42 | 	-rm -rf $(BUILDDIR)/*
 43 | 
 44 | html:
 45 | 	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
 46 | 	@echo
 47 | 	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
 48 | 
 49 | dirhtml:
 50 | 	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
 51 | 	@echo
 52 | 	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
 53 | 
 54 | singlehtml:
 55 | 	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
 56 | 	@echo
 57 | 	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
 58 | 
 59 | pickle:
 60 | 	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
 61 | 	@echo
 62 | 	@echo "Build finished; now you can process the pickle files."
 63 | 
 64 | json:
 65 | 	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
 66 | 	@echo
 67 | 	@echo "Build finished; now you can process the JSON files."
 68 | 
 69 | htmlhelp:
 70 | 	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
 71 | 	@echo
 72 | 	@echo "Build finished; now you can run HTML Help Workshop with the" \
 73 | 	      ".hhp project file in $(BUILDDIR)/htmlhelp."
 74 | 
 75 | qthelp:
 76 | 	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
 77 | 	@echo
 78 | 	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
 79 | 	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
 80 | 	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/htmlmin.qhcp"
 81 | 	@echo "To view the help file:"
 82 | 	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/htmlmin.qhc"
 83 | 
 84 | devhelp:
 85 | 	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
 86 | 	@echo
 87 | 	@echo "Build finished."
 88 | 	@echo "To view the help file:"
 89 | 	@echo "# mkdir -p $$HOME/.local/share/devhelp/htmlmin"
 90 | 	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/htmlmin"
 91 | 	@echo "# devhelp"
 92 | 
 93 | epub:
 94 | 	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
 95 | 	@echo
 96 | 	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
 97 | 
 98 | latex:
 99 | 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
100 | 	@echo
101 | 	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
102 | 	@echo "Run \`make' in that directory to run these through (pdf)latex" \
103 | 	      "(use \`make latexpdf' here to do that automatically)."
104 | 
105 | latexpdf:
106 | 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
107 | 	@echo "Running LaTeX files through pdflatex..."
108 | 	$(MAKE) -C $(BUILDDIR)/latex all-pdf
109 | 	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
110 | 
111 | text:
112 | 	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
113 | 	@echo
114 | 	@echo "Build finished. The text files are in $(BUILDDIR)/text."
115 | 
116 | man:
117 | 	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
118 | 	@echo
119 | 	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
120 | 
121 | texinfo:
122 | 	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
123 | 	@echo
124 | 	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
125 | 	@echo "Run \`make' in that directory to run these through makeinfo" \
126 | 	      "(use \`make info' here to do that automatically)."
127 | 
128 | info:
129 | 	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
130 | 	@echo "Running Texinfo files through makeinfo..."
131 | 	make -C $(BUILDDIR)/texinfo info
132 | 	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
133 | 
134 | gettext:
135 | 	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
136 | 	@echo
137 | 	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
138 | 
139 | changes:
140 | 	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
141 | 	@echo
142 | 	@echo "The overview file is in $(BUILDDIR)/changes."
143 | 
144 | linkcheck:
145 | 	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
146 | 	@echo
147 | 	@echo "Link check complete; look for any errors in the above output " \
148 | 	      "or in $(BUILDDIR)/linkcheck/output.txt."
149 | 
150 | doctest:
151 | 	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
152 | 	@echo "Testing of doctests in the sources finished, look at the " \
153 | 	      "results in $(BUILDDIR)/doctest/output.txt."
154 | 


--------------------------------------------------------------------------------
/docs/quickstart.rst:
--------------------------------------------------------------------------------
  1 | Quickstart
  2 | ==========
  3 | For single invocations, there is the :class:`htmlmin.minify`
  4 | method. It takes input html as a string for its first argument and returns
  5 | minified html. It accepts multiple different options that allow you to tune the
  6 | amount of minification being done, with the defaults being the safest available
  7 | options::
  8 | 
  9 |   >>> import htmlmin
 10 |   >>> input_html = '''
 11 |     <body   style="background-color: tomato;">
 12 |       <h1>  htmlmin   rocks</h1>
 13 |       <pre>
 14 |         and rolls
 15 |       </pre>
 16 |     </body>'''
 17 |   >>> htmlmin.minify(input_html)
 18 |   u' <body style="background-color: tomato;"> <h1> htmlmin rocks</h1> <pre>\n        and rolls\n      </pre> </body>'
 19 |   >>> print htmlmin.minify(input_html)
 20 |    <body style="background-color: tomato;"> <h1> htmlmin rocks</h1> <pre>
 21 |           and rolls
 22 |         </pre> </body>
 23 | 
 24 | If there is a chunk of html which you do not want minified, put a ``pre``
 25 | attribute on an HTML tag that wraps it. htmlmin will leave the contents of the
 26 | tag alone and will remove the ``pre`` attribute before it is output::
 27 | 
 28 |   >>> import htmlmin
 29 |   >>> input_html = '''<span>   minified   </span><span pre>   not minified   </span>'''
 30 |   >>> htmlmin.minify(input_html)
 31 |   u'<span> minified </span><span>   not minified   </span>'
 32 | 
 33 | Attributes will be condensed to their smallest possible representation by 
 34 | default. You can prefix an individual attribute with ``pre-`` to leave it
 35 | unchanged::
 36 | 
 37 |   >>> import htmlmin
 38 |   >>> input_html = '''<input value="&lt;minified&gt;" /><input pre-value="&lt;not minified&gt;" />'''
 39 |   >>> htmlmin.minify(input_html)
 40 |   u'<input value="<minified>"><input value=&lt;not minified&gt;>'
 41 | 
 42 | The :class:`minify <htmlmin.minify>` function works well for one off
 43 | minifications. However, if you are going to minify several pieces of HTML, the
 44 | :class:`Minifier <htmlmin.Minifier>` class is provided. It works similarly, but
 45 | allows for persistence of options between invocations and recycles the internal
 46 | data structures used for minification.
 47 | 
 48 | .. _command_line:
 49 | 
 50 | Command Line
 51 | ------------
 52 | htmlmin is invoked by running::
 53 | 
 54 |   htmlmin input.html output.html
 55 | 
 56 | If no output file is specified, it will print to ``stdout``. If no input
 57 | specified, it reads form ``stdin``. Help with options can be retrieved at
 58 | any time by running `htmlmin -h`::
 59 | 
 60 |   htmlmin -h
 61 |   usage: htmlmin [-h] [-c] [-s] [--remove-all-empty-space]
 62 |                  [--keep-optional-attribute-quotes] [-H] [-k] [-a PRE_ATTR]
 63 |                  [-p [TAG [TAG ...]]] [-e ENCODING]
 64 |                  [INPUT] [OUTPUT]
 65 | 
 66 |   Minify HTML
 67 | 
 68 |   positional arguments:
 69 |     INPUT                 File path to html file to minify. Defaults to stdin.
 70 |     OUTPUT                File path to output to. Defaults to stdout.
 71 | 
 72 |   optional arguments:
 73 |     -h, --help            show this help message and exit
 74 |     -c, --remove-comments
 75 |                           When set, comments will be removed. They can be kept on an individual basis
 76 |                           by starting them with a '!': <!--! comment -->. The '!' will be removed from
 77 |                           the final output. If you want a '!' as the leading character of your comment,
 78 |                           put two of them: <!--!! comment -->.
 79 | 
 80 |     -s, --remove-empty-space
 81 |                           When set, this removes empty space betwen tags in certain cases. 
 82 |                           Specifically, it will remove empty space if and only if there a newline
 83 |                           character occurs within the space. Thus, code like 
 84 |                           '<span>x</span> <span>y</span>' will be left alone, but code such as
 85 |                           '   ...
 86 |                             </head>
 87 |                             <body>
 88 |                               ...'
 89 |                           will become '...</head><body>...'. Note that this CAN break your 
 90 |                           html if you spread two inline tags over two lines. Use with caution.
 91 | 
 92 |     --remove-all-empty-space
 93 |                           When set, this removes ALL empty space betwen tags. WARNING: this can and
 94 |                           likely will cause unintended consequences. For instance, '<i>X</i> <i>Y</i>'
 95 |                           will become '<i>X</i><i>Y</i>'. Putting whitespace along with other text will
 96 |                           avoid this problem. Only use if you are confident in the result. Whitespace is
 97 |                           not removed from inside of tags, thus '<span> </span>' will be left alone.
 98 | 
 99 |     --keep-optional-attribute-quotes
100 |                           When set, this keeps all attribute quotes, even if they are optional.
101 | 
102 |     -H, --in-head         If you are parsing only a fragment of HTML, and the fragment occurs in the
103 |                           head of the document, setting this will remove some extra whitespace.
104 | 
105 |     -k, --keep-pre-attr   HTMLMin supports the propietary attribute 'pre' that can be added to elements
106 |                           to prevent minification. This attribute is removed by default. Set this flag to
107 |                           keep the 'pre' attributes in place.
108 | 
109 |     -a PRE_ATTR, --pre-attr PRE_ATTR
110 |                           The attribute htmlmin looks for to find blocks of HTML that it should not 
111 |                           minify. This attribute will be removed from the HTML unless '-k' is
112 |                           specified. Defaults to 'pre'. You can also prefix individual tag attributes
113 |                           with ``{pre_attr}-`` to prevent the contents of the individual attribute from
114 |                           being changed.
115 | 
116 |     -p [TAG [TAG ...]], --pre-tags [TAG [TAG ...]]
117 |                           By default, the contents of 'pre', and 'textarea' tags are left unminified.
118 |                           You can specify different tags using the --pre-tags option. 'script' and 'style'
119 |                           tags are always left unmininfied.
120 | 
121 |     -e ENCODING, --encoding ENCODING
122 |                           Encoding to read and write with. Default 'utf-8'.
123 | 


--------------------------------------------------------------------------------
/htmlmin/command.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | """
  3 | Copyright (c) 2013, Dave Mankoff
  4 | All rights reserved.
  5 | 
  6 | Redistribution and use in source and binary forms, with or without
  7 | modification, are permitted provided that the following conditions are met:
  8 |     * Redistributions of source code must retain the above copyright
  9 |       notice, this list of conditions and the following disclaimer.
 10 |     * Redistributions in binary form must reproduce the above copyright
 11 |       notice, this list of conditions and the following disclaimer in the
 12 |       documentation and/or other materials provided with the distribution.
 13 |     * Neither the name of Dave Mankoff nor the
 14 |       names of its contributors may be used to endorse or promote products
 15 |       derived from this software without specific prior written permission.
 16 | 
 17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 18 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 19 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 20 | DISCLAIMED. IN NO EVENT SHALL DAVE MANKOFF BE LIABLE FOR ANY
 21 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 22 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 23 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 24 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 25 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 26 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 27 | """
 28 | 
 29 | import argparse
 30 | import codecs
 31 | import locale
 32 | import io
 33 | import sys
 34 | 
 35 | #import htmlmin
 36 | from . import Minifier
 37 | 
 38 | parser = argparse.ArgumentParser(
 39 |   description='Minify HTML',
 40 |   formatter_class=argparse.RawTextHelpFormatter
 41 |   )
 42 | 
 43 | parser.add_argument('input_file',
 44 |   nargs='?',
 45 |   metavar='INPUT',
 46 |   help='File path to html file to minify. Defaults to stdin.',
 47 |   )
 48 | 
 49 | parser.add_argument('output_file',
 50 |   nargs='?',
 51 |   metavar='OUTPUT',
 52 |   help="File path to output to. Defaults to stdout.",
 53 |   )
 54 | 
 55 | parser.add_argument('-c', '--remove-comments',
 56 |   help=(
 57 | '''When set, comments will be removed. They can be kept on an individual basis
 58 | by starting them with a '!': <!--! comment -->. The '!' will be removed from
 59 | the final output. If you want a '!' as the leading character of your comment,
 60 | put two of them: <!--!! comment -->.
 61 | 
 62 | '''),
 63 |   action='store_true')
 64 | 
 65 | parser.add_argument('-s', '--remove-empty-space',
 66 |   help=(
 67 | '''When set, this removes empty space betwen tags in certain cases.
 68 | Specifically, it will remove empty space if and only if there a newline
 69 | character occurs within the space. Thus, code like
 70 | '<span>x</span> <span>y</span>' will be left alone, but code such as
 71 | '   ...
 72 |   </head>
 73 |   <body>
 74 |     ...'
 75 | will become '...</head><body>...'. Note that this CAN break your
 76 | html if you spread two inline tags over two lines. Use with caution.
 77 | 
 78 | '''),
 79 |   action='store_true')
 80 | 
 81 | parser.add_argument('--remove-all-empty-space',
 82 |   help=(
 83 | '''When set, this removes ALL empty space betwen tags. WARNING: this can and
 84 | likely will cause unintended consequences. For instance, '<i>X</i> <i>Y</i>'
 85 | will become '<i>X</i><i>Y</i>'. Putting whitespace along with other text will
 86 | avoid this problem. Only use if you are confident in the result. Whitespace is
 87 | not removed from inside of tags, thus '<span> </span>' will be left alone.
 88 | 
 89 | '''),
 90 |   action='store_true')
 91 | 
 92 | parser.add_argument('--keep-optional-attribute-quotes',
 93 |   help=(
 94 | '''When set, this keeps all attribute quotes, even if they are optional.
 95 | 
 96 | '''),
 97 |   action='store_true')
 98 | 
 99 | parser.add_argument('-H', '--in-head',
100 |   help=(
101 | '''If you are parsing only a fragment of HTML, and the fragment occurs in the
102 | head of the document, setting this will remove some extra whitespace.
103 | 
104 | '''),
105 |   action='store_true')
106 | 
107 | parser.add_argument('-k', '--keep-pre-attr',
108 |   help=(
109 | '''HTMLMin supports the propietary attribute 'pre' that can be added to elements
110 | to prevent minification. This attribute is removed by default. Set this flag to
111 | keep the 'pre' attributes in place.
112 | 
113 | '''),
114 |   action='store_true')
115 | 
116 | parser.add_argument('-a', '--pre-attr',
117 |   help=(
118 | '''The attribute htmlmin looks for to find blocks of HTML that it should not
119 | minify. This attribute will be removed from the HTML unless '-k' is
120 | specified. Defaults to 'pre'.
121 | 
122 | '''),
123 |   default='pre')
124 | 
125 | 
126 | parser.add_argument('-p', '--pre-tags',
127 |   metavar='TAG',
128 |   help=(
129 | '''By default, the contents of 'pre', and 'textarea' tags are left unminified.
130 | You can specify different tags using the --pre-tags option. 'script' and 'style'
131 | tags are always left unmininfied.
132 | 
133 | '''),
134 |   nargs='*',
135 |   default=['pre', 'textarea'])
136 | parser.add_argument('-e', '--encoding',
137 |   help=("Encoding to read and write with. Default 'utf-8'."
138 |         " When reading from stdin, attempts to use the system's"
139 |         " encoding before defaulting to utf-8.\n\n"),
140 |   default=None,
141 |   )
142 | 
143 | def main():
144 |   args = parser.parse_args()
145 |   minifier = Minifier(
146 |     remove_comments=args.remove_comments,
147 |     remove_empty_space=args.remove_empty_space,
148 |     remove_optional_attribute_quotes=not args.keep_optional_attribute_quotes,
149 |     pre_tags=args.pre_tags,
150 |     keep_pre=args.keep_pre_attr,
151 |     pre_attr=args.pre_attr,
152 |     )
153 |   default_encoding = args.encoding or 'utf-8'
154 | 
155 |   if args.input_file:
156 |     inp = codecs.open(args.input_file, encoding=default_encoding)
157 |   else:
158 |     encoding = args.encoding or sys.stdin.encoding \
159 |       or locale.getpreferredencoding() or default_encoding
160 |     inp = io.open(sys.stdin.fileno(), encoding=encoding)
161 | 
162 |   for line in inp.readlines():
163 |     minifier.input(line)
164 | 
165 |   if args.output_file:
166 |     codecs.open(
167 |       args.output_file, 'w', encoding=default_encoding).write(minifier.output)
168 |   else:
169 |     encoding = args.encoding or sys.stdout.encoding \
170 |       or locale.getpreferredencoding() or default_encoding
171 |     io.open(sys.stdout.fileno(), 'w', encoding=encoding).write(minifier.output)
172 | 
173 | if __name__ == '__main__':
174 |   main()
175 | 
176 | 


--------------------------------------------------------------------------------
/htmlmin/escape.py:
--------------------------------------------------------------------------------
  1 | """
  2 | Copyright (c) 2015, Dave Mankoff
  3 | All rights reserved.
  4 | 
  5 | Redistribution and use in source and binary forms, with or without
  6 | modification, are permitted provided that the following conditions are met:
  7 |     * Redistributions of source code must retain the above copyright
  8 |       notice, this list of conditions and the following disclaimer.
  9 |     * Redistributions in binary form must reproduce the above copyright
 10 |       notice, this list of conditions and the following disclaimer in the
 11 |       documentation and/or other materials provided with the distribution.
 12 |     * Neither the name of Dave Mankoff nor the
 13 |       names of its contributors may be used to endorse or promote products
 14 |       derived from this software without specific prior written permission.
 15 | 
 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 19 | DISCLAIMED. IN NO EVENT SHALL DAVE MANKOFF BE LIABLE FOR ANY
 20 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 23 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 26 | """
 27 | 
 28 | import re
 29 | 
 30 | try:
 31 |   from html import escape
 32 | except ImportError:
 33 |   from cgi import escape
 34 | 
 35 | import re
 36 | 
 37 | NO_QUOTES = 0
 38 | SINGLE_QUOTE = 1
 39 | DOUBLE_QUOTE = 2
 40 | 
 41 | UPPER_A = ord('A')
 42 | UPPER_F = ord('F')
 43 | UPPER_Z = ord('Z')
 44 | LOWER_A = ord('a')
 45 | LOWER_F = ord('f')
 46 | LOWER_Z = ord('z')
 47 | ZERO = ord('0')
 48 | NINE = ord('9')
 49 | 
 50 | 
 51 | # https://www.w3.org/TR/html5/syntax.html#attributes-0
 52 | CHARS_TO_QUOTE_RE = re.compile(u'[\x20\x09\x0a\x0c\x0d=><`]')
 53 | 
 54 | def escape_tag(val):
 55 |   return escape(val)
 56 | 
 57 | def escape_attr_name(val):
 58 |   return escape(val)
 59 | 
 60 | def escape_attr_value(val, double_quote=False):
 61 |   val = escape_ambiguous_ampersand(val)
 62 |   has_html_tag = '<' in val or '>' in val
 63 |   if double_quote:
 64 |     return (val.replace('"', '&#34;'), DOUBLE_QUOTE)
 65 | 
 66 |   double_quote_count = 0
 67 |   single_quote_count = 0
 68 |   for ch in val:
 69 |     if ch == '"':
 70 |       double_quote_count += 1
 71 |     elif ch == "'":
 72 |       single_quote_count += 1
 73 |   if double_quote_count > single_quote_count:
 74 |     return (val.replace("'", '&#39;'), SINGLE_QUOTE)
 75 |   elif single_quote_count:
 76 |     return (val.replace('"', '&#34;'), DOUBLE_QUOTE)
 77 | 
 78 |   if not val or CHARS_TO_QUOTE_RE.search(val):
 79 |     return (val, DOUBLE_QUOTE)
 80 |   return (val, NO_QUOTES)
 81 | 
 82 | def escape_ambiguous_ampersand(val):
 83 |   # TODO: this function could probably me made a lot faster.
 84 |   if not '&' in val:  # short circuit for speed
 85 |     return val
 86 | 
 87 |   state = 0
 88 |   result = []
 89 |   amp_buff = []
 90 |   for c in val:
 91 |     if state == 0:  # beginning
 92 |       if c == '&':
 93 |         state = 1
 94 |       else:
 95 |         result.append(c)
 96 |     elif state == 1:  # ampersand
 97 |       ord_c = ord(c)
 98 |       if (UPPER_A <= ord_c <= UPPER_Z or
 99 |             LOWER_A <= ord_c <= LOWER_Z or
100 |             ZERO <= ord_c <= NINE):
101 |         amp_buff.append(c)  # TODO: use "name character references" section
102 |         # https://html.spec.whatwg.org/multipage/syntax.html#named-character-references
103 |       elif c == '#':
104 |         state = 2
105 |       elif c == ';':
106 |         if amp_buff:
107 |           result.append('&')
108 |           result.extend(amp_buff)
109 |           result.append(';')
110 |         else:
111 |           result.append('&;')
112 |         state = 0
113 |         amp_buff = []
114 |       elif c == '&':
115 |         if amp_buff:
116 |           result.append('&amp;')
117 |           result.extend(amp_buff)
118 |         else:
119 |           result.append('&')
120 |         amp_buff = []
121 |       else:
122 |         result.append('&')
123 |         result.extend(amp_buff)
124 |         result.append(c)
125 |         state = 0
126 |         amp_buff = []
127 |     elif state == 2:  # numeric character reference
128 |       ord_c = ord(c)
129 |       if c == 'x' or c == 'X':
130 |         state = 3
131 |       elif ZERO <= ord_c <= NINE:
132 |         amp_buff.append(c)
133 |       elif c == ';':
134 |         if amp_buff:
135 |           result.append('&#')
136 |           result.extend(amp_buff)
137 |           result.append(';')
138 |         else:
139 |           result.append('&#;')
140 |         state = 0
141 |         amp_buff = []
142 |       elif c == '&':
143 |         if amp_buff:
144 |           result.append('&amp;#')
145 |           result.extend(amp_buff)
146 |         else:
147 |           result.append('&#')
148 |         state = 1
149 |         amp_buff = []
150 |       else:
151 |         if amp_buff:
152 |           result.append('&amp;#')
153 |           result.extend(amp_buff)
154 |           result.append(c)
155 |         else:
156 |           result.append('&#')
157 |           result.append(c)
158 |         state = 0
159 |         amp_buff = []
160 |     elif state == 3:  # hex character reference
161 |       ord_c = ord(c)
162 |       if (UPPER_A <= ord_c <= UPPER_F or
163 |           LOWER_A <= ord_c <= LOWER_F or
164 |           ZERO <= ord_c <= NINE):
165 |         amp_buff.append(c)
166 |       elif c == ';':
167 |         if amp_buff:
168 |           result.append('&#x')
169 |           result.extend(amp_buff)
170 |           result.append(';')
171 |         else:
172 |           result.append('&#x;')
173 |         state = 0
174 |         amp_buff = []
175 |       elif c == '&':
176 |         if amp_buff:
177 |           result.append('&amp;#x')
178 |           result.extend(amp_buff)
179 |         else:
180 |           result.append('&#x')
181 |         state = 1
182 |         amp_buff = []
183 |       else:
184 |         if amp_buff:
185 |           result.append('&amp;#x')
186 |           result.extend(amp_buff)
187 |           result.append(c)
188 |         else:
189 |           result.append('&#x')
190 |           result.append(c)
191 |         state = 0
192 |         amp_buff = []
193 | 
194 |   if state == 1:
195 |     result.append('&amp;')
196 |     result.extend(amp_buff)
197 |   elif state == 2:
198 |     result.append('&amp;#')
199 |     result.extend(amp_buff)
200 |   elif state == 3:
201 |     result.append('&amp;#x')
202 |     result.extend(amp_buff)
203 | 
204 |   return ''.join(result)
205 | 


--------------------------------------------------------------------------------
/docs/conf.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | #
  3 | # htmlmin documentation build configuration file, created by
  4 | # sphinx-quickstart on Thu Feb 14 22:56:34 2013.
  5 | #
  6 | # This file is execfile()d with the current directory set to its containing dir.
  7 | #
  8 | # Note that not all possible configuration values are present in this
  9 | # autogenerated file.
 10 | #
 11 | # All configuration values have a default; values that are commented out
 12 | # serve to show the default.
 13 | 
 14 | import sys, os
 15 | 
 16 | # If extensions (or modules to document with autodoc) are in another directory,
 17 | # add these directories to sys.path here. If the directory is relative to the
 18 | # documentation root, use os.path.abspath to make it absolute, like shown here.
 19 | #sys.path.insert(0, os.path.abspath('.'))
 20 | 
 21 | sys.path.insert(0, os.path.abspath('..'))
 22 | 
 23 | # -- General configuration -----------------------------------------------------
 24 | 
 25 | # If your documentation needs a minimal Sphinx version, state it here.
 26 | #needs_sphinx = '1.0'
 27 | 
 28 | # Add any Sphinx extension module names here, as strings. They can be extensions
 29 | # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 30 | extensions = ['sphinx.ext.autodoc']
 31 | 
 32 | # Add any paths that contain templates here, relative to this directory.
 33 | templates_path = ['_templates']
 34 | 
 35 | # The suffix of source filenames.
 36 | source_suffix = '.rst'
 37 | 
 38 | # The encoding of source files.
 39 | #source_encoding = 'utf-8-sig'
 40 | 
 41 | # The master toctree document.
 42 | master_doc = 'index'
 43 | 
 44 | # General information about the project.
 45 | project = u'htmlmin'
 46 | copyright = u'2013, Dave Mankoff'
 47 | 
 48 | # The version info for the project you're documenting, acts as replacement for
 49 | # |version| and |release|, also used in various other places throughout the
 50 | # built documents.
 51 | #
 52 | # The short X.Y version.
 53 | version = '0.1'
 54 | # The full version, including alpha/beta/rc tags.
 55 | release = '0.1'
 56 | 
 57 | # The language for content autogenerated by Sphinx. Refer to documentation
 58 | # for a list of supported languages.
 59 | #language = None
 60 | 
 61 | # There are two options for replacing |today|: either, you set today to some
 62 | # non-false value, then it is used:
 63 | #today = ''
 64 | # Else, today_fmt is used as the format for a strftime call.
 65 | #today_fmt = '%B %d, %Y'
 66 | 
 67 | # List of patterns, relative to source directory, that match files and
 68 | # directories to ignore when looking for source files.
 69 | exclude_patterns = ['_build']
 70 | 
 71 | # The reST default role (used for this markup: `text`) to use for all documents.
 72 | #default_role = None
 73 | 
 74 | # If true, '()' will be appended to :func: etc. cross-reference text.
 75 | #add_function_parentheses = True
 76 | 
 77 | # If true, the current module name will be prepended to all description
 78 | # unit titles (such as .. function::).
 79 | #add_module_names = True
 80 | 
 81 | # If true, sectionauthor and moduleauthor directives will be shown in the
 82 | # output. They are ignored by default.
 83 | #show_authors = False
 84 | 
 85 | # The name of the Pygments (syntax highlighting) style to use.
 86 | pygments_style = 'sphinx'
 87 | 
 88 | # A list of ignored prefixes for module index sorting.
 89 | #modindex_common_prefix = []
 90 | 
 91 | 
 92 | # -- Options for HTML output ---------------------------------------------------
 93 | 
 94 | # The theme to use for HTML and HTML Help pages.  See the documentation for
 95 | # a list of builtin themes.
 96 | html_theme = 'default'
 97 | 
 98 | # Theme options are theme-specific and customize the look and feel of a theme
 99 | # further.  For a list of options available for each theme, see the
100 | # documentation.
101 | #html_theme_options = {}
102 | 
103 | # Add any paths that contain custom themes here, relative to this directory.
104 | #html_theme_path = []
105 | 
106 | # The name for this set of Sphinx documents.  If None, it defaults to
107 | # "<project> v<release> documentation".
108 | #html_title = None
109 | 
110 | # A shorter title for the navigation bar.  Default is the same as html_title.
111 | #html_short_title = None
112 | 
113 | # The name of an image file (relative to this directory) to place at the top
114 | # of the sidebar.
115 | #html_logo = None
116 | 
117 | # The name of an image file (within the static path) to use as favicon of the
118 | # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
119 | # pixels large.
120 | #html_favicon = None
121 | 
122 | # Add any paths that contain custom static files (such as style sheets) here,
123 | # relative to this directory. They are copied after the builtin static files,
124 | # so a file named "default.css" will overwrite the builtin "default.css".
125 | html_static_path = ['_static']
126 | 
127 | # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
128 | # using the given strftime format.
129 | #html_last_updated_fmt = '%b %d, %Y'
130 | 
131 | # If true, SmartyPants will be used to convert quotes and dashes to
132 | # typographically correct entities.
133 | #html_use_smartypants = True
134 | 
135 | # Custom sidebar templates, maps document names to template names.
136 | #html_sidebars = {}
137 | 
138 | # Additional templates that should be rendered to pages, maps page names to
139 | # template names.
140 | #html_additional_pages = {}
141 | 
142 | # If false, no module index is generated.
143 | #html_domain_indices = True
144 | 
145 | # If false, no index is generated.
146 | #html_use_index = True
147 | 
148 | # If true, the index is split into individual pages for each letter.
149 | #html_split_index = False
150 | 
151 | # If true, links to the reST sources are added to the pages.
152 | #html_show_sourcelink = True
153 | 
154 | # If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
155 | #html_show_sphinx = True
156 | 
157 | # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
158 | #html_show_copyright = True
159 | 
160 | # If true, an OpenSearch description file will be output, and all pages will
161 | # contain a <link> tag referring to it.  The value of this option must be the
162 | # base URL from which the finished HTML is served.
163 | #html_use_opensearch = ''
164 | 
165 | # This is the file name suffix for HTML files (e.g. ".xhtml").
166 | #html_file_suffix = None
167 | 
168 | # Output file base name for HTML help builder.
169 | htmlhelp_basename = 'htmlmindoc'
170 | 
171 | 
172 | # -- Options for LaTeX output --------------------------------------------------
173 | 
174 | latex_elements = {
175 | # The paper size ('letterpaper' or 'a4paper').
176 | #'papersize': 'letterpaper',
177 | 
178 | # The font size ('10pt', '11pt' or '12pt').
179 | #'pointsize': '10pt',
180 | 
181 | # Additional stuff for the LaTeX preamble.
182 | #'preamble': '',
183 | }
184 | 
185 | # Grouping the document tree into LaTeX files. List of tuples
186 | # (source start file, target name, title, author, documentclass [howto/manual]).
187 | latex_documents = [
188 |   ('index', 'htmlmin.tex', u'htmlmin Documentation',
189 |    u'Dave Mankoff', 'manual'),
190 | ]
191 | 
192 | # The name of an image file (relative to this directory) to place at the top of
193 | # the title page.
194 | #latex_logo = None
195 | 
196 | # For "manual" documents, if this is true, then toplevel headings are parts,
197 | # not chapters.
198 | #latex_use_parts = False
199 | 
200 | # If true, show page references after internal links.
201 | #latex_show_pagerefs = False
202 | 
203 | # If true, show URL addresses after external links.
204 | #latex_show_urls = False
205 | 
206 | # Documents to append as an appendix to all manuals.
207 | #latex_appendices = []
208 | 
209 | # If false, no module index is generated.
210 | #latex_domain_indices = True
211 | 
212 | 
213 | # -- Options for manual page output --------------------------------------------
214 | 
215 | # One entry per manual page. List of tuples
216 | # (source start file, name, description, authors, manual section).
217 | man_pages = [
218 |     ('index', 'htmlmin', u'htmlmin Documentation',
219 |      [u'Dave Mankoff'], 1)
220 | ]
221 | 
222 | # If true, show URL addresses after external links.
223 | #man_show_urls = False
224 | 
225 | 
226 | # -- Options for Texinfo output ------------------------------------------------
227 | 
228 | # Grouping the document tree into Texinfo files. List of tuples
229 | # (source start file, target name, title, author,
230 | #  dir menu entry, description, category)
231 | texinfo_documents = [
232 |   ('index', 'htmlmin', u'htmlmin Documentation',
233 |    u'Dave Mankoff', 'htmlmin', 'One line description of project.',
234 |    'Miscellaneous'),
235 | ]
236 | 
237 | # Documents to append as an appendix to all manuals.
238 | #texinfo_appendices = []
239 | 
240 | # If false, no module index is generated.
241 | #texinfo_domain_indices = True
242 | 
243 | # How to display URL addresses: 'footnote', 'no', or 'inline'.
244 | #texinfo_show_urls = 'footnote'
245 | 


--------------------------------------------------------------------------------
/htmlmin/main.py:
--------------------------------------------------------------------------------
  1 | """
  2 | Copyright (c) 2013, Dave Mankoff
  3 | All rights reserved.
  4 | 
  5 | Redistribution and use in source and binary forms, with or without
  6 | modification, are permitted provided that the following conditions are met:
  7 |     * Redistributions of source code must retain the above copyright
  8 |       notice, this list of conditions and the following disclaimer.
  9 |     * Redistributions in binary form must reproduce the above copyright
 10 |       notice, this list of conditions and the following disclaimer in the
 11 |       documentation and/or other materials provided with the distribution.
 12 |     * Neither the name of Dave Mankoff nor the
 13 |       names of its contributors may be used to endorse or promote products
 14 |       derived from this software without specific prior written permission.
 15 | 
 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 19 | DISCLAIMED. IN NO EVENT SHALL DAVE MANKOFF BE LIABLE FOR ANY
 20 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 23 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 26 | """
 27 | 
 28 | import cgi
 29 | 
 30 | from . import parser
 31 | 
 32 | def minify(input,
 33 |            remove_comments=False,
 34 |            remove_empty_space=False,
 35 |            remove_all_empty_space=False,
 36 |            reduce_empty_attributes=True,
 37 |            reduce_boolean_attributes=False,
 38 |            remove_optional_attribute_quotes=True,
 39 |            convert_charrefs=True,
 40 |            keep_pre=False,
 41 |            pre_tags=parser.PRE_TAGS,
 42 |            pre_attr='pre',
 43 |            cls=parser.HTMLMinParser):
 44 |   """Minifies HTML in one shot.
 45 | 
 46 |   :param input: A string containing the HTML to be minified.
 47 |   :param remove_comments: Remove comments found in HTML. Individual comments can
 48 |     be maintained by putting a ``!`` as the first character inside the comment.
 49 |     Thus::
 50 | 
 51 |        <!-- FOO --> <!--! BAR -->
 52 | 
 53 |     Will become simply::
 54 | 
 55 |        <!-- BAR -->
 56 | 
 57 |     The added exclamation is removed.
 58 |   :param remove_empty_space: Remove empty space found in HTML between an opening
 59 |     and a closing tag and when it contains a newline or carriage return. If
 60 |     whitespace is found that is only spaces and/or tabs, it will be turned into
 61 |     a single space. Be careful, this can have unintended consequences.
 62 |   :param remove_all_empty_space: A more extreme version of
 63 |     ``remove_empty_space``, this removes all empty whitespace found between
 64 |     tags. This is almost guaranteed to break your HTML unless you are very
 65 |     careful.
 66 |   :param reduce_boolean_attributes: Where allowed by the HTML5 specification,
 67 |     attributes such as 'disabled' and 'readonly' will have their value removed,
 68 |     so 'disabled="true"' will simply become 'disabled'. This is generally a
 69 |     good option to turn on except when JavaScript relies on the values.
 70 |   :param remove_optional_attribute_quotes: When True, optional quotes around
 71 |     attributes are removed. When False, all attribute quotes are left intact.
 72 |     Defaults to True.
 73 |   :param conver_charrefs: Decode character references such as &amp; and &#46;
 74 |     to their single charater values where safe. This currently only applies to
 75 |     attributes. Data content between tags will be left encoded.
 76 |   :param keep_pre: By default, htmlmin uses the special attribute ``pre`` to
 77 |     allow you to demarcate areas of HTML that should not be minified. It removes
 78 |     this attribute as it finds it. Setting this value to ``True`` tells htmlmin
 79 |     to leave the attribute in the output.
 80 |   :param pre_tags: A list of tag names that should never be minified. You are
 81 |     free to change this list as you see fit, but you will probably want to
 82 |     include ``pre`` and ``textarea`` if you make any changes to the list. Note
 83 |     that ``<script>`` and ``<style>`` tags are never minimized.
 84 |   :param pre_attr: Specifies the attribute that, when found in an HTML tag,
 85 |     indicates that the content of the tag should not be minified. Defaults to
 86 |     ``pre``. You can also prefix individual tag attributes with 
 87 |     ``{pre_attr}-`` to prevent the contents of the individual attribute from
 88 |     being changed.
 89 |   :return: A string containing the minified HTML.
 90 | 
 91 |   If you are going to be minifying multiple HTML documents, each with the same
 92 |   settings, consider using :class:`.Minifier`.
 93 |   """
 94 |   minifier = cls(
 95 |       remove_comments=remove_comments,
 96 |       remove_empty_space=remove_empty_space,
 97 |       remove_all_empty_space=remove_all_empty_space,
 98 |       reduce_empty_attributes=reduce_empty_attributes,
 99 |       reduce_boolean_attributes=reduce_boolean_attributes,
100 |       remove_optional_attribute_quotes=remove_optional_attribute_quotes,
101 |       convert_charrefs=convert_charrefs,
102 |       keep_pre=keep_pre,
103 |       pre_tags=pre_tags,
104 |       pre_attr=pre_attr)
105 |   minifier.feed(input)
106 |   minifier.close()
107 |   return minifier.result
108 | 
109 | class Minifier(object):
110 |   """An object that supports HTML Minification.
111 | 
112 |   Options are passed into this class at initialization time and are then
113 |   persisted across each use of the instance. If you are going to be minifying
114 |   multiple peices of HTML, this will be more efficient than using
115 |   :class:`htmlmin.minify`.
116 | 
117 |   See :class:`htmlmin.minify` for an explanation of options.
118 |   """
119 | 
120 |   def __init__(self,
121 |                remove_comments=False,
122 |                remove_empty_space=False,
123 |                remove_all_empty_space=False,
124 |                reduce_empty_attributes=True,
125 |                reduce_boolean_attributes=False,
126 |                remove_optional_attribute_quotes=True,
127 |                convert_charrefs=True,
128 |                keep_pre=False,
129 |                pre_tags=parser.PRE_TAGS,
130 |                pre_attr='pre',
131 |                cls=parser.HTMLMinParser):
132 |     """Initialize the Minifier.
133 | 
134 |     See :class:`htmlmin.minify` for an explanation of options.
135 |     """
136 |     self._parser = cls(
137 |       remove_comments=remove_comments,
138 |       remove_empty_space=remove_empty_space,
139 |       remove_all_empty_space=remove_all_empty_space,
140 |       reduce_empty_attributes=reduce_empty_attributes,
141 |       reduce_boolean_attributes=reduce_boolean_attributes,
142 |       remove_optional_attribute_quotes=remove_optional_attribute_quotes,
143 |       convert_charrefs=convert_charrefs,
144 |       keep_pre=keep_pre,
145 |       pre_tags=pre_tags,
146 |       pre_attr=pre_attr)
147 | 
148 |   def minify(self, *input):
149 |     """Runs HTML through the minifier in one pass.
150 | 
151 |     :param input: HTML to be fed into the minimizer. Multiple chunks of HTML
152 |       can be provided, and they are fed in sequentially as if they were
153 |       concatenated.
154 |     :returns: A string containing the minified HTML.
155 | 
156 |     This is the simplest way to use an existing ``Minifier`` instance. This
157 |     method takes in HTML and minfies it, returning the result. Note that this
158 |     method resets the internal state of  the parser before it does any work. If
159 |     there is pending HTML in the buffers, it will be lost.
160 |     """
161 |     self._parser.reset()
162 |     self.input(*input)
163 |     return self.finalize()
164 | 
165 |   def input(self, *input):
166 |     """Feed more HTML into the input stream
167 | 
168 |     :param input: HTML to be fed into the minimizer. Multiple chunks of HTML
169 |       can be provided, and they are fed in sequentially as if they were
170 |       concatenated. You can also call this method multiple times to achieve
171 |       the same effect.
172 |     """
173 |     for i in input:
174 |       self._parser.feed(i)
175 | 
176 |   @property
177 |   def output(self):
178 |     """Retrieve the minified output generated thus far.
179 |     """
180 |     return self._parser.result
181 | 
182 |   def finalize(self):
183 |     """Finishes current input HTML and returns mininified result.
184 | 
185 |     This method flushes any remaining input HTML and returns the minified
186 |     result. It resets the state of the internal parser in the process so that
187 |     new HTML can be minified. Be sure to call this method before you reuse
188 |     the ``Minifier`` instance on a new HTML document.
189 |     """
190 |     self._parser.close()
191 |     result = self._parser.result
192 |     self._parser.reset()
193 |     return result
194 | 


--------------------------------------------------------------------------------
/htmlmin/python3html/LICENSE:
--------------------------------------------------------------------------------
  1 | A. HISTORY OF THE SOFTWARE
  2 | ==========================
  3 | 
  4 | Python was created in the early 1990s by Guido van Rossum at Stichting
  5 | Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
  6 | as a successor of a language called ABC.  Guido remains Python's
  7 | principal author, although it includes many contributions from others.
  8 | 
  9 | In 1995, Guido continued his work on Python at the Corporation for
 10 | National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
 11 | in Reston, Virginia where he released several versions of the
 12 | software.
 13 | 
 14 | In May 2000, Guido and the Python core development team moved to
 15 | BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
 16 | year, the PythonLabs team moved to Digital Creations (now Zope
 17 | Corporation, see http://www.zope.com).  In 2001, the Python Software
 18 | Foundation (PSF, see http://www.python.org/psf/) was formed, a
 19 | non-profit organization created specifically to own Python-related
 20 | Intellectual Property.  Zope Corporation is a sponsoring member of
 21 | the PSF.
 22 | 
 23 | All Python releases are Open Source (see http://www.opensource.org for
 24 | the Open Source Definition).  Historically, most, but not all, Python
 25 | releases have also been GPL-compatible; the table below summarizes
 26 | the various releases.
 27 | 
 28 |     Release         Derived     Year        Owner       GPL-
 29 |                     from                                compatible? (1)
 30 | 
 31 |     0.9.0 thru 1.2              1991-1995   CWI         yes
 32 |     1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
 33 |     1.6             1.5.2       2000        CNRI        no
 34 |     2.0             1.6         2000        BeOpen.com  no
 35 |     1.6.1           1.6         2001        CNRI        yes (2)
 36 |     2.1             2.0+1.6.1   2001        PSF         no
 37 |     2.0.1           2.0+1.6.1   2001        PSF         yes
 38 |     2.1.1           2.1+2.0.1   2001        PSF         yes
 39 |     2.1.2           2.1.1       2002        PSF         yes
 40 |     2.1.3           2.1.2       2002        PSF         yes
 41 |     2.2 and above   2.1.1       2001-now    PSF         yes
 42 | 
 43 | Footnotes:
 44 | 
 45 | (1) GPL-compatible doesn't mean that we're distributing Python under
 46 |     the GPL.  All Python licenses, unlike the GPL, let you distribute
 47 |     a modified version without making your changes open source.  The
 48 |     GPL-compatible licenses make it possible to combine Python with
 49 |     other software that is released under the GPL; the others don't.
 50 | 
 51 | (2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
 52 |     because its license has a choice of law clause.  According to
 53 |     CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
 54 |     is "not incompatible" with the GPL.
 55 | 
 56 | Thanks to the many outside volunteers who have worked under Guido's
 57 | direction to make these releases possible.
 58 | 
 59 | 
 60 | B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
 61 | ===============================================================
 62 | 
 63 | PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
 64 | --------------------------------------------
 65 | 
 66 | 1. This LICENSE AGREEMENT is between the Python Software Foundation
 67 | ("PSF"), and the Individual or Organization ("Licensee") accessing and
 68 | otherwise using this software ("Python") in source or binary form and
 69 | its associated documentation.
 70 | 
 71 | 2. Subject to the terms and conditions of this License Agreement, PSF hereby
 72 | grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
 73 | analyze, test, perform and/or display publicly, prepare derivative works,
 74 | distribute, and otherwise use Python alone or in any derivative version,
 75 | provided, however, that PSF's License Agreement and PSF's notice of copyright,
 76 | i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
 77 | 2011, 2012, 2013, 2014, 2015, 2016 Python Software Foundation; All Rights
 78 | Reserved" are retained in Python alone or in any derivative version prepared by
 79 | Licensee.
 80 | 
 81 | 3. In the event Licensee prepares a derivative work that is based on
 82 | or incorporates Python or any part thereof, and wants to make
 83 | the derivative work available to others as provided herein, then
 84 | Licensee hereby agrees to include in any such work a brief summary of
 85 | the changes made to Python.
 86 | 
 87 | 4. PSF is making Python available to Licensee on an "AS IS"
 88 | basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
 89 | IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
 90 | DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
 91 | FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
 92 | INFRINGE ANY THIRD PARTY RIGHTS.
 93 | 
 94 | 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
 95 | FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
 96 | A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
 97 | OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
 98 | 
 99 | 6. This License Agreement will automatically terminate upon a material
100 | breach of its terms and conditions.
101 | 
102 | 7. Nothing in this License Agreement shall be deemed to create any
103 | relationship of agency, partnership, or joint venture between PSF and
104 | Licensee.  This License Agreement does not grant permission to use PSF
105 | trademarks or trade name in a trademark sense to endorse or promote
106 | products or services of Licensee, or any third party.
107 | 
108 | 8. By copying, installing or otherwise using Python, Licensee
109 | agrees to be bound by the terms and conditions of this License
110 | Agreement.
111 | 
112 | 
113 | BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
114 | -------------------------------------------
115 | 
116 | BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
117 | 
118 | 1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
119 | office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
120 | Individual or Organization ("Licensee") accessing and otherwise using
121 | this software in source or binary form and its associated
122 | documentation ("the Software").
123 | 
124 | 2. Subject to the terms and conditions of this BeOpen Python License
125 | Agreement, BeOpen hereby grants Licensee a non-exclusive,
126 | royalty-free, world-wide license to reproduce, analyze, test, perform
127 | and/or display publicly, prepare derivative works, distribute, and
128 | otherwise use the Software alone or in any derivative version,
129 | provided, however, that the BeOpen Python License is retained in the
130 | Software, alone or in any derivative version prepared by Licensee.
131 | 
132 | 3. BeOpen is making the Software available to Licensee on an "AS IS"
133 | basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
134 | IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
135 | DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
136 | FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
137 | INFRINGE ANY THIRD PARTY RIGHTS.
138 | 
139 | 4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
140 | SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
141 | AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
142 | DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
143 | 
144 | 5. This License Agreement will automatically terminate upon a material
145 | breach of its terms and conditions.
146 | 
147 | 6. This License Agreement shall be governed by and interpreted in all
148 | respects by the law of the State of California, excluding conflict of
149 | law provisions.  Nothing in this License Agreement shall be deemed to
150 | create any relationship of agency, partnership, or joint venture
151 | between BeOpen and Licensee.  This License Agreement does not grant
152 | permission to use BeOpen trademarks or trade names in a trademark
153 | sense to endorse or promote products or services of Licensee, or any
154 | third party.  As an exception, the "BeOpen Python" logos available at
155 | http://www.pythonlabs.com/logos.html may be used according to the
156 | permissions granted on that web page.
157 | 
158 | 7. By copying, installing or otherwise using the software, Licensee
159 | agrees to be bound by the terms and conditions of this License
160 | Agreement.
161 | 
162 | 
163 | CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
164 | ---------------------------------------
165 | 
166 | 1. This LICENSE AGREEMENT is between the Corporation for National
167 | Research Initiatives, having an office at 1895 Preston White Drive,
168 | Reston, VA 20191 ("CNRI"), and the Individual or Organization
169 | ("Licensee") accessing and otherwise using Python 1.6.1 software in
170 | source or binary form and its associated documentation.
171 | 
172 | 2. Subject to the terms and conditions of this License Agreement, CNRI
173 | hereby grants Licensee a nonexclusive, royalty-free, world-wide
174 | license to reproduce, analyze, test, perform and/or display publicly,
175 | prepare derivative works, distribute, and otherwise use Python 1.6.1
176 | alone or in any derivative version, provided, however, that CNRI's
177 | License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
178 | 1995-2001 Corporation for National Research Initiatives; All Rights
179 | Reserved" are retained in Python 1.6.1 alone or in any derivative
180 | version prepared by Licensee.  Alternately, in lieu of CNRI's License
181 | Agreement, Licensee may substitute the following text (omitting the
182 | quotes): "Python 1.6.1 is made available subject to the terms and
183 | conditions in CNRI's License Agreement.  This Agreement together with
184 | Python 1.6.1 may be located on the Internet using the following
185 | unique, persistent identifier (known as a handle): 1895.22/1013.  This
186 | Agreement may also be obtained from a proxy server on the Internet
187 | using the following URL: http://hdl.handle.net/1895.22/1013".
188 | 
189 | 3. In the event Licensee prepares a derivative work that is based on
190 | or incorporates Python 1.6.1 or any part thereof, and wants to make
191 | the derivative work available to others as provided herein, then
192 | Licensee hereby agrees to include in any such work a brief summary of
193 | the changes made to Python 1.6.1.
194 | 
195 | 4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
196 | basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
197 | IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
198 | DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
199 | FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
200 | INFRINGE ANY THIRD PARTY RIGHTS.
201 | 
202 | 5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
203 | 1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
204 | A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
205 | OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
206 | 
207 | 6. This License Agreement will automatically terminate upon a material
208 | breach of its terms and conditions.
209 | 
210 | 7. This License Agreement shall be governed by the federal
211 | intellectual property law of the United States, including without
212 | limitation the federal copyright law, and, to the extent such
213 | U.S. federal law does not apply, by the law of the Commonwealth of
214 | Virginia, excluding Virginia's conflict of law provisions.
215 | Notwithstanding the foregoing, with regard to derivative works based
216 | on Python 1.6.1 that incorporate non-separable material that was
217 | previously distributed under the GNU General Public License (GPL), the
218 | law of the Commonwealth of Virginia shall govern this License
219 | Agreement only as to issues arising under or with respect to
220 | Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
221 | License Agreement shall be deemed to create any relationship of
222 | agency, partnership, or joint venture between CNRI and Licensee.  This
223 | License Agreement does not grant permission to use CNRI trademarks or
224 | trade name in a trademark sense to endorse or promote products or
225 | services of Licensee, or any third party.
226 | 
227 | 8. By clicking on the "ACCEPT" button where indicated, or by copying,
228 | installing or otherwise using Python 1.6.1, Licensee agrees to be
229 | bound by the terms and conditions of this License Agreement.
230 | 
231 |         ACCEPT
232 | 
233 | 
234 | CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
235 | --------------------------------------------------
236 | 
237 | Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
238 | The Netherlands.  All rights reserved.
239 | 
240 | Permission to use, copy, modify, and distribute this software and its
241 | documentation for any purpose and without fee is hereby granted,
242 | provided that the above copyright notice appear in all copies and that
243 | both that copyright notice and this permission notice appear in
244 | supporting documentation, and that the name of Stichting Mathematisch
245 | Centrum or CWI not be used in advertising or publicity pertaining to
246 | distribution of the software without specific, written prior
247 | permission.
248 | 
249 | STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
250 | THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
251 | FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
252 | FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
253 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
254 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
255 | OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
256 | 


--------------------------------------------------------------------------------
/htmlmin/parser.py:
--------------------------------------------------------------------------------
  1 | """
  2 | Copyright (c) 2013, Dave Mankoff
  3 | All rights reserved.
  4 | 
  5 | Redistribution and use in source and binary forms, with or without
  6 | modification, are permitted provided that the following conditions are met:
  7 |     * Redistributions of source code must retain the above copyright
  8 |       notice, this list of conditions and the following disclaimer.
  9 |     * Redistributions in binary form must reproduce the above copyright
 10 |       notice, this list of conditions and the following disclaimer in the
 11 |       documentation and/or other materials provided with the distribution.
 12 |     * Neither the name of Dave Mankoff nor the
 13 |       names of its contributors may be used to endorse or promote products
 14 |       derived from this software without specific prior written permission.
 15 | 
 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 19 | DISCLAIMED. IN NO EVENT SHALL DAVE MANKOFF BE LIABLE FOR ANY
 20 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 23 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 26 | """
 27 | 
 28 | from __future__ import unicode_literals
 29 | import logging
 30 | import sys
 31 | 
 32 | import re
 33 | from .python3html.parser import HTMLParser
 34 | 
 35 | from . import escape
 36 | 
 37 | # https://www.w3.org/TR/html5/single-page.html#space-character
 38 | HTML_SPACE_RE = re.compile('[\x20\x09\x0a\x0c\x0d]+')
 39 | HTML_ALL_SPACE_RE = re.compile('^[\x20\x09\x0a\x0c\x0d]+$')
 40 | HTML_LEADING_SPACE_RE = re.compile(
 41 |   '^[\x20\x09\x0a\x0c\x0d]+')
 42 | HTML_TRAILING_SPACE_RE = re.compile(
 43 |   '[\x20\x09\x0a\x0c\x0d]+$')
 44 | HTML_LEADING_TRAILING_SPACE_RE = re.compile(
 45 |   '(^[\x20\x09\x0a\x0c\x0d]+)|([\x20\x09\x0a\x0c\x0d]+$)')
 46 | 
 47 | PRE_TAGS = ('pre', 'textarea')  # styles and scripts are never minified
 48 | # http://www.w3.org/TR/html51/syntax.html#elements-0
 49 | NO_CLOSE_TAGS = ('area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img',
 50 |                  'input', 'keygen', 'link', 'meta', 'param', 'source', 'track',
 51 |                  'wbr')
 52 | # http://www.w3.org/TR/html51/index.html#attributes-1
 53 | BOOLEAN_ATTRIBUTES = {
 54 |   'audio': ('autoplay', 'controls', 'hidden', 'loop', 'muted',),
 55 |   'button': ('autofocus', 'disabled', 'formnovalidate', 'hidden',),
 56 |   'command': ('checked', 'disabled', 'hidden'),
 57 |   'dialog': ('hidden', 'open',),
 58 |   'fieldset': ('disabled', 'hidden',),
 59 |   'form': ('hidden', 'novalidate',),
 60 |   'iframe': ('hidden', 'seamless',),
 61 |   'img': ('hidden', 'ismap',),
 62 |   'input': ('autofocus', 'checked', 'disabled', 'formnovalidate', 'hidden',
 63 |             'multiple', 'readonly', 'required',),
 64 |   'keygen': ('autofocus', 'disabled', 'hidden',),
 65 |   'object': ('hidden', 'typesmustmatch',),
 66 |   'ol': ('hidden', 'reversed',),
 67 |   'optgroup': ('disabled', 'hidden',),
 68 |   'option': ('disabled', 'hidden', 'selected',),
 69 |   'script': ('async', 'defer', 'hidden',),
 70 |   'select': ('autofocus', 'disabled', 'hidden', 'multiple', 'required',),
 71 |   'style': ('hidden', 'scoped',),
 72 |   'textarea': ('autofocus', 'disabled', 'hidden', 'readonly', 'required',),
 73 |   'track': ('default', 'hidden', ),
 74 |   'video': ('autoplay', 'controls', 'hidden', 'loop', 'muted',),
 75 |   '*': ('hidden',),
 76 | }
 77 | 
 78 | # a list of tags and tags that they are closed by
 79 | TAG_SETS = {
 80 |   'li': ('li',),
 81 |   'dd': ('dd', 'dt'),
 82 |   'rp': ('rp', 'rt'),
 83 |   'p': ('address', 'article', 'aside', 'blockquote', 'dir', 'div', 'dl',
 84 |         'fieldset', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
 85 |         'header', 'hgroup', 'hr', 'menu', 'nav', 'ol', 'p', 'pre', 'section',
 86 |         'table', 'ul'),
 87 |   'optgroup': ('optgroup',),
 88 |   'option': ('option', 'optgroup'),
 89 |   'colgroup': '*',
 90 |   'tbody': ('tbody', 'tfoot'),
 91 |   'tfoot': ('tbody',),
 92 |   'tr': ('tr',),
 93 |   'td': ('td', 'th'),
 94 | }
 95 | TAG_SETS['dt'] = TAG_SETS['dd']
 96 | TAG_SETS['rt'] = TAG_SETS['rp']
 97 | TAG_SETS['thead'] = TAG_SETS['tbody']
 98 | TAG_SETS['th'] = TAG_SETS['td']
 99 | 
100 | # Tag omission rules:
101 | # http://www.w3.org/TR/html51/syntax.html#optional-tags
102 | 
103 | class HTMLMinError(Exception): pass
104 | class ParseError(HTMLMinError): pass
105 | class OpenTagNotFoundError(ParseError): pass
106 | 
107 | class HTMLMinParser(HTMLParser):
108 |   def __init__(self,
109 |                remove_comments=False,
110 |                remove_empty_space=False,
111 |                remove_all_empty_space=False,
112 |                reduce_empty_attributes=True,
113 |                reduce_boolean_attributes=False,
114 |                remove_optional_attribute_quotes=True,
115 |                convert_charrefs=True,
116 |                keep_pre=False,
117 |                pre_tags=PRE_TAGS,
118 |                pre_attr='pre'):
119 |     if sys.version_info[0] >= 3 and sys.version_info[1] >= 4:
120 |       # convert_charrefs is True by default in Python 3.5.0 and newer. It was
121 |       # introduced in 3.4.
122 |       HTMLParser.__init__(self, convert_charrefs=False)
123 |     else:
124 |       HTMLParser.__init__(self)
125 |     self.keep_pre = keep_pre
126 |     self.pre_tags = pre_tags
127 |     self.remove_comments = remove_comments
128 |     self.remove_empty_space = remove_empty_space
129 |     self.remove_all_empty_space = remove_all_empty_space
130 |     self.reduce_empty_attributes = reduce_empty_attributes
131 |     self.reduce_boolean_attributes = reduce_boolean_attributes
132 |     self.remove_optional_attribute_quotes = remove_optional_attribute_quotes
133 |     self.convert_charrefs = convert_charrefs
134 |     self.pre_attr = pre_attr
135 |     self.reset()
136 | 
137 |   def _tag_lang(self):
138 |     return self._tag_stack[0][2] if self._tag_stack else None
139 | 
140 |   def build_tag(self, tag, attrs, close_tag):
141 |     has_pre = False
142 | 
143 |     if self.reduce_boolean_attributes:
144 |       bool_attrs = BOOLEAN_ATTRIBUTES.get(tag, BOOLEAN_ATTRIBUTES['*'])
145 |     else:
146 |       bool_attrs = False
147 | 
148 |     lang = self._tag_lang()
149 |     attrs = list(attrs)  # We're modifying it in place
150 |     last_quoted = last_no_slash = i = -1
151 |     for k, v in attrs:
152 |       pre_prefix = k.startswith("{}-".format(self.pre_attr))
153 |       if pre_prefix:
154 |         k = k[len(self.pre_attr)+1:]
155 |       if k == self.pre_attr:
156 |         has_pre = True
157 |         if not self.keep_pre and not pre_prefix:
158 |           continue
159 |       if v and self.convert_charrefs and not pre_prefix:
160 |         v = HTMLParser.unescape(self, v)
161 |       if k == 'lang':
162 |         lang = v
163 |         if v == self._tag_lang():
164 |           continue
165 | 
166 |       i += 1
167 |       if not pre_prefix:
168 |         k = escape.escape_attr_name(k)
169 |       if (v is None or (not v and self.reduce_empty_attributes) or
170 |           (bool_attrs and k in bool_attrs)):
171 |         # For our use case, we treat boolean attributes as quoted because they
172 |         # don't require space between them and "/>" in closing tags.
173 |         attrs[i] = k
174 |         last_quoted = i
175 |       else:
176 |         if pre_prefix:
177 |           has_double_quotes = '"' in v
178 |           has_single_quotes = "'" in v
179 |           if not has_double_quotes:
180 |             if not has_single_quotes and self.remove_optional_attribute_quotes:
181 |               q = escape.NO_QUOTES
182 |             else:
183 |               q = escape.DOUBLE_QUOTE
184 |           elif not has_single_quotes:
185 |             q = escape.SINGLE_QUOTES
186 |           else:
187 |             logging.error('Unsafe content found in pre-attribute. Escaping.')
188 |             (v, q) = escape.escape_attr_value(
189 |               v, double_quote=not self.remove_optional_attribute_quotes)
190 |         else:
191 |           (v, q) = escape.escape_attr_value(
192 |             v, double_quote=not self.remove_optional_attribute_quotes)
193 |         if q == escape.NO_QUOTES:
194 |           attrs[i] = '%s=%s' % (k, v)
195 |           if v[-1] != '/':
196 |             last_no_slash = i
197 |         else:
198 |           q = '"' if q == escape.DOUBLE_QUOTE else "'"
199 |           attrs[i] = '%s=%s%s%s' % (k, q, v, q)
200 |           last_quoted = i
201 | 
202 |     i += 1
203 |     if i != len(attrs):
204 |       del attrs[i:]
205 | 
206 |     # 1. If there are no attributes, no additional space is necessary.
207 |     # 2. If last attribute is quoted, no additional space is necessary.
208 |     # 3. Two things are happening here:
209 |     #    a) according to the standard, <foo bar=baz/> should be treated as <foo
210 |     #       bar="baz/"> so space is necessary if this is self-closing tag,
211 |     #       however
212 |     #    b) reportedly (https://github.com/mankyd/htmlmin/pull/12), older
213 |     #       versions of WebKit interpret <foo bar=baz/> as self-closing tag so
214 |     #       we need the space if the last argument ends with a slash.
215 |     space_maybe = ''
216 |     if attrs:
217 |       needs_space = lambda last_attr: (last_attr[-1] not in '"\'' and
218 |                                        (close_tag or last_attr[-1] == '/'))
219 |       if needs_space(attrs[-1][-1]):
220 |         # If moving attributes around can help, do it.  Otherwise bite the
221 |         # bullet and put the space in.
222 |         i = last_no_slash if last_quoted == -1 else last_quoted
223 |         if i == -1 or needs_space(attrs[i]):
224 |           space_maybe = ' '
225 |         else:
226 |           attrs.append(attrs[i])
227 |           del attrs[i]
228 | 
229 |     return has_pre, '<%s%s%s%s%s>' % (escape.escape_tag(tag),
230 |                                       ' ' if attrs else '',
231 |                                       ' '.join(attrs),
232 |                                       space_maybe,
233 |                                       '/' if close_tag else ''), lang
234 | 
235 |   def handle_decl(self, decl):
236 |     if (len(self._data_buffer) == 1 and 
237 |         HTML_SPACE_RE.match(self._data_buffer[0][0])):
238 |       self._data_buffer = []
239 |     self._data_buffer.append('<!' + decl + '>')
240 |     self._after_doctype = True
241 | 
242 |   def _close_tags_up_to(self, tag):
243 |     num_pres = 0
244 |     i = 0
245 |     for i, t in enumerate(self._tag_stack):
246 |       if t[1]:
247 |         num_pres += 1
248 |       if t[0] == tag:
249 |         break
250 | 
251 |       # Only the html tag can close out everything. Put on the brakes if
252 |       # we encounter a closing tag that we didn't recognize.
253 |       if tag != 'html' and t[0] in ('body', 'html', 'head'):
254 |         raise OpenTagNotFoundError()
255 | 
256 |     self._tag_stack = self._tag_stack[i+1:]
257 | 
258 |     return num_pres
259 | 
260 |   def handle_starttag(self, tag, attrs):
261 |     self._after_doctype = False
262 |     if tag == 'head':
263 |       self._in_head = True
264 |     elif self._in_head and tag == 'title':
265 |       self._in_title = True
266 |       self._title_newly_opened = True
267 | 
268 |     for t in self._tag_stack:
269 |       closed_by_tags = TAG_SETS.get(t[0])
270 |       if closed_by_tags and (closed_by_tags == '*' or tag in closed_by_tags):
271 |         self._in_pre_tag -= self._close_tags_up_to(t[0])
272 |         break
273 | 
274 |     has_pre, data, lang = self.build_tag(tag, attrs, False)
275 |     start_pre = False
276 |     if (has_pre or self._in_pre_tag > 0 or
277 |         tag == 'script' or tag == 'style' or tag in self.pre_tags):
278 |       self._in_pre_tag += 1
279 |       start_pre = True
280 | 
281 |     self._tag_stack.insert(0, (tag, start_pre, lang))
282 |     self._data_buffer.append(data)
283 | 
284 |   def handle_endtag(self, tag):
285 |     # According to the spec, <p> tags don't get closed when a parent a
286 |     # tag closes them. Here's some logic that addresses this.
287 |     if tag == 'a':
288 |       contains_p = False
289 |       for i, t in enumerate(self._tag_stack):
290 |         if t[0] == 'p':
291 |           contains_p = True
292 |         elif t[0] == 'a':
293 |           break
294 |       if contains_p: # the p tag, and all its children should be left open
295 |         a_tag = self._tag_stack.pop(i)
296 |         if a_tag[1]:
297 |           self._in_pre_tag -= 1
298 |     else:
299 |       if tag == 'head':
300 |         # TODO: Did we know that we were in an head tag?! If not, we need to
301 |         # reminify everything to remove extra spaces.
302 |         self._in_head = False
303 |       elif tag == 'title':
304 |         self._in_title = False
305 |         self._title_newly_opened = False
306 |       try:
307 |         self._in_pre_tag -= self._close_tags_up_to(tag)
308 |       except OpenTagNotFoundError:
309 |         # Some tags don't require a start tag. Most do. Either way, we leave
310 |         # closing tags along since they affect output. For instance, a '</p>'
311 |         # results in a '<p></p>' in Chrome.
312 |         pass
313 |     if tag not in NO_CLOSE_TAGS:
314 |       self._data_buffer.extend(['</', escape.escape_tag(tag), '>'])
315 | 
316 |   def handle_startendtag(self, tag, attrs):
317 |     self._after_doctype = False
318 |     data = self.build_tag(tag, attrs, tag not in NO_CLOSE_TAGS)[1]
319 |     self._data_buffer.append(data)
320 | 
321 |   def handle_comment(self, data):
322 |     if not self.remove_comments or re.match(r'^(?:!|\[if\s)', data):
323 |       self._data_buffer.append('<!--{}-->'.format(
324 |           data[1:] if len(data) and data[0] == '!' else data))
325 | 
326 |   def handle_data(self, data):
327 |     if self._in_pre_tag > 0:
328 |       self._data_buffer.append(data)
329 |     else:
330 |       # remove_all_empty_space matches everything. remove_empty_space only
331 |       # matches if there's a newline involved.
332 |       if self.remove_all_empty_space or self._in_head or self._after_doctype:
333 |         if HTML_ALL_SPACE_RE.match(data):
334 |           return
335 |       elif (self.remove_empty_space and HTML_ALL_SPACE_RE.match(data) and
336 |             ('\n' in data or '\r' in data)):
337 |         return
338 | 
339 |       # if we're in the title, remove leading and trailing whitespace.
340 |       # note that the title may be parsed in chunks if entityref's or charrefs
341 |       # are encountered.
342 |       if self._in_title:
343 |         if self.__title_trailing_whitespace:
344 |           self._data_buffer.append(' ')
345 |         self.__title_trailing_whitespace = (
346 |           HTML_ALL_SPACE_RE.match(data[-1]) is not None)
347 |         if self._title_newly_opened:
348 |           self._title_newly_opened = False
349 |           data = HTML_LEADING_TRAILING_SPACE_RE.sub('', data)
350 |         else:
351 |           data = HTML_TRAILING_SPACE_RE.sub(
352 |             '', HTML_LEADING_TRAILING_SPACE_RE.sub(' ', data))
353 | 
354 |       data = HTML_SPACE_RE.sub(' ', data)
355 |       if not data:
356 |         return
357 | 
358 |       if self._in_pre_tag == 0 and self._data_buffer:
359 |         # If we're not in a pre block, its possible that we append two spaces
360 |         # together, which we want to avoid. For instance, if we remove a comment
361 |         # from between two blocks of text: a <!-- B --> c => a  c.
362 |         if data[0] == ' ' and self._data_buffer[-1][-1] == ' ':
363 |           data = data[1:]
364 |           if not data:
365 |             return
366 |       self._data_buffer.append(data)
367 | 
368 |   def handle_entityref(self, data):
369 |     if self._in_title:
370 |       if not self._title_newly_opened and self.__title_trailing_whitespace:
371 |         self._data_buffer.append(' ')
372 |         self.__title_trailing_whitespace = False
373 |       self._title_newly_opened = False
374 |     self._data_buffer.append('&{};'.format(data))
375 | 
376 |   def handle_charref(self, data):
377 |     if self._in_title:
378 |       if not self._title_newly_opened and self.__title_trailing_whitespace:
379 |         self._data_buffer.append(' ')
380 |         self.__title_trailing_whitespace = False
381 |       self._title_newly_opened = False
382 |     self._data_buffer.append('&#{};'.format(data))
383 | 
384 |   def handle_pi(self, data):
385 |     self._data_buffer.append('<?' + data + '>')
386 | 
387 |   def unknown_decl(self, data):
388 |     self._data_buffer.append('<![' + data + ']>')
389 | 
390 |   def reset(self):
391 |     self._data_buffer = []
392 |     self._in_pre_tag = 0
393 |     self._in_head = False
394 |     self._in_title = False
395 |     self._after_doctype = False
396 |     self._tag_stack = []
397 |     self._title_newly_opened = False
398 |     self.__title_trailing_whitespace = False
399 |     HTMLParser.reset(self)
400 | 
401 |   def unescape(self, val):
402 |     """Override this method so that we can handle char ref conversion ourself.
403 |     """
404 |     return val
405 | 
406 |   @property
407 |   def result(self):
408 |     return ''.join(self._data_buffer)
409 | 


--------------------------------------------------------------------------------
/htmlmin/python3html/parser.py:
--------------------------------------------------------------------------------
  1 | """A parser for HTML and XHTML."""
  2 | 
  3 | ########
  4 | # This is copied from Python3 and the slightly modified to support needed
  5 | # features. The original file can be found at:
  6 | # https://github.com/python/cpython/blob/44b548dda872c0d4f30afd6b44fd74b053a55ad8/Lib/html/parser.py
  7 | #
  8 | # The largest difference is the reinstatment of the unescape method in 
  9 | # HTMLParser, which is needed for features in htmlmin. Changes are also
 10 | # made to ensure Python2.7 compatability.
 11 | ########
 12 | 
 13 | 
 14 | # This file is based on sgmllib.py, but the API is slightly different.
 15 | 
 16 | # XXX There should be a way to distinguish between PCDATA (parsed
 17 | # character data -- the normal case), RCDATA (replaceable character
 18 | # data -- only char and entity references and end tags are special)
 19 | # and CDATA (character data -- only end tags are special).
 20 | 
 21 | 
 22 | import re
 23 | import warnings
 24 | try:
 25 |     import _markupbase as markupbase
 26 | except ImportError:
 27 |     import markupbase
 28 | 
 29 | from . import unescape
 30 | 
 31 | 
 32 | __all__ = ['HTMLParser']
 33 | 
 34 | # Regular expressions used for parsing
 35 | 
 36 | interesting_normal = re.compile('[&<]')
 37 | incomplete = re.compile('&[a-zA-Z#]')
 38 | 
 39 | entityref = re.compile('&([a-zA-Z][-.a-zA-Z0-9]*)[^a-zA-Z0-9]')
 40 | charref = re.compile('&#(?:[0-9]+|[xX][0-9a-fA-F]+)[^0-9a-fA-F]')
 41 | 
 42 | starttagopen = re.compile('<[a-zA-Z]')
 43 | piclose = re.compile('>')
 44 | commentclose = re.compile(r'--\s*>')
 45 | # Note:
 46 | #  1) if you change tagfind/attrfind remember to update locatestarttagend too;
 47 | #  2) if you change tagfind/attrfind and/or locatestarttagend the parser will
 48 | #     explode, so don't do it.
 49 | # see http://www.w3.org/TR/html5/tokenization.html#tag-open-state
 50 | # and http://www.w3.org/TR/html5/tokenization.html#tag-name-state
 51 | tagfind_tolerant = re.compile(r'([a-zA-Z][^\t\n\r\f />\x00]*)(?:\s|/(?!>))*')
 52 | attrfind_tolerant = re.compile(
 53 |     r'((?<=[\'"\s/])[^\s/>][^\s/=>]*)(\s*=+\s*'
 54 |     r'(\'[^\']*\'|"[^"]*"|(?![\'"])[^>\s]*))?(?:\s|/(?!>))*')
 55 | locatestarttagend_tolerant = re.compile(r"""
 56 |   <[a-zA-Z][^\t\n\r\f />\x00]*       # tag name
 57 |   (?:[\s/]*                          # optional whitespace before attribute name
 58 |     (?:(?<=['"\s/])[^\s/>][^\s/=>]*  # attribute name
 59 |       (?:\s*=+\s*                    # value indicator
 60 |         (?:'[^']*'                   # LITA-enclosed value
 61 |           |"[^"]*"                   # LIT-enclosed value
 62 |           |(?!['"])[^>\s]*           # bare value
 63 |          )
 64 |          (?:\s*,)*                   # possibly followed by a comma
 65 |        )?(?:\s|/(?!>))*
 66 |      )*
 67 |    )?
 68 |   \s*                                # trailing whitespace
 69 | """, re.VERBOSE)
 70 | endendtag = re.compile('>')
 71 | # the HTML 5 spec, section 8.1.2.2, doesn't allow spaces between
 72 | # </ and the tag name, so maybe this should be fixed
 73 | endtagfind = re.compile(r'</\s*([a-zA-Z][-.a-zA-Z0-9:_]*)\s*>')
 74 | 
 75 | 
 76 | 
 77 | class HTMLParser(markupbase.ParserBase):
 78 |     """Find tags and other markup and call handler functions.
 79 | 
 80 |     Usage:
 81 |         p = HTMLParser()
 82 |         p.feed(data)
 83 |         ...
 84 |         p.close()
 85 | 
 86 |     Start tags are handled by calling self.handle_starttag() or
 87 |     self.handle_startendtag(); end tags by self.handle_endtag().  The
 88 |     data between tags is passed from the parser to the derived class
 89 |     by calling self.handle_data() with the data as argument (the data
 90 |     may be split up in arbitrary chunks).  If convert_charrefs is
 91 |     True the character references are converted automatically to the
 92 |     corresponding Unicode character (and self.handle_data() is no
 93 |     longer split in chunks), otherwise they are passed by calling
 94 |     self.handle_entityref() or self.handle_charref() with the string
 95 |     containing respectively the named or numeric reference as the
 96 |     argument.
 97 |     """
 98 | 
 99 |     CDATA_CONTENT_ELEMENTS = ("script", "style")
100 | 
101 |     def __init__(self, convert_charrefs=True):
102 |         """Initialize and reset this instance.
103 | 
104 |         If convert_charrefs is True (the default), all character references
105 |         are automatically converted to the corresponding Unicode characters.
106 |         """
107 |         self.convert_charrefs = convert_charrefs
108 |         self.reset()
109 | 
110 |     def reset(self):
111 |         """Reset this instance.  Loses all unprocessed data."""
112 |         self.rawdata = ''
113 |         self.lasttag = '???'
114 |         self.interesting = interesting_normal
115 |         self.cdata_elem = None
116 |         markupbase.ParserBase.reset(self)
117 | 
118 |     def feed(self, data):
119 |         r"""Feed data to the parser.
120 | 
121 |         Call this as often as you want, with as little or as much text
122 |         as you want (may include '\n').
123 |         """
124 |         self.rawdata = self.rawdata + data
125 |         self.goahead(0)
126 | 
127 |     def close(self):
128 |         """Handle any buffered data."""
129 |         self.goahead(1)
130 | 
131 |     __starttag_text = None
132 | 
133 |     def get_starttag_text(self):
134 |         """Return full source of start tag: '<...>'."""
135 |         return self.__starttag_text
136 | 
137 |     def set_cdata_mode(self, elem):
138 |         self.cdata_elem = elem.lower()
139 |         self.interesting = re.compile(r'</\s*%s\s*>' % self.cdata_elem, re.I)
140 | 
141 |     def clear_cdata_mode(self):
142 |         self.interesting = interesting_normal
143 |         self.cdata_elem = None
144 | 
145 |     # Internal -- handle data as far as reasonable.  May leave state
146 |     # and data to be processed by a subsequent call.  If 'end' is
147 |     # true, force handling all data as if followed by EOF marker.
148 |     def goahead(self, end):
149 |         rawdata = self.rawdata
150 |         i = 0
151 |         n = len(rawdata)
152 |         while i < n:
153 |             if self.convert_charrefs and not self.cdata_elem:
154 |                 j = rawdata.find('<', i)
155 |                 if j < 0:
156 |                     # if we can't find the next <, either we are at the end
157 |                     # or there's more text incoming.  If the latter is True,
158 |                     # we can't pass the text to handle_data in case we have
159 |                     # a charref cut in half at end.  Try to determine if
160 |                     # this is the case before proceeding by looking for an
161 |                     # & near the end and see if it's followed by a space or ;.
162 |                     amppos = rawdata.rfind('&', max(i, n-34))
163 |                     if (amppos >= 0 and
164 |                         not re.compile(r'[\s;]').search(rawdata, amppos)):
165 |                         break  # wait till we get all the text
166 |                     j = n
167 |             else:
168 |                 match = self.interesting.search(rawdata, i)  # < or &
169 |                 if match:
170 |                     j = match.start()
171 |                 else:
172 |                     if self.cdata_elem:
173 |                         break
174 |                     j = n
175 |             if i < j:
176 |                 if self.convert_charrefs and not self.cdata_elem:
177 |                     self.handle_data(self.unescape(rawdata[i:j]))
178 |                 else:
179 |                     self.handle_data(rawdata[i:j])
180 |             i = self.updatepos(i, j)
181 |             if i == n: break
182 |             startswith = rawdata.startswith
183 |             if startswith('<', i):
184 |                 if starttagopen.match(rawdata, i): # < + letter
185 |                     k = self.parse_starttag(i)
186 |                 elif startswith("</", i):
187 |                     k = self.parse_endtag(i)
188 |                 elif startswith("<!--", i):
189 |                     k = self.parse_comment(i)
190 |                 elif startswith("<?", i):
191 |                     k = self.parse_pi(i)
192 |                 elif startswith("<!", i):
193 |                     k = self.parse_html_declaration(i)
194 |                 elif (i + 1) < n:
195 |                     self.handle_data("<")
196 |                     k = i + 1
197 |                 else:
198 |                     break
199 |                 if k < 0:
200 |                     if not end:
201 |                         break
202 |                     k = rawdata.find('>', i + 1)
203 |                     if k < 0:
204 |                         k = rawdata.find('<', i + 1)
205 |                         if k < 0:
206 |                             k = i + 1
207 |                     else:
208 |                         k += 1
209 |                     if self.convert_charrefs and not self.cdata_elem:
210 |                         self.handle_data(self.unescape(rawdata[i:k]))
211 |                     else:
212 |                         self.handle_data(rawdata[i:k])
213 |                 i = self.updatepos(i, k)
214 |             elif startswith("&#", i):
215 |                 match = charref.match(rawdata, i)
216 |                 if match:
217 |                     name = match.group()[2:-1]
218 |                     self.handle_charref(name)
219 |                     k = match.end()
220 |                     if not startswith(';', k-1):
221 |                         k = k - 1
222 |                     i = self.updatepos(i, k)
223 |                     continue
224 |                 else:
225 |                     if ";" in rawdata[i:]:  # bail by consuming &#
226 |                         self.handle_data(rawdata[i:i+2])
227 |                         i = self.updatepos(i, i+2)
228 |                     break
229 |             elif startswith('&', i):
230 |                 match = entityref.match(rawdata, i)
231 |                 if match:
232 |                     name = match.group(1)
233 |                     self.handle_entityref(name)
234 |                     k = match.end()
235 |                     if not startswith(';', k-1):
236 |                         k = k - 1
237 |                     i = self.updatepos(i, k)
238 |                     continue
239 |                 match = incomplete.match(rawdata, i)
240 |                 if match:
241 |                     # match.group() will contain at least 2 chars
242 |                     if end and match.group() == rawdata[i:]:
243 |                         k = match.end()
244 |                         if k <= i:
245 |                             k = n
246 |                         i = self.updatepos(i, i + 1)
247 |                     # incomplete
248 |                     break
249 |                 elif (i + 1) < n:
250 |                     # not the end of the buffer, and can't be confused
251 |                     # with some other construct
252 |                     self.handle_data("&")
253 |                     i = self.updatepos(i, i + 1)
254 |                 else:
255 |                     break
256 |             else:
257 |                 assert 0, "interesting.search() lied"
258 |         # end while
259 |         if end and i < n and not self.cdata_elem:
260 |             if self.convert_charrefs and not self.cdata_elem:
261 |                 self.handle_data(self.unescape(rawdata[i:n]))
262 |             else:
263 |                 self.handle_data(rawdata[i:n])
264 |             i = self.updatepos(i, n)
265 |         self.rawdata = rawdata[i:]
266 | 
267 |     # Internal -- parse html declarations, return length or -1 if not terminated
268 |     # See w3.org/TR/html5/tokenization.html#markup-declaration-open-state
269 |     # See also parse_declaration in _markupbase
270 |     def parse_html_declaration(self, i):
271 |         rawdata = self.rawdata
272 |         assert rawdata[i:i+2] == '<!', ('unexpected call to '
273 |                                         'parse_html_declaration()')
274 |         if rawdata[i:i+4] == '<!--':
275 |             # this case is actually already handled in goahead()
276 |             return self.parse_comment(i)
277 |         elif rawdata[i:i+3] == '<![':
278 |             return self.parse_marked_section(i)
279 |         elif rawdata[i:i+9].lower() == '<!doctype':
280 |             # find the closing >
281 |             gtpos = rawdata.find('>', i+9)
282 |             if gtpos == -1:
283 |                 return -1
284 |             self.handle_decl(rawdata[i+2:gtpos])
285 |             return gtpos+1
286 |         else:
287 |             return self.parse_bogus_comment(i)
288 | 
289 |     # Internal -- parse bogus comment, return length or -1 if not terminated
290 |     # see http://www.w3.org/TR/html5/tokenization.html#bogus-comment-state
291 |     def parse_bogus_comment(self, i, report=1):
292 |         rawdata = self.rawdata
293 |         assert rawdata[i:i+2] in ('<!', '</'), ('unexpected call to '
294 |                                                 'parse_comment()')
295 |         pos = rawdata.find('>', i+2)
296 |         if pos == -1:
297 |             return -1
298 |         if report:
299 |             self.handle_comment(rawdata[i+2:pos])
300 |         return pos + 1
301 | 
302 |     # Internal -- parse processing instr, return end or -1 if not terminated
303 |     def parse_pi(self, i):
304 |         rawdata = self.rawdata
305 |         assert rawdata[i:i+2] == '<?', 'unexpected call to parse_pi()'
306 |         match = piclose.search(rawdata, i+2) # >
307 |         if not match:
308 |             return -1
309 |         j = match.start()
310 |         self.handle_pi(rawdata[i+2: j])
311 |         j = match.end()
312 |         return j
313 | 
314 |     # Internal -- handle starttag, return end or -1 if not terminated
315 |     def parse_starttag(self, i):
316 |         self.__starttag_text = None
317 |         endpos = self.check_for_whole_start_tag(i)
318 |         if endpos < 0:
319 |             return endpos
320 |         rawdata = self.rawdata
321 |         self.__starttag_text = rawdata[i:endpos]
322 | 
323 |         # Now parse the data between i+1 and j into a tag and attrs
324 |         attrs = []
325 |         match = tagfind_tolerant.match(rawdata, i+1)
326 |         assert match, 'unexpected call to parse_starttag()'
327 |         k = match.end()
328 |         self.lasttag = tag = match.group(1).lower()
329 |         while k < endpos:
330 |             m = attrfind_tolerant.match(rawdata, k)
331 |             if not m:
332 |                 break
333 |             attrname, rest, attrvalue = m.group(1, 2, 3)
334 |             if not rest:
335 |                 attrvalue = None
336 |             elif attrvalue[:1] == '\'' == attrvalue[-1:] or \
337 |                  attrvalue[:1] == '"' == attrvalue[-1:]:
338 |                 attrvalue = attrvalue[1:-1]
339 |             if attrvalue:
340 |                 attrvalue = self.unescape(attrvalue)
341 |             attrs.append((attrname.lower(), attrvalue))
342 |             k = m.end()
343 | 
344 |         end = rawdata[k:endpos].strip()
345 |         if end not in (">", "/>"):
346 |             lineno, offset = self.getpos()
347 |             if "\n" in self.__starttag_text:
348 |                 lineno = lineno + self.__starttag_text.count("\n")
349 |                 offset = len(self.__starttag_text) \
350 |                          - self.__starttag_text.rfind("\n")
351 |             else:
352 |                 offset = offset + len(self.__starttag_text)
353 |             self.handle_data(rawdata[i:endpos])
354 |             return endpos
355 |         if end.endswith('/>'):
356 |             # XHTML-style empty tag: <span attr="value" />
357 |             self.handle_startendtag(tag, attrs)
358 |         else:
359 |             self.handle_starttag(tag, attrs)
360 |             if tag in self.CDATA_CONTENT_ELEMENTS:
361 |                 self.set_cdata_mode(tag)
362 |         return endpos
363 | 
364 |     # Internal -- check to see if we have a complete starttag; return end
365 |     # or -1 if incomplete.
366 |     def check_for_whole_start_tag(self, i):
367 |         rawdata = self.rawdata
368 |         m = locatestarttagend_tolerant.match(rawdata, i)
369 |         if m:
370 |             j = m.end()
371 |             next = rawdata[j:j+1]
372 |             if next == ">":
373 |                 return j + 1
374 |             if next == "/":
375 |                 if rawdata.startswith("/>", j):
376 |                     return j + 2
377 |                 if rawdata.startswith("/", j):
378 |                     # buffer boundary
379 |                     return -1
380 |                 # else bogus input
381 |                 if j > i:
382 |                     return j
383 |                 else:
384 |                     return i + 1
385 |             if next == "":
386 |                 # end of input
387 |                 return -1
388 |             if next in ("abcdefghijklmnopqrstuvwxyz=/"
389 |                         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"):
390 |                 # end of input in or before attribute value, or we have the
391 |                 # '/' from a '/>' ending
392 |                 return -1
393 |             if j > i:
394 |                 return j
395 |             else:
396 |                 return i + 1
397 |         raise AssertionError("we should not get here!")
398 | 
399 |     # Internal -- parse endtag, return end or -1 if incomplete
400 |     def parse_endtag(self, i):
401 |         rawdata = self.rawdata
402 |         assert rawdata[i:i+2] == "</", "unexpected call to parse_endtag"
403 |         match = endendtag.search(rawdata, i+1) # >
404 |         if not match:
405 |             return -1
406 |         gtpos = match.end()
407 |         match = endtagfind.match(rawdata, i) # </ + tag + >
408 |         if not match:
409 |             if self.cdata_elem is not None:
410 |                 self.handle_data(rawdata[i:gtpos])
411 |                 return gtpos
412 |             # find the name: w3.org/TR/html5/tokenization.html#tag-name-state
413 |             namematch = tagfind_tolerant.match(rawdata, i+2)
414 |             if not namematch:
415 |                 # w3.org/TR/html5/tokenization.html#end-tag-open-state
416 |                 if rawdata[i:i+3] == '</>':
417 |                     return i+3
418 |                 else:
419 |                     return self.parse_bogus_comment(i)
420 |             tagname = namematch.group(1).lower()
421 |             # consume and ignore other stuff between the name and the >
422 |             # Note: this is not 100% correct, since we might have things like
423 |             # </tag attr=">">, but looking for > after tha name should cover
424 |             # most of the cases and is much simpler
425 |             gtpos = rawdata.find('>', namematch.end())
426 |             self.handle_endtag(tagname)
427 |             return gtpos+1
428 | 
429 |         elem = match.group(1).lower() # script or style
430 |         if self.cdata_elem is not None:
431 |             if elem != self.cdata_elem:
432 |                 self.handle_data(rawdata[i:gtpos])
433 |                 return gtpos
434 | 
435 |         self.handle_endtag(elem.lower())
436 |         self.clear_cdata_mode()
437 |         return gtpos
438 | 
439 |     # Overridable -- finish processing of start+end tag: <tag.../>
440 |     def handle_startendtag(self, tag, attrs):
441 |         self.handle_starttag(tag, attrs)
442 |         self.handle_endtag(tag)
443 | 
444 |     # Overridable -- handle start tag
445 |     def handle_starttag(self, tag, attrs):
446 |         pass
447 | 
448 |     # Overridable -- handle end tag
449 |     def handle_endtag(self, tag):
450 |         pass
451 | 
452 |     # Overridable -- handle character reference
453 |     def handle_charref(self, name):
454 |         pass
455 | 
456 |     # Overridable -- handle entity reference
457 |     def handle_entityref(self, name):
458 |         pass
459 | 
460 |     # Overridable -- handle data
461 |     def handle_data(self, data):
462 |         pass
463 | 
464 |     # Overridable -- handle comment
465 |     def handle_comment(self, data):
466 |         pass
467 | 
468 |     # Overridable -- handle declaration
469 |     def handle_decl(self, decl):
470 |         pass
471 | 
472 |     # Overridable -- handle processing instruction
473 |     def handle_pi(self, data):
474 |         pass
475 | 
476 |     def unknown_decl(self, data):
477 |         pass
478 | 
479 |     # Internal -- helper to remove special character quoting
480 |     def unescape(self, s):
481 |         return unescape(s)
482 | 


--------------------------------------------------------------------------------
/htmlmin/tests/tests.py:
--------------------------------------------------------------------------------
  1 | """
  2 | Copyright (c) 2013, Dave Mankoff
  3 | All rights reserved.
  4 | 
  5 | Redistribution and use in source and binary forms, with or without
  6 | modification, are permitted provided that the following conditions are met:
  7 |     * Redistributions of source code must retain the above copyright
  8 |       notice, this list of conditions and the following disclaimer.
  9 |     * Redistributions in binary form must reproduce the above copyright
 10 |       notice, this list of conditions and the following disclaimer in the
 11 |       documentation and/or other materials provided with the distribution.
 12 |     * Neither the name of Dave Mankoff nor the
 13 |       names of its contributors may be used to endorse or promote products
 14 |       derived from this software without specific prior written permission.
 15 | 
 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 19 | DISCLAIMED. IN NO EVENT SHALL DAVE MANKOFF BE LIABLE FOR ANY
 20 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 23 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 26 | """
 27 | 
 28 | from __future__ import unicode_literals
 29 | import unittest
 30 | 
 31 | import htmlmin
 32 | from htmlmin.decorator import htmlmin as htmlmindecorator
 33 | from htmlmin.middleware import HTMLMinMiddleware
 34 | 
 35 | from . import test_escape
 36 | 
 37 | MINIFY_FUNCTION_TEXTS = {
 38 |   'simple_text': (
 39 |     '  a  b',
 40 |     ' a b'
 41 |   ),
 42 |   'long_text': (
 43 |     '''When doing     test-driven development, or
 44 |     running automated builds that need testing before they are  deployed
 45 | \t\t for downloading or use, it's often useful to be able to run a project's
 46 | unit tests without actually deploying the project anywhere.\r\n\r\n\n\r\rThe
 47 | test command runs project's unit tests without actually deploying it, by
 48 |     temporarily putting the project's source on sys.path, after first running
 49 |      build_ext -i to ensure that any C extensions are built.
 50 | 
 51 |     ''',
 52 |     ("When doing test-driven development, or running automated "
 53 |       "builds that need testing before they are deployed for "
 54 |       "downloading or use, it's often useful to be able to run a "
 55 |       "project's unit tests without actually deploying the project "
 56 |       "anywhere. The test command runs project's unit tests without "
 57 |       "actually deploying it, by temporarily putting the project's "
 58 |       "source on sys.path, after first running build_ext -i to "
 59 |       "ensure that any C extensions are built. ")
 60 |   ),
 61 |   'simple_html': (
 62 |     (' <body> <b>  a <i pre>b  </i>'  # <b> is not closed
 63 |      '<pre>   x </pre> <textarea>   Y  </textarea></body> '),
 64 |     (' <body> <b> a <i>b  </i>'
 65 |      '<pre>   x </pre> <textarea>   Y  </textarea></body> ')
 66 |   ),
 67 |   'with_doctype': (
 68 |     '\n\n<!DOCTYPE html>\n\n<body>   X   Y   </body>',
 69 |     '<!DOCTYPE html><body> X Y </body>'
 70 |   ),
 71 |   'dangling_tag': (
 72 |     "<p>first page",
 73 |     "<p>first page"
 74 |     ),
 75 |   'dangling_tag_followup': (
 76 |     "<html><p>next page",
 77 |     "<html><p>next page"
 78 |     )
 79 | }
 80 | 
 81 | FEATURES_TEXTS = {
 82 |   'remove_quotes': (
 83 |     '<body  >  <div id="x" style="   abc " data-a=b></div></  body>  ',
 84 |     '<body> <div id=x style="   abc " data-a=b></div></body> ',
 85 |   ),
 86 |   'remove_quotes_drop_trailing_slash': (
 87 |     '<div x="x/" y="y/"></div>',
 88 |     # Note: According to https://github.com/mankyd/htmlmin/pull/12 older version
 89 |     # of WebKit would erroneously interpret "<... y=y/>" as self-closing tag.
 90 |     '<div x=x/ y=y/ ></div>',
 91 |   ),
 92 |   'remove_quotes_keep_space_before_slash': (
 93 |     '<foo x="x/"/>',
 94 |     '<foo x=x/ />',  # NOTE: Space added so self-closing tag is parsed as such.
 95 |   ),
 96 |   'remove_single_quotes': (
 97 |     '<body><div thing=\'what\'></div></body> ',
 98 |     '<body><div thing=what></div></body> ',
 99 |   ),
100 |   'keep_nested_single_quotes': (
101 |     '<body><div thing="wh\'at"></div></body> ',
102 |     '<body><div thing="wh\'at"></div></body> ',
103 |   ),
104 |   'remove_tag_name_whitespace': (
105 |     '<body  >  <br   />  <textarea  >   </ textarea  ></  body>  ',
106 |     '<body> <br> <textarea>   </textarea></body> '
107 |   ),
108 |   'no_reduce_empty_attributes': (
109 |     '<body><img src="/x.png" alt="" /></body>',
110 |     '<body><img src=/x.png alt=""></body>',
111 |   ),
112 |   'no_reduce_empty_attributes_keep_quotes': (
113 |     '<body><img src="/x.png" alt="" /></body>',
114 |     '<body><img src="/x.png" alt=""></body>',
115 |   ),
116 |   'reduce_empty_attributes': (
117 |     '<body><img src="/x.png" alt="" /></body>',
118 |     '<body><img src=/x.png alt></body>',
119 |   ),
120 |   'keep_boolean_attributes': (
121 |     '<body><input id="x" disabled="disabled"></body>',
122 |     '<body><input id=x disabled=disabled></body>',
123 |   ),
124 |   'reduce_boolean_attributes': (
125 |     '<body><input id="x" disabled="disabled"></body>',
126 |     '<body><input id=x disabled></body>',
127 |   ),
128 |   'remove_close_tags': (
129 |     '<body><br></br><br pre>   x   </br> </body>',
130 |     '<body><br><br>   x   </body>',
131 |   ),
132 |   'remove_comments': (
133 |     '<body> this text should <!-- X --> have <!----> comments removed</body>',
134 |     '<body> this text should have comments removed</body>',
135 |   ),
136 |   'keep_comments': (
137 |     '<body> this text should <!--! not --> have comments removed</body>',
138 |     '<body> this text should <!-- not --> have comments removed</body>',
139 |   ),
140 |   'keep_empty_comments': (
141 |     '<body> this text should not<!----> have empty comments removed</body>',
142 |     '<body> this text should not<!----> have empty comments removed</body>',
143 |   ),
144 |   'keep_conditional_comments': (
145 |     '<body>keep IE conditional styles <!--[if IE8]><style>h1 {color: red;}</style><![endif]--></body>',
146 |     '<body>keep IE conditional styles <!--[if IE8]><style>h1 {color: red;}</style><![endif]--></body>',
147 |   ),
148 |   'remove_nonconditional_comments': (
149 |     '<body>remove other [if] things <!-- so [if IE8]--><style>h1 {color: red;}</style><!--[endif]--></body>',
150 |     '<body>remove other [if] things <style>h1 {color: red;}</style></body>',
151 |   ),
152 |   'keep_optional_attribute_quotes': (
153 |     '<img width="100" height="50" src="#something" />',
154 |     '<img width="100" height="50" src="#something">',
155 |   ),
156 |   'remove_optional_attribute_quotes': (
157 |     (
158 |       '<td data-text="&lt;script&gt;alert(\'123\');&lt;/script&gt;">',
159 |       '<td data-text="<script>alert(\'123\');</script>">',
160 |     ),
161 |     (
162 |       '<td data-text="&lt;script&gt;alert(123);&lt;/script&gt;">',
163 |       '<td data-text="<script>alert(123);</script>">',
164 |     ),
165 |   ),
166 |   'keep_pre_attribute': (
167 |     '<body>the <strong pre   style="">pre</strong> should stay  </body>',
168 |     '<body>the <strong pre style>pre</strong> should stay </body>',
169 |   ),
170 |   'custom_pre_attribute': (
171 |     '<body>the <strong pre  >   X  </strong><span custom>  Y  </span></body>',
172 |     '<body>the <strong pre> X </strong><span>  Y  </span></body>',
173 |   ),
174 |   'keep_empty': (
175 |     '<body> <div id="x"  >  A </div>  <div id="  y ">  B    </div>  </body>',
176 |     '<body> <div id=x> A </div> <div id="  y "> B </div> </body>',
177 |   ),
178 |   'remove_empty': (
179 |     ('<body>  \n  <div id="x"  >  A </div>\r'
180 |      '<div id="  y ">  B    </div>\r\n  <div> C </div>  <div>D</div> </body>'),
181 |     ('<body><div id=x> A </div>'
182 |      '<div id="  y "> B </div><div> C </div> <div>D</div> </body>'),
183 |   ),
184 |   'remove_all_empty': (
185 |     ('<body>  \n  <div id=x  >  A </div>\r'
186 |      '<div id="  y ">  B    </div>\r\n  <div> C </div>  <div>D</div> </body>'),
187 |     ('<body><div id=x> A </div>'
188 |      '<div id="  y "> B </div><div> C </div><div>D</div></body>'),
189 |   ),
190 |   'dont_minify_div': (
191 |     '<body>  <div>   X  </div>   </body>',
192 |     '<body> <div>   X  </div> </body>',
193 |   ),
194 |   'minify_pre': (
195 |     '<body>  <pre>   X  </pre>   </body>',
196 |     '<body> <pre> X </pre> </body>',
197 |   ),
198 |   'remove_head_spaces': (
199 |     '<head>  <title>   &#x2603;X  Y  &amp;  Z </title>  </head>',
200 |     '<head><title>&#x2603;X Y &amp; Z</title></head>',
201 |   ),
202 |   'dont_minify_scripts_or_styles': (
203 |     '<body>  <script>   X  </script>  <style>   X</style>   </body>',
204 |     '<body> <script>   X  </script> <style>   X</style> </body>',
205 |   ),
206 |   'remove_close_from_tags': (
207 |     ('<body> <area/> <base/> <br /> <col/><command /><embed /><hr/> <img />'
208 |      '   <input   /> <keygen/> <meta  /><param/><source/><track  /><wbr />'
209 |      '  </body>'),
210 |     ('<body> <area> <base> <br> <col><command><embed><hr> <img>'
211 |      ' <input> <keygen> <meta><param><source><track><wbr>'
212 |      ' </body>'),
213 |   ),
214 |   'remove_space_from_self_closed_tags': (
215 |     '<body>    <y />   <x    /></body>',
216 |     '<body> <y/> <x/></body>',
217 |   ),
218 |   'remove_redundant_lang_0': (
219 |     ('<html><body lang=en><p lang=en>This is an example.'
220 |      '<p lang=pl>I po polsku <span lang=el>and more English</span>.'),
221 |     ('<html><body lang=en><p>This is an example.'
222 |      '<p lang=pl>I po polsku <span lang=el>and more English</span>.'),
223 |   ),
224 |   'convert_charrefs': (
225 |     '<input value="&#34;&#39;&#39;&#39;&lt;&#46;&pi;&gt; &#34;">',
226 |      u'<input value="&#34;\'\'\'<.\u03c0> &#34;">',
227 |   ),
228 |   'convert_charrefs_false': (
229 |     '<input value="&#34;&#39;&#39;&#39;&lt;&#46;&pi;&gt; &#34;">',
230 |     '<input value="&#34;&#39;&#39;&#39;&lt;&#46;&pi;&gt; &#34;">',
231 |   ),
232 |   'dont_convert_pre_attr': (
233 |     '<input pre-value="&#34;&#39;&#39;&#39;&lt;&#46;&pi;&gt; &#34;">',
234 |     '<input value=&#34;&#39;&#39;&#39;&lt;&#46;&pi;&gt; &#34;>',
235 |   ),
236 | }
237 | 
238 | SELF_CLOSE_TEXTS = {
239 |   'p_self_close': (
240 |     '<body>  <p pre  >  X  <p>  Y  ',
241 |     '<body> <p>  X  <p> Y ',
242 |   ),
243 |   'li_self_close': (
244 |     '<body> <ul>  <li pre  >  X  <li>  Y  <li pre>  Z</ul>   Q',
245 |     '<body> <ul> <li>  X  <li> Y <li>  Z</ul> Q',
246 |   ),
247 |   'dt_self_close': (
248 |     '<body> <dl>  <dt pre  >  X  <dt>  Y  <dt pre>  Z</dt></dl>   Q',
249 |     '<body> <dl> <dt>  X  <dt> Y <dt>  Z</dt></dl> Q',
250 |   ),
251 |   'dd_self_close': (
252 |     '<body> <dl>  <dd pre  >  X  <dd>  Y  <dd pre>  Z</dl>   Q',
253 |     '<body> <dl> <dd>  X  <dd> Y <dd>  Z</dl> Q',
254 |   ),
255 |   'optgroup_self_close': (
256 |     ('<body>   <select  a >  <optgroup pre>   <option>   X</option>   '
257 |      '<optgroup>   <option>   Y</option> </optgroup> </select>   </body>'),
258 |     ('<body> <select a> <optgroup>   <option>   X</option>   '
259 |      '<optgroup> <option> Y</option> </optgroup> </select> </body>'),
260 |   ),
261 |   'option_self_close': (
262 |     ('<body>   <select  a >  <option pre  >   X    '
263 |      '<option> Y    </option></select>   </body>'),
264 |     ('<body> <select a> <option>   X    '
265 |      '<option> Y </option></select> </body>'),
266 |   ),
267 |   'colgroup_self_close': (
268 |     '<body>  <table>  <colgroup pre>   </table></body>',
269 |     '<body> <table> <colgroup>   </table></body>',
270 |   ),
271 |   'tbody_self_close': (
272 |     ('<body>  <table>   <tbody pre>  <tr>  <td> X  </td></tr>  \n'
273 |      '\n  <tbody>   <tr>   <td>Y   </td></tr>\n\n\n   </body>'),
274 |     ('<body> <table> <tbody>  <tr>  <td> X  </td></tr>  \n'
275 |      '\n  <tbody> <tr> <td>Y </td></tr> </body>'),
276 |   ),
277 |   'thead_self_close': (
278 |     ('<body>  <table>   <thead pre>  <tr>  <td> X  </td></tr>  '
279 |      '  <tbody>   <tr>   <td>Y   </td></tr> </body>'),
280 |     ('<body> <table> <thead>  <tr>  <td> X  </td></tr>  '
281 |      '  <tbody> <tr> <td>Y </td></tr> </body>'),
282 |   ),
283 |   'tfoot_self_close': (
284 |     ('<body>  <table>   <tfoot pre>  <tr>  <td> X  </td></tr>  '
285 |      '  <tbody>   <tr>   <td>Y   </td></tr> </body>'),
286 |     ('<body> <table> <tfoot>  <tr>  <td> X  </td></tr>  '
287 |      '  <tbody> <tr> <td>Y </td></tr> </body>'),
288 |   ),
289 |   'tr_self_close': (
290 |     ('<body>  <table>   <thead>  <tr pre >  <td> X  </td>  '
291 |      '    <tr>   <td>Y   </td> </body>'),
292 |     ('<body> <table> <thead> <tr>  <td> X  </td>  '
293 |      '    <tr> <td>Y </td> </body>'),
294 |   ),
295 |   'td_self_close': (
296 |     '<body>  <table>   <thead>  <tr>  <td  pre> X       <td>Y    </body>',
297 |     '<body> <table> <thead> <tr> <td> X       <td>Y </body>',
298 |   ),
299 |   'th_self_close': (
300 |     '<body>  <table>   <thead>  <tr>  <th pre> X        <th>Y    </body>',
301 |     '<body> <table> <thead> <tr> <th> X        <th>Y </body>',
302 |   ),
303 |   'a_p_interaction': ( # the 'pre' functionality continues after the </a>
304 |     '<body><a>   <p pre>  X  </a>    <p>   Y</body>',
305 |     '<body><a> <p>  X  </a>    <p> Y</body>',
306 |   ),
307 | }
308 | 
309 | SELF_OPENING_TEXTS = {
310 |   'html_closed_no_open': (
311 |     '<head></head><body>  X  </body></html>',
312 |     '<head></head><body> X </body></html>'
313 |   ),
314 |   'head_closed_no_open': (
315 |     '    </head><body>  X  </body>',
316 |     ' </head><body> X </body>' # TODO: we could theoretically kill that leading
317 |                                # space. See HTMLMinParse.handle_endtag
318 |   ),
319 |   'body_closed_no_open': (
320 |     '   X  </body>',
321 |     ' X </body>'
322 |   ),
323 |   'colgroup_self_open': (
324 |     '<body>  <table>  </colgroup>   </table></body>',
325 |     '<body> <table> </colgroup> </table></body>',
326 |   ),
327 |   'tbody_self_open': (
328 |     '<body>  <table>  </tbody>   </table></body>',
329 |     '<body> <table> </tbody> </table></body>',
330 |   ),
331 |   'p_closed_no_open': ( # this isn't valid html, but its worth accounting for
332 |     '<body><div pre>   X  </p>   </div><div>    Y   </p>  </div></body>',
333 |     '<body><div>   X  </p>   </div><div> Y </p> </div></body>',
334 |   ),
335 | }
336 | 
337 | class HTMLMinTestMeta(type):
338 |   def __new__(cls, name, bases, dct):
339 |     def make_test(text):
340 |       def inner_test(self):
341 |         self.assertEqual(self.minify(text[0]), text[1])
342 |       return inner_test
343 | 
344 |     for k, v in dct.get('__reference_texts__',{}).items():
345 |       if 'test_'+k not in dct:
346 |         dct['test_'+k] = make_test(v)
347 |     return type.__new__(cls, str(name), bases, dct)
348 | 
349 | class HTMLMinTestCase(
350 |   HTMLMinTestMeta('HTMLMinTestCase', (unittest.TestCase, ), {})):
351 |   def setUp(self):
352 |     self.minify = htmlmin.minify
353 | 
354 | class TestMinifyFunction(HTMLMinTestCase):
355 |   __reference_texts__ = MINIFY_FUNCTION_TEXTS
356 | 
357 |   def test_basic_minification_quality(self):
358 |     import codecs
359 |     with codecs.open('htmlmin/tests/large_test.html', encoding='utf-8') as inpf:
360 |       inp = inpf.read()
361 |     out = self.minify(inp)
362 |     self.assertEqual(len(inp) - len(out), 9408)
363 | 
364 |   def test_high_minification_quality(self):
365 |     import codecs
366 |     with codecs.open('htmlmin/tests/large_test.html', encoding='utf-8') as inpf:
367 |       inp = inpf.read()
368 |     out = self.minify(inp, remove_all_empty_space=True, remove_comments=True)
369 |     self.assertEqual(len(inp) - len(out), 12518)
370 | 
371 | class TestMinifierObject(HTMLMinTestCase):
372 |   __reference_texts__ = MINIFY_FUNCTION_TEXTS
373 | 
374 |   def setUp(self):
375 |     HTMLMinTestCase.setUp(self)
376 |     self.minifier = htmlmin.Minifier()
377 |     self.minify = self.minifier.minify
378 | 
379 |   def test_reuse(self):
380 |     text = self.__reference_texts__['simple_text']
381 |     self.assertEqual(self.minify(text[0]), text[1])
382 |     self.assertEqual(self.minify(text[0]), text[1])
383 | 
384 |   def test_dangling_tag(self):
385 |     dangling_tag = self.__reference_texts__['dangling_tag']
386 |     dangling_tag_followup = self.__reference_texts__['dangling_tag_followup']
387 |     self.assertEqual(self.minify(dangling_tag[0]), dangling_tag[1])
388 |     self.assertEqual(self.minify(dangling_tag_followup[0]), dangling_tag_followup[1])
389 | 
390 |   def test_buffered_input(self):
391 |     text = self.__reference_texts__['long_text']
392 |     self.minifier.input(text[0][:len(text[0]) // 2])
393 |     self.minifier.input(text[0][len(text[0]) // 2:])
394 |     self.assertEqual(self.minifier.finalize(), text[1])
395 | 
396 |   
397 | class TestMinifyFeatures(HTMLMinTestCase):
398 |   __reference_texts__ = FEATURES_TEXTS
399 | 
400 |   def test_remove_comments(self):
401 |     text = self.__reference_texts__['remove_comments']
402 |     self.assertEqual(htmlmin.minify(text[0], remove_comments=True), text[1])
403 | 
404 |   def test_no_reduce_empty_attributes(self):
405 |     text = self.__reference_texts__['no_reduce_empty_attributes']
406 |     self.assertEqual(htmlmin.minify(text[0], reduce_empty_attributes=False), text[1])
407 | 
408 |   def test_no_reduce_empty_attributes_keep_quotes(self):
409 |     text = self.__reference_texts__['no_reduce_empty_attributes_keep_quotes']
410 |     self.assertEqual(htmlmin.minify(text[0], reduce_empty_attributes=False, remove_optional_attribute_quotes=False), text[1])
411 | 
412 |   def test_reduce_empty_attributes(self):
413 |     text = self.__reference_texts__['reduce_empty_attributes']
414 |     self.assertEqual(htmlmin.minify(text[0], reduce_empty_attributes=True), text[1])
415 | 
416 |   def test_reduce_boolean_attributes(self):
417 |     text = self.__reference_texts__['reduce_boolean_attributes']
418 |     self.assertEqual(htmlmin.minify(text[0], reduce_boolean_attributes=True), text[1])
419 | 
420 |   def test_keep_comments(self):
421 |     text = self.__reference_texts__['keep_comments']
422 |     self.assertEqual(htmlmin.minify(text[0], remove_comments=True), text[1])
423 | 
424 |   def test_keep_empty_comments(self):
425 |     text = self.__reference_texts__['keep_empty_comments']
426 |     self.assertEqual(htmlmin.minify(text[0]), text[1])
427 | 
428 |   def test_keep_conditional_comments(self):
429 |     text = self.__reference_texts__['keep_conditional_comments']
430 |     self.assertEqual(htmlmin.minify(text[0], remove_comments=True), text[1])
431 | 
432 |   def test_remove_nonconditional_comments(self):
433 |     text = self.__reference_texts__['remove_nonconditional_comments']
434 |     self.assertEqual(htmlmin.minify(text[0], remove_comments=True), text[1])
435 | 
436 |   def test_keep_optional_attribute_quotes(self):
437 |     text = self.__reference_texts__['keep_optional_attribute_quotes']
438 |     self.assertEqual(htmlmin.minify(text[0], remove_optional_attribute_quotes=False), text[1])
439 | 
440 |   def test_remove_optional_attribute_quotes(self):
441 |     texts = self.__reference_texts__['remove_optional_attribute_quotes']
442 |     for text in texts:
443 |       self.assertEqual(htmlmin.minify(text[0], remove_optional_attribute_quotes=True), text[1])
444 | 
445 |   def test_keep_pre_attribute(self):
446 |     text = self.__reference_texts__['keep_pre_attribute']
447 |     self.assertEqual(htmlmin.minify(text[0], keep_pre=True), text[1])
448 | 
449 |   def test_custom_pre_attribute(self):
450 |     text = self.__reference_texts__['custom_pre_attribute']
451 |     self.assertEqual(htmlmin.minify(text[0], pre_attr='custom'), text[1])
452 | 
453 |   def test_keep_empty(self):
454 |     text = self.__reference_texts__['keep_empty']
455 |     self.assertEqual(htmlmin.minify(text[0]), text[1])
456 | 
457 |   def test_remove_empty(self):
458 |     text = self.__reference_texts__['remove_empty']
459 |     self.assertEqual(htmlmin.minify(text[0], remove_empty_space=True), text[1])
460 | 
461 |   def test_remove_all_empty(self):
462 |     text = self.__reference_texts__['remove_all_empty']
463 |     self.assertEqual(htmlmin.minify(text[0], remove_all_empty_space=True),
464 |                      text[1])
465 | 
466 |   def test_dont_minify_div(self):
467 |     text = self.__reference_texts__['dont_minify_div']
468 |     self.assertEqual(htmlmin.minify(text[0], pre_tags=('div',)), text[1])
469 | 
470 |   def test_minify_pre(self):
471 |     text = self.__reference_texts__['minify_pre']
472 |     self.assertEqual(htmlmin.minify(text[0], pre_tags=('div',)), text[1])
473 | 
474 |   def test_remove_head_spaces(self):
475 |     text = self.__reference_texts__['remove_head_spaces']
476 |     self.assertEqual(htmlmin.minify(text[0]), text[1])
477 | 
478 |   def test_dont_minify_scripts_or_styles(self):
479 |     text = self.__reference_texts__['dont_minify_scripts_or_styles']
480 |     self.assertEqual(htmlmin.minify(text[0], pre_tags=[]), text[1])
481 | 
482 |   def test_convert_charrefs_false(self):
483 |     text = self.__reference_texts__['convert_charrefs_false']
484 |     self.assertEqual(htmlmin.minify(text[0], convert_charrefs=False), text[1])
485 | 
486 | 
487 | class TestSelfClosingTags(HTMLMinTestCase):
488 |   __reference_texts__ = SELF_CLOSE_TEXTS
489 | 
490 | class TestSelfOpeningTags(HTMLMinTestCase):
491 |   __reference_texts__ = SELF_OPENING_TEXTS
492 | 
493 | class TestDecorator(HTMLMinTestCase):
494 |   def test_direct_decorator(self):
495 |     @htmlmindecorator
496 |     def directly_decorated():
497 |       return '   X   Y   '
498 | 
499 |     self.assertEqual(' X Y ', directly_decorated())
500 | 
501 |   def test_options_decorator(self):
502 |     @htmlmindecorator(remove_comments=True)
503 |     def directly_decorated():
504 |       return '   X <!-- Removed -->  Y   '
505 | 
506 |     self.assertEqual(' X Y ', directly_decorated())
507 | 
508 | class TestMiddleware(HTMLMinTestCase):
509 |   def setUp(self):
510 |     HTMLMinTestCase.setUp(self)
511 |     def wsgi_app(environ, start_response):
512 |       start_response(environ['status'], environ['headers'])
513 |       yield environ['content']
514 | 
515 |     self.wsgi_app = wsgi_app
516 | 
517 |   def call_app(self, app, status, headers, content):
518 |     response_status = []  # these need to be mutable so that they can be changed
519 |     response_headers = [] # within our inner function.
520 |     def start_response(status, headers, exc_info=None):
521 |       response_status.append(status)
522 |       response_headers.append(headers)
523 |     response_body = ''.join(app({'status': status,
524 |                                  'content': content,
525 |                                  'headers': headers},
526 |                                 start_response))
527 |     return response_status[0], response_headers[0], response_body
528 | 
529 |   def test_middlware(self):
530 |     app = HTMLMinMiddleware(self.wsgi_app)
531 |     status, headers, body = self.call_app(
532 |       app, '200 OK', (('Content-Type', 'text/html'),),
533 |       '    X    Y   ')
534 |     self.assertEqual(body, ' X Y ')
535 | 
536 |   def test_middlware_minifier_options(self):
537 |     app = HTMLMinMiddleware(self.wsgi_app, remove_comments=True)
538 |     status, headers, body = self.call_app(
539 |       app, '200 OK', (('Content-Type', 'text/html'),),
540 |       '    X    Y   <!-- Z -->')
541 |     self.assertEqual(body, ' X Y ')
542 | 
543 |   def test_middlware_off_by_default(self):
544 |     app = HTMLMinMiddleware(self.wsgi_app, by_default=False)
545 |     status, headers, body = self.call_app(
546 |       app, '200 OK', (('Content-Type', 'text/html'),),
547 |       '    X    Y   ')
548 |     self.assertEqual(body, '    X    Y   ')
549 | 
550 |   def test_middlware_on_by_header(self):
551 |     app = HTMLMinMiddleware(self.wsgi_app, by_default=False)
552 |     status, headers, body = self.call_app(
553 |       app, '200 OK', (
554 |         ('Content-Type', 'text/html'),
555 |         ('X-HTML-Min-Enable', 'True'),
556 |         ),
557 |       '    X    Y   ')
558 |     self.assertEqual(body, ' X Y ')
559 | 
560 |   def test_middlware_off_by_header(self):
561 |     app = HTMLMinMiddleware(self.wsgi_app)
562 |     status, headers, body = self.call_app(
563 |       app, '200 OK', (
564 |         ('Content-Type', 'text/html'),
565 |         ('X-HTML-Min-Enable', 'False'),
566 |         ),
567 |       '    X    Y   ')
568 |     self.assertEqual(body, '    X    Y   ')
569 | 
570 |   def test_middlware_remove_header(self):
571 |     app = HTMLMinMiddleware(self.wsgi_app)
572 |     status, headers, body = self.call_app(
573 |       app, '200 OK', (
574 |         ('Content-Type', 'text/html'),
575 |         ('X-HTML-Min-Enable', 'False'),
576 |         ),
577 |       '    X    Y   ')
578 |     self.assertFalse(any((h == 'X-HTML-Min-Enable' for h, v in headers)))
579 | 
580 |   def test_middlware_keep_header(self):
581 |     app = HTMLMinMiddleware(self.wsgi_app, keep_header=True)
582 |     status, headers, body = self.call_app(
583 |       app, '200 OK', [
584 |         ('Content-Type', 'text/html'),
585 |         ('X-HTML-Min-Enable', 'False'),
586 |         ],
587 |       '    X    Y   ')
588 |     self.assertTrue(any((h == 'X-HTML-Min-Enable' for h, v in headers)))
589 | 
590 | def suite():
591 |     minify_function_suite = unittest.TestLoader().\
592 |         loadTestsFromTestCase(TestMinifyFunction)
593 |     minifier_object_suite = unittest.TestLoader().\
594 |         loadTestsFromTestCase(TestMinifierObject)
595 |     minify_features_suite = unittest.TestLoader().\
596 |         loadTestsFromTestCase(TestMinifyFeatures)
597 |     self_closing_tags_suite = unittest.TestLoader().\
598 |         loadTestsFromTestCase(TestSelfClosingTags)
599 |     self_opening_tags_suite = unittest.TestLoader().\
600 |         loadTestsFromTestCase(TestSelfOpeningTags)
601 |     decorator_suite = unittest.TestLoader().\
602 |         loadTestsFromTestCase(TestDecorator)
603 |     middleware_suite = unittest.TestLoader().\
604 |         loadTestsFromTestCase(TestMiddleware)
605 |     return unittest.TestSuite([
606 |         minify_function_suite,
607 |         minifier_object_suite,
608 |         minify_features_suite,
609 |         self_closing_tags_suite,
610 |         self_opening_tags_suite,
611 |         decorator_suite,
612 |         middleware_suite,
613 |         test_escape.suite(),
614 |         ])
615 | 
616 | if __name__ == '__main__':
617 |   unittest.main()
618 | 


--------------------------------------------------------------------------------