rbhint 0.8.5.rc1

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop looks for trailing blank lines and a final newline in the
+      # source code.
+      #
+      # @example EnforcedStyle: final_blank_line
+      #   # `final_blank_line` looks for one blank line followed by a new line
+      #   # at the end of files.
+      #
+      #   # bad
+      #   class Foo; end
+      #   # EOF
+      #
+      #   # bad
+      #   class Foo; end # EOF
+      #
+      #   # good
+      #   class Foo; end
+      #
+      #   # EOF
+      #
+      # @example EnforcedStyle: final_newline (default)
+      #   # `final_newline` looks for one newline at the end of files.
+      #
+      #   # bad
+      #   class Foo; end
+      #
+      #   # EOF
+      #
+      #   # bad
+      #   class Foo; end # EOF
+      #
+      #   # good
+      #   class Foo; end
+      #   # EOF
+      #
+      class TrailingEmptyLines < Cop
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        def investigate(processed_source)
+          buffer = processed_source.buffer
+          return if buffer.source.empty?
+
+          # The extra text that comes after the last token could be __END__
+          # followed by some data to read. If so, we don't check it because
+          # there could be good reasons why it needs to end with a certain
+          # number of newlines.
+          return if ends_in_end?(processed_source)
+
+          whitespace_at_end = buffer.source[/\s*\Z/]
+          blank_lines = whitespace_at_end.count("\n") - 1
+          wanted_blank_lines = style == :final_newline ? 0 : 1
+
+          return unless blank_lines != wanted_blank_lines
+
+          offense_detected(buffer, wanted_blank_lines, blank_lines,
+                           whitespace_at_end)
+        end
+
+        def autocorrect(range)
+          lambda do |corrector|
+            corrector.replace(range, style == :final_newline ? "\n" : "\n\n")
+          end
+        end
+
+        private
+
+        def offense_detected(buffer, wanted_blank_lines, blank_lines,
+                             whitespace_at_end)
+          begin_pos = buffer.source.length - whitespace_at_end.length
+          autocorrect_range = range_between(begin_pos, buffer.source.length)
+          begin_pos += 1 unless whitespace_at_end.empty?
+          report_range = range_between(begin_pos, buffer.source.length)
+
+          add_offense(autocorrect_range,
+                      location: report_range,
+                      message: message(wanted_blank_lines, blank_lines))
+        end
+
+        def ends_in_end?(processed_source)
+          buffer = processed_source.buffer
+
+          return true if buffer.source.strip.start_with?('__END__')
+          return false if processed_source.tokens.empty?
+
+          extra = buffer.source[processed_source.tokens.last.end_pos..-1]
+          extra&.strip&.start_with?('__END__')
+        end
+
+        def message(wanted_blank_lines, blank_lines)
+          case blank_lines
+          when -1
+            'Final newline missing.'
+          when 0
+            'Trailing blank line missing.'
+          else
+            instead_of = if wanted_blank_lines.zero?
+                           ''
+                         else
+                           "instead of #{wanted_blank_lines} "
+                         end
+            format('%<current>d trailing blank lines %<prefer>sdetected.',
+                   current: blank_lines, prefer: instead_of)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop looks for trailing whitespace in the source code.
+      #
+      # @example
+      #   # The line in this example contains spaces after the 0.
+      #   # bad
+      #   x = 0
+      #
+      #   # The line in this example ends directly after the 0.
+      #   # good
+      #   x = 0
+      #
+      # @example AllowInHeredoc: false
+      #   # The line in this example contains spaces after the 0.
+      #   # bad
+      #   code = <<~RUBY
+      #     x = 0
+      #   RUBY
+      #
+      # @example AllowInHeredoc: true (default)
+      #   # The line in this example contains spaces after the 0.
+      #   # good
+      #   code = <<~RUBY
+      #     x = 0
+      #   RUBY
+      #
+      class TrailingWhitespace < Cop
+        include RangeHelp
+
+        MSG = 'Trailing whitespace detected.'
+
+        def investigate(processed_source)
+          heredoc_ranges = extract_heredoc_ranges(processed_source.ast)
+          processed_source.lines.each_with_index do |line, index|
+            lineno = index + 1
+
+            next unless line.end_with?(' ', "\t")
+            next if skip_heredoc? && inside_heredoc?(heredoc_ranges, lineno)
+
+            range = source_range(processed_source.buffer,
+                                 lineno,
+                                 (line.rstrip.length)...(line.length))
+
+            add_offense(range, location: range)
+          end
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def skip_heredoc?
+          cop_config.fetch('AllowInHeredoc', false)
+        end
+
+        def inside_heredoc?(heredoc_ranges, line_number)
+          heredoc_ranges.any? { |r| r.include?(line_number) }
+        end
+
+        def extract_heredoc_ranges(ast)
+          return [] unless ast
+
+          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
+            body = node.location.heredoc_body
+            (body.first_line...body.last_line)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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 `%<param>s` to make sure that the ' \
+              'block will be associated with the `%<method>s` method ' \
+              'call.'
+
+        def on_send(node)
+          return if !node.arguments? || node.parenthesized? ||
+                    node.last_argument.lambda? || allowed_method?(node)
+
+          return unless ambiguous_block_association?(node)
+
+          add_offense(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def ambiguous_block_association?(send_node)
+          send_node.last_argument.block_type? &&
+            !send_node.last_argument.send_node.arguments?
+        end
+
+        def allowed_method?(node)
+          node.assignment? || node.operator_method? || node.method?(:[])
+        end
+
+        def message(send_node)
+          block_param = send_node.last_argument
+
+          format(MSG, param: block_param.source,
+                      method: block_param.send_node.source)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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.'
+
+        def autocorrect(node)
+          lambda do |corrector|
+            add_parentheses(node, corrector)
+          end
+        end
+
+        private
+
+        def relevant_diagnostic?(diagnostic)
+          diagnostic.reason == :ambiguous_prefix
+        end
+
+        def find_offense_node_by(diagnostic)
+          ast = processed_source.ast
+          ast.each_node(:splat, :block_pass, :kwsplat) do |node|
+            next unless offense_position?(node, diagnostic)
+
+            offense_node = offense_node(node)
+            return offense_node if offense_node
+          end
+
+          ast.each_node(:send).find do |send_node|
+            first_argument = send_node.first_argument
+
+            first_argument &&
+              offense_position?(first_argument, diagnostic) &&
+              unary_operator?(first_argument, diagnostic)
+          end
+        end
+
+        def alternative_message(diagnostic)
+          operator = diagnostic.location.source
+          hash = AMBIGUITIES[operator]
+          format(MSG_FORMAT, hash)
+        end
+
+        def offense_position?(node, diagnostic)
+          node.source_range.begin_pos == diagnostic.location.begin_pos
+        end
+
+        def offense_node(node)
+          case node.type
+          when :splat, :block_pass
+            node.parent
+          when :kwsplat
+            node.parent.parent
+          end
+        end
+
+        def unary_operator?(node, diagnostic)
+          node.source.start_with?(diagnostic.arguments[:prefix])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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.'
+
+        def autocorrect(node)
+          lambda do |corrector|
+            add_parentheses(node, corrector)
+          end
+        end
+
+        private
+
+        def relevant_diagnostic?(diagnostic)
+          diagnostic.reason == :ambiguous_literal
+        end
+
+        def find_offense_node_by(diagnostic)
+          node = processed_source.ast.each_node(:regexp).find do |regexp_node|
+            regexp_node.source_range.begin_pos == diagnostic.location.begin_pos
+          end
+
+          node.parent
+        end
+
+        def alternative_message(_diagnostic)
+          MSG
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for assignments in the conditions of
+      # if/while/until.
+      #
+      # `AllowSafeAssignment` option for safe assignment.
+      # By safe assignment we mean putting parentheses around
+      # an assignment to indicate "I know I'm using an assignment
+      # as a condition. It's not a mistake."
+      #
+      # @example
+      #   # bad
+      #   if some_var = true
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if some_var == true
+      #     do_something
+      #   end
+      #
+      # @example AllowSafeAssignment: true (default)
+      #   # good
+      #   if (some_var = true)
+      #     do_something
+      #   end
+      #
+      # @example AllowSafeAssignment: false
+      #   # bad
+      #   if (some_var = true)
+      #     do_something
+      #   end
+      #
+      class AssignmentInCondition < Cop
+        include SafeAssignment
+
+        MSG_WITH_SAFE_ASSIGNMENT_ALLOWED =
+          'Use `==` if you meant to do a comparison or wrap the expression ' \
+          'in parentheses to indicate you meant to assign in a ' \
+          'condition.'
+        MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED =
+          'Use `==` if you meant to do a comparison or move the assignment ' \
+          'up out of the condition.'
+        ASGN_TYPES = [:begin, *AST::Node::EQUALS_ASSIGNMENTS, :send].freeze
+
+        def on_if(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, location: :operator)
+          end
+        end
+        alias on_while on_if
+        alias on_until on_if
+
+        private
+
+        def message(_node)
+          if safe_assignment_allowed?
+            MSG_WITH_SAFE_ASSIGNMENT_ALLOWED
+          else
+            MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED
+          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.assignment_method?) ||
+            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