rubbycop 0.49.0

data/lib/rubbycop/cop/style/inverse_methods.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop check for usages of not (`not` or `!`) called on a method
+      # when an inverse of that method can be used instead.
+      # Methods that can be inverted by a not (`not` or `!`) should be defined
+      # in `InverseMethods`
+      # Methods that are inverted by inverting the return
+      # of the block that is passed to the method should be defined in
+      # `InverseBlocks`
+      #
+      # @example
+      #   # bad
+      #   !foo.none?
+      #   !foo.any? { |f| f.even? }
+      #   !foo.blank?
+      #   !(foo == bar)
+      #   foo.select { |f| !f.even? }
+      #   foo.reject { |f| f != 7 }
+      #
+      #   # good
+      #   foo.none?
+      #   foo.blank?
+      #   foo.any? { |f| f.even? }
+      #   foo != bar
+      #   foo == bar
+      class InverseMethods < Cop
+        MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'.freeze
+        EQUALITY_METHODS = %i[== != =~ !~ <= >= < >].freeze
+
+        def_node_matcher :inverse_candidate?, <<-PATTERN
+          {
+            (send $(send (...) $_ ...) :!)
+            (send (block $(send (...) $_) ...) :!)
+            (send (begin $(send (...) $_ ...)) :!)
+          }
+        PATTERN
+
+        def_node_matcher :inverse_block?, <<-PATTERN
+          (block $(send (...) $_) ... { $(send ... :!)
+                                        $(send (...) {:!= :!~} ...)
+                                        (begin ... $(send ... :!))
+                                        (begin ... $(send (...) {:!= :!~} ...))
+                                      })
+        PATTERN
+
+        def on_send(node)
+          inverse_candidate?(node) do |_method_call, method|
+            return unless inverse_methods.key?(method)
+
+            add_offense(node,
+                        :expression,
+                        format(MSG, method: method,
+                                    inverse: inverse_methods[method]))
+          end
+        end
+
+        def on_block(node)
+          inverse_block?(node) do |_method_call, method, _block|
+            return unless inverse_blocks.key?(method)
+
+            add_offense(node,
+                        :expression,
+                        format(MSG, method: method,
+                                    inverse: inverse_blocks[method]))
+          end
+        end
+
+        def autocorrect(node)
+          method_call, method = inverse_candidate?(node)
+
+          if method_call && method
+            lambda do |corrector|
+              corrector.remove(not_to_receiver(node, method_call))
+              corrector.replace(method_call.loc.selector,
+                                inverse_methods[method].to_s)
+
+              if EQUALITY_METHODS.include?(method)
+                corrector.remove(end_parentheses(node, method_call))
+              end
+            end
+          else
+            correct_inverse_block(node)
+          end
+        end
+
+        def correct_inverse_block(node)
+          method_call, method, block = inverse_block?(node)
+          selector = block.loc.selector.source
+
+          lambda do |corrector|
+            corrector.replace(method_call.loc.selector,
+                              inverse_blocks[method].to_s)
+
+            if ['!=', '!~'].include?(selector)
+              selector[0] = '='
+              corrector.replace(block.loc.selector, selector)
+            else
+              corrector.remove(block.loc.selector)
+            end
+          end
+        end
+
+        def inverse_methods
+          @inverse_methods ||= cop_config['InverseMethods']
+                               .merge(cop_config['InverseMethods'].invert)
+        end
+
+        def inverse_blocks
+          @inverse_blocks ||= cop_config['InverseBlocks']
+                              .merge(cop_config['InverseBlocks'].invert)
+        end
+
+        def not_to_receiver(node, method_call)
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    node.loc.selector.begin_pos,
+                                    method_call.loc.expression.begin_pos)
+        end
+
+        def end_parentheses(node, method_call)
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    method_call.loc.expression.end_pos,
+                                    node.loc.expression.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 ' \
+                          '%s lambdas.'.freeze
+        METHOD_MESSAGE = 'Use the `lambda` method for %s lambdas.'.freeze
+
+        OFFENDING_SELECTORS = {
+          style: {
+            lambda: { single_line: '->', multiline: '->' },
+            literal: { single_line: 'lambda', multiline: 'lambda' },
+            line_count_dependent: { single_line: 'lambda', multiline: '->' }
+          }
+        }.freeze
+
+        def_node_matcher :lambda_node?, '(block $(send nil :lambda) ...)'
+
+        def on_block(node)
+          lambda_node?(node) do |block_method|
+            selector = block_method.source
+
+            return unless offending_selector?(node, selector)
+
+            add_offense(node,
+                        block_method.source_range,
+                        message(node, selector))
+          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, 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(node)
+          block_method, _args = *node
+          selector = block_method.source
+
+          # Don't autocorrect if this would change the meaning of the code
+          return if selector == '->' && arg_to_unparenthesized_call?(node)
+
+          lambda do |corrector|
+            if selector == 'lambda'
+              autocorrect_method_to_literal(corrector, node)
+            else
+              autocorrect_literal_to_method(corrector, node)
+            end
+          end
+        end
+
+        def autocorrect_literal_to_method(corrector, node)
+          block_method, args = *node
+
+          # Check for unparenthesized args' preceding and trailing whitespaces.
+          remove_unparenthesized_whitespaces(corrector, node)
+
+          # Avoid correcting to `lambdado` by inserting whitespace
+          # if none exists before or after the lambda arguments.
+          if needs_whitespace?(block_method, args, node)
+            corrector.insert_before(node.loc.begin, ' ')
+          end
+          corrector.replace(block_method.source_range, 'lambda')
+          corrector.remove(args.source_range) if args.source_range
+          return if args.children.empty?
+          arg_str = " |#{lambda_arg_string(args)}|"
+          corrector.insert_after(node.loc.begin, arg_str)
+        end
+
+        def autocorrect_method_to_literal(corrector, node)
+          block_method, args = *node
+          corrector.replace(block_method.source_range, '->')
+          return if args.children.empty?
+
+          arg_str = "(#{lambda_arg_string(args)})"
+          whitespace_and_old_args = node.loc.begin.end.join(args.loc.end)
+          corrector.insert_after(block_method.source_range, arg_str)
+          corrector.remove(whitespace_and_old_args)
+        end
+
+        def needs_whitespace?(block_method, args, node)
+          selector_end = block_method.loc.selector.end.end_pos
+          block_begin  = node.loc.begin.begin_pos
+
+          (block_begin == end_pos(args) && selector_end == begin_pos(args)) ||
+            (block_begin == selector_end)
+        end
+
+        def begin_pos(node)
+          node.loc.begin && node.loc.begin.begin_pos
+        end
+
+        def end_pos(node)
+          node.loc.end && node.loc.end.end_pos
+        end
+
+        def lambda_arg_string(args)
+          args.children.map(&:source).join(', ')
+        end
+
+        def arg_to_unparenthesized_call?(arg_node)
+          parent = arg_node.parent
+
+          if parent && parent.pair_type?
+            arg_node = parent.parent
+            parent = arg_node.parent
+          end
+
+          return false unless parent && parent.send_type?
+          return false if parenthesized_call?(parent)
+
+          arg_node.sibling_index > 1
+        end
+
+        def remove_unparenthesized_whitespaces(corrector, node)
+          block_method, args = *node
+          return unless unparenthesized_literal_args?(args)
+          # First, remove leading whitespaces (between arrow and args)
+          corrector.remove_preceding(
+            args.source_range,
+            args.source_range.begin_pos - block_method.source_range.end_pos
+          )
+
+          # Then, remove trailing whitespaces (between args and 'do')
+          delta = node.loc.begin.begin_pos - args.source_range.end_pos - 1
+          corrector.remove_preceding(node.loc.begin, delta)
+        end
+
+        def unparenthesized_literal_args?(args)
+          args.source_range && args.source_range.begin && !parentheses?(args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for use of the lambda.(args) syntax.
+      #
+      # @example
+      #
+      #  # bad
+      #  lambda.(x, y)
+      #
+      #  # good
+      #  lambda.call(x, y)
+      class LambdaCall < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_send(node)
+          return unless node.receiver && node.method?(:call)
+
+          if offense?(node)
+            add_offense(node, :expression) { opposite_style_detected }
+          else
+            correct_style_detected
+          end
+        end
+
+        private
+
+        def offense?(node)
+          explicit_style? && node.implicit_call? ||
+            implicit_style? && !node.implicit_call?
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if explicit_style?
+              receiver = node.receiver.source
+              replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
+
+              corrector.replace(node.source_range, replacement)
+            else
+              corrector.remove(node.loc.selector)
+            end
+          end
+        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/rubbycop/cop/style/line_end_concatenation.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+        MSG = 'Use `\\` instead of `+` or `<<` to concatenate ' \
+              'those strings.'.freeze
+        CONCAT_TOKEN_TYPES = %i[tPLUS tLSHFT].freeze
+        SIMPLE_STRING_TOKEN_TYPE = :tSTRING
+        COMPLEX_STRING_EDGE_TOKEN_TYPES = %i[tSTRING_BEG tSTRING_END].freeze
+        HIGH_PRECEDENCE_OP_TOKEN_TYPES = %i[tSTAR2 tPERCENT tDOT
+                                            tLBRACK2].freeze
+        QUOTE_DELIMITERS = %w[' "].freeze
+
+        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(operator_range,
+                                                        :right,
+                                                        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_successor?(successor) &&
+                        eligible_operator?(operator) &&
+                        eligible_predecessor?(predecessor)
+
+          return if operator.pos.line == successor.pos.line
+
+          next_successor = token_after_last_string(successor, index)
+
+          return unless eligible_next_successor?(next_successor)
+
+          add_offense(operator.pos, operator.pos)
+        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
+          begin_token, end_token = COMPLEX_STRING_EDGE_TOKEN_TYPES
+          if successor.type == begin_token
+            ends_to_find = 1
+            while ends_to_find > 0
+              case processed_source.tokens[index].type
+              when begin_token then ends_to_find += 1
+              when 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_EDGE_TOKEN_TYPES
+            QUOTE_DELIMITERS.include?(token.text)
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end