rubocop-exception_messages 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc8af98d6bdcef4ebe89488a40c7bbb813ca3a9cbc6c6c87e7ad9fa5a09a1127
-  data.tar.gz: e6f89e17ee748d3f978f4bf332a1ec7d3d9d6f1731ce6d5dbdf2fdb6bb39c852
+  metadata.gz: 30c6a33ca2d34e81294dc56ebfbc93487038a551befad0f019569e9622606635
+  data.tar.gz: 2302c462589b5aa9981c6c75bdb0cd25b3a76ed4e4c1e97e34a9bc6db9b051e9
 SHA512:
-  metadata.gz: debf11ec95b5b9533c58d471b44d142747437fe951c797fa5734723d6eab32ae945e511b24a179590d822155e859f85d983a85365af8a2b6cb3b858353df4b7b
-  data.tar.gz: f8cf2d88a4542efc375d5e9074f0efcee550266a2f69d18ada7dfccadddeb66850b6e7be8df8056d166f0a25c6f49f89bb539e13bb4b9c5984266b2124935ba0
+  metadata.gz: 656845e5a38eeff400ab2ad31c1ae62537ec57d577978a648f50c192f14a29ef58564bf8630701e83cda3f44738d502c4dd99f916b942e6c55e467fa19ae8fec
+  data.tar.gz: d1dcbe5ed3a6c9ac92548f3ed2892ace8797cb5354b1477635a009ef93f04de6b1b9161710b64750993495576a6a4dbba01a950f76a18272b3841b8d32c1768f

data/CHANGELOG.md

