* 7.0.2 Apr 28 2017

- Fix two typos which would result in exceptions
- Add "href" as a standard property name for anchors (so em.href = 'abc' sets
the href attribute)

* 7.0.0 Apr 6 2017
- Add "filter"-style functions (think ORM-style filtering, like
name__contains='abc' or name='abc' or name__ne='something'). Supports all filter operations provided by QueryableList
  * These have been added to AdvancedHTMLParser.AdvancedHTMLParser (as
  filter/filterAnd and filterOr) to work on all nodes in the parser
  * These have been added to AdvancedTag (as filter/filterAnd and filterOr)
  which work on the tag itself and all children (and their children, and so
  on)
  * These have been added to TagCollection (as filter/filterAnd and filterOr)
  that work directly on the elements contained only
  * Also, TagCollection has filterAll/filterAllAnd and filterAllOr that work
  directly on the containing elements, and all children of those elements (and
  their children)

 This adds QueryableList as a dependency, but setup.py can be passed "--no-deps" to skip that installation (and the filter methods will be unavailable)

- Add "find" function on AdvancedHTMLParser, which supports a very very small subset of QueryableList (only equals, contains, and icontains) and can be used for "similar" functionality but without the QueryableList dependency, and only usable from the document level (AdvancedHTMLParser.AdvancedHTMLParser)

- Support javascript-style assignment and access on a handful of tags (The older ones, name, id, align, etc).
  You can now do things like:   myTag.name = 'hello'    to set the name, and    myTag.name   to access it 
  (previously you had to use setAttribute and getAttribute for everything)
  The names used here match what are used in HTML, and include the javascript events


- Fix where "className" could get out of sync with "classList"/"classNames"
- No longer treat "classname" and "class" as the same attribute, they are in fact distinct on the attribute dict, but
  className maps to class on object-access

- Support binary-style attribute set/access, (like for "hidden" property, or "checked")
- Support attributes conditional on tag name, like "checked" on an input

- Change so accessing an attribute on an AdvancedTag which is not set returns None (undefined/null), instead of raising an AttributeError

- Implement "cloneNode" function from JS DOM
- Fix TagCollection __add__ and __sub__ were working on the inline element. Moved these to __iadd__ and __isub__ (for += and -=)
  and implemented add and subtract to work on copies
- Add "isEqualNode" JS DOM method as equivilant to the '==' operator on AdvancedTag
- Add "contains" JS DOM method to both AdvancedTag, TagCollection, and AdvancedHTMLParser
- Implemented "in" operator on Parser to check if an element ( or uuid if passed) is contained

- Implements "hasChild" method to see if an element is a direct child of another element
- Implement "remove" method on an AdvancedTag, to remove it from the parent.

- Some other minor DOM methods, (childElementCount)
- Rename on AdvancedTag "attributes" to "_attributes" in preparation of implementing DOM-style named node map

- Add ownerDocument to Tags which point to the document (parser), if associated with one

- Added some functions for accessing the whole of uids

- Proper quote-escaping within attribute values. \" isn't understood across the board, but &quot; is, so switch from former to latter.

- Add DOM-style "attributes" to every AdvancedTag. This follows the horrible antiquated interface that DOM
  uses for "attributes", created before getAttribute/setAttribute were standardized.
  This is always available as .attributesDOM , and the dict impl always available as .attributesDict

  By default, we will retain the "dict" impl, as the NamedNodeMap impl is deprecated.
  There's a new function, toggleAttributesDOM which will change the global .attributes property to be the DOM (official) or Dict (sane and prior) impl.

- Some minor cleanups, doc updates, test updates, etc


* 6.8.0 
- Add "getAllChildNodes" to tags, which return all the children (and all their
children, on and so forth) of the given tag

- Add "getAllNodes" to AdvancedHTMLParser.AdvancedHTMLParser - which gets the
root nodes, all children of them, and all children all the way to the end

- Add "getAllNodes" to TagCollection, which returns those nodes contained
within, and all of their children (on and so forth)

- Add "find" method to AdvancedHTMLParser.AdvancedHTMLParser, which supports filtering by attr=value style, supporting
either single values or list of values (for ANY aka or), and some specials
( __contains and __icontains suffixes on keys for "value contains" or
"case-insensitive value contains") This method is only available in one place.
7.0.0 will have a full filter implementation on the parser, tags, and tag
collections, but will require QueryableList to be installed. This will be
optional, and this method will remain as an incomplete version.


* 6.7.0 Mar 14 2017
- Fix camel-case vs dash names when using style attributes (like so em.style.paddingTop translates to 'padding-top')
-  Implement __repr__ on AdvancedTag

-  Fix __repr__ on StyleAttribute to include the class name
-  Make style attributes compare (__eq__ and __ne__) regardless of order
-  Allow StyleAttribute objects to be created from other StyleAttribute objects

-  Implement __eq__ and __ne__ on AdvancedTag, these do identity
comparison (same tag equals itself ONLY).

- Implement __copy__ and __deepcopy__ methods on StyleAttribute and
AdvancedTag so that tags can be copied.

- Add getAttributesList and getAttributesDict on an AdvancedTag to make a copy of a list
of values (like for attrList on AdvancedTag constructor) or a copy of a
dict of values.

-  Implement an isTagEqual method on AdvancedTag which compares the tag
name and attributes to another tag (for testing between < and > are the
same), non-identity comparison.

- Add tests for all changes


* 6.6.4 Oct 27 2016
- Fix regression where "AdvancedTag.getAttribute" method would not accept a default
(second param).
- Fix calling ".value" on an AdvancedTag to get the "value" attribute (was
broken by previous regression)


