rubocop 0.87.1

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop (by default) checks for uses of the lambda literal syntax for
+      # single line lambdas, and the method call syntax for multiline lambdas.
+      # It is configurable to enforce one of the styles for both single line
+      # and multiline lambdas as well.
+      #
+      # @example EnforcedStyle: line_count_dependent (default)
+      #   # bad
+      #   f = lambda { |x| x }
+      #   f = ->(x) do
+      #         x
+      #       end
+      #
+      #   # good
+      #   f = ->(x) { x }
+      #   f = lambda do |x|
+      #         x
+      #       end
+      #
+      # @example EnforcedStyle: lambda
+      #   # bad
+      #   f = ->(x) { x }
+      #   f = ->(x) do
+      #         x
+      #       end
+      #
+      #   # good
+      #   f = lambda { |x| x }
+      #   f = lambda do |x|
+      #         x
+      #       end
+      #
+      # @example EnforcedStyle: literal
+      #   # bad
+      #   f = lambda { |x| x }
+      #   f = lambda do |x|
+      #         x
+      #       end
+      #
+      #   # good
+      #   f = ->(x) { x }
+      #   f = ->(x) do
+      #         x
+      #       end
+      class Lambda < Cop
+        include ConfigurableEnforcedStyle
+
+        LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for ' \
+                          '%<modifier>s lambdas.'
+        METHOD_MESSAGE = 'Use the `lambda` method for %<modifier>s ' \
+                         'lambdas.'
+
+        OFFENDING_SELECTORS = {
+          style: {
+            lambda: { single_line: '->', multiline: '->' },
+            literal: { single_line: 'lambda', multiline: 'lambda' },
+            line_count_dependent: { single_line: 'lambda', multiline: '->' }
+          }
+        }.freeze
+
+        def on_block(node)
+          return unless node.lambda?
+
+          selector = node.send_node.source
+
+          return unless offending_selector?(node, selector)
+
+          add_offense(node,
+                      location: node.send_node.source_range,
+                      message: message(node, selector))
+        end
+        alias on_numblock on_block
+
+        def autocorrect(node)
+          if node.send_node.source == 'lambda'
+            lambda do |corrector|
+              autocorrect_method_to_literal(corrector, node)
+            end
+          else
+            LambdaLiteralToMethodCorrector.new(node)
+          end
+        end
+
+        private
+
+        def offending_selector?(node, selector)
+          lines = node.multiline? ? :multiline : :single_line
+
+          selector == OFFENDING_SELECTORS[:style][style][lines]
+        end
+
+        def message(node, selector)
+          message = selector == '->' ? METHOD_MESSAGE : LITERAL_MESSAGE
+
+          format(message, modifier: message_line_modifier(node))
+        end
+
+        def message_line_modifier(node)
+          case style
+          when :line_count_dependent
+            node.multiline? ? 'multiline' : 'single line'
+          else
+            'all'
+          end
+        end
+
+        def autocorrect_method_to_literal(corrector, node)
+          corrector.replace(node.send_node, '->')
+
+          return unless node.arguments?
+
+          arg_str = "(#{lambda_arg_string(node.arguments)})"
+
+          corrector.insert_after(node.send_node, arg_str)
+          corrector.remove(arguments_with_whitespace(node))
+        end
+
+        def arguments_with_whitespace(node)
+          node.loc.begin.end.join(node.arguments.loc.end)
+        end
+
+        def lambda_arg_string(args)
+          args.children.map(&:source).join(', ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for use of the lambda.(args) syntax.
+      #
+      # @example EnforcedStyle: call (default)
+      #  # bad
+      #  lambda.(x, y)
+      #
+      #  # good
+      #  lambda.call(x, y)
+      #
+      # @example EnforcedStyle: braces
+      #  # bad
+      #  lambda.call(x, y)
+      #
+      #  # good
+      #  lambda.(x, y)
+      class LambdaCall < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_send(node)
+          return unless node.receiver && node.method?(:call)
+
+          if offense?(node)
+            add_offense(node) { opposite_style_detected }
+          else
+            correct_style_detected
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if explicit_style?
+              receiver = node.receiver.source
+              replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
+
+              corrector.replace(node, replacement)
+            else
+              add_parentheses(node, corrector) unless node.parenthesized?
+              corrector.remove(node.loc.selector)
+            end
+          end
+        end
+
+        private
+
+        def offense?(node)
+          explicit_style? && node.implicit_call? ||
+            implicit_style? && !node.implicit_call?
+        end
+
+        def message(_node)
+          if explicit_style?
+            'Prefer the use of `lambda.call(...)` over `lambda.(...)`.'
+          else
+            'Prefer the use of `lambda.(...)` over `lambda.call(...)`.'
+          end
+        end
+
+        def implicit_style?
+          style == :braces
+        end
+
+        def explicit_style?
+          style == :call
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for string literal concatenation at
+      # the end of a line.
+      #
+      # @example
+      #
+      #   # bad
+      #   some_str = 'ala' +
+      #              'bala'
+      #
+      #   some_str = 'ala' <<
+      #              'bala'
+      #
+      #   # good
+      #   some_str = 'ala' \
+      #              'bala'
+      #
+      class LineEndConcatenation < Cop
+        include RangeHelp
+
+        MSG = 'Use `\\` instead of `+` or `<<` to concatenate ' \
+              'those strings.'
+        CONCAT_TOKEN_TYPES = %i[tPLUS tLSHFT].freeze
+        SIMPLE_STRING_TOKEN_TYPE = :tSTRING
+        COMPLEX_STRING_BEGIN_TOKEN = :tSTRING_BEG
+        COMPLEX_STRING_END_TOKEN = :tSTRING_END
+        HIGH_PRECEDENCE_OP_TOKEN_TYPES = %i[tSTAR2 tPERCENT tDOT
+                                            tLBRACK2].freeze
+        QUOTE_DELIMITERS = %w[' "].freeze
+
+        def self.autocorrect_incompatible_with
+          [Style::RedundantInterpolation]
+        end
+
+        def investigate(processed_source)
+          processed_source.tokens.each_index do |index|
+            check_token_set(index)
+          end
+        end
+
+        def autocorrect(operator_range)
+          # Include any trailing whitespace so we don't create a syntax error.
+          operator_range = range_with_surrounding_space(range: operator_range,
+                                                        side: :right,
+                                                        newlines: false)
+          one_more_char = operator_range.resize(operator_range.size + 1)
+          # Don't create a double backslash at the end of the line, in case
+          # there already was a backslash after the concatenation operator.
+          operator_range = one_more_char if one_more_char.source.end_with?('\\')
+
+          ->(corrector) { corrector.replace(operator_range, '\\') }
+        end
+
+        private
+
+        def check_token_set(index)
+          predecessor, operator, successor = processed_source.tokens[index, 3]
+
+          return unless eligible_token_set?(predecessor, operator, successor)
+
+          return if operator.line == successor.line
+
+          next_successor = token_after_last_string(successor, index)
+
+          return unless eligible_next_successor?(next_successor)
+
+          add_offense(operator.pos, location: operator.pos)
+        end
+
+        def eligible_token_set?(predecessor, operator, successor)
+          eligible_successor?(successor) &&
+            eligible_operator?(operator) &&
+            eligible_predecessor?(predecessor)
+        end
+
+        def eligible_successor?(successor)
+          successor && standard_string_literal?(successor)
+        end
+
+        def eligible_operator?(operator)
+          CONCAT_TOKEN_TYPES.include?(operator.type)
+        end
+
+        def eligible_next_successor?(next_successor)
+          !(next_successor &&
+            HIGH_PRECEDENCE_OP_TOKEN_TYPES.include?(next_successor.type))
+        end
+
+        def eligible_predecessor?(predecessor)
+          standard_string_literal?(predecessor)
+        end
+
+        def token_after_last_string(successor, base_index)
+          index = base_index + 3
+          if successor.type == COMPLEX_STRING_BEGIN_TOKEN
+            ends_to_find = 1
+            while ends_to_find.positive?
+              case processed_source.tokens[index].type
+              when COMPLEX_STRING_BEGIN_TOKEN then ends_to_find += 1
+              when COMPLEX_STRING_END_TOKEN then ends_to_find -= 1
+              end
+              index += 1
+            end
+          end
+          processed_source.tokens[index]
+        end
+
+        def standard_string_literal?(token)
+          case token.type
+          when SIMPLE_STRING_TOKEN_TYPE
+            true
+          when COMPLEX_STRING_BEGIN_TOKEN, COMPLEX_STRING_END_TOKEN
+            QUOTE_DELIMITERS.include?(token.text)
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the presence (default) or absence of parentheses in
+      # method calls containing parameters.
+      #
+      # In the default style (require_parentheses), macro methods are ignored.
+      # Additional methods can be added to the `IgnoredMethods`
+      # or `IgnoredPatterns` list. These options are
+      # valid only in the default style. Macros can be included by
+      # either setting `IgnoreMacros` to false or adding specific macros to
+      # the `IncludedMacros` list.
+      #
+      # Precedence of options is all follows:
+      #
+      # 1. `IgnoredMethods`
+      # 2. `IgnoredPatterns`
+      # 3. `IncludedMacros`
+      #
+      # eg. If a method is listed in both
+      # `IncludedMacros` and `IgnoredMethods`, then the latter takes
+      # precedence (that is, the method is ignored).
+      #
+      # In the alternative style (omit_parentheses), there are three additional
+      # options.
+      #
+      # 1. `AllowParenthesesInChaining` is `false` by default. Setting it to
+      #    `true` allows the presence of parentheses in the last call during
+      #    method chaining.
+      #
+      # 2. `AllowParenthesesInMultilineCall` is `false` by default. Setting it
+      #     to `true` allows the presence of parentheses in multi-line method
+      #     calls.
+      #
+      # 3. `AllowParenthesesInCamelCaseMethod` is `false` by default. This
+      #     allows the presence of parentheses when calling a method whose name
+      #     begins with a capital letter and which has no arguments. Setting it
+      #     to `true` allows the presence of parentheses in such a method call
+      #     even with arguments.
+      #
+      # @example EnforcedStyle: require_parentheses (default)
+      #
+      #   # bad
+      #   array.delete e
+      #
+      #   # good
+      #   array.delete(e)
+      #
+      #   # good
+      #   # Operators don't need parens
+      #   foo == bar
+      #
+      #   # good
+      #   # Setter methods don't need parens
+      #   foo.bar = baz
+      #
+      #   # okay with `puts` listed in `IgnoredMethods`
+      #   puts 'test'
+      #
+      #   # okay with `^assert` listed in `IgnoredPatterns`
+      #   assert_equal 'test', x
+      #
+      # @example EnforcedStyle: omit_parentheses
+      #
+      #   # bad
+      #   array.delete(e)
+      #
+      #   # good
+      #   array.delete e
+      #
+      #   # bad
+      #   foo.enforce(strict: true)
+      #
+      #   # good
+      #   foo.enforce strict: true
+      #
+      # @example IgnoreMacros: true (default)
+      #
+      #   # good
+      #   class Foo
+      #     bar :baz
+      #   end
+      #
+      # @example IgnoreMacros: false
+      #
+      #   # bad
+      #   class Foo
+      #     bar :baz
+      #   end
+      #
+      # @example AllowParenthesesInMultilineCall: false (default)
+      #
+      #   # bad
+      #   foo.enforce(
+      #     strict: true
+      #   )
+      #
+      #   # good
+      #   foo.enforce \
+      #     strict: true
+      #
+      # @example AllowParenthesesInMultilineCall: true
+      #
+      #   # good
+      #   foo.enforce(
+      #     strict: true
+      #   )
+      #
+      #   # good
+      #   foo.enforce \
+      #     strict: true
+      #
+      # @example AllowParenthesesInChaining: false (default)
+      #
+      #   # bad
+      #   foo().bar(1)
+      #
+      #   # good
+      #   foo().bar 1
+      #
+      # @example AllowParenthesesInChaining: true
+      #
+      #   # good
+      #   foo().bar(1)
+      #
+      #   # good
+      #   foo().bar 1
+      #
+      # @example AllowParenthesesInCamelCaseMethod: false (default)
+      #
+      #   # bad
+      #   Array(1)
+      #
+      #   # good
+      #   Array 1
+      #
+      # @example AllowParenthesesInCamelCaseMethod: true
+      #
+      #   # good
+      #   Array(1)
+      #
+      #   # good
+      #   Array 1
+      class MethodCallWithArgsParentheses < Cop
+        include ConfigurableEnforcedStyle
+        include IgnoredMethods
+        include IgnoredPattern
+
+        def initialize(*)
+          super
+          return unless style_configured?
+
+          case style
+          when :require_parentheses
+            extend RequireParentheses
+          when :omit_parentheses
+            extend OmitParentheses
+          end
+        end
+
+        # @abstract Overridden in style modules
+        def autocorrect(_node); end
+
+        private
+
+        def args_begin(node)
+          loc = node.loc
+          selector =
+            node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+
+          resize_by = args_parenthesized?(node) ? 2 : 1
+          selector.end.resize(resize_by)
+        end
+
+        def args_end(node)
+          node.loc.expression.end
+        end
+
+        def args_parenthesized?(node)
+          return false unless node.arguments.one?
+
+          first_node = node.arguments.first
+          first_node.begin_type? && first_node.parenthesized_call?
+        end
+      end
+    end
+  end
+end