loofah 2.10.0 → 2.21.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c72ce5ed9c2a65db0a32b4bcdc141b9bf30caded7ee60d180c7872691246cafd
-  data.tar.gz: 953c1316bd83c03ded6eae4ca754a0b3d9dd1cc1f1f22a6e4c4fc2762de6aed7
+  metadata.gz: '00569b28a0bc6307a0a8eb8704ad374f10269008dada5d09470c1a2a87da0a6f'
+  data.tar.gz: eff12a44f1152dc377ac0a6859be97f85b5a0a031a0b7688387c73f7130351d3
 SHA512:
-  metadata.gz: e0c876928b0ec84a84e38e66f5318a1d0539996d75ef96c07b7cceb953565e2d1f9409b1bbae7e10b94e5dc1e98959cd9d67397c1a83c4f622a9f3d5b5d61f09
-  data.tar.gz: 507b03b508b1725f8c2a67397e4b3b9e7c337e92b519c93cd8687bf371df844dfe3f15fdb3efd5e4f9bfd70b19842b7eec48cf27d888c1552a084f33fab37db0
+  metadata.gz: fbcf412c0105203fe3d9ee057dc146cc7f8e9f29587c0f97b9c03a5206eacd31f7170042c74050d40093875b8109f524434a0960ef9305269fdda536e3049e3b
+  data.tar.gz: 48c3f2c0f4a0b2316c46ad1826c61ded9c3438ace28c477d7b67cc345847a00bb5747bab5b22cf5d774e82c90bedd085a9878c40609f93abda49f6aa01257f7c

data/CHANGELOG.md

@@ -1,5 +1,144 @@
 # Changelog
 
