rubocop 0.75.1

data/lib/rubocop/cop/style/trailing_body_on_module.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing code after the module definition.
+      #
+      # @example
+      #   # bad
+      #   module Foo extend self
+      #   end
+      #
+      #   # good
+      #   module Foo
+      #     extend self
+      #   end
+      #
+      class TrailingBodyOnModule < Cop
+        include Alignment
+        include TrailingBody
+
+        MSG = 'Place the first line of module body on its own line.'
+
+        def on_module(node)
+          return unless trailing_body?(node)
+
+          add_offense(node, location: first_part_of(node.to_a.last))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            LineBreakCorrector.correct_trailing_body(
+              configured_width: configured_indentation_width,
+              corrector: corrector,
+              node: node,
+              processed_source: processed_source
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/trailing_comma_in_arguments.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing comma in argument lists.
+      #
+      # @example EnforcedStyleForMultiline: consistent_comma
+      #   # bad
+      #   method(1, 2,)
+      #
+      #   # good
+      #   method(1, 2)
+      #
+      #   # good
+      #   method(
+      #     1, 2,
+      #     3,
+      #   )
+      #
+      #   # good
+      #   method(
+      #     1,
+      #     2,
+      #   )
+      #
+      # @example EnforcedStyleForMultiline: comma
+      #   # bad
+      #   method(1, 2,)
+      #
+      #   # good
+      #   method(1, 2)
+      #
+      #   # good
+      #   method(
+      #     1,
+      #     2,
+      #   )
+      #
+      # @example EnforcedStyleForMultiline: no_comma (default)
+      #   # bad
+      #   method(1, 2,)
+      #
+      #   # good
+      #   method(1, 2)
+      #
+      #   # good
+      #   method(
+      #     1,
+      #     2
+      #   )
+      class TrailingCommaInArguments < Cop
+        include TrailingComma
+
+        def on_send(node)
+          return unless node.arguments? && node.parenthesized?
+
+          check(node, node.arguments, 'parameter of %<article>s method call',
+                node.last_argument.source_range.end_pos,
+                node.source_range.end_pos)
+        end
+        alias on_csend on_send
+
+        def autocorrect(range)
+          PunctuationCorrector.swap_comma(range)
+        end
+
+        def self.autocorrect_incompatible_with
+          [Layout::HeredocArgumentClosingParenthesis]
+        end
+
+        private
+
+        def avoid_autocorrect?(args)
+          args.last.hash_type? && args.last.braces? &&
+            braces_will_be_removed?(args)
+        end
+
+        # Returns true if running with --auto-correct would remove the braces
+        # of the last argument.
+        def braces_will_be_removed?(args)
+          brace_config = config.for_cop('Style/BracesAroundHashParameters')
+          return false unless brace_config.fetch('Enabled')
+          return false if brace_config['AutoCorrect'] == false
+
+          brace_style = brace_config['EnforcedStyle']
+          return true if brace_style == 'no_braces'
+
+          return false unless brace_style == 'context_dependent'
+
+          args.one? || !args[-2].hash_type?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/trailing_comma_in_array_literal.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing comma in array literals.
+      #
+      # @example EnforcedStyleForMultiline: consistent_comma
+      #   # bad
+      #   a = [1, 2,]
+      #
+      #   # good
+      #   a = [
+      #     1, 2,
+      #     3,
+      #   ]
+      #
+      #   # good
+      #   a = [
+      #     1,
+      #     2,
+      #   ]
+      #
+      # @example EnforcedStyleForMultiline: comma
+      #   # bad
+      #   a = [1, 2,]
+      #
+      #   # good
+      #   a = [
+      #     1,
+      #     2,
+      #   ]
+      #
+      # @example EnforcedStyleForMultiline: no_comma (default)
+      #   # bad
+      #   a = [1, 2,]
+      #
+      #   # good
+      #   a = [
+      #     1,
+      #     2
+      #   ]
+      class TrailingCommaInArrayLiteral < Cop
+        include TrailingComma
+
+        def on_array(node)
+          return unless node.square_brackets?
+
+          check_literal(node, 'item of %<article>s array')
+        end
+
+        def autocorrect(range)
+          PunctuationCorrector.swap_comma(range)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/trailing_comma_in_hash_literal.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing comma in hash literals.
+      #
+      # @example EnforcedStyleForMultiline: consistent_comma
+      #   # bad
+      #   a = { foo: 1, bar: 2, }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1, bar: 2,
+      #     qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1,
+      #     bar: 2,
+      #   }
+      #
+      # @example EnforcedStyleForMultiline: comma
+      #   # bad
+      #   a = { foo: 1, bar: 2, }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1,
+      #     bar: 2,
+      #   }
+      #
+      # @example EnforcedStyleForMultiline: no_comma (default)
+      #   # bad
+      #   a = { foo: 1, bar: 2, }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1,
+      #     bar: 2
+      #   }
+      class TrailingCommaInHashLiteral < Cop
+        include TrailingComma
+
+        def on_hash(node)
+          check_literal(node, 'item of %<article>s hash')
+        end
+
+        def autocorrect(range)
+          PunctuationCorrector.swap_comma(range)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/trailing_method_end_statement.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing code after the method definition.
+      #
+      # @example
+      #   # bad
+      #   def some_method
+      #   do_stuff; end
+      #
+      #   def do_this(x)
+      #     baz.map { |b| b.this(x) } end
+      #
+      #   def foo
+      #     block do
+      #       bar
+      #     end end
+      #
+      #   # good
+      #   def some_method
+      #     do_stuff
+      #   end
+      #
+      #   def do_this(x)
+      #     baz.map { |b| b.this(x) }
+      #   end
+      #
+      #   def foo
+      #     block do
+      #       bar
+      #     end
+      #   end
+      #
+      class TrailingMethodEndStatement < Cop
+        include Alignment
+
+        MSG = 'Place the end statement of a multi-line method on ' \
+              'its own line.'
+
+        def on_def(node)
+          return unless trailing_end?(node)
+
+          add_offense(node, location: end_token(node).pos)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            break_line_before_end(node, corrector)
+            remove_semicolon(node, corrector)
+          end
+        end
+
+        private
+
+        def trailing_end?(node)
+          node.body &&
+            node.multiline? &&
+            body_and_end_on_same_line?(node)
+        end
+
+        def end_token(node)
+          tokens(node).reverse.find(&:end?)
+        end
+
+        def body_and_end_on_same_line?(node)
+          end_token(node).line == token_before_end(node).line
+        end
+
+        def token_before_end(node)
+          i = tokens(node).index(end_token(node))
+          tokens(node)[i - 1]
+        end
+
+        def break_line_before_end(node, corrector)
+          corrector.insert_before(
+            end_token(node).pos,
+            "\n" + ' ' * configured_indentation_width
+          )
+        end
+
+        def remove_semicolon(node, corrector)
+          return unless token_before_end(node).semicolon?
+
+          corrector.remove(token_before_end(node).pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/trailing_underscore_variable.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for extra underscores in variable assignment.
+      #
+      # @example
+      #   # bad
+      #   a, b, _ = foo()
+      #   a, b, _, = foo()
+      #   a, _, _ = foo()
+      #   a, _, _, = foo()
+      #
+      #   # good
+      #   a, b, = foo()
+      #   a, = foo()
+      #   *a, b, _ = foo()
+      #   # => We need to know to not include 2 variables in a
+      #   a, *b, _ = foo()
+      #   # => The correction `a, *b, = foo()` is a syntax error
+      #
+      #   # good if AllowNamedUnderscoreVariables is true
+      #   a, b, _something = foo()
+      class TrailingUnderscoreVariable < Cop
+        include SurroundingSpace
+        include RangeHelp
+
+        MSG = 'Do not use trailing `_`s in parallel assignment. ' \
+              'Prefer `%<code>s`.'
+        UNDERSCORE = '_'
+
+        def on_masgn(node)
+          ranges = unneeded_ranges(node)
+
+          ranges.each do |range|
+            good_code = node.source
+            offset = range.begin_pos - node.source_range.begin_pos
+            good_code[offset, range.size] = ''
+
+            add_offense(node,
+                        location: range,
+                        message: format(MSG, code: good_code))
+          end
+        end
+
+        def autocorrect(node)
+          ranges = unneeded_ranges(node)
+
+          lambda do |corrector|
+            ranges.each { |range| corrector.remove(range) if range }
+          end
+        end
+
+        private
+
+        def find_first_offense(variables)
+          first_offense = find_first_possible_offense(variables.reverse)
+
+          return unless first_offense
+          return if splat_variable_before?(first_offense, variables)
+
+          first_offense
+        end
+
+        def find_first_possible_offense(variables)
+          variables.reduce(nil) do |offense, variable|
+            break offense unless %i[lvasgn splat].include?(variable.type)
+
+            var, = *variable
+            var, = *var
+            if allow_named_underscore_variables
+              break offense unless var == :_
+            else
+              break offense unless var.to_s.start_with?(UNDERSCORE)
+            end
+
+            variable
+          end
+        end
+
+        def splat_variable_before?(first_offense, variables)
+          # Account for cases like `_, *rest, _`, where we would otherwise get
+          # the index of the first underscore.
+          first_offense_index = reverse_index(variables, first_offense)
+
+          variables[0...first_offense_index].any?(&:splat_type?)
+        end
+
+        def reverse_index(collection, item)
+          collection.size - 1 - collection.reverse.index(item)
+        end
+
+        def allow_named_underscore_variables
+          @allow_named_underscore_variables ||=
+            cop_config['AllowNamedUnderscoreVariables']
+        end
+
+        def unneeded_ranges(node)
+          node.masgn_type? ? (mlhs_node, = *node) : mlhs_node = node
+          variables = *mlhs_node
+
+          main_offense = main_node_offense(node)
+          if main_offense.nil?
+            children_offenses(variables)
+          else
+            children_offenses(variables) << main_offense
+          end
+        end
+
+        def main_node_offense(node)
+          node.masgn_type? ? (mlhs_node, right = *node) : mlhs_node = node
+
+          variables = *mlhs_node
+          first_offense = find_first_offense(variables)
+
+          return unless first_offense
+
+          if unused_variables_only?(first_offense, variables)
+            return unused_range(node.type, mlhs_node, right)
+          end
+
+          if Util.parentheses?(mlhs_node)
+            return range_for_parentheses(first_offense, mlhs_node)
+          end
+
+          range_between(first_offense.source_range.begin_pos,
+                        node.loc.operator.begin_pos)
+        end
+
+        def children_offenses(variables)
+          variables.select(&:mlhs_type?).flat_map { |v| unneeded_ranges(v) }
+        end
+
+        def unused_variables_only?(offense, variables)
+          offense.source_range == variables.first.source_range
+        end
+
+        def unused_range(node_type, mlhs_node, right)
+          start_range = mlhs_node.source_range.begin_pos
+
+          end_range = case node_type
+                      when :masgn
+                        right.source_range.begin_pos
+                      when :mlhs
+                        mlhs_node.source_range.end_pos
+                      end
+
+          range_between(start_range, end_range)
+        end
+
+        def range_for_parentheses(offense, left)
+          range_between(
+            offense.source_range.begin_pos - 1,
+            left.loc.expression.end_pos - 1
+          )
+        end
+      end
+    end
+  end
+end