haml_lint 0.40.0 → 0.51.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ef9ca7cc6bbd3b5f9663a2bda75669062b25efeb53af9e32cf152fd7f5aee6c
-  data.tar.gz: 35e34d39d55e13910ec90f9ee7ece9a4baa2d6bc44f2f6962b230f6387519174
+  metadata.gz: 71dc6acf56f28f4f6878ff300a653d1fb6c5cc6fa9da23c71813463ea9e1b67a
+  data.tar.gz: af2fa134ec9718c24d019e20c359c9a965d6d09490e6f57fe202654f5f7f95a3
 SHA512:
-  metadata.gz: 376df9f9c0de3c0949bd2187bb1ba9f3bc5e381644a93c827ca085125ac2922f59f98d048d8bf548b379ebe5def5180f9b182628030f4e66454f3edf71478f9f
-  data.tar.gz: fa1a9ad202224e1059dd7802b1aea08db8b9d11570feca891a31650dc3b10f0b991b2585ad27faa4425bc2165a2b23e799075c944250a43568e1d17c7f83f8b1
+  metadata.gz: 73c8a4c7fbd68cfbeacd29e5d313dcf9ae120a624a0359fecf5ca25396a8e68a0cfbad68b0ac9854af82a9233ffb26a9adf7db156f8dd3b5eb8b7a83773db035
+  data.tar.gz: fcb59570ff3b999f81f12208993ab75118013b0262586478145d7d0eaa9bab78002d9808757e10025324082f895bb0962743133898dd31dbb6c3db73d4c7f68c

data/bin/haml-lint

@@ -4,5 +4,5 @@
 require 'haml_lint'
 require 'haml_lint/cli'
 
-logger = HamlLint::Logger.new(STDOUT)
+logger = HamlLint::Logger.new($stdout)
 exit HamlLint::CLI.new(logger).run(ARGV)

data/config/default.yml

@@ -76,6 +76,9 @@ linters:
   MultilineScript:
     enabled: true
 
+  NoPlaceholders:
+    enabled: false
+
   ObjectReferenceAttributes:
     enabled: true
 
@@ -85,33 +88,9 @@ linters:
 
   RuboCop:
     enabled: true
-    # These cops are incredibly noisy when it comes to HAML templates, so we
-    # ignore them.
-    ignored_cops:
-      - Lint/BlockAlignment
-      - Lint/EndAlignment
-      - Lint/Void
-      - Layout/AlignHash # renamed to Layout/HashAlignment in rubocop 0.77
-      - Layout/AlignParameters # renamed to Layout/ParameterAlignment in rubocop 0.77
-      - Layout/ArgumentAlignment
-      - Layout/CaseIndentation
-      - Layout/ElseAlignment
-      - Layout/EndOfLine
-      - Layout/HashAlignment
-      - Layout/IndentationWidth
-      - Layout/LineLength # renamed from Metrics/LineLength in rubocop 0.79.0
-      - Layout/ParameterAlignment
-      - Layout/TrailingBlankLines # renamed to Layout/TrailingEmptyLines in rubocop 0.77
-      - Layout/TrailingEmptyLines
-      - Layout/TrailingWhitespace
-      - Metrics/BlockLength
-      - Metrics/BlockNesting
-      - Metrics/LineLength
-      - Naming/FileName
-      - Style/FrozenStringLiteralComment
-      - Style/IfUnlessModifier
-      - Style/Next
-      - Style/WhileUntilModifier
+    # Users can ignore cops using this configuration instead of editing their rubocop configuration.
+    # Mostly there for backward compatibility.
+    ignored_cops: []
 
   RubyComments:
     enabled: true
@@ -126,6 +105,9 @@ linters:
   TagName:
     enabled: true
 
+  TrailingEmptyLines:
+    enabled: true
+
   TrailingWhitespace:
     enabled: true
 

data/config/forced_rubocop_config.yml

