rubocop 0.42.0 → 0.52.1

data/lib/rubocop/cop/layout/align_hash.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Check that the keys, separators, and values of a multi-line hash
+      # literal are aligned according to configuration. The configuration
+      # options are:
+      #
+      #   - key (left align keys)
+      #   - separator (align hash rockets and colons, right align keys)
+      #   - table (left align keys, hash rockets, and values)
+      #
+      # The treatment of hashes passed as the last argument to a method call
+      # can also be configured. The options are:
+      #
+      #   - always_inspect
+      #   - always_ignore
+      #   - ignore_implicit (without curly braces)
+      #   - ignore_explicit (with curly braces)
+      #
+      # @example
+      #
+      #   # EnforcedHashRocketStyle: key (default)
+      #   # EnforcedColonStyle: key (default)
+      #
+      #   # good
+      #   {
+      #     foo: bar,
+      #     ba: baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #     :ba => baz
+      #   }
+      #
+      #   # bad
+      #   {
+      #     foo: bar,
+      #      ba: baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #      :ba => baz
+      #   }
+      #
+      # @example
+      #
+      #   # EnforcedHashRocketStyle: separator
+      #   # EnforcedColonStyle: separator
+      #
+      #   #good
+      #   {
+      #     foo: bar,
+      #      ba: baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #      :ba => baz
+      #   }
+      #
+      #   #bad
+      #   {
+      #     foo: bar,
+      #     ba: baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #     :ba => baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #     :ba  => baz
+      #   }
+      #
+      # @example
+      #
+      #   # EnforcedHashRocketStyle: table
+      #   # EnforcedColonStyle: table
+      #
+      #   #good
+      #   {
+      #     foo: bar,
+      #     ba:  baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #     :ba  => baz
+      #   }
+      #
+      #   #bad
+      #   {
+      #     foo: bar,
+      #     ba: baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #      :ba => baz
+      #   }
+      class AlignHash < Cop
+        include HashAlignment
+
+        MSG = 'Align the elements of a hash literal if they span more than ' \
+              'one line.'.freeze
+
+        def on_send(node)
+          return if double_splat?(node)
+
+          last_argument = node.last_argument
+
+          return unless last_argument.hash_type? &&
+                        ignore_hash_argument?(last_argument)
+
+          ignore_node(last_argument)
+        end
+
+        def on_hash(node)
+          return if ignored_node?(node)
+          return if node.pairs.empty? || node.single_line?
+
+          return unless alignment_for_hash_rockets.checkable_layout?(node) &&
+                        alignment_for_colons.checkable_layout?(node)
+
+          check_pairs(node)
+        end
+
+        def autocorrect(node)
+          # We can't use the instance variable inside the lambda. That would
+          # just give each lambda the same reference and they would all get the
+          # last value of each. A local variable fixes the problem.
+          key_delta = column_deltas[:key] || 0
+
+          if !node.value
+            correct_no_value(key_delta, node.source_range)
+          else
+            correct_key_value(key_delta, node.key.source_range,
+                              node.value.source_range,
+                              node.loc.operator)
+          end
+        end
+
+        private
+
+        attr_accessor :column_deltas
+
+        def double_splat?(node)
+          node.children.last.is_a?(Symbol)
+        end
+
+        def check_pairs(node)
+          first_pair = node.pairs.first
+          self.column_deltas = alignment_for(first_pair)
+                               .deltas_for_first_pair(first_pair, node)
+          add_offense(first_pair) unless good_alignment?
+
+          node.children.each do |current|
+            self.column_deltas = alignment_for(current)
+                                 .deltas(first_pair, current)
+            add_offense(current) unless good_alignment?
+          end
+        end
+
+        def ignore_hash_argument?(node)
+          case cop_config['EnforcedLastArgumentHashStyle']
+          when 'always_inspect'  then false
+          when 'always_ignore'   then true
+          when 'ignore_explicit' then node.braces?
+          when 'ignore_implicit' then !node.braces?
+          end
+        end
+
+        def alignment_for(pair)
+          if pair.hash_rocket?
+            alignment_for_hash_rockets
+          else
+            alignment_for_colons
+          end
+        end
+
+        def alignment_for_hash_rockets
+          @alignment_for_hash_rockets ||=
+            new_alignment('EnforcedHashRocketStyle')
+        end
+
+        def alignment_for_colons
+          @alignment_for_colons ||=
+            new_alignment('EnforcedColonStyle')
+        end
+
+        def correct_no_value(key_delta, key)
+          ->(corrector) { adjust(corrector, key_delta, key) }
+        end
+
+        def correct_key_value(key_delta, key, value, separator)
+          # We can't use the instance variable inside the lambda. That would
+          # just give each lambda the same reference and they would all get the
+          # last value of each. Some local variables fix the problem.
+          separator_delta = column_deltas[:separator] || 0
+          value_delta     = column_deltas[:value] || 0
+
+          key_column = key.column
+          key_delta = -key_column if key_delta < -key_column
+
+          lambda do |corrector|
+            adjust(corrector, key_delta, key)
+            adjust(corrector, separator_delta, separator)
+            adjust(corrector, value_delta, value)
+          end
+        end
+
+        def new_alignment(key)
+          case cop_config[key]
+          when 'key'       then KeyAlignment.new
+          when 'table'     then TableAlignment.new
+          when 'separator' then SeparatorAlignment.new
+          else raise "Unknown #{key}: #{cop_config[key]}"
+          end
+        end
+
+        def adjust(corrector, delta, range)
+          if delta > 0
+            corrector.insert_before(range, ' ' * delta)
+          elsif delta < 0
+            range = range_between(range.begin_pos - delta.abs, range.begin_pos)
+            corrector.remove(range)
+          end
+        end
+
+        def good_alignment?
+          column_deltas.values.all?(&:zero?)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/{style → layout}/align_parameters.rb

