loofah 2.19.1 → 2.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd3edb0acdf2359d82564aca0bc13710d9f6c49157963d18953ff55bd7c14413
-  data.tar.gz: 3a6e11b7deb9cfb469aaf6ec919062687bd4215ef11980bded72ca298807610c
+  metadata.gz: e003942bbd3be7a5d576d4b48002964664c844b3aa66aa24a6b55e536ecd0662
+  data.tar.gz: f959fadbc762a26167cc46563d92e8be0d085372467b774dcbb3f18dabc6d8c8
 SHA512:
-  metadata.gz: 4970a6aa72265f60556dd6fd254375c86d3f83be23f3bbcc8b04df00ce0e801e8ef9e67d0a77ca6a21915be89226131c16a7f3540f02538cc2b9a369950dfebf
-  data.tar.gz: 27e3a06cc391ec3d9e3c966efdb6b4ce58e98c397ec87490d418406c17757e5cb0193edabaced30a9f24320c729e6730308e346610859f9f7c6d5fcc6f72cd56
+  metadata.gz: 254caef30657885b063ae85c0ac01ba386aa387571a7f5587dfee57f4e803047f56579d11425bb01a6aa50209b3b1755d7e2c613412f4783f3ce5e6d4fd70b70
+  data.tar.gz: 4a531c380c0ce45a9c3e9ea1a87c08da487331bf56db20e6bf42b903ca1e1f3e043f72ddfc1ad82076fffcad6bd08055131952b62c40f0b6067fcac3a552cfd7

data/CHANGELOG.md

@@ -1,5 +1,107 @@
 # Changelog
 