@@ -0,0 +1,180 @@
+# These are some configurations that are required for RuboCop because:
+# * HAML-Lint compiles ruby code with a particular format. If the rules mis-match that format,
+#   HAML-Lint would generate lints that the user cannot fix.
+# * HAML-Lint can autocorrect code only if the result matches some specific format
+#
+# So these configuration should not be overwritable by users.
+
+Layout/ArgumentAlignment:
+  # The alternative, with_fixed_indentation, breaks because we sometimes remove indentation when
+  # dealing with multi-line scripts. (Because a line starting with "=" adds a "HL.out = " to the
+  # intermediary Ruby source, which requires indentation, and the removal of the indentation)
+  EnforcedStyle: with_first_argument
+
+Layout/ArrayAlignment:
+  # The alternative, with_fixed_indentation, breaks because we sometimes remove indentation when
+  # dealing with multi-line scripts. (Because a line starting with "=" adds a "HL.out = " to the
+  # intermediary Ruby source, which requires indentation, and the removal of the indentation)
+  EnforcedStyle: with_first_element
+
+# In Haml, there are edge cases when `when` is indented, such as this one:
+# - case 1
+#   - when 1
+#   - when 2
+#     foo
+# This generates 2 `end` when building Ruby.
+# So it's safer to make the `when` be not indented, to avoid auto-correct chains that could turn
+# a valid `if` into an invalid `case` such as above.
+Layout/CaseIndentation:
+  Enabled: true
+  EnforcedStyle: end
+  IndentOneStep: false # Need to force the `false`
+
+# Need this cop so that code gets formatted similarly to Haml's indentation,
+# since HAML-Lint relies on Ruby's indentation being the same as Haml's.
+Layout/ElseAlignment:
+  Enabled: true
+
+# Need this cop so that code gets formatted similarly to Haml's indentation,
+# since HAML-Lint relies on Ruby's indentation being the same as Haml's.
+Layout/EndAlignment:
+  EnforcedStyleAlignWith: start_of_line
+  Enabled: true
+
+# We generate the ruby content, this is basically useless and should be a lint in HAML-Lint
+Layout/EndOfLine:
+  Enabled: false
+
+# Turning this cop on can turn
+# = content_tag(:span) do
+#   - foo
+#   - bar
+#
+# Into
+# - HL.out =
+#   - content_tag(:span) do
+#     - foo
+#     - bar
+#
+# Which is wrong... It would take too much analysis to detect and fix that situation.
+Layout/MultilineAssignmentLayout:
+  Enabled: false
+
+Layout/ParameterAlignment:
+  # The alternative, with_fixed_indentation, breaks because we sometimes remove indentation when
+  # dealing with multi-line scripts. (Because a line starting with "=" adds a "HL.out = " to the
+  # intermediary Ruby source, which requires indentation, and the removal of the indentation)
+  EnforcedStyle: with_first_parameter
+
+# HamlLint generate lots of extra code which would make blocks much longer
+Metrics/BlockLength:
+  Enabled: false
+
+# The nesting may be due to the html's nesting nature... These lints are probably not helpful
+Metrics/BlockNesting:
+  Enabled: false
+
+# The file names are generated by HamlLint, so any related lint would be unfixable by the user
+Naming/FileName:
+  Enabled: false
+
+# HAML doesn't properly support multiline blocks using { }, only using do/end.
+# If you don't consider the { } block for indentation, things "works", but the indentation is misleading.
+# For example, this works:
+# - a = lambda {
+# - if abc
+#  - something
+# - }
+# But if you indented the 2 lines within { }, then HAML would add an extra `end` and the generated
+# ruby would be invalid.
+Style/BlockDelimiters:
+  # So we need this cop to cleanup those cases and turn them to `end`.
+  Enabled: true
+  EnforcedStyle: line_count_based
+  # We don't allow the default "Can be anything" exception for lambda/proc
+  <%= rubocop_version < '1.33' ? 'IgnoredMethods' : 'AllowedMethods' %>: []
+
+# We don't support correcting HAML comments
+Style/CommentAnnotation:
+  AutoCorrect: false
+
+# If this was enabled, the equal sign would bubble up in a if like this:
+#   - if a
+#     = abc
+#   - else
+#     = bcd
+# Into:
+#   = if a
+#     - abc
+#   - else
+#     - bcd
+# Feels like this might be annoying or less visibly intuitive.
+Style/ConditionalAssignment:
+  Enabled: false
+
+# If this gets added, it wont do anything anyways.
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+# Looking at the changelog, this cop has quite a few bugfixes over time.
+# It still has problematic behaviors for us, such as breaking a line into multiple
+# ones with high indentation, which doesn't work for haml
+Style/IfUnlessModifier:
+  AutoCorrect: false
+
+<% if rubocop_version >= '1.37.0' %>
+# This new cop can trigger on the here-doc we use for filters that contain interpolation.
+# Ex:
+# :javascript
+#   hello #{world} \. bad escape
+Style/RedundantStringEscape:
+  Enabled: false
+<% end %>
+
+# In some case, this cop can cause a change in the spacing.
+# In HAML 5.2, going from (absurd example for clarity):
+#   = 'abc' rescue nil
+#   = 'def'
+# to:
+#   = begin
+#     - 'abc'
+#   - rescue StandardError
+#     - nil
+#   = 'def'
+# Will remove the only whitespace (a \n) that is between the abc and the def.
+# This could affect spacing, ex: seeing "abc def" become "abcdef" when rendering
+# after running this auto-correct
+Style/RescueModifier:
+  AutoCorrect: false
+
+# Cops that remove commas can be a problem when lines are split on multiple ones.
+# If we have a big array on more than one line, the removal of the comma generates
+# invalid HAML
+Style/SymbolArray:
+  Enabled: false
+
+# This can easily change the order of the markers in the document, which result in un-transferable corrections
+Style/UnlessElse:
+  AutoCorrect: false
+
+# If an array of strings was on multiple lines, this cop will make a %w(...) on multiple lines.
+# Without the comma at the end of the first line, there the resulting HAML will be invalid, since the only
+# case where a script can change line is after a comma.
+Style/WordArray:
+  AutoCorrect: false
+
+# Not RuboCop's job
+Layout/TrailingEmptyLines:
+  Enabled: false
+
+<% if rubocop_version < '1.8.1' %>
+# There were a few bugs with this cop that got fixed in this version.
+# Before, those bugs would generate invalid Ruby code and that would make it look like HAML-lint is
+# responsible, at least from the user's point of view.
+Style/StringConcatenation:
+  Enabled: false
+<% end %>
+
+# There is already a linter dedicated to this in haml-lint
+Layout/LineLength:
+  Enabled: false

