rubbycop 0.49.0

data/lib/rubbycop/cop/layout/multiline_method_definition_brace_layout.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks that the closing brace in a method definition is either
+      # on the same line as the last method parameter, or a new line.
+      #
+      # When using the `symmetrical` (default) style:
+      #
+      # If a method definition's opening brace is on the same line as the
+      # first parameter of the definition, then the closing brace should be
+      # on the same line as the last parameter of the definition.
+      #
+      # If an method definition's opening brace is on the line above the first
+      # parameter of the definition, then the closing brace should be on the
+      # line below the last parameter of the definition.
+      #
+      # When using the `new_line` style:
+      #
+      # The closing brace of a multi-line method definition must be on the line
+      # after the last parameter of the definition.
+      #
+      # When using the `same_line` style:
+      #
+      # The closing brace of a multi-line method definition must be on the same
+      # line as the last parameter of the definition.
+      #
+      # @example
+      #
+      #     # symmetrical: bad
+      #     # new_line: good
+      #     # same_line: bad
+      #     def foo(a,
+      #       b
+      #     )
+      #
+      #     # symmetrical: bad
+      #     # new_line: bad
+      #     # same_line: good
+      #     def foo(
+      #       a,
+      #       b)
+      #
+      #     # symmetrical: good
+      #     # new_line: bad
+      #     # same_line: good
+      #     def foo(a,
+      #       b)
+      #
+      #     # symmetrical: good
+      #     # new_line: good
+      #     # same_line: bad
+      #     def foo(
+      #       a,
+      #       b
+      #     )
+      class MultilineMethodDefinitionBraceLayout < Cop
+        include OnMethodDef
+        include MultilineLiteralBraceLayout
+
+        SAME_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
+          'same line as the last parameter when opening brace is on the same ' \
+          'line as the first parameter.'.freeze
+
+        NEW_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
+          'line after the last parameter when opening brace is on a separate ' \
+          'line from the first parameter.'.freeze
+
+        ALWAYS_NEW_LINE_MESSAGE = 'Closing method definition brace must be ' \
+          'on the line after the last parameter.'.freeze
+
+        ALWAYS_SAME_LINE_MESSAGE = 'Closing method definition brace must be ' \
+          'on the same line as the last parameter.'.freeze
+
+        def on_method_def(_node, _method_name, args, _body)
+          check_brace_layout(args)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/multiline_operation_indentation.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks the indentation of the right hand side operand in
+      # binary operations that span more than one line.
+      #
+      # @example
+      #   # bad
+      #   if a +
+      #   b
+      #     something
+      #   end
+      class MultilineOperationIndentation < Cop
+        include ConfigurableEnforcedStyle
+        include AutocorrectAlignment
+        include MultilineExpressionIndentation
+
+        def on_and(node)
+          check_and_or(node)
+        end
+
+        def on_or(node)
+          check_and_or(node)
+        end
+
+        def validate_config
+          return unless style == :aligned && cop_config['IndentationWidth']
+
+          raise ValidationError, 'The `Layout/MultilineOperationIndentation`' \
+                                ' cop only accepts an `IndentationWidth` ' \
+                                'configuration parameter when ' \
+                                '`EnforcedStyle` is `indented`.'
+        end
+
+        private
+
+        def relevant_node?(node)
+          !node.loc.dot # Don't check method calls with dot operator.
+        end
+
+        def check_and_or(node)
+          lhs, rhs = *node
+          range = offending_range(node, lhs, rhs.source_range, style)
+          check(range, node, lhs, rhs.source_range)
+        end
+
+        def offending_range(node, lhs, rhs, given_style)
+          return false unless begins_its_line?(rhs)
+          return false if lhs.loc.line == rhs.line # Needed for unary op.
+          return false if not_for_this_cop?(node)
+
+          correct_column = if should_align?(node, rhs, given_style)
+                             node.loc.column
+                           else
+                             indentation(lhs) + correct_indentation(node)
+                           end
+          @column_delta = correct_column - rhs.column
+          rhs if @column_delta.nonzero?
+        end
+
+        def should_align?(node, rhs, given_style)
+          assignment_node = part_of_assignment_rhs(node, rhs)
+          if assignment_node
+            assignment_rhs = CheckAssignment.extract_rhs(assignment_node)
+            return true if begins_its_line?(assignment_rhs.source_range)
+          end
+
+          given_style == :aligned &&
+            (kw_node_with_special_indentation(node) ||
+             assignment_node ||
+             argument_in_method_call(node, :with_or_without_parentheses))
+        end
+
+        def message(node, lhs, rhs)
+          what = operation_description(node, rhs)
+          if should_align?(node, rhs, style)
+            "Align the operands of #{what} spanning multiple lines."
+          else
+            used_indentation = rhs.column - indentation(lhs)
+            "Use #{correct_indentation(node)} (not #{used_indentation}) " \
+              "spaces for indenting #{what} spanning multiple lines."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/rescue_ensure_alignment.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks whether the rescue and ensure keywords are aligned
+      # properly.
+      #
+      # @example
+      #
+      #   # bad
+      #   begin
+      #     something
+      #     rescue
+      #     puts 'error'
+      #   end
+      #
+      #   # good
+      #   begin
+      #     something
+      #   rescue
+      #     puts 'error'
+      #   end
+      class RescueEnsureAlignment < Cop
+        MSG = '`%s` at %d, %d is not aligned with `end` at %d, %d.'.freeze
+
+        def on_resbody(node)
+          check(node) unless modifier?(node)
+        end
+
+        def on_ensure(node)
+          check(node)
+        end
+
+        def investigate(processed_source)
+          @modifier_locations =
+            processed_source.tokens.each_with_object([]) do |token, locations|
+              next unless token.type == :kRESCUE_MOD
+              locations << token.pos
+            end
+        end
+
+        def autocorrect(node)
+          whitespace = whitespace_range(node)
+          return false unless whitespace.source.strip.empty?
+
+          new_column = ancestor_node(node).loc.end.column
+          ->(corrector) { corrector.replace(whitespace, ' ' * new_column) }
+        end
+
+        private
+
+        def check(node)
+          end_loc = ancestor_node(node).loc.end
+          kw_loc = node.loc.keyword
+
+          return if end_loc.column == kw_loc.column
+          return if end_loc.line == kw_loc.line
+
+          add_offense(node, kw_loc, format_message(kw_loc, end_loc))
+        end
+
+        def format_message(kw_loc, end_loc)
+          format(MSG, kw_loc.source, kw_loc.line, kw_loc.column, end_loc.line,
+                 end_loc.column)
+        end
+
+        def modifier?(node)
+          return false unless @modifier_locations.respond_to?(:include?)
+          @modifier_locations.include?(node.loc.keyword)
+        end
+
+        def whitespace_range(node)
+          begin_pos = node.loc.keyword.begin_pos
+          current_column = node.loc.keyword.column
+
+          range_between(begin_pos - current_column, begin_pos)
+        end
+
+        def ancestor_node(node)
+          node.each_ancestor(:kwbegin, :def, :defs, :class, :module).first
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/space_after_colon.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks for colon (:) not followed by some kind of space.
+      # N.B. this cop does not handle spaces after a ternary operator, which are
+      # instead handled by Layout/SpaceAroundOperators.
+      class SpaceAfterColon < Cop
+        MSG = 'Space missing after colon.'.freeze
+
+        def on_pair(node)
+          return unless node.colon?
+
+          colon = node.loc.operator
+
+          add_offense(colon, colon) unless followed_by_space?(colon)
+        end
+
+        def on_kwoptarg(node)
+          # We have no direct reference to the colon source range following an
+          # optional keyword argument's name, so must construct one.
+          colon = node.loc.name.end.resize(1)
+
+          add_offense(colon, colon) unless followed_by_space?(colon)
+        end
+
+        private
+
+        def followed_by_space?(colon)
+          colon.source_buffer.source[colon.end_pos] =~ /\s/
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.insert_after(range, ' ') }
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/space_after_comma.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks for comma (,) not followed by some kind of space.
+      class SpaceAfterComma < Cop
+        include SpaceAfterPunctuation
+
+        def space_style_before_rcurly
+          cfg = config.for_cop('Layout/SpaceInsideHashLiteralBraces')
+          cfg['EnforcedStyle'] || 'space'
+        end
+
+        def kind(token)
+          'comma' if token.type == :tCOMMA
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/space_after_method_name.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks for space between a method name and a left parenthesis in defs.
+      #
+      # @example
+      #
+      #   # bad
+      #   def func (x) ... end
+      #
+      #   # good
+      #   def func(x) ... end
+      class SpaceAfterMethodName < Cop
+        include OnMethodDef
+
+        MSG = 'Do not put a space between a method name and the opening ' \
+              'parenthesis.'.freeze
+
+        def on_method_def(_node, _method_name, args, _body)
+          return unless args.loc.begin && args.loc.begin.is?('(')
+          expr = args.source_range
+          pos_before_left_paren = range_between(expr.begin_pos - 1,
+                                                expr.begin_pos)
+          return unless pos_before_left_paren.source =~ /\s/
+
+          add_offense(pos_before_left_paren, pos_before_left_paren)
+        end
+
+        def autocorrect(pos_before_left_paren)
+          ->(corrector) { corrector.remove(pos_before_left_paren) }
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/space_after_not.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks for space after `!`.
+      #
+      # @example
+      #   # bad
+      #   ! something
+      #
+      #   # good
+      #   !something
+      class SpaceAfterNot < Cop
+        MSG = 'Do not leave space between `!` and its argument.'.freeze
+
+        def on_send(node)
+          return unless node.keyword_bang? && whitespace_after_operator?(node)
+
+          add_offense(node, :expression)
+        end
+
+        def whitespace_after_operator?(node)
+          node.receiver.loc.column - node.loc.column > 1
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(
+              range_between(node.loc.selector.end_pos,
+                            node.receiver.source_range.begin_pos)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/space_after_semicolon.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks for semicolon (;) not followed by some kind of space.
+      class SpaceAfterSemicolon < Cop
+        include SpaceAfterPunctuation
+
+        def space_style_before_rcurly
+          cfg = config.for_cop('Layout/SpaceInsideBlockBraces')
+          cfg['EnforcedStyle'] || 'space'
+        end
+
+        def kind(token)
+          'semicolon' if token.type == :tSEMI
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/space_around_block_parameters.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks the spacing inside and after block parameters pipes.
+      #
+      # @example
+      #
+      #   # bad
+      #   {}.each { | x,  y |puts x }
+      #
+      #   # good
+      #   {}.each { |x, y| puts x }
+      class SpaceAroundBlockParameters < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_block(node)
+          _method, args, body = *node
+          opening_pipe = args.loc.begin
+          closing_pipe = args.loc.end
+          return unless !args.children.empty? && opening_pipe
+
+          check_inside_pipes(args.children, opening_pipe, closing_pipe)
+
+          if body
+            check_space(closing_pipe.end_pos, body.source_range.begin_pos,
+                        closing_pipe, 'after closing `|`')
+          end
+
+          check_each_arg(args)
+        end
+
+        private
+
+        def style_parameter_name
+          'EnforcedStyleInsidePipes'
+        end
+
+        def check_inside_pipes(args, opening_pipe, closing_pipe)
+          if style == :no_space
+            check_no_space_style_inside_pipes(args, opening_pipe, closing_pipe)
+          elsif style == :space
+            check_space_style_inside_pipes(args, opening_pipe, closing_pipe)
+          end
+        end
+
+        def check_no_space_style_inside_pipes(args, opening_pipe, closing_pipe)
+          first = args.first.source_range
+          last = args.last.source_range
+
+          check_no_space(opening_pipe.end_pos, first.begin_pos,
+                         'Space before first')
+          check_no_space(last_end_pos_inside_pipes(last.end_pos),
+                         closing_pipe.begin_pos, 'Space after last')
+        end
+
+        def check_space_style_inside_pipes(args, opening_pipe, closing_pipe)
+          first = args.first.source_range
+          last = args.last.source_range
+          last_end_pos = last_end_pos_inside_pipes(last.end_pos)
+
+          check_space(opening_pipe.end_pos, first.begin_pos, first,
+                      'before first block parameter')
+          check_space(last_end_pos, closing_pipe.begin_pos, last,
+                      'after last block parameter')
+          check_no_space(opening_pipe.end_pos, first.begin_pos - 1,
+                         'Extra space before first')
+          check_no_space(last_end_pos + 1, closing_pipe.begin_pos,
+                         'Extra space after last')
+        end
+
+        def last_end_pos_inside_pipes(pos)
+          processed_source.buffer.source[pos] == ',' ? pos + 1 : pos
+        end
+
+        def check_each_arg(args)
+          args.children.butfirst.each do |arg|
+            expr = arg.source_range
+            check_no_space(range_with_surrounding_space(expr, :left).begin_pos,
+                           expr.begin_pos - 1, 'Extra space before')
+          end
+        end
+
+        def check_space(space_begin_pos, space_end_pos, range, msg)
+          return if space_begin_pos != space_end_pos
+
+          add_offense(range, range, "Space #{msg} missing.")
+        end
+
+        def check_no_space(space_begin_pos, space_end_pos, msg)
+          return if space_begin_pos >= space_end_pos
+
+          range = range_between(space_begin_pos, space_end_pos)
+          add_offense(range, range, "#{msg} block parameter detected.")
+        end
+
+        def autocorrect(range)
+          lambda do |corrector|
+            case range.source
+            when /^\s+$/ then corrector.remove(range)
+            else              corrector.insert_after(range, ' ')
+            end
+          end
+        end
+      end
+    end
+  end
+end