brakeman 6.2.2 → 8.0.6

data/bundle/ruby/3.2.0/gems/erubi-1.13.1/lib/erubi.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+module Erubi
+  VERSION = '1.13.1'
+
+  # :nocov:
+  if RUBY_VERSION >= '1.9'
+    RANGE_FIRST = 0
+    RANGE_LAST = -1
+  else
+    RANGE_FIRST = 0..0
+    RANGE_LAST = -1..-1
+  end
+
+  MATCH_METHOD = RUBY_VERSION >= '2.4' ? :match? : :match
+  SKIP_DEFINED_FOR_INSTANCE_VARIABLE = RUBY_VERSION > '3'
+  FREEZE_TEMPLATE_LITERALS = !eval("''").frozen? && RUBY_VERSION >= '2.1'
+  # :nocov:
+
+  begin
+    require 'erb/escape'
+    define_method(:h, ERB::Escape.instance_method(:html_escape))
+  # :nocov:
+  rescue LoadError
+    begin
+      require 'cgi/escape'
+      unless CGI.respond_to?(:escapeHTML) # work around for JRuby 9.1
+        CGI = Object.new
+        CGI.extend(defined?(::CGI::Escape) ? ::CGI::Escape : ::CGI::Util)
+      end
+      # Escape characters with their HTML/XML equivalents.
+      def h(value)
+        CGI.escapeHTML(value.to_s)
+      end
+    rescue LoadError
+      ESCAPE_TABLE = {'&' => '&amp;'.freeze, '<' => '&lt;'.freeze, '>' => '&gt;'.freeze, '"' => '&quot;'.freeze, "'" => '&#39;'.freeze}.freeze
+      if RUBY_VERSION >= '1.9'
+        def h(value)
+          value.to_s.gsub(/[&<>"']/, ESCAPE_TABLE)
+        end
+      else
+        def h(value)
+          value.to_s.gsub(/[&<>"']/){|s| ESCAPE_TABLE[s]}
+        end
+      end
+    end
+  end
+  # :nocov:
+  module_function :h
+
+  class Engine
+    # The default regular expression used for scanning.
+    DEFAULT_REGEXP = /<%(={1,2}|-|\#|%)?(.*?)([-=])?%>([ \t]*\r?\n)?/m
+    
+    # The frozen ruby source code generated from the template, which can be evaled.
+    attr_reader :src
+
+    # The filename of the template, if one was given.
+    attr_reader :filename
+
+    # The variable name used for the buffer variable.
+    attr_reader :bufvar
+
+    # Initialize a new Erubi::Engine.  Options:
+    # +:bufval+ :: The value to use for the buffer variable, as a string (default <tt>'::String.new'</tt>).
+    # +:bufvar+ :: The variable name to use for the buffer variable, as a string.
+    # +:chain_appends+ :: Whether to chain <tt><<</t> calls to the buffer variable. Offers better
+    #                     performance, but can cause issues when the buffer variable is reassigned during
+    #                     template rendering (default +false+).
+    # +:ensure+ :: Wrap the template in a begin/ensure block restoring the previous value of bufvar.
+    # +:escapefunc+ :: The function to use for escaping, as a string (default: <tt>'::Erubi.h'</tt>).
+    # +:escape+ :: Whether to make <tt><%=</tt> escape by default, and <tt><%==</tt> not escape by default.
+    # +:escape_html+ :: Same as +:escape+, with lower priority.
+    # +:filename+ :: The filename for the template.
+    # +:freeze+ :: Whether to enable add a <tt>frozen_string_literal: true</tt> magic comment at the top of
+    #              the resulting source code.  Note this may cause problems if you are wrapping the resulting
+    #              source code in other code, because the magic comment only has an effect at the beginning of
+    #              the file, and having the magic comment later in the file can trigger warnings.
+    # +:freeze_template_literals+ :: Whether to suffix all literal strings for template code with <tt>.freeze</tt>
+    #                                (default: +true+ on Ruby 2.1+, +false+ on Ruby 2.0 and older).
+    #                                Can be set to +false+ on Ruby 2.3+ when frozen string literals are enabled
+    #                                in order to improve performance.
+    # +:literal_prefix+ :: The prefix to output when using escaped tag delimiters (default <tt>'<%'</tt>).
+    # +:literal_postfix+ :: The postfix to output when using escaped tag delimiters (default <tt>'%>'</tt>).
+    # +:outvar+ :: Same as +:bufvar+, with lower priority.
+    # +:postamble+ :: The postamble for the template, by default returns the resulting source code.
+    # +:preamble+ :: The preamble for the template, by default initializes the buffer variable.
+    # +:regexp+ :: The regexp to use for scanning.
+    # +:src+ :: The initial value to use for the source code, an empty string by default.
+    # +:trim+ :: Whether to trim leading and trailing whitespace, true by default.
+    def initialize(input, properties={})
+      @escape = escape = properties.fetch(:escape){properties.fetch(:escape_html, false)}
+      trim       = properties[:trim] != false
+      @filename  = properties[:filename]
+      @bufvar = bufvar = properties[:bufvar] || properties[:outvar] || "_buf"
+      bufval = properties[:bufval] || '::String.new'
+      regexp = properties[:regexp] || DEFAULT_REGEXP
+      literal_prefix = properties[:literal_prefix] || '<%'
+      literal_postfix = properties[:literal_postfix] || '%>'
+      preamble   = properties[:preamble] || "#{bufvar} = #{bufval};"
+      postamble  = properties[:postamble] || "#{bufvar}.to_s\n"
+      @chain_appends = properties[:chain_appends]
+      @text_end = if properties.fetch(:freeze_template_literals, FREEZE_TEMPLATE_LITERALS)
+        "'.freeze"
+      else
+        "'"
+      end
+
+      @buffer_on_stack = false
+      @src = src = properties[:src] || String.new
+      src << "# frozen_string_literal: true\n" if properties[:freeze]
+      if properties[:ensure]
+        src << "begin; __original_outvar = #{bufvar}"
+        if SKIP_DEFINED_FOR_INSTANCE_VARIABLE && /\A@[^@]/ =~ bufvar
+          src << "; "
+        else
+          src << " if defined?(#{bufvar}); "
+        end
+      end
+
+      unless @escapefunc = properties[:escapefunc]
+        if escape
+          @escapefunc = '__erubi.h'
+          src << "__erubi = ::Erubi; "
+        else
+          @escapefunc = '::Erubi.h'
+        end
+      end
+
+      src << preamble
+
+      pos = 0
+      is_bol = true
+      input.scan(regexp) do |indicator, code, tailch, rspace|
+        match = Regexp.last_match
+        len  = match.begin(0) - pos
+        text = input[pos, len]
+        pos  = match.end(0)
+        ch   = indicator ? indicator[RANGE_FIRST] : nil
+
+        lspace = nil
+
+        unless ch == '='
+          if text.empty?
+            lspace = "" if is_bol
+          elsif text[RANGE_LAST] == "\n"
+            lspace = ""
+          else
+            rindex = text.rindex("\n")
+            if rindex
+              range = rindex+1..-1
+              s = text[range]
+              if /\A[ \t]*\z/.send(MATCH_METHOD, s)
+                lspace = s
+                text[range] = ''
+              end
+            else
+              if is_bol && /\A[ \t]*\z/.send(MATCH_METHOD, text)
+                lspace = text
+                text = ''
+              end
+            end
+          end
+        end
+
+        is_bol = rspace
+        add_text(text)
+        case ch
+        when '='
+          rspace = nil if tailch && !tailch.empty?
+          add_expression(indicator, code)
+          add_text(rspace) if rspace
+        when nil, '-'
+          if trim && lspace && rspace
+            add_code("#{lspace}#{code}#{rspace}")
+          else
+            add_text(lspace) if lspace
+            add_code(code)
+            add_text(rspace) if rspace
+          end
+        when '#'
+          n = code.count("\n") + (rspace ? 1 : 0)
+          if trim && lspace && rspace
+            add_code("\n" * n)
+          else
+            add_text(lspace) if lspace
+            add_code("\n" * n)
+            add_text(rspace) if rspace
+          end
+        when '%'
+          add_text("#{lspace}#{literal_prefix}#{code}#{tailch}#{literal_postfix}#{rspace}")
+        else
+          handle(indicator, code, tailch, rspace, lspace)
+        end
+      end
+      rest = pos == 0 ? input : input[pos..-1]
+      add_text(rest)
+
+      src << "\n" unless src[RANGE_LAST] == "\n"
+      add_postamble(postamble)
+      src << "; ensure\n  " << bufvar << " = __original_outvar\nend\n" if properties[:ensure]
+      src.freeze
+      freeze
+    end
+
+    private
+
+    if RUBY_VERSION >= '2.3'
+      def _dup_string_if_frozen(string)
+        +string
+      end
+    # :nocov:
+    else
+      def _dup_string_if_frozen(string)
+        string.frozen? ? string.dup : string
+      end
+    end
+    # :nocov:
+
+    # Add raw text to the template.  Modifies argument if argument is mutable as a memory optimization.
+    # Must be called with a string, cannot be called with nil (Rails's subclass depends on it).
+    def add_text(text)
+      return if text.empty?
+
+      text = _dup_string_if_frozen(text)
+      text.gsub!(/['\\]/, '\\\\\&')
+
+      with_buffer{@src << " << '" << text << @text_end}
+    end
+
+    # Add ruby code to the template
+    def add_code(code)
+      terminate_expression
+      @src << code
+      @src << ';' unless code[RANGE_LAST] == "\n"
+      @buffer_on_stack = false
+    end
+
+    # Add the given ruby expression result to the template,
+    # escaping it based on the indicator given and escape flag.
+    def add_expression(indicator, code)
+      if ((indicator == '=') ^ @escape)
+        add_expression_result(code)
+      else
+        add_expression_result_escaped(code)
+      end
+    end
+
+    # Add the result of Ruby expression to the template
+    def add_expression_result(code)
+      with_buffer{@src << ' << (' << code << ').to_s'}
+    end
+
+    # Add the escaped result of Ruby expression to the template
+    def add_expression_result_escaped(code)
+      with_buffer{@src << ' << ' << @escapefunc << '((' << code << '))'}
+    end
+
+    # Add the given postamble to the src.  Can be overridden in subclasses
+    # to make additional changes to src that depend on the current state.
+    def add_postamble(postamble)
+      terminate_expression
+      @src << postamble
+    end
+
+    # Raise an exception, as the base engine class does not support handling other indicators.
+    def handle(indicator, code, tailch, rspace, lspace)
+      raise ArgumentError, "Invalid indicator: #{indicator}"
+    end
+
+    # Make sure the buffer variable is the target of the next append
+    # before yielding to the block. Mark that the buffer is the target
+    # of the next append after the block executes.
+    #
+    # This method should only be called if the block will result in
+    # code where << will append to the bufvar.
+    def with_buffer
+      if @chain_appends
+        unless @buffer_on_stack
+          @src << '; ' << @bufvar
+        end
+        yield
+        @buffer_on_stack = true
+      else
+        @src << ' ' << @bufvar
+        yield
+        @src << ';'
+      end
+    end
+
+    # Make sure that any current expression has been terminated.
+    # The default is to terminate all expressions, but when
+    # the chain_appends option is used, expressions may not be
+    # terminated.
+    def terminate_expression
+      @src << '; ' if @chain_appends
+    end
+  end
+end

data/bundle/ruby/{3.1.0/gems/haml-5.2.2 → 3.2.0/gems/haml-6.4.0}/CHANGELOG.md

@@ -1,12 +1,188 @@
 # Haml Changelog
 
+## 6.4.0
+
+* Authorize characters in attribute name for vuejs https://github.com/haml/haml/pull/1172
+* Compile new-style attributes statically https://github.com/haml/haml/pull/1165
+* Remove newlines from template annotation comments https://github.com/haml/haml/pull/1186
+* Fix line numbers within a :ruby filter https://github.com/haml/haml/pull/1166
+* Fix .class + nested class array bug https://github.com/haml/haml/pull/1191
+
+## 6.3.1
+
+* Optimize string transformation using `String#tr` https://github.com/haml/haml/pull/1168
+* Provide a Changelog link on rubygems.org https://github.com/haml/haml/pull/1157
+
+## 6.3.0
+
+* Remove `Haml::RailsTemplate#default_format` that was added in v6.1.3 for Turbo [#1152](https://github.com/haml/haml/issues/1152), [#1154](https://github.com/haml/haml/issues/1154) ([discussion](https://github.com/haml/haml/pull/1144#issuecomment-1755088572))
+  * See [the reference](https://github.com/haml/haml/blob/v6.3.0/REFERENCE.md#turbo) for suggested alternatives.
+
+## 6.2.5
+
+* Deprecate `Haml::RailsTemplate#default_format` that was added in v6.1.3 for Turbo ([discussion](https://github.com/haml/haml/pull/1144#issuecomment-1755088572))
+
+## 6.2.4
+
+* Support case-in statement [#1155](https://github.com/haml/haml/issues/1155)
+
+## 6.2.3
+
+* Resurrect RDFa doctype support [#1147](https://github.com/haml/haml/issues/1147)
+
+## 6.2.2
+
+* Allow adding custom attributes to `Haml::BOOLEAN_ATTRIBUTES` [#1148](https://github.com/haml/haml/issues/1148)
+* Consider `aria-xxx: false` as a boolean attribute
+
+## 6.2.1
+
+* Fix v6.2.0's bug in rendering dynamic `aria` attributes [#1149](https://github.com/haml/haml/issues/1149)
+
+## 6.2.0
+
+* Drop the C extension [#1146](https://github.com/haml/haml/issues/1146)
+
+## 6.1.4
+
+* Let `Haml::Util.escape_html` use `ERB::Escape` if available [#1145](https://github.com/haml/haml/issues/1145)
+
+## 6.1.3
+
+* Add `Haml::RailsTemplate#default_format` for Turbo compatibility [#1144](https://github.com/haml/haml/issues/1144)
+
+## 6.1.2
+
+* Use the rails template path as `filename` [#1140](https://github.com/haml/haml/issues/1140)
+
+## 6.1.1
+
+* Fix an empty output of Ruby 3.1's Hash shorthand syntax [#1083](https://github.com/haml/haml/issues/1083)
+
+## 6.1.0
+
+* Optimize away a `to_s` call on `=` scripts
+* Fix escaping for objects that return an `html_safe` string on `to_s` [#1117](https://github.com/haml/haml/issues/1117)
+
+## 6.0.12
+
+* Fix a whitespace removal with `>` and an `if`-`else` statement [#1114](https://github.com/haml/haml/issues/1114)
+
+## 6.0.11
+
+* Fix a whitespace removal with `>` and an `if` statement [#1114](https://github.com/haml/haml/issues/1114)
+
+## 6.0.10
+
+* Evaluate :erb filter in the template context like Haml 5
+
+## 6.0.9
+
+* Support sass-embedded [#1112](https://github.com/haml/haml/issues/1112)
+
+## 6.0.8
+
+* Support interpolation in HTML comments, which has not been working since 6.0.0
+  [#1107](https://github.com/haml/haml/issues/1107)
+
+## 6.0.7
+
+* `Haml::Engine` and `Haml::Template` use StringBuffer instead of ArrayBuffer
+  * It seems more performant in many cases with recent Ruby versions.
+  * `Haml::RailsTemplate` is not affected.
+
+## 6.0.6
+
+* Prevent CRuby from accidentally using the Ruby implementation fallback
+  * Reversing what v6.0.3 and v6.0.4 did, but still supporting Wasm.
+
+## 6.0.5
+
+* Resurrect `#haml_object_ref` support in an object reference [#1097](https://github.com/haml/haml/issues/1097)
+  * This was removed in 6.0.0, and added back in this version.
+* Stop warning `remove_whitespace: true` option.
+
+## 6.0.4
+
+Released on October 2, 2022
+([diff](https://github.com/haml/haml/compare/v6.0.3...v6.0.4)).
+
+* Fix a parse failure of `%` in attributes [#1096](https://github.com/haml/haml/issues/1096)
+* Add another fallback from C to Ruby for Wasm.
+
+## 6.0.3
+
+Released on September 28, 2022
+([diff](https://github.com/haml/haml/compare/v6.0.2...v6.0.3)).
+
+* For Wasm, fallback to Ruby when C extension is not available.
+
+## 6.0.2
+
+Released on September 28, 2022
+([diff](https://github.com/haml/haml/compare/v6.0.1...v6.0.2)).
+
+* Unescape HTML-safe arguments for `surround`, `succeed`, and `precede` on Rails
+  [#1088](https://github.com/haml/haml/issues/1088)
+
+## 6.0.1
+
+Released on September 23, 2022
+([diff](https://github.com/haml/haml/compare/v6.0.0...v6.0.1)).
+
+* Unescape HTML-safe interpolation on Rails [#1084](https://github.com/haml/haml/issues/1084)
+* Resurrect Haml 5's `AttributeParser.available?` for syntax\_tree-haml [#1085](https://github.com/haml/haml/issues/1085)
+
+## 6.0.0
+
+Released on September 21, 2022
+([diff](https://github.com/haml/haml/compare/v5.2.2...v6.0.0)).
+
+* Replace the implementation with Hamlit
+  * Haml 6 is about 1.7x faster than Haml 5 in [this benchmark](benchmark/slim/run-benchmarks.rb).
+  * The parser is kept as is, but everything else is replaced.
+  * The `haml` CLI interface was also replaced.
+  * The interface of `Haml::Engine` is changed. `Haml::Template` is most likely what you need now.
+     * before: `Haml::Engine.new("%p Haml code!").render`
+     * after: `Haml::Template.new { "%p Haml code!" }.render`
+  * Most Haml helpers are removed.
+     * Rails:
+         * Kept: `find_and_reserve`, `preserve`, `surround`, `precede`, `succeed`, `capture_haml`
+         * Removed: `block_is_haml?`, `flatten`, `haml_concat`, `haml_indent`, `haml_tag`, `haml_tag_if`, `html_attrs`,
+           `html_escape`, `init_haml_helpers`, `is_haml?`, `list_of`, `non_haml`, `tab_down`, `tab_up`, `with_tabs`
+     * Tilt:
+         * Kept: `preserve`
+         * Removed: `block_is_haml?`, `capture_haml`, `escape_once`, `find_and_preserve`, `flatten`, `haml_concat`,
+           `haml_indent`, `haml_tag`, `haml_tag_if`, `html_attrs`, `html_escape`, `init_haml_helpers`, `is_haml?`,
+           `list_of`, `non_haml`, `precede`, `succeed`, `surround`, `tab_down`, `tab_up`, `with_tabs`
+     * `:ruby` filter
+         * Removed: `haml_io`
+     * Alternatives to the removed helpers:
+         * Some simple ones could work by copying [the original definition](https://github.com/haml/haml/blob/v5.2.2/lib/haml/helpers.rb).
+         * For helpers generating general HTML tags, also consider using what your framework provides, e.g. Rails `content_tag`.
+           Same applies to `capture_haml`, e.g. Rails `capture`.
+         * Ones that rely on `Haml::Buffer` have no direct alternative by design. They existed at the cost of performance.
+           You need to define a helper, instantiate a String buffer in it, append stuff to it, and call it inside `=`.
+  * Only the following attributes and `aria`/`data` attributes are considered boolean attributes:
+     * `allowfullscreen`, `async`, `autobuffer`, `autofocus`, `autoplay`, `checked`, `controls`, `default`,
+       `defer`, `disabled`, `download`, `formnovalidate`, `hidden`, `inert`, `ismap`, `itemscope`, `loop`,
+       `multiple`, `muted`, `novalidate`, `open`, `pubdate`, `readonly`, `required`, `reversed`, `scoped`,
+       `seamless`, `selected`, `sortable`, `truespeed`, `typemustmatch`
+  * Only `data` and `aria` attributes support using a nested Hash to render hyphenated attributes, e.g.
+    `data: { foo: 'bar' }` becomes `data-foo="bar"`, but this no longer works for non-`data`/`aria` attributes.
+  * Some legacy Rails integration is removed.
+  * The default value of `escape_html` option became true.
+  * `-` script lines no longer support capturing. Only `=` lines are supported to yield a nested block.
+  * Overriding `data` attributes with another falsy `data-*` attribute that has the same name
+    is no longer supported. [#1105](https://github.com/haml/haml/issues/1105)
+  * :erb filter is not executed in the template context (fixed in 6.0.10)
+
 ## 5.2.2
+
 Released on July 27, 2021
 ([diff](https://github.com/haml/haml/compare/v5.2.1...v5.2.2)).
 
-* Support for adding Annotations to Haml output (a Rails feature 6.1+)
-* Expanded test matrix to include Ruby 3.0 and Rails 6.1
-* Only testing Ruby 2.7+ and Rails 5.2+
+* Support `config.action_view.annotate_rendered_view_with_filenames = true` of Rails 6.1
 
 ## 5.2.1
 
@@ -1311,7 +1487,7 @@ Haml 2.2 introduces a new syntax for attributes
 based on the HTML syntax.
 For example:
 
-    %a(href="http://haml.info" title="Haml's so cool!")
+    %a(href="https://haml.info" title="Haml's so cool!")
       %img(src="/images/haml.png" alt="Haml")
 
 There are two main reasons for this.

data/bundle/ruby/{3.1.0/gems/haml-5.2.2 → 3.2.0/gems/haml-6.4.0}/FAQ.md

@@ -141,7 +141,7 @@ For other plugins, a little searching will probably turn up a way to fix them as
 
 ## You still haven't answered my question!
 
-Sorry! Try looking at the [Haml](http://haml.info/docs/yardoc/file.REFERENCE.html) reference,
+Sorry! Try looking at the [Haml](https://haml.info/docs/yardoc/file.REFERENCE.html) reference,
 If you can't find an answer there,
 feel free to ask in `#haml` on irc.freenode.net
 or send an email to the [mailing list](http://groups.google.com/group/haml).

data/bundle/ruby/3.2.0/gems/haml-6.4.0/Gemfile

@@ -0,0 +1,34 @@
+source 'https://rubygems.org'
+
+git_source(:github) do |repo_name|
+  repo_name = "#{repo_name}/#{repo_name}" unless repo_name.include?("/")
+  "https://github.com/#{repo_name}.git"
+end
+
+# Specify your gem's dependencies in haml.gemspec
+gemspec
+
+gem 'benchmark-ips', '2.3.0'
+gem 'maxitest'
+gem 'pry'
+
+if /java/ === RUBY_PLATFORM # JRuby
+  gem 'pandoc-ruby'
+else
+  gem 'redcarpet'
+
+  if RUBY_PLATFORM !~ /mswin|mingw/ && RUBY_ENGINE != 'truffleruby'
+    gem 'stackprof'
+  end
+end
+
+if RUBY_VERSION < '2.6'
+  gem 'rake-compiler', '< 1.2.4'
+end
+
+# Temporary workaround to ensure Ruby 2.5 and 2.6 can pass tests with Rails 6.1
+# Reference: https://github.com/rails/rails/issues/54260
+# TODO: Remove this workaround when dropping support for Rails versions below 7.1
+if RUBY_VERSION < '2.7'
+  gem 'concurrent-ruby', '< 1.3.5'
+end

data/bundle/ruby/{3.1.0/gems/haml-5.2.2 → 3.2.0/gems/haml-6.4.0}/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2006-2019 Hampton Catlin and Natalie Weizenbaum
+Copyright (c) 2006-2021 Hampton Catlin, Natalie Weizenbaum and Takashi Kokubun
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/bundle/ruby/{3.1.0/gems/haml-5.2.2 → 3.2.0/gems/haml-6.4.0}/README.md

@@ -1,22 +1,16 @@
 # Haml
 
-[![Gem Version](https://badge.fury.io/rb/haml.svg)](http://rubygems.org/gems/haml)
-[![Build Status](https://travis-ci.org/haml/haml.svg?branch=main)](http://travis-ci.org/haml/haml)
+[![Gem Version](https://badge.fury.io/rb/haml.svg)](https://rubygems.org/gems/haml)
+[![test](https://github.com/haml/haml/actions/workflows/test.yml/badge.svg)](https://github.com/haml/haml/actions/workflows/test.yml)
 [![Code Climate](https://codeclimate.com/github/haml/haml/badges/gpa.svg)](https://codeclimate.com/github/haml/haml)
-[![Inline docs](http://inch-ci.org/github/haml/haml.png)](http://inch-ci.org/github/haml/haml)
+[![Inline docs](https://inch-ci.org/github/haml/haml.svg)](https://inch-ci.org/github/haml/haml)
+[![Discord Server](https://dcbadge.limes.pink/api/server/https://discord.gg/G8dEAwvV2Y)](https://discord.gg/G8dEAwvV2Y)
 
 Haml is a templating engine for HTML. It's designed to make it both easier and
 more pleasant to write HTML documents, by eliminating redundancy, reflecting the
 underlying structure that the document represents, and providing an elegant syntax
 that's both powerful and easy to understand.
 
-### Supported Versions
-
-* Ruby 2.6+
-* Rails 5.1+
-
-Other versions may likely work, but we don't test against them.
-
 ## Basic Usage
 
 Haml can be used from the command line or as part of a Ruby web framework. The
@@ -29,7 +23,7 @@ gem install haml
 After you write some Haml, you can run
 
 ~~~sh
-haml document.haml
+haml render document.haml
 ~~~
 
 to compile it to HTML. For more information on these commands, check out
@@ -38,7 +32,7 @@ to compile it to HTML. For more information on these commands, check out
 haml --help
 ~~~
 
-To use Haml programmatically, check out the [YARD documentation](http://haml.info/docs/yardoc/).
+To use Haml programmatically, check out the [YARD documentation](https://haml.info/docs/yardoc/).
 
 ## Using Haml with Rails
 
@@ -48,8 +42,8 @@ To use Haml with Rails, simply add Haml to your Gemfile and run `bundle`.
 gem 'haml'
 ~~~
 
-If you'd like to replace Rails's Erb-based generators with Haml, add
-[haml-rails](https://github.com/indirect/haml-rails) to your Gemfile as well.
+If you'd like to replace Rails's ERB-based generators with Haml, add
+[haml-rails](https://github.com/haml/haml-rails) to your Gemfile as well.
 
 ## Formatting
 
@@ -127,7 +121,7 @@ output the result. You can even use control statements like `if` and `while`:
 ~~~
 
 Haml provides far more tools than those presented here. Check out the [reference
-documentation](http://haml.info/docs/yardoc/file.REFERENCE.html)
+documentation](https://haml.info/docs/yardoc/file.REFERENCE.html)
 for full details.
 
 ### Indentation
@@ -139,7 +133,7 @@ can't be mixed, and the same number of tabs or spaces must be used throughout.
 ## Contributing
 
 Contributions are welcomed, but before you get started please read the
-[guidelines](http://haml.info/development.html#contributing).
+[guidelines](https://haml.info/development.html#contributing).
 
 After forking and then cloning the repo locally, install Bundler and then use it
 to install the development gem dependencies:
@@ -153,12 +147,6 @@ Once this is complete, you should be able to run the test suite:
 rake
 ~~~
 
-You'll get a warning that you need to install haml-spec, so run this:
-
-~~~sh
-git submodule update --init
-~~~
-
 At this point `rake` should run without error or warning and you are ready to
 start working on your patch!
 
@@ -169,34 +157,35 @@ on a specific area:
 ruby -Itest test/helper_test.rb -n test_buffer_access
 ~~~
 
-Haml currently supports Ruby 2.7.0 and higher, so please make sure your changes run on 2.7+.
+Haml currently supports Ruby 2.0.0 and higher, so please make sure your changes run on 2.0+.
 
 ## Team
 
 ### Current Maintainers
 
-* [Hampton Catlin](https://github.com/hcatlin)
-* [Takashi Kokubun](https://github.com/k0kubun)
 * [Akira Matsuda](https://github.com/amatsuda)
+* [Matt Wildig](https://github.com/mattwildig)
+* [Tee Parham](https://github.com/teeparham)
+* [Takashi Kokubun](https://github.com/k0kubun)
 
 ### Alumni
 
 Haml was created by [Hampton Catlin](http://hamptoncatlin.com), the author of
-the original implementation.
+the original implementation. Hampton is no longer involved in day-to-day coding,
+but still consults on language issues.
 
-[Natalie Weizenbaum](https://github.com/nex3) was for many years the primary developer
+[Natalie Weizenbaum](http://nex-3.com) was for many years the primary developer
 and architect of the "modern" Ruby implementation of Haml.
 
-This project's been around for many years, and we have many amazing people who kept the project 
-alive! as former maintainers like:
-
-[Norman Clarke](http://github.com/norman)
-[Matt Wildig](https://github.com/mattwildig)
-[Tee Parham](https://github.com/teeparham)
+[Norman Clarke](https://github.com/norman) was the primary maintainer of Haml from 2012 to 2016.
 
 ## License
 
-Copyright (c) 2006-2021 Hampton Catlin, Natalie Weizenbaum and the Haml team
+Some of Natalie's work on Haml was supported by Unspace Interactive.
+
+Beyond that, the implementation is licensed under the MIT License.
+
+Copyright (c) 2006-2019 Hampton Catlin, Natalie Weizenbaum and the Haml team
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in