data/lib/haml_lint/adapter/haml_4.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'forwardable'
+
 module HamlLint
   class Adapter
     # Adapts the Haml::Parser from Haml 4 for use in HamlLint
@@ -16,9 +18,21 @@ module HamlLint
       # @param source [String] Haml code to parse
       # @param options [Haml::Options]
       def initialize(source, options = Haml::Options.new)
+        @source = source
         @parser = Haml::Parser.new(source, options)
       end
 
+      def precompile
+        # Haml uses the filters as part of precompilation... we don't care about those,
+        # but without this tweak, it would fail on filters that are not loaded.
+        real_defined = Haml::Filters.defined
+        Haml::Filters.instance_variable_set(:@defined, Hash.new { real_defined['plain'] })
+
+        ::Haml::Engine.new(source).precompiled
+      ensure
+        Haml::Filters.instance_variable_set(:@defined, real_defined)
+      end
+
       # @!method
       #   Parses the source code into an abstract syntax tree
       #
@@ -37,6 +51,12 @@ module HamlLint
       # @api private
       # @return [Haml::Parser] the Haml 4 parser
       attr_reader :parser
+
+      # The Haml code to parse
+      #
+      # @api private
+      # @return [String] Haml code to parse
+      attr_reader :source
     end
   end
 end

data/lib/haml_lint/adapter/haml_5.rb

@@ -30,6 +30,17 @@ module HamlLint
         parser.call(source)
       end
 
+      def precompile
+        # Haml uses the filters as part of precompilation... we don't care about those,
+        # but without this tweak, it would fail on filters that are not loaded.
+        real_defined = Haml::Filters.defined
+        Haml::Filters.instance_variable_set(:@defined, Hash.new { real_defined['plain'] })
+
+        ::Haml::Engine.new(source).precompiled
+      ensure
+        Haml::Filters.instance_variable_set(:@defined, real_defined)
+      end
+
       private
 
       # The Haml parser to adapt for HamlLint

