rubbycop 0.49.0

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop looks for trailing whitespace in the source code.
+      class TrailingWhitespace < Cop
+        MSG = 'Trailing whitespace detected.'.freeze
+
+        def investigate(processed_source)
+          processed_source.lines.each_with_index do |line, index|
+            next unless line.end_with?(' ', "\t")
+
+            range = source_range(processed_source.buffer,
+                                 index + 1,
+                                 (line.rstrip.length)...(line.length))
+
+            add_offense(range, range)
+          end
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.remove(range) }
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/ambiguous_block_association.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for ambiguous block association with method
+      # when param passed without parentheses.
+      #
+      # @example
+      #
+      #   # bad
+      #   some_method a { |val| puts val }
+      #
+      # @example
+      #
+      #   # good
+      #   # With parentheses, there's no ambiguity.
+      #   some_method(a) { |val| puts val }
+      #
+      #   # good
+      #   # Operator methods require no disambiguation
+      #   foo == bar { |b| b.baz }
+      #
+      #   # good
+      #   # Lambda arguments require no disambiguation
+      #   foo = ->(bar) { bar.baz }
+      class AmbiguousBlockAssociation < Cop
+        MSG = 'Parenthesize the param `%s` to make sure that the block will be'\
+              ' associated with the `%s` method call.'.freeze
+
+        def on_send(node)
+          return if node.parenthesized? || allowed_method?(node)
+          return if lambda_argument?(node.last_argument)
+
+          return unless method_with_block?(node.last_argument)
+          last_param = node.last_argument.children.first
+          return unless method_as_param?(last_param)
+
+          add_offense(node, :expression, message(node.last_argument))
+        end
+
+        private
+
+        def allowed_method?(node)
+          node.assignment? || node.operator_method? || node.method?(:[])
+        end
+
+        def method_with_block?(param)
+          param && param.block_type?
+        end
+
+        def method_as_param?(param)
+          param && param.send_type? && !param.arguments?
+        end
+
+        def message(param)
+          format(MSG, param.source, param.children.first.source)
+        end
+
+        def_node_matcher :lambda_argument?, <<-PATTERN
+          (block (send _ :lambda) ...)
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/ambiguous_operator.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for ambiguous operators in the first argument of a
+      # method invocation without parentheses.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # The `*` is interpreted as a splat operator but it could possibly be
+      #   # a `*` method invocation (i.e. `do_something.*(some_array)`).
+      #   do_something *some_array
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # With parentheses, there's no ambiguity.
+      #   do_something(*some_array)
+      class AmbiguousOperator < Cop
+        include ParserDiagnostic
+
+        AMBIGUITIES = {
+          '+'  => { actual: 'positive number', possible: 'addition' },
+          '-'  => { actual: 'negative number', possible: 'subtraction' },
+          '*'  => { actual: 'splat',           possible: 'multiplication' },
+          '&'  => { actual: 'block',           possible: 'binary AND' },
+          '**' => { actual: 'keyword splat',   possible: 'exponent' }
+        }.each do |key, hash|
+          hash[:operator] = key
+        end
+
+        MSG_FORMAT = 'Ambiguous %<actual>s operator. Parenthesize the method ' \
+                     "arguments if it's surely a %<actual>s operator, or add " \
+                     'a whitespace to the right of the `%<operator>s` if it ' \
+                     'should be a %<possible>s.'.freeze
+
+        private
+
+        def relevant_diagnostic?(diagnostic)
+          diagnostic.reason == :ambiguous_prefix
+        end
+
+        def alternative_message(diagnostic)
+          operator = diagnostic.location.source
+          hash = AMBIGUITIES[operator]
+          format(MSG_FORMAT, hash)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/ambiguous_regexp_literal.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for ambiguous regexp literals in the first argument of
+      # a method invocation without parentheses.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # This is interpreted as a method invocation with a regexp literal,
+      #   # but it could possibly be `/` method invocations.
+      #   # (i.e. `do_something./(pattern)./(i)`)
+      #   do_something /pattern/i
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # With parentheses, there's no ambiguity.
+      #   do_something(/pattern/i)
+      class AmbiguousRegexpLiteral < Cop
+        include ParserDiagnostic
+
+        MSG = 'Ambiguous regexp literal. Parenthesize the method arguments ' \
+              "if it's surely a regexp literal, or add a whitespace to the " \
+              'right of the `/` if it should be a division.'.freeze
+
+        private
+
+        def relevant_diagnostic?(diagnostic)
+          diagnostic.reason == :ambiguous_literal
+        end
+
+        def alternative_message(_diagnostic)
+          MSG
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/assignment_in_condition.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for assignments in the conditions of
+      # if/while/until.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   if some_var = true
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   if some_var == true
+      #     do_something
+      #   end
+      class AssignmentInCondition < Cop
+        include SafeAssignment
+
+        MSG = 'Assignment in condition - you probably meant to use `==`.'.freeze
+        ASGN_TYPES = [:begin, *EQUALS_ASGN_NODES, :send].freeze
+
+        def on_if(node)
+          check(node)
+        end
+
+        def on_while(node)
+          check(node)
+        end
+
+        def on_until(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return if node.condition.block_type?
+
+          traverse_node(node.condition, ASGN_TYPES) do |asgn_node|
+            next :skip_children if skip_children?(asgn_node)
+            next if allowed_construct?(asgn_node)
+
+            add_offense(asgn_node, :operator)
+          end
+        end
+
+        def allowed_construct?(asgn_node)
+          asgn_node.begin_type? || conditional_assignment?(asgn_node)
+        end
+
+        def conditional_assignment?(asgn_node)
+          !asgn_node.loc.operator
+        end
+
+        def skip_children?(asgn_node)
+          (asgn_node.send_type? && asgn_node.method_name !~ /=\z/) ||
+            empty_condition?(asgn_node) ||
+            (safe_assignment_allowed? && safe_assignment?(asgn_node))
+        end
+
+        # each_node/visit_descendants_with_types with :skip_children
+        def traverse_node(node, types, &block)
+          result = yield node if types.include?(node.type)
+
+          return if result == :skip_children
+
+          node.each_child_node { |child| traverse_node(child, types, &block) }
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/block_alignment.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks whether the end keywords are aligned properly for do
+      # end blocks.
+      #
+      # Three modes are supported through the `EnforcedStyleAlignWith`
+      # configuration parameter:
+      #
+      # `start_of_block` : the `end` shall be aligned with the
+      # start of the line where the `do` appeared.
+      #
+      # `start_of_line` : the `end` shall be aligned with the
+      # start of the line where the expression started.
+      #
+      # `either` (which is the default) : the `end` is allowed to be in either
+      # location. The autofixer will default to `start_of_line`.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
+      #
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: either (default)
+      #
+      #   # good
+      #
+      #   variable = lambda do |i|
+      #     i
+      #   end
+      #
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: start_of_block
+      #
+      #   # good
+      #
+      #   foo.bar
+      #     .each do
+      #        baz
+      #      end
+      #
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: start_of_line
+      #
+      #   # good
+      #
+      #   foo.bar
+      #     .each do
+      #        baz
+      #   end
+      class BlockAlignment < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = '%s is not aligned with %s%s.'.freeze
+
+        def_node_matcher :block_end_align_target?, <<-PATTERN
+          {assignment?
+           splat
+           and
+           or
+           (send _ :<<  ...)
+           (send equal?(%1) !:[] ...)}
+        PATTERN
+
+        def on_block(node)
+          check_block_alignment(start_for_block_node(node), node)
+        end
+
+        def style_parameter_name
+          'EnforcedStyleAlignWith'
+        end
+
+        private
+
+        def start_for_block_node(block_node)
+          # Which node should we align the 'end' with?
+          result = block_end_align_target(block_node)
+
+          # In offense message, we want to show the assignment LHS rather than
+          # the entire assignment
+          result, = *result while result.op_asgn_type? || result.masgn_type?
+          result
+        end
+
+        def block_end_align_target(node)
+          while (parent = node.parent)
+            break if !parent || !parent.loc
+            break if parent.loc.line != node.loc.line && !parent.masgn_type?
+            break unless block_end_align_target?(parent, node)
+            node = parent
+          end
+
+          node
+        end
+
+        def check_block_alignment(start_node, block_node)
+          end_loc = block_node.loc.end
+          return unless begins_its_line?(end_loc)
+
+          start_loc = start_node.source_range
+          return unless start_loc.column != end_loc.column ||
+                        style == :start_of_block
+
+          do_source_line_column =
+            compute_do_source_line_column(block_node, end_loc)
+          return unless do_source_line_column
+
+          register_offense(
+            block_node,
+            start_loc,
+            end_loc,
+            do_source_line_column
+          )
+        end
+
+        def register_offense(block_node,
+                             start_loc,
+                             end_loc,
+                             do_source_line_column)
+
+          error_source_line_column = if style == :start_of_block
+                                       do_source_line_column
+                                     else
+                                       loc_to_source_line_column(start_loc)
+                                     end
+
+          message = format_message(start_loc, end_loc, do_source_line_column,
+                                   error_source_line_column)
+
+          add_offense(block_node, end_loc, message)
+        end
+
+        def format_message(start_loc, end_loc, do_source_line_column,
+                           error_source_line_column)
+          format(
+            MSG,
+            format_source_line_column(loc_to_source_line_column(end_loc)),
+            format_source_line_column(error_source_line_column),
+            alt_start_msg(start_loc, do_source_line_column)
+          )
+        end
+
+        def compute_do_source_line_column(node, end_loc)
+          do_loc = node.loc.begin # Actually it's either do or {.
+
+          # We've found that "end" is not aligned with the start node (which
+          # can be a block, a variable assignment, etc). But we also allow
+          # the "end" to be aligned with the start of the line where the "do"
+          # is, which is a style some people use in multi-line chains of
+          # blocks.
+          match = /\S.*/.match(do_loc.source_line)
+          indentation_of_do_line = match.begin(0)
+          return unless end_loc.column != indentation_of_do_line ||
+                        style == :start_of_line
+
+          {
+            source: match[0],
+            line: do_loc.line,
+            column: indentation_of_do_line
+          }
+        end
+
+        def loc_to_source_line_column(loc)
+          {
+            source: loc.source.lines.to_a.first.chomp,
+            line: loc.line,
+            column: loc.column
+          }
+        end
+
+        def alt_start_msg(start_loc, source_line_column)
+          if style != :either
+            ''
+          elsif start_loc.line == source_line_column[:line] &&
+                start_loc.column == source_line_column[:column]
+            ''
+          else
+            ' or ' + format_source_line_column(source_line_column)
+          end
+        end
+
+        def format_source_line_column(source_line_column)
+          "`#{source_line_column[:source]}` at #{source_line_column[:line]}, " \
+          "#{source_line_column[:column]}"
+        end
+
+        def compute_start_col(ancestor_node, node)
+          if style == :start_of_block
+            do_loc = node.loc.begin
+            return do_loc.source_line =~ /\S/
+          end
+          (ancestor_node || node).source_range.column
+        end
+
+        def autocorrect(node)
+          ancestor_node = start_for_block_node(node)
+          start_col = compute_start_col(ancestor_node, node)
+          loc_end = node.loc.end
+          delta = start_col - loc_end.column
+
+          if delta > 0
+            add_space_before(loc_end, delta)
+          elsif delta < 0
+            remove_space_before(loc_end.begin_pos, -delta)
+          end
+        end
+
+        def add_space_before(loc, delta)
+          ->(corrector) { corrector.insert_before(loc, ' ' * delta) }
+        end
+
+        def remove_space_before(end_pos, delta)
+          range = range_between(end_pos - delta, end_pos)
+          ->(corrector) { corrector.remove(range) }
+        end
+      end
+    end
+  end
+end