yard-lint 1.6.1 → 1.7.0

data/lib/yard/lint/validators/tags/example_syntax/validator.rb

@@ -18,15 +18,22 @@ module Yard
             def in_process_query(object, collector)
               return unless object.has_tag?(:example)
 
+              skip_non_ruby = config_or_default('SkipNonRuby')
               example_tags = object.tags(:example)
 
               example_tags.each_with_index do |example, index|
                 code = example.text
                 next if code.nil? || code.empty?
 
-                # Clean the code: strip output indicators (#=>) and everything after it
+                # Opt-in: an interactive console transcript is not runnable Ruby,
+                # so skip it rather than reporting its prompts as syntax errors.
+                next if skip_non_ruby && console_transcript?(code)
+
+                # Clean the code: strip YARD output indicators (# =>) and
+                # everything after them, but only when the "# =>" is a real
+                # trailing comment - not when it appears inside a string literal
                 code_lines = code.split("\n").map do |line|
-                  line.sub(/\s*#\s*=>.*$/, '')
+                  strip_output_marker(line)
                 end
 
                 cleaned_code = code_lines.join("\n").strip
@@ -51,7 +58,7 @@ module Yard
                   $VERBOSE = nil
                   RubyVM::InstructionSequence.compile(cleaned_code)
                 rescue SyntaxError => e
-                  example_name = example.name || "Example #{index + 1}"
+                  example_name = example.name.to_s.empty? ? "Example #{index + 1}" : example.name
                   collector.puts "#{object.file}:#{object.line}: #{object.title}"
                   collector.puts 'syntax_error'
                   collector.puts example_name
@@ -67,6 +74,70 @@ module Yard
                 end
               end
             end
+
+            private
+
+            # Matches a line that begins (after optional whitespace) with an
+            # interactive console prompt or REPL output marker:
+            #   >> / ?>      irb input / continuation
+            #   =>           irb/pry result output
+            #   irb( irb>    irb prompt
+            #   pry( / [n] pry(   pry prompt
+            #   $            shell prompt
+            CONSOLE_PROMPT = /\A\s*(?:>>|\?>|=>|\$\s|irb[\s(>]|(?:\[\d+\]\s*)?pry[\s(>])/.freeze
+
+            private_constant :CONSOLE_PROMPT
+
+            # Check whether an @example body is an interactive console transcript
+            # (irb/pry session or shell prompt) rather than runnable Ruby.
+            # @param code [String] the raw @example text
+            # @return [Boolean] true if any line looks like a console prompt/output
+            def console_transcript?(code)
+              code.each_line.any? { |line| line.match?(CONSOLE_PROMPT) }
+            end
+
+            # Removes a trailing YARD `# => result` output marker from a line of
+            # example code, but only when the `#` actually starts a comment - a
+            # `#` inside a string or character literal is left untouched, so a
+            # string such as `"result # => x"` is not corrupted into an
+            # unterminated literal.
+            # @param line [String] a single line of example source
+            # @return [String] the line with a trailing output marker removed
+            def strip_output_marker(line)
+              in_single = false
+              in_double = false
+              i = 0
+
+              while i < line.length
+                char = line[i]
+
+                if (in_single || in_double) && char == '\\'
+                  i += 2
+                  next
+                end
+
+                if in_single
+                  in_single = false if char == "'"
+                elsif in_double
+                  in_double = false if char == '"'
+                elsif char == "'"
+                  in_single = true
+                elsif char == '"'
+                  in_double = true
+                elsif char == '#'
+                  # A comment starts here (outside any string). Strip it only
+                  # when it is a YARD output marker; leave ordinary comments,
+                  # which the Ruby parser handles fine.
+                  return line[0...i].rstrip if line[i..].match?(/\A#\s*=>/)
+
+                  break
+                end
+
+                i += 1
+              end
+
+              line
+            end
           end
         end
       end

data/lib/yard/lint/validators/tags/forbidden_tags/validator.rb

@@ -18,7 +18,11 @@ module Yard
               patterns = forbidden_patterns
               return if patterns.empty?
 
-              object.docstring.tags.each do |tag|
+              # Include tags nested inside @overload blocks - they live on the
+              # overload's own docstring and are invisible to docstring.tags
+              forbidden_tag_names = patterns.map { |pattern| pattern['Tag'] }.compact.uniq
+
+              all_typed_tags(object.docstring, forbidden_tag_names).each do |tag|
                 patterns.each do |pattern|
                   next unless matches_pattern?(tag, pattern)
 
@@ -45,7 +49,7 @@ module Yard
               pattern_types = pattern['Types']
               return true if pattern_types.nil? || pattern_types.empty?
 
-              tag_types = tag.types || []
+              tag_types = tag_data(tag).types || []
               (tag_types & pattern_types).any?
             end
 
@@ -54,7 +58,7 @@ module Yard
             # @param pattern [Hash] the matched pattern
             # @return [String] details line for parser
             def build_details(tag, pattern)
-              types_text = (tag.types || []).join(',')
+              types_text = (tag_data(tag).types || []).join(',')
               pattern_types = (pattern['Types'] || []).join(',')
               "#{tag.tag_name}|#{types_text}|#{pattern_types}"
             end

data/lib/yard/lint/validators/tags/informal_notation/config.rb

@@ -13,6 +13,11 @@ module Yard
               'Severity' => 'warning',
               'CaseSensitive' => false,
               'RequireStartOfLine' => true,
+              # Opt-in: also skip 4-space (or tab) indented Markdown code blocks,
+              # not just fenced (```) blocks. Off by default because indented
+              # content is also used for list continuations and wrapped prose,
+              # which would then be skipped too.
+              'SkipIndentedCodeBlocks' => false,
               'Patterns' => {
                 'Note' => '@note',
                 'IMPORTANT' => '@note',
@@ -22,7 +27,7 @@ module Yard
                 'FIXME' => '@todo',
                 'See' => '@see',
                 'See also' => '@see',
-                'Warning' => '@deprecated',
+                'Warning' => '@note',
                 'Deprecated' => '@deprecated',
                 'Author' => '@author',
                 'Version' => '@version',

data/lib/yard/lint/validators/tags/informal_notation/validator.rb

@@ -19,16 +19,19 @@ module Yard
             def in_process_query(object, collector)
               docstring_text = object.docstring.to_s
               return if docstring_text.empty?
+              return if duplicate_docstring?(object)
 
               patterns = config_patterns
               case_sensitive = config_case_sensitive
               require_start = config_require_start_of_line
+              skip_indented = config_skip_indented_code_blocks
 
               found_patterns = find_informal_patterns(
                 docstring_text,
                 patterns,
                 case_sensitive,
-                require_start
+                require_start,
+                skip_indented
               )
 
               return if found_patterns.empty?
@@ -37,7 +40,8 @@ module Yard
               # Line 1: file:line: object_title
               # Line 2: pattern|replacement|line_offset|line_text (pipe-separated)
               found_patterns.each do |match|
-                collector.puts "#{object.file}:#{object.line}: #{object.title}"
+                line = docstring_line(object, match[:line_offset])
+                collector.puts "#{object.file}:#{line}: #{object.title}"
                 collector.puts "#{match[:pattern]}|#{match[:replacement]}|" \
                                "#{match[:line_offset]}|#{match[:line_text]}"
               end
@@ -50,8 +54,9 @@ module Yard
             # @param patterns [Hash] pattern => replacement mapping
             # @param case_sensitive [Boolean] whether to match case-sensitively
             # @param require_start [Boolean] whether pattern must be at start of line
+            # @param skip_indented [Boolean] whether to also skip indented code blocks
             # @return [Array<Hash>] array of matches with pattern, replacement, line_offset, line_text
-            def find_informal_patterns(docstring_text, patterns, case_sensitive, require_start)
+            def find_informal_patterns(docstring_text, patterns, case_sensitive, require_start, skip_indented = false)
               found_patterns = []
               matched_lines = Set.new
               in_code_block = false
@@ -66,6 +71,9 @@ module Yard
                 # Skip lines inside code blocks
                 next if in_code_block
 
+                # Optionally skip 4-space/tab indented Markdown code blocks
+                next if skip_indented && indented_code_line?(line)
+
                 # Skip lines already matched (avoids duplicate reports for similar patterns)
                 next if matched_lines.include?(line_offset)
 
@@ -87,6 +95,14 @@ module Yard
               found_patterns
             end
 
+            # Check if a line is part of a Markdown indented code block
+            # (4+ leading spaces or a leading tab, with non-whitespace content).
+            # @param line [String] the raw docstring line
+            # @return [Boolean] true if the line is indented code
+            def indented_code_line?(line)
+              line.match?(/\A(?: {4}|\t)/) && !line.strip.empty?
+            end
+
             # Check if a line matches the informal pattern
             # @param line [String] the line to check
             # @param pattern [String] the pattern to match (without colon)
@@ -125,6 +141,11 @@ module Yard
             def config_require_start_of_line
               config_or_default('RequireStartOfLine')
             end
+
+            # @return [Boolean] whether to skip indented Markdown code blocks
+            def config_skip_indented_code_blocks
+              config_or_default('SkipIndentedCodeBlocks')
+            end
           end
         end
       end

data/lib/yard/lint/validators/tags/invalid_types/config.rb

@@ -12,7 +12,13 @@ module Yard
               'Enabled' => true,
               'Severity' => 'warning',
               'ValidatedTags' => %w[param option return yieldreturn yieldparam raise],
-              'ExtraTypes' => []
+              'ExtraTypes' => [],
+              # Opt-in: when true, a CamelCase type name that is neither a loaded
+              # Ruby constant nor resolvable in the analyzed codebase's YARD
+              # registry is flagged (catches typos like `Strng`). Off by default
+              # because YARD does not load the project, so types defined only in
+              # un-analyzed dependencies would otherwise be reported.
+              'StrictConstantNames' => false
             }.freeze
           end
         end

data/lib/yard/lint/validators/tags/invalid_types/parser.rb

@@ -10,8 +10,12 @@ module Yard
           #   /path/to/file.rb:10: ClassName#method_name
           #   @tagname param_name:BadType1,BadType2|@tagname2:BadType3
           class Parser < Parsers::Base
-            # @return [Regexp] matches "file:line: ClassName#method"
-            LOCATION_REGEX = /^(.+):(\d+):\s+(.+)[#.](.+)$/
+            # @return [Regexp] matches "file:line: ObjectTitle"
+            LOCATION_REGEX = /^(.+):(\d+):\s+(.+)$/
+            # @return [Regexp] splits a title into namespace and method name on
+            #   the last # or . separator; titles without one (e.g. CONST,
+            #   Foo::Bar) are kept whole
+            TITLE_REGEX = /\A(.*)[#.]([^#.]+)\z/
             # @return [Regexp] matches the tag violations line (starts with @)
             TAG_VIOLATIONS_REGEX = /^@/
 
@@ -23,18 +27,22 @@ module Yard
               i = 0
 
               while i < lines.size
-                match = lines[i].match(LOCATION_REGEX)
+                # Violation lines (starting with @) must never be consumed as
+                # location lines, even if they happen to match the loose regex
+                match = lines[i].match?(TAG_VIOLATIONS_REGEX) ? nil : lines[i].match(LOCATION_REGEX)
 
                 unless match
                   i += 1
                   next
                 end
 
+                class_name, method_name = split_title(match[3])
+
                 offense = {
                   location: match[1],
                   line: match[2].to_i,
-                  class_name: match[3],
-                  method_name: match[4],
+                  class_name: class_name,
+                  method_name: method_name,
                   tag_violations: []
                 }
 
@@ -54,6 +62,15 @@ module Yard
 
             private
 
+            # Splits a YARD object title into namespace and method name parts
+            # @param title [String] object title (e.g. "Foo#bar", "#bar", "CONST")
+            # @return [Array(String, String)] namespace and method name; for titles
+            #   without a separator both parts are the full title
+            def split_title(title)
+              match = title.match(TITLE_REGEX)
+              match ? [match[1], match[2]] : [title, title]
+            end
+
             # Parse "tagname param:Type1,Type2|tagname2:Type3" into structured data
             # @param line [String] the violations line
             # @return [Array<Hash>] each entry has :tag, :param (may be nil), :types

data/lib/yard/lint/validators/tags/invalid_types/validator.rb

@@ -22,6 +22,7 @@ module Yard
               undefined
               unspecified
               unknown
+              Boolean
             ].freeze
 
             private_constant :ALLOWED_DEFAULTS
@@ -34,17 +35,18 @@ module Yard
             def in_process_query(object, collector)
               checked_tags = config_or_default('ValidatedTags')
               extra_types = config_or_default('ExtraTypes')
+              strict = config_or_default('StrictConstantNames')
               allowed_types = ALLOWED_DEFAULTS + extra_types
 
               # Collect per-tag violations to surface in the offense message.
               # Each entry is "tagname param_name:Type1,Type2" (param_name omitted when nil).
               tag_violations = all_typed_tags(object.docstring, checked_tags).filter_map do |tag|
-                bad = (tag.types || [])
+                bad = (tag_data(tag).types || [])
                         .compact
                         .flat_map { |type| extract_type_names(type) }
                         .uniq
                         .reject { |type| allowed_types.include?(type) }
-                        .reject { |type| type_defined?(type) }
+                        .reject { |type| type_defined?(type, strict: strict) }
                         .reject { |type| type.include?('#') }
                 next if bad.empty?
 
@@ -73,17 +75,16 @@ module Yard
             # Check if a type is defined in Ruby runtime or YARD registry
             # In in-process mode, parsed classes are in YARD registry but not loaded into Ruby
             # @param type [String] type name to check
+            # @param strict [Boolean] when true, a syntactically valid but unknown
+            #   constant name (e.g. a typo) is treated as undefined instead of recognized
             # @return [Boolean] true if type is defined (or at least recognized as a valid type)
-            def type_defined?(type)
+            def type_defined?(type, strict: false)
               # Symbol and string literal types (:foo, "bar") are valid hash key notations
               return true if type.start_with?(':', '"', "'")
 
-              # Check Ruby runtime first
-              # The shell query uses: !(Kernel.const_defined?(type) rescue nil).nil?
-              # This means: if const_defined? returns ANY value (true or false, not nil),
-              # the type is considered "recognized" and should not be flagged as invalid.
-              # This allows common types like "Boolean" which aren't actual Ruby classes
-              # but are still recognized by Ruby as valid constant names to check.
+              # Check Ruby runtime first.
+              # const_defined? returns true (loaded constant), false (valid name but
+              # not loaded), or raises NameError (invalid constant syntax).
               begin
                 const_result = Kernel.const_defined?(type)
               rescue NameError
@@ -91,7 +92,20 @@ module Yard
                 # These aren't valid Ruby constants, so we can't check them this way
                 const_result = nil
               end
-              return true unless const_result.nil?
+
+              if strict
+                # Strict mode: only a constant actually loaded in this process
+                # (Ruby core/stdlib) is accepted outright. A valid-but-unloaded
+                # name (const_result == false) or invalid syntax (nil) still gets
+                # the YARD registry check below, so codebase-defined types pass but
+                # unknown CamelCase names (typos) are flagged.
+                return true if const_result == true
+              else
+                # Lenient (default): any syntactically valid constant name is
+                # accepted, because YARD does not load the project's code so most
+                # real types are not const_defined? in this process.
+                return true unless const_result.nil?
+              end
 
               # Check YARD registry (for classes defined in parsed files)
               # This may fail for malformed type strings or registry issues

data/lib/yard/lint/validators/tags/missing_yield/validator.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'ripper'
+
 module Yard
   module Lint
     module Validators
@@ -12,11 +14,15 @@ module Yard
 
             # Matches the `yield` keyword. The negative lookbehind `(?<![:.])`
             # prevents matching method calls like `Fiber.yield` or `yielder.yield`
-            # and symbol literals like `:yield`. Word boundaries ensure `yield_self`
-            # and similar identifiers are not matched.
+            # and symbol literals like `:yield`. The negative lookahead `(?!:)`
+            # prevents matching the label form - a symbol hash key or keyword
+            # argument like `{ yield: true }` (a real block yield is never
+            # directly followed by a colon: `yield ::Const` has a space).
+            # Word boundaries ensure `yield_self` and similar identifiers are
+            # not matched.
             # Known limitation: `yield` inside regex literals (e.g. /yield/) is
             # not stripped before scanning; it is rare enough to be acceptable.
-            YIELD_PATTERN = /(?<![:.])\byield\b/.freeze
+            YIELD_PATTERN = /(?<![:.])\byield\b(?!:)/.freeze
 
             # @return [Regexp] matches full-line Ruby comments
             COMMENT_LINE_PATTERN = /\A\s*#/.freeze
@@ -58,8 +64,42 @@ module Yard
             end
 
             # @param source [String] raw method source code
-            # @return [Boolean] true if the source contains the `yield` keyword
+            # @return [Boolean] true if the method itself yields (ignoring yields
+            #   that belong to a nested method definition)
             def source_contains_yield?(source)
+              sexp = ::Ripper.sexp(source)
+              # If the isolated source does not parse on its own, fall back to the
+              # line scan rather than silently missing a yield.
+              return yield_in_lines?(source) if sexp.nil?
+
+              method_level_yield?(sexp)
+            end
+
+            # Walks the Ripper S-expression for a `yield` that belongs to the
+            # method being analysed - one nested directly inside this definition
+            # rather than inside a nested `def`. `def_depth` counts enclosing
+            # method definitions; the analysed method's own body is depth 1, so a
+            # yield inside a nested `def` (depth 2+) is correctly ignored.
+            # @param node [Object] a Ripper S-expression node
+            # @param def_depth [Integer] number of enclosing `def`/`defs` nodes
+            # @return [Boolean] true if a yield at the method's own level is found
+            def method_level_yield?(node, def_depth = 0)
+              return false unless node.is_a?(::Array)
+
+              case node.first
+              when :yield, :yield0
+                return def_depth == 1
+              when :def, :defs
+                return node.any? { |child| method_level_yield?(child, def_depth + 1) }
+              end
+
+              node.any? { |child| method_level_yield?(child, def_depth) }
+            end
+
+            # Line-based fallback used when Ripper cannot parse the source.
+            # @param source [String] raw method source code
+            # @return [Boolean] true if a `yield` keyword appears on a code line
+            def yield_in_lines?(source)
               source.each_line.any? do |line|
                 next false if line.match?(COMMENT_LINE_PATTERN)
 

data/lib/yard/lint/validators/tags/missing_yield.rb

@@ -13,14 +13,6 @@ module Yard
         #
         # This validator is disabled by default (opt-in).
         #
-        # @note Does not flag the inverse case (has `@yield` tag but no actual
-        #   `yield` in source) - that is intentional for abstract/overridable methods.
-        #
-        # @note Known limitation: `yield` appearing inside heredoc bodies or
-        #   multi-line string literals may produce false positives. These cases
-        #   are rare enough in practice that the validator does not attempt to
-        #   handle them.
-        #
         # @example Bad - method yields but block is undocumented
         #   # Iterates over items
         #   # @param items [Array] the items
@@ -43,6 +35,14 @@ module Yard
         #     items.each { |item| yield item }
         #   end
         #
+        # @note Does not flag the inverse case (has `@yield` tag but no actual
+        #   `yield` in source) - that is intentional for abstract/overridable methods.
+        #
+        # @note Known limitation: `yield` appearing inside heredoc bodies or
+        #   multi-line string literals may produce false positives. These cases
+        #   are rare enough in practice that the validator does not attempt to
+        #   handle them.
+        #
         # ## Configuration
         #
         #     Tags/MissingYield:

data/lib/yard/lint/validators/tags/non_ascii_type/validator.rb

@@ -14,6 +14,15 @@ module Yard
             # Pattern to match non-ASCII characters
             NON_ASCII_PATTERN = /[^\x00-\x7F]/
 
+            # Matches a string literal type (e.g. "naïve"). Such literals are
+            # values, not Ruby type names, so non-ASCII inside them is valid.
+            STRING_LITERAL = /\A("[^"]*"|'[^']*')\z/
+            # Matches a quoted-symbol literal type (e.g. :"naïve"); non-ASCII
+            # inside the quoted value is likewise valid.
+            QUOTED_SYMBOL_LITERAL = /\A:("[^"]*"|'[^']*')\z/
+
+            private_constant :STRING_LITERAL, :QUOTED_SYMBOL_LITERAL
+
             # Execute query for a single object during in-process execution.
             # Checks type specifications for non-ASCII characters.
             # @param object [YARD::CodeObjects::Base] the code object to query
@@ -21,12 +30,15 @@ module Yard
             # @return [void]
             def in_process_query(object, collector)
               validated_tags = config.validator_config('Tags/NonAsciiType', 'ValidatedTags') ||
-                               %w[param option return yieldreturn yieldparam]
+                               Config.defaults['ValidatedTags']
 
               all_typed_tags(object.docstring, validated_tags).each do |tag|
                 next unless tag.types
 
                 tag.types.each do |type_str|
+                  # Skip literal value types - non-ASCII is valid inside them.
+                  next if type_str.match?(STRING_LITERAL) || type_str.match?(QUOTED_SYMBOL_LITERAL)
+
                   non_ascii_chars = type_str.scan(NON_ASCII_PATTERN).uniq
                   next if non_ascii_chars.empty?
 

data/lib/yard/lint/validators/tags/option_tags/result.rb

@@ -28,6 +28,7 @@ module Yard
                   severity: configured_severity,
                   type: self.class.offense_type,
                   name: offense_data[:name] || self.class.offense_name,
+                  validator: validator_name,
                   message: build_message(offense_data),
                   location: offense_data[:location] || offense_data[:file],
                   location_line: offense_data[:line] || offense_data[:location_line] || 0

data/lib/yard/lint/validators/tags/option_tags/validator.rb

@@ -28,8 +28,15 @@ module Yard
 
               return unless has_options_param
 
-              # Check if method has any @option tags
-              option_tags = object.tags(:option)
+              # A parameter that merely has an options-like name but is
+              # documented as a non-Hash type (e.g. a Boolean keyword argument
+              # or an Array) is not an options hash, so do not demand @option.
+              return if options_param_documented_as_non_hash?(object, parameter_names)
+
+              # Check if method has any @option tags; tags nested inside
+              # overload blocks live on the overload's own docstring, so
+              # check those too
+              option_tags = all_typed_tags(object.docstring, %w[option])
 
               return unless option_tags.empty?
 
@@ -39,6 +46,27 @@ module Yard
 
             private
 
+            # Whether an options-named parameter is documented with a concrete
+            # non-Hash @param type. Such a parameter (e.g. `@param options
+            # [Boolean]`) is not an options hash and should not require @option.
+            # @param object [YARD::CodeObjects::MethodObject] the method
+            # @param parameter_names [Array<String>] configured options names
+            # @return [Boolean]
+            def options_param_documented_as_non_hash?(object, parameter_names)
+              param_tags = all_typed_tags(object.docstring, %w[param])
+
+              object.parameters.any? do |param|
+                name = param[0].to_s.gsub(/[*:]/, '')
+                next false unless parameter_names.include?(name)
+
+                tag = param_tags.find { |t| t.name == name }
+                types = tag&.types
+                next false if types.nil? || types.empty?
+
+                types.none? { |type| type.to_s.match?(/\AHash\b|\AHash[<{(]/) }
+              end
+            end
+
             # @return [Array<String>] parameter names that should have @option tags
             def config_parameter_names
               config.validator_config('Tags/OptionTags', 'ParameterNames') || Config.defaults['ParameterNames']

data/lib/yard/lint/validators/tags/order/parser.rb

@@ -40,12 +40,19 @@ module Yard
               end
 
               base_hash.delete_if { |_key, value| value == 'valid' }
-              order = base_hash.values.map(&:last)
 
-              Validators::Documentation::UndocumentedMethodArguments::Parser
-                .new
-                .call(base_hash.values.map(&:first).join("\n"))
-                .each.with_index { |element, index| element[:order] = order[index] }
+              location_parser = Validators::Documentation::UndocumentedMethodArguments::Parser.new
+
+              # Parse each location together with its own ordering so that an
+              # unparseable location line drops only its own offense instead of
+              # shifting the orderings of all offenses that follow it
+              base_hash.values.filter_map do |location, ordering|
+                element = location_parser.call(location).first
+                next unless element
+
+                element[:order] = ordering
+                element
+              end
             end
 
             private

data/lib/yard/lint/validators/tags/order/validator.rb

@@ -17,7 +17,9 @@ module Yard
             # @param collector [Executor::ResultCollector] collector for output
             # @return [void]
             def in_process_query(object, collector)
-              return if object.is_alias?
+              # is_alias? exists only on method objects; on namespace objects
+              # YARD's method_missing raises NameError, so guard by type first
+              return if object.type == :method && object.is_alias?
 
               # Extract @tag names from docstring
               tag_pattern = /^@(\S+)/
@@ -51,7 +53,10 @@ module Yard
 
             # @return [Array<String>] tags order
             def tags_order
-              config.validator_config('Tags/Order', 'EnforcedOrder')
+              # Fall back to the default when EnforcedOrder is unset or
+              # explicitly null in the config - otherwise `nil.dup` crashes
+              # the entire run.
+              config_or_default('EnforcedOrder')
             end
           end
         end