data/lib/haml_lint/adapter/haml_6.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module HamlLint
+  class Adapter
+    # Adapts the Haml::Parser from Haml 5 for use in HamlLint
+    # :reek:UncommunicativeModuleName
+    class Haml6 < Adapter
+      # Parses the specified Haml code into an abstract syntax tree
+      #
+      # @example
+      #   HamlLint::Adapter::Haml6.new('%div')
+      #
+      # @api public
+      # @param source [String] Haml code to parse
+      # @param options [private Haml::Parser::ParserOptions]
+      def initialize(source, options = {})
+        @source = source
+        @parser = Haml::Parser.new(options)
+      end
+
+      # Parses the source code into an abstract syntax tree
+      #
+      # @example
+      #   HamlLint::Adapter::Haml6.new('%div').parse
+      #
+      # @api public
+      # @return [Haml::Parser::ParseNode]
+      # @raise [Haml::Error]
+      def parse
+        parser.call(source)
+      end
+
+      def precompile
+        # Haml uses the filters as part of precompilation... we don't care about those,
+        # but without this tweak, it would fail on filters that are not loaded.
+        real_defined = Haml::Filters.registered
+        Haml::Filters.instance_variable_set(:@registered, Hash.new { real_defined['plain'] })
+
+        ::Haml::Engine.new.call(source)
+      ensure
+        Haml::Filters.instance_variable_set(:@registered, real_defined)
+      end
+
+      private
+
+      # The Haml parser to adapt for HamlLint
+      #
+      # @api private
+      # @return [Haml::Parser] the Haml 4 parser
+      attr_reader :parser
+
+      # The Haml code to parse
+      #
+      # @api private
+      # @return [String] Haml code to parse
+      attr_reader :source
+    end
+  end
+end

data/lib/haml_lint/adapter.rb

@@ -2,6 +2,7 @@
 
 require 'haml_lint/adapter/haml_4'
 require 'haml_lint/adapter/haml_5'
+require 'haml_lint/adapter/haml_6'
 require 'haml_lint/exceptions'
 
 module HamlLint
@@ -20,6 +21,7 @@ module HamlLint
       case version
       when '~> 4.0' then HamlLint::Adapter::Haml4
       when '~> 5.0', '~> 5.1', '~> 5.2' then HamlLint::Adapter::Haml5
+      when '~> 6.0', '~> 6.0.a', '~> 6.1', '~> 6.2' then HamlLint::Adapter::Haml6
       else fail HamlLint::Exceptions::UnknownHamlVersion, "Cannot handle Haml version: #{version}"
       end
     end

data/lib/haml_lint/cli.rb

@@ -7,7 +7,7 @@ require 'sysexits'
 
 module HamlLint
   # Command line application interface.
-  class CLI # rubocop:disable Metrics/ClassLength
+  class CLI
     # Create a CLI that outputs to the specified logger.
     #
     # @param logger [HamlLint::Logger]
@@ -34,9 +34,14 @@ module HamlLint
     # Given the provided options, execute the appropriate command.
     #
     # @return [Integer] exit status code
-    def act_on_options(options)
+    def act_on_options(options) # rubocop:disable Metrics
       configure_logger(options)
-
+      if options[:debug]
+        ENV['HAML_LINT_DEBUG'] = 'true'
+      end
+      if options[:internal_debug]
+        ENV['HAML_LINT_INTERNAL_DEBUG'] = 'true'
+      end
       if options[:help]
         print_help(options)
         Sysexits::EX_OK

data/lib/haml_lint/configuration_loader.rb

@@ -2,6 +2,7 @@
 
 require 'pathname'
 require 'yaml'
+require 'erb'
 
 module HamlLint
   # Manages configuration file loading.
@@ -31,7 +32,7 @@ module HamlLint
       def default_path_to_config
         directory = File.expand_path(Dir.pwd)
         config_file = possible_config_files(directory).find(&:file?)
-        config_file ? config_file.to_path : nil
+        config_file&.to_path
       end
 
       # Loads the built-in default configuration.
@@ -48,13 +49,20 @@ module HamlLint
       # @option context :exclude_files [Array<String>] files that should not
       #   be loaded even if they're requested via inherits_from
       # @return [HamlLint::Configuration]
-      def load_file(file, context = {})
+      def load_file(file, context = {}) # rubocop:disable Metrics
         context[:loaded_files] ||= []
+        context[:loaded_files].map! { |config_file| File.expand_path(config_file) }
         context[:exclude_files] ||= []