@@ -1,43 +1,62 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # Here we check if the parameters on a multi-line method call or
       # definition are aligned.
+      #
+      # @example EnforcedStyle: with_first_parameter (default)
+      #   # good
+      #
+      #   foo :bar,
+      #       :baz
+      #
+      #   # bad
+      #
+      #   foo :bar,
+      #     :baz
+      #
+      # @example EnforcedStyle: with_fixed_indentation
+      #   # good
+      #
+      #   foo :bar,
+      #     :baz
+      #
+      #   # bad
+      #
+      #   foo :bar,
+      #       :baz
       class AlignParameters < Cop
-        include AutocorrectAlignment
-        include OnMethodDef
+        include Alignment
 
-        ALIGN_PARAMS_MSG = 'Align the parameters of a method %s if they span ' \
-          'more than one line.'.freeze
+        ALIGN_PARAMS_MSG = 'Align the parameters of a method %<type>s if ' \
+          'they span more than one line.'.freeze
 
         FIXED_INDENT_MSG = 'Use one level of indentation for parameters ' \
-          'following the first line of a multi-line method %s.'.freeze
+          'following the first line of a multi-line method %<type>s.'.freeze
 
         def on_send(node)
-          _receiver, method, *args = *node
+          return if node.arguments.size < 2 ||
+                    node.send_type? && node.method?(:[]=)
 
-          return if method == :[]=
-          return if args.size < 2
-
-          check_alignment(args, base_column(node, args))
+          check_alignment(node.arguments, base_column(node, node.arguments))
         end
+        alias on_def  on_send
+        alias on_defs on_send
 
-        def on_method_def(node, _method_name, args, _body)
-          args = args.children
-          return if args.size < 2
-          check_alignment(args, base_column(node, args))
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
         end
 
+        private
+
         def message(node)
           type = node && node.parent.send_type? ? 'call' : 'definition'
           msg = fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
-          format(msg, type)
-        end
 
-        private
+          format(msg, type: type)
+        end
 
         def fixed_indentation?
           cop_config['EnforcedStyle'] == 'with_fixed_indentation'

data/lib/rubocop/cop/{style → layout}/block_end_newline.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks whether the end statement of a do..end block
       # is on its own line.
       #
@@ -26,31 +25,50 @@ module RuboCop
       #     foo(i)
       #   }
       class BlockEndNewline < Cop
-        MSG = 'Expression at %d, %d should be on its own line.'.freeze
+        MSG = 'Expression at %<line>d, %<column>d should be on its own line.'
+              .freeze
 
         def on_block(node)