+## 2.21.3 / 2023-05-15
+
+* Quash "instance variable not initialized" warning in Ruby < 3.0. [[#268](https://github.com/flavorjones/loofah/issues/268)] (Thanks, [@dharamgollapudi](https://github.com/dharamgollapudi)!)
+
+
+## 2.21.2 / 2023-05-11
+
+### Dependencies
+
+* Update the dependency on Nokogiri to be `>= 1.12.0`. The dependency in 2.21.0 and 2.21.1 was left at `>= 1.5.9` but versions before 1.12 would result in a `NameError` exception. [[#266](https://github.com/flavorjones/loofah/issues/266)]
+
+
+## 2.21.1 / 2023-05-10
+
+### Fixed
+
+* Don't define `HTML5::Document` and `HTML5::DocumentFragment` when Nokogiri is `< 1.14`. In 2.21.0 these classes were defined whenever `Nokogiri::HTML5` was defined, but Nokogiri v1.12 and v1.13 do not support Loofah subclassing properly.
+
+
+## 2.21.0 / 2023-05-10
+
+### HTML5 Support
+
+Classes `Loofah::HTML5::Document` and `Loofah::HTML5::DocumentFragment` are introduced, along with helper methods:
+
+- `Loofah.html5_document`
+- `Loofah.html5_fragment`
+- `Loofah.scrub_html5_document`
+- `Loofah.scrub_html5_fragment`
+
+These classes and methods use Nokogiri's HTML5 parser to ensure modern web standards are used.
+
+⚠ HTML5 functionality is only available with Nokogiri v1.14.0 and higher.
+
+⚠ HTML5 functionality is not available for JRuby. Please see [this upstream Nokogiri issue](https://github.com/sparklemotion/nokogiri/issues/2227) if you're interested in helping implement and support HTML5 support.
+
+
+### `Loofah::HTML4` module and namespace
+
+`Loofah::HTML` has been renamed to `Loofah::HTML4`, and `Loofah::HTML` is aliased to preserve backwards-compatibility. `Nokogiri::HTML` and `Nokogiri::HTML4` parse methods still use libxml2's (or NekoHTML's) HTML4 parser.
+
+Take special note that if you rely on the class name of an object in your code, objects will now report a class of `Loofah::HTML4::Foo` where they previously reported `Loofah::HTML::Foo`. Instead of relying on the string returned by `Object#class`, prefer `Class#===` or `Object#is_a?` or `Object#instance_of?`.
+
+Future releases of Nokogiri may deprecate `HTML` classes and methods or otherwise change this behavior, so please start using `HTML4` in place of `HTML`.
+
+
+### Official support for JRuby
+
+This version introduces official support for JRuby. Previously, the test suite had never been green due to differences in behavior in the underlying HTML parser used by Nokogiri. We've updated the test suite to accommodate those differences, and have added JRuby to the CI suite.
+
+
+## 2.20.0 / 2023-04-01
+
+### Features
+
+* Allow SVG attributes `color-profile`, `cursor`, `filter`, `marker`, and `mask`. [[#246](https://github.com/flavorjones/loofah/issues/246)]
+* Allow SVG elements `altGlyph`, `cursor`, `feImage`, `pattern`, and `tref`. [[#246](https://github.com/flavorjones/loofah/issues/246)]
+* Allow protocols `fax` and `modem`. [[#255](https://github.com/flavorjones/loofah/issues/255)] (Thanks, [@cjba7](https://github.com/cjba7)!)
+
+
+## 2.19.1 / 2022-12-13
+
+### Security
+
+* Address CVE-2022-23514, inefficient regular expression complexity. See [GHSA-486f-hjj9-9vhh](https://github.com/flavorjones/loofah/security/advisories/GHSA-486f-hjj9-9vhh) for more information.
+* Address CVE-2022-23515, improper neutralization of data URIs. See [GHSA-228g-948r-83gx](https://github.com/flavorjones/loofah/security/advisories/GHSA-228g-948r-83gx) for more information.
+* Address CVE-2022-23516, uncontrolled recursion. See [GHSA-3x8r-x6xp-q4vm](https://github.com/flavorjones/loofah/security/advisories/GHSA-3x8r-x6xp-q4vm) for more information.
+
+
+## 2.19.0 / 2022-09-14
+
+### Features
+
+* Allow SVG 1.0 color keyword names in CSS attributes. These colors are part of the [CSS Color Module Level 3](https://www.w3.org/TR/css-color-3/#svg-color) recommendation released 2022-01-18. [[#243](https://github.com/flavorjones/loofah/issues/243)]
+
+
+## 2.18.0 / 2022-05-11
+
+### Features
+
+* Allow CSS property `aspect-ratio`. [[#236](https://github.com/flavorjones/loofah/issues/236)] (Thanks, [@louim](https://github.com/louim)!)
+
+
+## 2.17.0 / 2022-04-28
+
+### Features
+
+* Allow ARIA attributes. [[#232](https://github.com/flavorjones/loofah/issues/232), [#233](https://github.com/flavorjones/loofah/issues/233)] (Thanks, [@nick-desteffen](https://github.com/nick-desteffen)!)
+
+
+## 2.16.0 / 2022-04-01
+
+### Features
+
+* Allow MathML elements `menclose` and `ms`, and MathML attributes `dir`, `href`, `lquote`, `mathsize`, `notation`, and `rquote`. [[#231](https://github.com/flavorjones/loofah/issues/231)] (Thanks, [@nick-desteffen](https://github.com/nick-desteffen)!)
+
+
+## 2.15.0 / 2022-03-14
+
+### Features
+
+* Expand set of allowed protocols to include `sms:`. [[#228](https://github.com/flavorjones/loofah/issues/228)] (Thanks, [@brendon](https://github.com/brendon)!)
+
+
+## 2.14.0 / 2022-02-11
+
+### Features
+
+* The `#to_text` method on `Loofah::HTML::{Document,DocumentFragment}` replaces `<br>` line break elements with a newline. [[#225](https://github.com/flavorjones/loofah/issues/225)]
+
+
+## 2.13.0 / 2021-12-10
+
+### Bug fixes
+
+* Loofah::HTML::DocumentFragment#text no longer serializes top-level comment children. [[#221](https://github.com/flavorjones/loofah/issues/221)]
+
+
+## 2.12.0 / 2021-08-11
+
+### Features
+
+* Support empty HTML5 data attributes. [[#215](https://github.com/flavorjones/loofah/issues/215)]
+
+
+## 2.11.0 / 2021-07-31
+
+### Features
+
+* Allow HTML5 element `wbr`.
+* Allow all CSS property values for `border-collapse`. [[#201](https://github.com/flavorjones/loofah/issues/201)]
+
+
+### Changes
+
+* Deprecating `Loofah::HTML5::SafeList::VOID_ELEMENTS` which is not a canonical list of void HTML4 or HTML5 elements.
+* Removed some elements from `Loofah::HTML5::SafeList::VOID_ELEMENTS` that either are not acceptable elements or aren't considered "void" by libxml2.
+
+
 ## 2.10.0 / 2021-06-06
 
 ### Features

data/README.md

@@ -6,8 +6,7 @@
 
 ## Status
 
-[![Concourse CI](https://ci.nokogiri.org/api/v1/teams/nokogiri-core/pipelines/loofah/jobs/ruby-3.0/badge)](https://ci.nokogiri.org/teams/nokogiri-core/pipelines/loofah)
-[![Code Climate](https://codeclimate.com/github/flavorjones/loofah.svg)](https://codeclimate.com/github/flavorjones/loofah)
+[![ci](https://github.com/flavorjones/loofah/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/flavorjones/loofah/actions/workflows/ci.yml)
 [![Tidelift dependencies](https://tidelift.com/badges/package/rubygems/loofah)](https://tidelift.com/subscription/pkg/rubygems-loofah?utm_source=rubygems-loofah&utm_medium=referral&utm_campaign=readme)
 
 
@@ -15,59 +14,61 @@
 
 Loofah is a general library for manipulating and transforming HTML/XML documents and fragments, built on top of Nokogiri.
 
-Loofah excels at HTML sanitization (XSS prevention). It includes some nice HTML sanitizers, which are based on HTML5lib's safelist, so it most likely won't make your codes less secure. (These statements have not been evaluated by Netexperts.)
+Loofah also includes some HTML sanitizers based on `html5lib`'s safelist, which are a specific application of the general transformation functionality.
 
-ActiveRecord extensions for sanitization are available in the [`loofah-activerecord` gem](https://github.com/flavorjones/loofah-activerecord).
+Active Record extensions for HTML sanitization are available in the [`loofah-activerecord` gem](https://github.com/flavorjones/loofah-activerecord).
 
 
 ## Features
 
-* Easily write custom scrubbers for HTML/XML leveraging the sweetness of Nokogiri (and HTML5lib's safelists).
-* Common HTML sanitizing tasks are built-in:
+* Easily write custom transformations for HTML and XML
+* Common HTML sanitizing transformations are built-in:
   * _Strip_ unsafe tags, leaving behind only the inner text.
   * _Prune_ unsafe tags and their subtrees, removing all traces that they ever existed.
   * _Escape_ unsafe tags and their subtrees, leaving behind lots of <tt>&lt;</tt> and <tt>&gt;</tt> entities.
   * _Whitewash_ the markup, removing all attributes and namespaced nodes.
-* Common HTML transformation tasks are built-in:
+* Other common HTML transformations are built-in:
   * Add the _nofollow_ attribute to all hyperlinks.
-* Format markup as plain text, with or without sensible whitespace handling around block elements.
+  * Remove _unprintable_ characters from text nodes.
+* Format markup as plain text, with (or without) sensible whitespace handling around block elements.
 * Replace Rails's `strip_tags` and `sanitize` view helper methods.
 
 
 ## Compare and Contrast
 
-Loofah is one of two known Ruby XSS/sanitization solutions that
-guarantees well-formed and valid markup (the other is Sanitize, which
-also uses Nokogiri).
+Loofah is both:
 
-Loofah works on XML, XHTML and HTML documents.
+- a general framework for transforming XML, XHTML, and HTML documents
+- a specific toolkit for HTML sanitization
 
-Also, it's pretty fast. Here is a benchmark comparing Loofah to other
-commonly-used libraries (ActionView, Sanitize, HTML5lib and HTMLfilter):
+### General document transformation
 
-* https://gist.github.com/170193
+Loofah tries to make it easy to write your own custom scrubbers for whatever document transformation you need. You don't like the built-in scrubbers? Build your own, like a boss.
 
-Lastly, Loofah is extensible. It's super-easy to write your own custom
-scrubbers for whatever document manipulation you need. You don't like
-the built-in scrubbers? Build your own, like a boss.
+
+### HTML sanitization
+
+Another Ruby library that provides HTML sanitization is [`rgrove/sanitize`](https://github.com/rgrove/sanitize), another library built on top of Nokogiri, which provides a bit more flexibility on the tags and attributes being scrubbed.
+
+You may also want to look at [`rails/rails-html-sanitizer`](https://github.com/rails/rails-html-sanitizer) which is built on top of Loofah and provides some useful extensions and additional flexibility in the HTML sanitization.
 
 
 ## The Basics
 
-Loofah wraps [Nokogiri](http://nokogiri.org) in a loving
-embrace. Nokogiri is an excellent HTML/XML parser. If you don't know
-how Nokogiri works, you might want to pause for a moment and go check
-it out. I'll wait.
+Loofah wraps [Nokogiri](http://nokogiri.org) in a loving embrace. Nokogiri is a stable, well-maintained parser for XML, HTML4, and HTML5.
 
-Loofah presents the following classes:
+Loofah implements the following classes:
 
-* `Loofah::HTML::Document` and `Loofah::HTML::DocumentFragment`
-* `Loofah::XML::Document` and `Loofah::XML::DocumentFragment`
-* `Loofah::Scrubber`
+* `Loofah::HTML5::Document`
+* `Loofah::HTML5::DocumentFragment`
+* `Loofah::HTML4::Document` (aliased as `Loofah::HTML::Document` for now)
+* `Loofah::HTML4::DocumentFragment` (aliased as `Loofah::HTML::DocumentFragment` for now)
+* `Loofah::XML::Document`
+* `Loofah::XML::DocumentFragment`
 
-The documents and fragments are subclasses of the similar Nokogiri classes.
+These document and fragment classes are subclasses of the similarly-named Nokogiri classes `Nokogiri::HTML5::Document` et al.
 
-The Scrubber represents the document manipulation, either by wrapping
+Loofah also implements `Loofah::Scrubber`, which represents the document transformation, either by wrapping
 a block,
 
 ``` ruby
@@ -81,50 +82,49 @@ or by implementing a method.
 
 ### Side Note: Fragments vs Documents
 
-Generally speaking, unless you expect to have a DOCTYPE and a single
-root node, you don't have a *document*, you have a *fragment*. For
-HTML, another rule of thumb is that *documents* have `html` and `body`
-tags, and *fragments* usually do not.
+Generally speaking, unless you expect to have a DOCTYPE and a single root node, you don't have a *document*, you have a *fragment*. For HTML, another rule of thumb is that *documents* have `html` and `body` tags, and *fragments* usually do not.
+
+**HTML fragments** should be parsed with `Loofah.html5_fragment` or `Loofah.html4_fragment`. The result won't be wrapped in `html` or `body` tags, won't have a DOCTYPE declaration, `head` elements will be silently ignored, and multiple root nodes are allowed.
+
+**HTML documents** should be parsed with `Loofah.html5_document` or `Loofah.html4_document`. The result will have a DOCTYPE declaration, along with `html`, `head` and `body` tags.
+
+**XML fragments** should be parsed with `Loofah.xml_fragment`. The result won't have a DOCTYPE declaration, and multiple root nodes are allowed.
+
+**XML documents** should be parsed with `Loofah.xml_document`. The result will have a DOCTYPE declaration and a single root node.
 
-HTML fragments should be parsed with Loofah.fragment. The result won't
-be wrapped in `html` or `body` tags, won't have a DOCTYPE declaration,
-`head` elements will be silently ignored, and multiple root nodes are
-allowed.
 
-XML fragments should be parsed with Loofah.xml_fragment. The result
-won't have a DOCTYPE declaration, and multiple root nodes are allowed.
+### Side Note: HTML4 vs HTML5
 
-HTML documents should be parsed with Loofah.document. The result will
-have a DOCTYPE declaration, along with `html`, `head` and `body` tags.
+⚠ _HTML5 functionality is not available on JRuby, or with versions of Nokogiri `< 1.14.0`._
 
-XML documents should be parsed with Loofah.xml_document. The result
-will have a DOCTYPE declaration and a single root node.
+Currently, Loofah's methods `Loofah.document` and `Loofah.fragment` are aliases to `.html4_document` and `.html4_fragment`, which use Nokogiri's HTML4 parser. (Similarly, `Loofah::HTML::Document` and `Loofah::HTML::DocumentFragment` are aliased to `Loofah::HTML4::Document` and `Loofah::HTML4::DocumentFragment`.)
 
+**Please note** that in a future version of Loofah, these methods and classes may switch to using Nokogiri's HTML5 parser and classes on platforms that support it [1].
 
-### Loofah::HTML::Document and Loofah::HTML::DocumentFragment
+**We strongly recommend that you explicitly use `.html5_document` or `.html5_fragment`** unless you know of a compelling reason not to. If you are sure that you need to use the HTML4 parser, you should explicitly call `.html4_document` or `.html4_fragment` to avoid breakage in a future version.
 
-These classes are subclasses of Nokogiri::HTML::Document and
-Nokogiri::HTML::DocumentFragment, so you get all the markup
-fixer-uppery and API goodness of Nokogiri.
+  [1]: [[feature request] HTML5 parser for JRuby implementation · Issue #2227 · sparklemotion/nokogiri](https://github.com/sparklemotion/nokogiri/issues/2227)
 
-The module methods Loofah.document and Loofah.fragment will parse an
-HTML document and an HTML fragment, respectively.
+
+### `Loofah::HTML5::Document` and `Loofah::HTML5::DocumentFragment`
+
+These classes are subclasses of `Nokogiri::HTML5::Document` and `Nokogiri::HTML5::DocumentFragment`.
+
+The module methods `Loofah.html5_document` and `Loofah.html5_fragment` will parse either an HTML document and an HTML fragment, respectively.
 
 ``` ruby
-Loofah.document(unsafe_html).is_a?(Nokogiri::HTML::Document)         # => true
-Loofah.fragment(unsafe_html).is_a?(Nokogiri::HTML::DocumentFragment) # => true
+Loofah.html5_document(unsafe_html).is_a?(Nokogiri::HTML5::Document)         # => true
+Loofah.html5_fragment(unsafe_html).is_a?(Nokogiri::HTML5::DocumentFragment) # => true
 ```
 
-Loofah injects a `scrub!` method, which takes either a symbol (for
-built-in scrubbers) or a Loofah::Scrubber object (for custom
-scrubbers), and modifies the document in-place.
+Loofah injects a `scrub!` method, which takes either a symbol (for built-in scrubbers) or a `Loofah::Scrubber` object (for custom scrubbers), and modifies the document in-place.
 
 Loofah overrides `to_s` to return HTML:
 
 ``` ruby
 unsafe_html = "ohai! <div>div is safe</div> <script>but script is not</script>"
 
-doc = Loofah.fragment(unsafe_html).scrub!(:prune)
+doc = Loofah.html5_fragment(unsafe_html).scrub!(:prune)
 doc.to_s    # => "ohai! <div>div is safe</div> "
 ```
 
@@ -134,36 +134,41 @@ and `text` to return plain text:
 doc.text    # => "ohai! div is safe "
 ```
 
-Also, `to_text` is available, which does the right thing with
-whitespace around block-level elements.
+Also, `to_text` is available, which does the right thing with whitespace around block-level and line break elements.
+
+``` ruby
+doc = Loofah.html5_fragment("<h1>Title</h1><div>Content<br>Next line</div>")
+doc.text    # => "TitleContentNext line"            # probably not what you want
+doc.to_text # => "\nTitle\n\nContent\nNext line\n"  # better
+```
+
+### `Loofah::HTML4::Document` and `Loofah::HTML4::DocumentFragment`
+
+These classes are subclasses of `Nokogiri::HTML4::Document` and `Nokogiri::HTML4::DocumentFragment`.
+
+The module methods `Loofah.html4_document` and `Loofah.html4_fragment` will parse either an HTML document and an HTML fragment, respectively.
 
 ``` ruby
-doc = Loofah.fragment("<h1>Title</h1><div>Content</div>")
-doc.text    # => "TitleContent"           # probably not what you want
-doc.to_text # => "\nTitle\n\nContent\n"   # better
+Loofah.html4_document(unsafe_html).is_a?(Nokogiri::HTML4::Document)         # => true
+Loofah.html4_fragment(unsafe_html).is_a?(Nokogiri::HTML4::DocumentFragment) # => true
 ```
 
-### Loofah::XML::Document and Loofah::XML::DocumentFragment
+### `Loofah::XML::Document` and `Loofah::XML::DocumentFragment`
 
-These classes are subclasses of Nokogiri::XML::Document and
-Nokogiri::XML::DocumentFragment, so you get all the markup
-fixer-uppery and API goodness of Nokogiri.
+These classes are subclasses of `Nokogiri::XML::Document` and `Nokogiri::XML::DocumentFragment`.
 
-The module methods Loofah.xml_document and Loofah.xml_fragment will
-parse an XML document and an XML fragment, respectively.
+The module methods `Loofah.xml_document` and `Loofah.xml_fragment` will parse an XML document and an XML fragment, respectively.
 
 ``` ruby
 Loofah.xml_document(bad_xml).is_a?(Nokogiri::XML::Document)         # => true
 Loofah.xml_fragment(bad_xml).is_a?(Nokogiri::XML::DocumentFragment) # => true
 ```
 
-### Nodes and NodeSets
+### Nodes and Node Sets
 
-Nokogiri::XML::Node and Nokogiri::XML::NodeSet also get a `scrub!`
-method, which makes it easy to scrub subtrees.
+Nokogiri's `Node` and `NodeSet` classes also get a `scrub!` method, which makes it easy to scrub subtrees.
 
-The following code will apply the `employee_scrubber` only to the
-`employee` nodes (and their subtrees) in the document:
+The following code will apply the `employee_scrubber` only to the `employee` nodes (and their subtrees) in the document:
 
 ``` ruby
 Loofah.xml_document(bad_xml).xpath("//employee").scrub!(employee_scrubber)
@@ -175,7 +180,7 @@ And this code will only scrub the first `employee` node and its subtree:
 Loofah.xml_document(bad_xml).at_xpath("//employee").scrub!(employee_scrubber)
 ```
 
-### Loofah::Scrubber
+### `Loofah::Scrubber`
 
 A Scrubber wraps up a block (or method) that is run on a document node:
 
@@ -189,14 +194,11 @@ end
 This can then be run on a document:
 
 ``` ruby
-Loofah.fragment("<span>foo</span><p>bar</p>").scrub!(span2div).to_s
+Loofah.html5_fragment("<span>foo</span><p>bar</p>").scrub!(span2div).to_s
 # => "<div>foo</div><p>bar</p>"
 ```
 
-Scrubbers can be run on a document in either a top-down traversal (the
-default) or bottom-up. Top-down scrubbers can optionally return
-Scrubber::STOP to terminate the traversal of a subtree. Read below and
-in the Loofah::Scrubber class for more detailed usage.
+Scrubbers can be run on a document in either a top-down traversal (the default) or bottom-up. Top-down scrubbers can optionally return `Scrubber::STOP` to terminate the traversal of a subtree. Read below and in the `Loofah::Scrubber` class for more detailed usage.
 
 Here's an XML example:
 
@@ -213,10 +215,10 @@ Loofah.xml_document(File.read('plague.xml')).scrub!(bring_out_your_dead)
 
 ### Built-In HTML Scrubbers
 
-Loofah comes with a set of sanitizing scrubbers that use HTML5lib's
-safelist algorithm:
+Loofah comes with a set of sanitizing scrubbers that use `html5lib`'s safelist algorithm:
 
 ``` ruby
+doc = Loofah.html5_document(input)
 doc.scrub!(:strip)       # replaces unknown/unsafe tags with their inner text
 doc.scrub!(:prune)       #  removes unknown/unsafe tags and their children
 doc.scrub!(:escape)      #  escapes unknown/unsafe tags, like this: &lt;script&gt;
@@ -224,14 +226,14 @@ doc.scrub!(:whitewash)   #  removes unknown/unsafe/namespaced tags and their chi
                          #          and strips all node attributes
 ```
 
-Loofah also comes with some common transformation tasks: 
+Loofah also comes with some common transformation tasks:
 
 ``` ruby
 doc.scrub!(:nofollow)    #     adds rel="nofollow" attribute to links
 doc.scrub!(:unprintable) #  removes unprintable characters from text nodes
 ```
 
-See Loofah::Scrubbers for more details and example usage.
+See `Loofah::Scrubbers` for more details and example usage.
 
 
 ### Chaining Scrubbers
@@ -239,7 +241,7 @@ See Loofah::Scrubbers for more details and example usage.
 You can chain scrubbers:
 
 ``` ruby
-Loofah.fragment("<span>hello</span> <script>alert('OHAI')</script>") \
+Loofah.html5_fragment("<span>hello</span> <script>alert('OHAI')</script>") \
       .scrub!(:prune) \
       .scrub!(span2div).to_s
 # => "<div>hello</div> "
@@ -247,21 +249,26 @@ Loofah.fragment("<span>hello</span> <script>alert('OHAI')</script>") \
 
 ### Shorthand
 
-The class methods Loofah.scrub_fragment and Loofah.scrub_document are
-shorthand.
+The class methods `Loofah.scrub_html5_fragment` and `Loofah.scrub_html5_document` (and the corresponding HTML4 methods) are shorthand.
+
+These methods:
 
 ``` ruby
-Loofah.scrub_fragment(unsafe_html, :prune)
-Loofah.scrub_document(unsafe_html, :prune)
+Loofah.scrub_html5_fragment(unsafe_html, :prune)
+Loofah.scrub_html5_document(unsafe_html, :prune)
+Loofah.scrub_html4_fragment(unsafe_html, :prune)
+Loofah.scrub_html4_document(unsafe_html, :prune)
 Loofah.scrub_xml_fragment(bad_xml, custom_scrubber)
 Loofah.scrub_xml_document(bad_xml, custom_scrubber)
 ```
 
-are the same thing as (and arguably semantically clearer than):
+do the same thing as (and arguably semantically clearer than):
 
 ``` ruby
-Loofah.fragment(unsafe_html).scrub!(:prune)
-Loofah.document(unsafe_html).scrub!(:prune)
+Loofah.html5_fragment(unsafe_html).scrub!(:prune)
+Loofah.html5_document(unsafe_html).scrub!(:prune)
+Loofah.html4_fragment(unsafe_html).scrub!(:prune)
+Loofah.html4_document(unsafe_html).scrub!(:prune)
 Loofah.xml_fragment(bad_xml).scrub!(custom_scrubber)
 Loofah.xml_document(bad_xml).scrub!(custom_scrubber)
 ```
@@ -269,10 +276,9 @@ Loofah.xml_document(bad_xml).scrub!(custom_scrubber)
 
 ### View Helpers
 
-Loofah has two "view helpers": Loofah::Helpers.sanitize and
-Loofah::Helpers.strip_tags, both of which are drop-in replacements for
-the Rails ActionView helpers of the same name.
-These are no longer required automatically. You must require `loofah/helpers`. 
+Loofah has two "view helpers": `Loofah::Helpers.sanitize` and `Loofah::Helpers.strip_tags`, both of which are drop-in replacements for the Rails Action View helpers of the same name.
+
+These are not required automatically. You must require `loofah/helpers` to use them.
 
 
 ## Requirements
@@ -284,7 +290,11 @@ These are no longer required automatically. You must require `loofah/helpers`.
 
 Unsurprisingly:
 
-* gem install loofah
+> gem install loofah
+
+Requirements:
+
+* Ruby >= 2.5
 
 
 ## Support
@@ -298,8 +308,6 @@ And the mailing list is on Google Groups:
 * Mail: loofah-talk@googlegroups.com
 * Archive: https://groups.google.com/forum/#!forum/loofah-talk
 
-And the IRC channel is \#loofah on freenode.
-
 Consider subscribing to [Tidelift][tidelift] which provides license assurances and timely security notifications for your open source dependencies, including Loofah. [Tidelift][tidelift] subscriptions also help the Loofah maintainers fund our [automated testing](https://ci.nokogiri.org) which in turn allows us to ship releases, bugfixes, and security updates more often.
 
   [tidelift]: https://tidelift.com/subscription/pkg/rubygems-loofah?utm_source=undefined&utm_medium=referral&utm_campaign=enterprise
@@ -310,26 +318,12 @@ Consider subscribing to [Tidelift][tidelift] which provides license assurances a
 See [`SECURITY.md`](SECURITY.md) for vulnerability reporting details.
 
 
-### "Secure by Default"
-
-Some tools may incorrectly report Loofah as a potential security
-vulnerability.
-
-Loofah depends on Nokogiri, and it's _possible_ to use Nokogiri in a
-dangerous way (by enabling its DTDLOAD option and disabling its NONET
-option). This specifically allows the opportunity for an XML External
-Entity (XXE) vulnerability if the XML data is untrusted.
-
-However, Loofah __never enables this Nokogiri configuration__; Loofah
-never enables DTDLOAD, and it never disables NONET, thereby protecting
-you by default from this XXE vulnerability.
-
-
 ## Related Links
 
+* loofah-activerecord: https://github.com/flavorjones/loofah-activerecord
 * Nokogiri: http://nokogiri.org
 * libxml2: http://xmlsoft.org
-* html5lib: https://code.google.com/p/html5lib
+* html5lib: https://github.com/html5lib/
 
 
 ## Authors
@@ -350,15 +344,14 @@ And a big shout-out to Corey Innis for the name, and feedback on the API.
 
 ## Thank You
 
-The following people have generously donated via the [Pledgie](http://pledgie.com) badge on the [Loofah github page](https://github.com/flavorjones/loofah):
+The following people have generously funded Loofah:
 
 * Bill Harding
 
 
 ## Historical Note
 
-This library was formerly known as Dryopteris, which was a very bad
-name that nobody could spell properly.
+This library was once named "Dryopteris", which was a very bad name that nobody could spell properly.
 
 
 ## License