-        config = load_from_file(file)
+        context[:exclude_files].map! { |config_file| File.expand_path(config_file) }
+        config = load_from_file(File.expand_path(file))
 
-        [default_configuration, resolve_inheritance(config, context), config]
-          .reduce { |acc, elem| acc.merge(elem) }
+        configs = if context[:loaded_files].any?
+                    [resolve_inheritance(config, context), config]
+                  else
+                    [default_configuration, resolve_inheritance(config, context), config]
+                  end
+
+        configs.reduce { |acc, elem| acc.merge(elem) }
       rescue Psych::SyntaxError, Errno::ENOENT => e
         raise HamlLint::Exceptions::ConfigurationError,
               "Unable to load configuration from '#{file}': #{e}",
@@ -78,19 +86,29 @@ module HamlLint
       #
       # @param file [String]
       # @return [HamlLint::Configuration]
-      def load_from_file(file)
-        hash =
-          if yaml = YAML.load_file(file)
-            yaml.to_hash
-          else
-            {}
-          end
+      def load_from_file(file) # rubocop:disable Metrics
+        content = File.read(file)
+
+        processed_content = HamlLint::Utils.process_erb(content)
+        hash = (YAML.safe_load(processed_content) || {}).to_hash
 
         if hash.key?('inherit_from')
           hash['inherits_from'] ||= []
           hash['inherits_from'].concat(Array(hash.delete('inherit_from')))
         end
 
+        if hash.key?('inherit_gem')
+          hash['inherits_from'] ||= []
+
+          gems = hash.delete('inherit_gem')
+          (gems || {}).each_pair.reverse_each do |gem_name, config_path|
+            Array(config_path).reverse_each do |path|
+              # Put gem configuration first so local configuration overrides it.
+              hash['inherits_from'].unshift gem_config_path(gem_name, path)
+            end
+          end
+        end
+
         HamlLint::Configuration.new(hash, file)
       end
 
@@ -129,10 +147,28 @@ module HamlLint
       # @return [HamlLint::Configuration]
       def resolve_inheritance(config, context)
         Array(config['inherits_from'])
-          .map { |config_file| resolve(config_file, context) }
+          .map { |config_file| resolve(File.expand_path(config_file), context) }
           .compact
           .reduce { |acc, elem| acc.merge(elem) } || config
       end
+
+      # Resolves the config file path relative to a gem
+      #
+      # @param gem_name [String] name of the gem
+      # @param relative_config_path [String] path of the file to resolve, relative to the gem root
+      # @return [String]
+      def gem_config_path(gem_name, relative_config_path)
+        if defined?(Bundler)
+          gem = Bundler.load.specs[gem_name].first
+          gem_path = gem.full_gem_path if gem
+        end
+
+        gem_path ||= Gem::Specification.find_by_name(gem_name).gem_dir
+
+        File.join(gem_path, relative_config_path)
+      rescue Gem::LoadError => e
+        raise Gem::LoadError, "Unable to find gem #{gem_name}; is the gem installed? #{e}"
+      end
     end
   end
 end

data/lib/haml_lint/document.rb

@@ -23,6 +23,14 @@ module HamlLint
     # @return [Array<String>] original source code as an array of lines
     attr_reader :source_lines
 
+    # @return [Boolean] true if the source was changed (by autocorrect)
+    attr_reader :source_was_changed
+
+    # @return [String] the indentation used in the file
+    attr_reader :indentation
+
+    attr_reader :unescape_interpolation_to_original_cache
+
     # Parses the specified Haml code into a {Document}.
     #
     # @param source [String] Haml code to parse
@@ -32,22 +40,80 @@ module HamlLint
     def initialize(source, options)
       @config = options[:config]
       @file = options.fetch(:file, STRING_SOURCE)
-
+      @source_was_changed = false
       process_source(source)
     end
 