+## 2.24.0 / 2024-12-24
+
+### Added
+
+* Built-in scrubber `:double_breakpoint` which sees `<br><br>` and wraps the surrounding content in `<p>` tags. #279, #284 @josecolella @torihuang
+
+### Improved
+
+* Built-in scrubber `:targetblank` now skips `a` tags whose `href` attribute is an anchor link. Previously, all `a` tags were modified to have `target='_blank'`. #291 @fnando
+
+
+## 2.23.1 / 2024-10-25
+
+### Added
+
+* Allow CSS properties `min-height` and `max-height`. [#288] @lazyatom
+
+
+## 2.23.0 / 2024-10-24
+
+### Added
+
+* Allow CSS property `min-width`. [#287] @lazyatom
+
+
+## 2.22.0 / 2023-11-13
+
+### Added
+
+* A `:targetblank` HTML scrubber which ensures all hyperlinks have `target="_blank"`. [#275] @stefannibrasil and @thdaraujo
+* A `:noreferrer` HTML scrubber which ensures all hyperlinks have `rel=noreferrer`, similar to the `:nofollow` and `:noopener` scrubbers. [#277] @wynksaiddestroy
+
+
+## 2.21.4 / 2023-10-10
+
+### Fixed
+
+* `Loofah::HTML5::Scrub.scrub_css` is more consistent in preserving whitespace (and lack of whitespace) in CSS property values. In particular, `.scrub_css` no longer inserts whitespace between tokens that did not already have whitespace between them. [[#273](https://github.com/flavorjones/loofah/issues/273), fixes [#271](https://github.com/flavorjones/loofah/issues/271)]
+
+
+## 2.21.3 / 2023-05-15
+
+### Fixed
+
+* 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

data/README.md

@@ -14,59 +14,64 @@
 
 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.
+  * Add the _target=\_blank_ attribute to all hyperlinks.
+  * Remove _unprintable_ characters from text nodes.
+* Some specialized HTML transformations are also built-in:
+  * Where `<br><br>` exists inside a `p` tag, close the `p` and open a new one.
+* 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
@@ -80,50 +85,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> "
 ```
 
@@ -136,32 +140,38 @@ doc.text    # => "ohai! div is safe "
 Also, `to_text` is available, which does the right thing with whitespace around block-level and line break elements.
 
 ``` ruby
-doc = Loofah.fragment("<h1>Title</h1><div>Content<br>Next line</div>")
+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::XML::Document and Loofah::XML::DocumentFragment
+### `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
+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`
 
-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)
@@ -173,7 +183,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:
 
@@ -187,14 +197,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:
 
@@ -211,10 +218,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;
@@ -222,14 +229,18 @@ 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 built-in scrubers for some common transformation tasks:
 
 ``` ruby
-doc.scrub!(:nofollow)    #     adds rel="nofollow" attribute to links
-doc.scrub!(:unprintable) #  removes unprintable characters from text nodes
+doc.scrub!(:nofollow)          # adds rel="nofollow" attribute to links
+doc.scrub!(:noopener)          # adds rel="noopener" attribute to links
+doc.scrub!(:noreferrer)        # adds rel="noreferrer" attribute to links
+doc.scrub!(:unprintable)       # removes unprintable characters from text nodes
+doc.scrub!(:targetblank)       # adds target="_blank" attribute to links
+doc.scrub!(:double_breakpoint) # where `<br><br>` appears in a `p` tag, close the `p` and open a new one
 ```
 
-See Loofah::Scrubbers for more details and example usage.
+See `Loofah::Scrubbers` for more details and example usage.
 
 
 ### Chaining Scrubbers
@@ -237,7 +248,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> "
@@ -245,21 +256,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)
 ```
@@ -267,10 +283,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
@@ -282,7 +297,11 @@ These are no longer required automatically. You must require `loofah/helpers`.
 
 Unsurprisingly:
 
-* gem install loofah
+> gem install loofah
+
+Requirements:
+
+* Ruby >= 2.5
 
 
 ## Support
@@ -296,8 +315,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
@@ -308,26 +325,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
@@ -337,26 +340,69 @@ you by default from this XXE vulnerability.
 
 Featuring code contributed by:
 
-* Aaron Patterson
-* John Barnette
-* Josh Owens
-* Paul Dix
-* Luke Melia
+* [@flavorjones](https://github.com/flavorjones)
+* [@brynary](https://github.com/brynary)
+* [@olleolleolle](https://github.com/olleolleolle)
+* [@JuanitoFatas](https://github.com/JuanitoFatas)
+* [@kaspth](https://github.com/kaspth)
+* [@tenderlove](https://github.com/tenderlove)
+* [@ktdreyer](https://github.com/ktdreyer)
+* [@orien](https://github.com/orien)
+* [@asok](https://github.com/asok)
+* [@junaruga](https://github.com/junaruga)
+* [@MothOnMars](https://github.com/MothOnMars)
+* [@nick-desteffen](https://github.com/nick-desteffen)
+* [@NikoRoberts](https://github.com/NikoRoberts)
+* [@trans](https://github.com/trans)
+* [@andreynering](https://github.com/andreynering)
+* [@aried3r](https://github.com/aried3r)
+* [@baopham](https://github.com/baopham)
+* [@batter](https://github.com/batter)
+* [@brendon](https://github.com/brendon)
+* [@cjba7](https://github.com/cjba7)
+* [@christiankisssner](https://github.com/christiankisssner)
+* [@dacort](https://github.com/dacort)
+* [@danfstucky](https://github.com/danfstucky)
+* [@david-a-wheeler](https://github.com/david-a-wheeler)
+* [@dharamgollapudi](https://github.com/dharamgollapudi)
+* [@georgeclaghorn](https://github.com/georgeclaghorn)
+* [@gogainda](https://github.com/gogainda)
+* [@jaredbeck](https://github.com/jaredbeck)
+* [@ThatHurleyGuy](https://github.com/ThatHurleyGuy)
+* [@jstorimer](https://github.com/jstorimer)
+* [@jbarnette](https://github.com/jbarnette)
+* [@queso](https://github.com/queso)
+* [@technicalpickles](https://github.com/technicalpickles)
+* [@kyoshidajp](https://github.com/kyoshidajp)
+* [@kristianfreeman](https://github.com/kristianfreeman)
+* [@louim](https://github.com/louim)
+* [@mrpasquini](https://github.com/mrpasquini)
+* [@olivierlacan](https://github.com/olivierlacan)
+* [@pauldix](https://github.com/pauldix)
+* [@sampokuokkanen](https://github.com/sampokuokkanen)
+* [@stefannibrasil](https://github.com/stefannibrasil)
+* [@tastycode](https://github.com/tastycode)
+* [@vipulnsward](https://github.com/vipulnsward)
+* [@joncalhoun](https://github.com/joncalhoun)
+* [@ahorek](https://github.com/ahorek)
+* [@rmacklin](https://github.com/rmacklin)
+* [@y-yagi](https://github.com/y-yagi)
+* [@lazyatom](https://github.com/lazyatom)
 
 And a big shout-out to Corey Innis for the name, and feedback on the API.
 
 
 ## Thank You
 
-The following people have generously funded Loofah:
+The following people have generously funded Loofah with financial sponsorship:
 
 * Bill Harding
+* [Sentry](https://sentry.io/) @getsentry
 
 
 ## 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