lib/rubocop/cop/style/case_indentation.rb in rubocop-0.46.0 vs lib/rubocop/cop/style/case_indentation.rb in rubocop-0.47.0

@@ -9,52 +9,56 @@
       # It will register a separate offense for each misaligned *when*.
       class CaseIndentation < Cop
         include AutocorrectAlignment
         include ConfigurableEnforcedStyle
 
-        def on_case(case_node)
-          _condition, *whens, _else = *case_node
+        MSG = 'Indent `when` %s `%s`.'.freeze
 
-          base = style
-          indent = cop_config['IndentOneStep']
-          base_column = base_column(case_node, base)
-
-          whens.each do |when_node|
-            check_when(when_node, case_node, base, indent, base_column)
+        def on_case(case_node)
+          case_node.each_when do |when_node|
+            check_when(when_node)
           end
         end
 
         private
 
-        def check_when(when_node, case_node, base, indent, base_column)
-          pos = when_node.loc.keyword
-          expected_column = base_column +
-                            (indent ? configured_indentation_width : 0)
-          if pos.column == expected_column
+        def check_when(when_node)
+          when_column = when_node.loc.keyword.column
+          base_column = base_column(when_node.parent, style)
+
+          if when_column == base_column + indentation_width
             correct_style_detected
           else
-            incorrect_style(when_node, case_node, base, pos, indent)
+            incorrect_style(when_node)
           end
         end
 
-        def incorrect_style(when_node, case_node, base, pos, indent)
-          msg = 'Indent `when` ' + if indent
-                                     "one step more than `#{base}`."
-                                   else
-                                     "as deep as `#{base}`."
-                                   end
-          add_offense(when_node, pos, msg) do
-            if pos.column == base_column(case_node, alternative_style)
+        def indent_one_step?
+          cop_config['IndentOneStep']
+        end
+
+        def indentation_width
+          indent_one_step? ? configured_indentation_width : 0
+        end
+
+        def incorrect_style(when_node)
+          when_column = when_node.loc.keyword.column
+          base_column = base_column(when_node.parent, alternative_style)
+
+          add_offense(when_node, :keyword, message(style)) do
+            if when_column == base_column
               opposite_style_detected
             else
               unrecognized_style_detected
             end
           end
         end
 
-        def parameter_name
-          'IndentWhenRelativeTo'
+        def message(base)
+          depth = indent_one_step? ? 'one step more than' : 'as deep as'
+
+          format(MSG, depth, base)
         end
 
         def base_column(case_node, base)
           case base
           when :case then case_node.location.keyword.column
@@ -62,13 +66,16 @@
           end
         end
 
         def autocorrect(node)
           whitespace = whitespace_range(node)
+
           return false unless whitespace.source.strip.empty?
 
-          ->(corrector) { corrector.replace(whitespace, replacement(node)) }
+          lambda do |corrector|
+            corrector.replace(whitespace, replacement(node))
+          end
         end
 
         def whitespace_range(node)
           when_column = node.location.keyword.column
           begin_pos = node.loc.keyword.begin_pos
@@ -76,12 +83,14 @@
           range_between(begin_pos - when_column, begin_pos)
         end
 
         def replacement(node)
           case_node = node.each_ancestor(:case).first
-          base_type = cop_config[parameter_name] == 'end' ? :end : :case
+          base_type = cop_config[style_parameter_name] == 'end' ? :end : :case
+
           column = base_column(case_node, base_type)
-          column += configured_indentation_width if cop_config['IndentOneStep']
+          column += indentation_width
+
           ' ' * column
         end
       end
     end
   end