* 6.6.3 Oct 03 2016
- Fix no-value attributes not appearing in html output (like "checked" on an input). Was in attributes, but not in html output.

* 6.6.2 Jul 27 2016
- Python's HTMLParser on python3 only automatically converts charrefs
(backwards incompatible...) -- so make it stop doing that. This allows things
like &nbsp; and &lt; to not be converted to ' ' and '<' on python3. Added
tests as well.
- Cleanup imports and add comments to test cases.
- Add fixes made to AdvancedHTMLParser in 6.6.0, relating to text outside root
nodes into AdvancedHTMLFormatter.

* 6.6.0 Jul 25 2016
- In a multiple root node scenario, make sure getHTML returns text that falls
between the root nodes.
- Retain text, comments, etc that occur before and after the root node
- Update runTests.py to be latest from GoodTests -- allows providing arguments
to GoodTests.py (by passing them to runTests.py) and removes the need for the
symlink in the "tests" directory (which duplicates source in the dist)

* 6.5.1 Mar 23 2016
- Merge in patch by "Tai Kedzierski" which fixes a typo in getElementsByAttr. Thanks!
- Fix missing files in MANIFEST.in

* 6.5.0 Dec 24 2015
- Add "Validator" class and associated exceptions/tests/docs. Raises
exceptions when the standard parser would have to make an assumption during
parsing.
- Fix some tests in python 3.4.3

* 6.4.2 Oct 19 2015
- Cleanup setup file

* 6.4.1 Oct 15 2015
- Fix typo in formatter in MultipleRootNode case
- Fix encoding issue in parsing files (non-utf-8/ascii)
- Support providing an encoding to "formatHTML"
- When parsing, drop stray end-tags instead of crashing
- Strip internet explorer conditionals from the document, and optionally add a
blank <html> since that's where they usually are.
- Take into account doctype when inserting top-node on multiple-root-node case

* 6.3.0 Sep 03 2015
- Clarify that a set is better to use for getElementsWithAttrValues as the "attrValues" portion. If used within "Parser" -- make this conversion for them,
  as this is the most common case, and the only one-time-test case. Maybe worth splitting public and private methods to handle such microoptimizations in
  the future
- Support filtering on a custom function. Added "getElementsCustomFilter" to Parser, TagCollection, and AdvancedTag. With Tests.
- Support filtering the direct members of a TagCollection, using filterCollection method. Does not transverse to children. 
- Add AdvancedTag and TagCollection to __init__ (for "from AdvancedHTMLParser import *") 
- Add an integer version tuple, __int_version_tuple__ for easier comparison
- A couple micro optimizations
- Manually cleanup doc a bit

* 6.2.5 Aug 17 2015
- Fix style and class attributes not showing up in outerHTML
- Allow formatHTML script to read from stdin
- Cleanup setup.py to read description from file
- Fix MANIFEST.in

* 6.2.2 Aug 17 2015
- Enable tests that weren't running
- Unify calling .get('key') or ['key'] for tag attributes
- Fix using 'className' with get/set attribute

* 6.2.1 Aug 10 2015
- Add a lot more tests and  provide exception messages to assert keywords
(supported in GoodTests)
- Better error message when trying to set various attributes directly
- Add "setAttributes"  method that takes a dict and allows setting many
attributes at once
- Added nextSibling, nextSiblingElement, previousSibling, previousSiblingElement
- Added insertBefore and insertAfter (latter not present in HTML)

* 6.1.0 Aug 5 2015
- Fix issue where root node  would not get matched in some conditions
- Implement some real tests using GoodTests
- Much better handling of special attributes through a dedicated extension of
dict
- Ability to use "style" in the same way javascript allows, like
element.style.position = 'absolute'
- Various cleanups

* 6.1.0 prerelease July 27 2015
- More intuitive usage  with multiple root-level nodes (like parsing an AJAX
request). Add `getRootNodes` function to return a list of root nodes, and
abstracted a little magic of the previous handling of multiple root nodes.
They always worked before, but easier to work WITH now.
- Add "removeAttribute" function to remove an attribute
- Implement "setStyle" "setStyles" and "getStyle" - for working with the
"style" string. I will probably turn this into a real object extending str
before the release, but I'm tired now and going to bed.

* 6.0.1 June 27 2015
- Add more docstrings and add pydoc documentation

* 6.0.0 June 23 2015
- Split Indexing out into new IndexedAdvancedHTMLParser class to greatly
simplify the base class.
- Get rid of the onlyIndex* on the default constructor of
IndexedAdvancedHTMLParser, make all fields indexed by default, and add
useIndex to every get* method which can be set to False to ignore the index
- Add an indexed_example
- Modify example to include addition of element
- Split source into several files
- Simplify a few sections
- Ensure formatHTML ends with a newline

* 5.0.1 June 10 2015
 - Add AdvancedHTMLFormatter class and formatHTML Script
 - Add getFormattedHTML to AdvancedHTMLParser
 - Fix (invalid for html, but okay for subsections) multiple root node support
 - Auto-set isSelfClosing on an AdvancedTag when they are created ad-hoc.

* 4.0.1 June 9 2015
 - Also add input, img, hr, br to self-closing tags and make a set

* 4.0.0 June 9 2015
 - Fix handling of entities, character refs and comments
 - Add support for including doctype
 - Fix issues with getHTML
 - Implicitly close "meta" and "link" tags if they are not self-closed.
 - Better-support self-closing tags overall
 - Handle people who do not close child tags before closing parent
 - Unicode support