+          return if node.single_line?
+
           end_loc = node.loc.end
-          do_loc = node.loc.begin # Actually it's either do or {.
-          return if do_loc.line == end_loc.line # Ignore one-liners.
 
           # If the end is on its own line, there is no offense
           return if end_loc.source_line =~ /^\s*#{end_loc.source}/
 
-          msg = format(MSG, end_loc.line, end_loc.column + 1)
-          add_offense(node, end_loc, msg)
+          add_offense(node, location: end_loc)
         end
 
         def autocorrect(node)
           lambda do |corrector|
             indentation = indentation_of_block_start_line(node)
-            corrector.insert_before(node.loc.end, "\n" + (' ' * indentation))
+            new_block_end = "\n" + node.loc.end.source + (' ' * indentation)
+            corrector.replace(delimiter_range(node), new_block_end)
           end
         end
 
+        private
+
+        def message(node)
+          format(MSG, line: node.loc.end.line, column: node.loc.end.column + 1)
+        end
+
         def indentation_of_block_start_line(node)
           match = /\S.*/.match(node.loc.begin.source_line)
           match.begin(0)
         end
+
+        def delimiter_range(node)
+          Parser::Source::Range.new(
+            node.loc.end.source_buffer,
+            index_of_delimiter_with_whitespaces(node),
+            node.source.length
+          )
+        end
+
+        def index_of_delimiter_with_whitespaces(node)
+          node.source =~ /\s*#{node.closing_delimiter}/
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/case_indentation.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks how the *when*s of a *case* expression
+      # are indented in relation to its *case* or *end* keyword.
+      #
+      # It will register a separate offense for each misaligned *when*.
+      #
+      # @example
+      #   # If Layout/EndAlignment is set to keyword style (default)
+      #   # *case* and *end* should always be aligned to same depth,
+      #   # and therefore *when* should always be aligned to both -
+      #   # regardless of configuration.
+      #
+      #   # bad for all styles
+      #   case n
+      #     when 0
+      #       x * 2
+      #     else
+      #       y / 3
+      #   end
+      #
+      #   # good for all styles
+      #   case n
+      #   when 0
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
+      # @example EnforcedStyle: case (default)
+      #   # if EndAlignment is set to other style such as
+      #   # start_of_line (as shown below), then *when* alignment
+      #   # configuration does have an effect.
+      #
+      #   # bad
+      #   a = case n
+      #   when 0
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
+      #   # good
+      #   a = case n
+      #       when 0
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
+      # @example EnforcedStyle: end
+      #   # bad
+      #   a = case n
+      #       when 0
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
+      #   # good
+      #   a = case n
+      #   when 0
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      class CaseIndentation < Cop
+        include Alignment
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Indent `when` %<depth>s `%<base>s`.'.freeze
+
+        def on_case(case_node)
+          return if case_node.single_line?
+
+          case_node.each_when do |when_node|
+            check_when(when_node)
+          end
+        end
+
+        def autocorrect(node)
+          whitespace = whitespace_range(node)
+
+          return false unless whitespace.source.strip.empty?
+
+          lambda do |corrector|
+            corrector.replace(whitespace, replacement(node))
+          end
+        end
+
+        private
+
+        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)
+          end
+        end
+
+        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, location: :keyword, message: message(style)) do
+            if when_column == base_column
+              opposite_style_detected
+            else
+              unrecognized_style_detected
+            end
+          end
+        end
+
+        def message(base)
+          depth = indent_one_step? ? 'one step more than' : 'as deep as'
+
+          format(MSG, depth: depth, base: base)
+        end
+
+        def base_column(case_node, base)
+          case base
+          when :case then case_node.location.keyword.column
+          when :end  then case_node.location.end.column
+          end
+        end
+
+        def whitespace_range(node)
+          when_column = node.location.keyword.column
+          begin_pos = node.loc.keyword.begin_pos
+
+          range_between(begin_pos - when_column, begin_pos)
+        end
+
+        def replacement(node)
+          case_node = node.each_ancestor(:case).first
+          base_type = cop_config[style_parameter_name] == 'end' ? :end : :case
+
+          column = base_column(case_node, base_type)
+          column += indentation_width
+
+          ' ' * column
+        end
+      end
+    end
+  end
+end