@@ -1,6 +1,11 @@
-### 0.1.0 (2026/09/05)
+### 0.2.0 (2026/09/05)
+
+* [#6](https://github.com/dblock/rubocop-exception_messages/pull/6): Add `EnforcedStyle` support to `ExceptionMessages/Casing` (`lowercase`/`uppercase`) and `ExceptionMessages/Punctuation` (`no_period`/`period`) to allow the opposite convention - [@dblock](https://github.com/dblock).
+* [#7](https://github.com/dblock/rubocop-exception_messages/pull/7): Add `ExceptionMessages/RedundantExceptionName` cop that flags exception messages redundantly repeating the exception class name - [@dblock](https://github.com/dblock).
+* [#8](https://github.com/dblock/rubocop-exception_messages/pull/8): Add `ExceptionMessages/QuoteStyle` cop that checks consistent quoting of interpolated values in exception messages - [@dblock](https://github.com/dblock).
+* [#16](https://github.com/dblock/rubocop-exception_messages/pull/16): Fix `ExceptionMessages/Punctuation` not detecting a trailing period in heredoc messages, and an infinite autocorrection loop when it did; fix `ExceptionMessages/QuoteStyle` raising an error when autocorrecting a heredoc message - [@dblock](https://github.com/dblock).
 
-#### Features
+### 0.1.0 (2026/09/05)
 
 * Initial release with `ExceptionMessages/Casing` and `ExceptionMessages/Punctuation` cops - [@dblock](https://github.com/dblock).
 * Add Danger CI check that enforces a CHANGELOG entry on every pull request - [@dblock](https://github.com/dblock).

data/README.md

@@ -30,34 +30,125 @@ plugins:
 
 ### ExceptionMessages/Casing
 
-Checks that raised exception messages start with a lowercase letter.
+Checks the capitalization of raised exception messages. Defaults to `EnforcedStyle: lowercase`.
 
 ```ruby
 # bad
 raise ArgumentError, "Block is required"
-raise ArgumentError.new("Block is required")
 
 # good
 raise ArgumentError, "block is required"
-raise ArgumentError.new("block is required")
+```
+
+Configure `EnforcedStyle: uppercase` to require the opposite convention instead.
+
+```yaml
+ExceptionMessages/Casing:
+  EnforcedStyle: uppercase
+```
+
+```ruby
+# bad
+raise ArgumentError, "block is required"
+
+# good
+raise ArgumentError, "Block is required"
 ```
 
 ### ExceptionMessages/Punctuation
 
-Checks that raised exception messages do not end with a period.
+Checks the trailing punctuation of raised exception messages. Defaults to `EnforcedStyle: no_period`. A literal ellipsis (`"..."`) is never considered an offense.
 
 ```ruby
 # bad
 raise ArgumentError, "block is required."
-raise ArgumentError.new("block is required.")
 
 # good
 raise ArgumentError, "block is required"
-raise ArgumentError.new("block is required")
+```
+
+Configure `EnforcedStyle: period` to require a trailing period instead.
+
+```yaml
+ExceptionMessages/Punctuation:
+  EnforcedStyle: period
+```
+
+```ruby
+# bad
+raise ArgumentError, "block is required"
+
+# good
+raise ArgumentError, "block is required."
 ```
 
 Both cops support autocorrection (`rubocop -A`).
 
+### ExceptionMessages/RedundantExceptionName
+
+Checks that raised exception messages do not redundantly repeat the exception class name, since Ruby already prints the class name ahead of the message in a backtrace.
+
+```ruby
+# bad
+raise ArgumentError, "ArgumentError: block is required"
+
+# good
+raise ArgumentError, "block is required"
+```
+
+### ExceptionMessages/QuoteStyle
+
+Checks that interpolated values in raised exception messages are consistently quoted, making it easier to spot where a dynamic value begins and ends in a rendered message. Defaults to `EnforcedStyle: backticks`.
+
+```ruby
+# bad
+raise ArgumentError, "unknown type: #{type}"
+
+# good
+raise ArgumentError, "unknown type: `#{type}`"
+```
+
+Configure `EnforcedStyle: single_quotes`, `double_quotes`, `square_brackets`, `parentheses`, or `curly_braces` to require a different wrapping instead.
+
+```yaml
+ExceptionMessages/QuoteStyle:
+  Enabled: true
+  EnforcedStyle: single_quotes
+```
+
+```ruby
+# good
+raise ArgumentError, "unknown type: '#{type}'"
+```
+
+Configure `EnforcedStyle: custom` with `Prefix`/`Suffix` for anything else, including a single-sided marker with no closing character.
+
+```yaml
+ExceptionMessages/QuoteStyle:
+  Enabled: true
+  EnforcedStyle: custom
+  Prefix: '?'
+```
+
+```ruby
+# good
+raise ArgumentError, "unknown type: ?#{type}"
+```
+
+`Prefix`/`Suffix` aren't limited to a single character.
+
+```yaml
+ExceptionMessages/QuoteStyle:
+  Enabled: true
+  EnforcedStyle: custom
+  Prefix: '--'
+```
+
+```ruby
+# good
+raise ArgumentError, "unknown type: --#{type}"
+```
+
 ## Contributing
 
 See [CONTRIBUTING.md](CONTRIBUTING.md).

data/RELEASING.md

@@ -58,12 +58,6 @@ Add the next release to [CHANGELOG.md](CHANGELOG.md).
 ```
 ### 0.1.1 (Next)
 
-#### Features
-
-* Your contribution here.
-
-#### Fixes
-
 * Your contribution here.
 ```
 

data/config/default.yml

@@ -2,11 +2,42 @@ ExceptionMessages:
   Enabled: true
 
 ExceptionMessages/Casing:
-  Description: 'Checks that raised exception messages start with a lowercase letter.'
+  Description: 'Checks the capitalization of raised exception messages.'
   Enabled: true
+  EnforcedStyle: lowercase
+  SupportedStyles:
+    - lowercase
+    - uppercase
   VersionAdded: '0.1'
+  VersionChanged: '0.2'
 
 ExceptionMessages/Punctuation:
-  Description: 'Checks that raised exception messages do not end with a period.'
+  Description: 'Checks the trailing punctuation of raised exception messages.'
   Enabled: true
+  EnforcedStyle: no_period
+  SupportedStyles:
+    - no_period
+    - period
   VersionAdded: '0.1'
+  VersionChanged: '0.2'
+
+ExceptionMessages/RedundantExceptionName:
+  Description: 'Checks that raised exception messages do not repeat the exception class name.'
+  Enabled: true
+  VersionAdded: '0.2'
+
+ExceptionMessages/QuoteStyle:
+  Description: 'Checks that interpolated values in raised exception messages are consistently quoted.'
+  Enabled: true
+  EnforcedStyle: backticks
+  SupportedStyles:
+    - backticks
+    - single_quotes
+    - double_quotes
+    - square_brackets
+    - parentheses
+    - curly_braces
+    - custom
+  Prefix: ~
+  Suffix: ~
+  VersionAdded: '0.2'

data/lib/rubocop/cop/exception_messages/casing.rb

@@ -3,23 +3,31 @@
 module RuboCop
   module Cop
     module ExceptionMessages
-      # Checks that raised exception messages start with a lowercase letter,
-      # consistent with Ruby's own core and standard library exceptions
-      # (e.g. `TypeError: no implicit conversion from nil to integer`).
+      # Checks the capitalization of raised exception messages. By default,
+      # requires a lowercase first letter, consistent with Ruby's own core
+      # and standard library exceptions (e.g. `TypeError: no implicit
+      # conversion from nil to integer`). Configure `EnforcedStyle: uppercase`
+      # to require the opposite convention instead.
       #
-      # @example
+      # @example EnforcedStyle: lowercase (default)
       #   # bad
       #   raise ArgumentError, "Block is required"
-      #   raise ArgumentError.new("Block is required")
       #
       #   # good
       #   raise ArgumentError, "block is required"
-      #   raise ArgumentError.new("block is required")
+      #
+      # @example EnforcedStyle: uppercase
+      #   # bad
+      #   raise ArgumentError, "block is required"
+      #
+      #   # good
+      #   raise ArgumentError, "Block is required"
       class Casing < Base
+        include ConfigurableEnforcedStyle
         include MessageNode
         extend AutoCorrector
 
-        MSG = 'Exception messages should start with a lowercase letter.'
+        MSG = 'Exception messages should start with a %<style>s letter.'
 
         def on_send(node)
           message_node = raise_message_node(node)
@@ -29,16 +37,29 @@ module RuboCop
           return unless first_segment
 
           content = first_segment.value
-          return if content.empty? || content[0] !~ /[A-Z]/
+          return if content.empty? || !offense?(content)
 
-          add_offense(message_node) do |corrector|
-            corrected = content.sub(/\A./, &:downcase)
-            corrector.replace(first_segment.loc.expression, first_segment.source.sub(content, corrected))
-          end
+          register_offense(message_node, first_segment, content)
         end
 
         private
 
+        def register_offense(message_node, segment, content)
+          add_offense(message_node, message: format(MSG, style: style)) do |corrector|
+            corrected = content.sub(/\A./, &correction_method)
+            corrector.replace(segment.loc.expression, segment.source.sub(content, corrected))
+          end
+        end
+
+        def offense?(content)
+          first_char = content[0]
+          first_char =~ (style == :lowercase ? /[A-Z]/ : /[a-z]/)
+        end
+
+        def correction_method
+          style == :lowercase ? :downcase : :upcase
+        end
+
         def first_string_segment(message_node)
           segment = message_node.str_type? ? message_node : message_node.child_nodes.first
           segment if segment&.str_type?

data/lib/rubocop/cop/exception_messages/punctuation.rb

@@ -3,23 +3,34 @@
 module RuboCop
   module Cop
     module ExceptionMessages
-      # Checks that raised exception messages do not end with a period,
-      # consistent with Ruby's own core and standard library exceptions
-      # (e.g. `ArgumentError: wrong number of arguments`).
+      # Checks the trailing punctuation of raised exception messages. By
+      # default, disallows a trailing period, consistent with Ruby's own
+      # core and standard library exceptions (e.g. `ArgumentError: wrong
+      # number of arguments`). Configure `EnforcedStyle: period` to require
+      # the opposite convention instead. A literal ellipsis (`"..."`) is
+      # never considered an offense, since it's stylistic rather than a
+      # sentence-ending period.
       #
-      # @example
+      # @example EnforcedStyle: no_period (default)
       #   # bad
       #   raise ArgumentError, "block is required."
-      #   raise ArgumentError.new("block is required.")
       #
       #   # good
       #   raise ArgumentError, "block is required"
-      #   raise ArgumentError.new("block is required")
+      #
+      # @example EnforcedStyle: period
+      #   # bad
+      #   raise ArgumentError, "block is required"
+      #
+      #   # good
+      #   raise ArgumentError, "block is required."
       class Punctuation < Base
+        include ConfigurableEnforcedStyle
         include MessageNode
         extend AutoCorrector
 
-        MSG = 'Exception messages should not end with a period.'
+        MSG_NO_PERIOD = 'Exception messages should not end with a period.'
+        MSG_PERIOD = 'Exception messages should end with a period.'
 
         def on_send(node)
           message_node = raise_message_node(node)
@@ -34,16 +45,39 @@ module RuboCop
         private
 
         def check_segment(message_node, segment)
-          content = segment.value
-          return unless content.end_with?('.')
+          content = segment.value.chomp("\n")
           return if content.end_with?('..') # ellipsis-style, not a sentence-ending period
 
-          add_offense(message_node) do |corrector|
+          if style == :no_period
+            check_no_period(message_node, segment, content)
+          else
+            check_period(message_node, segment, content)
+          end
+        end
+
+        def check_no_period(message_node, segment, content)
+          return unless content.end_with?('.')
+
+          add_offense(message_node, message: MSG_NO_PERIOD) do |corrector|
             corrected = content.sub(/\.\z/, '')
-            corrector.replace(segment.loc.expression, segment.source.sub(content, corrected))
+            replace_content(corrector, segment, content, corrected)
           end
         end
 
+        def check_period(message_node, segment, content)
+          return if content.empty? || content.end_with?('.')
+
+          add_offense(message_node, message: MSG_PERIOD) do |corrector|
+            corrected = "#{content}."
+            replace_content(corrector, segment, content, corrected)
+          end
+        end
+
+        def replace_content(corrector, segment, content, corrected)
+          range = segment.loc.respond_to?(:heredoc_body) ? segment.loc.heredoc_body : segment.loc.expression
+          corrector.replace(range, range.source.sub(content, corrected))
+        end
+
         def last_string_segment(message_node)
           segment = message_node.str_type? ? message_node : message_node.child_nodes.last
           segment if segment&.str_type?

data/lib/rubocop/cop/exception_messages/quote_style.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ExceptionMessages
+      # Checks that interpolated values in raised exception messages are
+      # consistently quoted, making it easier to spot where a dynamic value
+      # begins and ends in a rendered message.
+      #
+      # @example EnforcedStyle: backticks (default)
+      #   # bad
+      #   raise ArgumentError, "unknown type: #{type}"
+      #
+      #   # good
+      #   raise ArgumentError, "unknown type: `#{type}`"
+      #
+      # @example EnforcedStyle: custom (with Prefix: '?', Suffix: '')
+      #   # bad
+      #   raise ArgumentError, "unknown type: #{type}"
+      #
+      #   # good
+      #   raise ArgumentError, "unknown type: ?#{type}"
+      class QuoteStyle < Base
+        include ConfigurableEnforcedStyle
+        include MessageNode
+        extend AutoCorrector
+
+        MSG = 'Interpolated values in exception messages should be wrapped in %<style>s.'
+
+        QUOTES = {
+          backticks: ['`', '`'],
+          single_quotes: ["'", "'"],
+          double_quotes: ['"', '"'],
+          square_brackets: ['[', ']'],
+          parentheses: ['(', ')'],
+          curly_braces: ['{', '}']
+        }.freeze
+
+        def on_send(node)
+          message_node = raise_message_node(node)
+          return unless message_node&.dstr_type?
+
+          message_node.child_nodes.each do |segment|
+            next unless segment.begin_type?
+
+            check_interpolation(message_node, segment)
+          end
+        end
+
+        private
+
+        def check_interpolation(message_node, segment)
+          open_quote, close_quote = quotes_for_style
+          return if quoted?(segment, open_quote, close_quote)
+
+          add_offense(segment, message: format(MSG, style: style_description)) do |corrector|
+            open_quote, close_quote = escape_for_literal(message_node, open_quote, close_quote)
+            corrector.insert_before(segment.loc.expression, open_quote)
+            corrector.insert_after(segment.loc.expression, close_quote) unless close_quote.empty?
+          end
+        end
+
+        def quotes_for_style
+          return QUOTES.fetch(style) unless style == :custom
+
+          [cop_config['Prefix'] || '', cop_config['Suffix'] || '']
+        end
+
+        def style_description
+          return "`#{cop_config['Prefix']}` / `#{cop_config['Suffix']}`" if style == :custom
+
+          style.to_s.tr('_', ' ')
+        end
+
+        def escape_for_literal(message_node, open_quote, close_quote)
+          return [open_quote, close_quote] unless message_node.loc.respond_to?(:begin) && message_node.loc.begin
+
+          outer_quote = message_node.loc.begin.source
+          return [open_quote, close_quote] unless outer_quote == open_quote || outer_quote == close_quote
+
+          [open_quote == outer_quote ? "\\#{open_quote}" : open_quote,
+           close_quote == outer_quote ? "\\#{close_quote}" : close_quote]
+        end
+
+        def quoted?(segment, open_quote, close_quote)
+          preceding = segment.left_sibling
+          following = segment.right_sibling
+
+          preceding_ok = open_quote.empty? ||
+                         (preceding.is_a?(RuboCop::AST::StrNode) && preceding.value.end_with?(open_quote))
+          following_ok = close_quote.empty? ||
+                         (following.is_a?(RuboCop::AST::StrNode) && following.value.start_with?(close_quote))
+
+          preceding_ok && following_ok
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/exception_messages/redundant_exception_name.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ExceptionMessages
+      # Checks that raised exception messages do not redundantly repeat the
+      # exception class name, since Ruby already prints the class name
+      # ahead of the message in a backtrace (`ArgumentError: block is
+      # required`, not `ArgumentError: ArgumentError: block is required`).
+      #
+      # @example
+      #   # bad
+      #   raise ArgumentError, "ArgumentError: block is required"
+      #
+      #   # good
+      #   raise ArgumentError, "block is required"
+      class RedundantExceptionName < Base
+        include MessageNode
+
+        MSG = 'Exception messages should not repeat the exception class name.'
+
+        def on_send(node)
+          message_node = raise_message_node(node)
+          return unless message_node
+
+          first_segment = first_string_segment(message_node)
+          return unless first_segment
+
+          exception_name = exception_class_name(node)
+          return unless exception_name
+
+          return unless redundant?(first_segment.value, exception_name)
+
+          add_offense(message_node)
+        end
+
+        private
+
+        def redundant?(content, exception_name)
+          content.match?(/\A#{Regexp.escape(exception_name)}\b/)
+        end
+
+        def exception_class_name(node)
+          klass = raised_class_node(node)
+          return unless klass&.const_type?
+
+          klass.const_name&.split('::')&.last
+        end
+
+        def raised_class_node(node)
+          first_arg = node.arguments.first
+          return unless first_arg
+          return first_arg.receiver if first_arg.send_type? && first_arg.method?(:new)
+
+          first_arg
+        end
+
+        def first_string_segment(message_node)
+          segment = message_node.str_type? ? message_node : message_node.child_nodes.first
+          segment if segment&.str_type?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/exception_messages_cops.rb

@@ -3,3 +3,5 @@
 require_relative 'exception_messages/message_node'
 require_relative 'exception_messages/casing'
 require_relative 'exception_messages/punctuation'
+require_relative 'exception_messages/redundant_exception_name'
+require_relative 'exception_messages/quote_style'

data/lib/rubocop/exception_messages/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module ExceptionMessages
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-exception_messages
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniel (dB.) Doubrovkine
@@ -59,6 +59,8 @@ files:
 - lib/rubocop/cop/exception_messages/casing.rb
 - lib/rubocop/cop/exception_messages/message_node.rb
 - lib/rubocop/cop/exception_messages/punctuation.rb
+- lib/rubocop/cop/exception_messages/quote_style.rb
+- lib/rubocop/cop/exception_messages/redundant_exception_name.rb
 - lib/rubocop/cop/exception_messages_cops.rb
 - lib/rubocop/exception_messages.rb
 - lib/rubocop/exception_messages/plugin.rb