+    # Returns the last non empty line of the document or 1 if all lines are empty
+    #
+    # @return [Integer] last non empty line of the document or 1 if all lines are empty
+    def last_non_empty_line
+      index = source_lines.rindex { |l| !l.empty? }
+      (index || 0) + 1
+    end
+
+    # Reparses the new source and remember that the document was changed
+    # Used when auto-correct does changes to the file. If the source hasn't changed,
+    # then the document will not be marked as changed.
+    #
+    # If the new_source fails to parse, automatically reparses the previous source
+    # to bring the document back to how it should be before re-raising the parse exception
+    #
+    # @param source [String] Haml code to parse
+    def change_source(new_source)
+      return if new_source == @source
+      check_new_source_compatible(new_source)
+
+      old_source = @source
+      begin
+        process_source(new_source)
+        @source_was_changed = true
+      rescue HamlLint::Exceptions::ParseError
+        # Reprocess the previous_source so that other linters can work on this document
+        # object from a clean slate
+        process_source(old_source)
+        raise
+      end
+      nil
+    end
+
+    def write_to_disk!
+      return unless @source_was_changed
+      if file == STRING_SOURCE
+        raise HamlLint::Exceptions::InvalidFilePath, 'Cannot write without :file option'
+      end
+      File.write(file, unstrip_frontmatter(source))
+      @source_was_changed = false
+    end
+
     private
 
     # @param source [String] Haml code to parse
     # @raise [HamlLint::Exceptions::ParseError] if there was a problem parsing
-    def process_source(source)
+    def process_source(source) # rubocop:disable Metrics/MethodLength
       @source = process_encoding(source)
       @source = strip_frontmatter(source)
-      @source_lines = @source.split(/\r\n|\r|\n/)
-
-      @tree = process_tree(HamlLint::Adapter.detect_class.new(@source).parse)
+      # the -1 is to keep the empty strings at the end of the array when the source
+      # ended with multiple new-lines
+      @source_lines = @source.split(/\r\n|\r|\n/, -1)
+      adapter = HamlLint::Adapter.detect_class.new(@source)
+      parsed_tree = adapter.parse
+      @indentation = adapter.send(:parser).instance_variable_get(:@indentation)
+      @tree = process_tree(parsed_tree)
+      @unescape_interpolation_to_original_cache =
+        Haml::Util.unescape_interpolation_to_original_cache_take_and_wipe
     rescue Haml::Error => e
-      error = HamlLint::Exceptions::ParseError.new(e.message, e.line)
+      location = if e.line
+                   "#{@file}:#{e.line}"
+                 else
+                   @file
+                 end
+      msg = if ENV['HAML_LINT_DEBUG'] == 'true'
+              "#{location} (DEBUG: source follows) - #{e.message}\n#{source}\n------"
+            else
+              "#{location} - #{e.message}"
+            end
+      error = HamlLint::Exceptions::ParseError.new(msg, e.line)
       raise error
     end
 
@@ -114,11 +180,26 @@ module HamlLint
         (---|\.\.\.)\s*$\n?/mx
 
       if config['skip_frontmatter'] && match = source.match(frontmatter)
-        newlines = match[0].count("\n")
-        source.sub!(frontmatter, "\n" * newlines)
+        @stripped_frontmatter = match[0]
+        @nb_newlines_for_frontmatter = match[0].count("\n")
+        source.sub!(frontmatter, "\n" * @nb_newlines_for_frontmatter)
       end
 
       source
     end
+
+    def check_new_source_compatible(new_source)
+      if @stripped_frontmatter && !new_source.start_with?("\n" * @nb_newlines_for_frontmatter)
+        raise HamlLint::Exceptions::IncompatibleNewSource,
+              "Internal error: new_source doesn't start with enough newlines for the Front Matter that was stripped"
+      end
+    end
+
+    def unstrip_frontmatter(source)
+      return source unless @stripped_frontmatter
+      check_new_source_compatible(source)
+
+      source.sub("\n" * @nb_newlines_for_frontmatter, @stripped_frontmatter)
+    end
   end
 end

data/lib/haml_lint/exceptions.rb

@@ -5,6 +5,12 @@ module HamlLint::Exceptions
   # Raised when a {Configuration} could not be loaded from a file.
   class ConfigurationError < StandardError; end
 
+  # Raised trying to change source with incompatible one (ex: due to frontmatter)
+  class IncompatibleNewSource < StandardError; end
+
+  # Raised when linter's autocorrection cause an infinite loop
+  class InfiniteLoopError < StandardError; end
+
   # Raised when invalid/incompatible command line options are provided.
   class InvalidCLIOption < StandardError; end