rubbycop 0.49.0

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Use symbols as procs when possible.
+      #
+      # @example
+      #   # bad
+      #   something.map { |s| s.upcase }
+      #
+      #   # good
+      #   something.map(&:upcase)
+      class SymbolProc < Cop
+        MSG = 'Pass `&:%s` as an argument to `%s` instead of a block.'.freeze
+        SUPER_TYPES = %i[super zsuper].freeze
+
+        def_node_matcher :proc_node?, '(send (const nil :Proc) :new)'
+        def_node_matcher :symbol_proc?, <<-PATTERN
+          (block
+            ${(send ...) (super ...) zsuper}
+            $(args (arg _))
+            $(send lvar $_))
+        PATTERN
+
+        def on_block(node)
+          symbol_proc?(node) do |send_or_super, block_args, block_body, method|
+            block_method_name = resolve_block_method_name(send_or_super)
+
+            # TODO: Rails-specific handling that we should probably make
+            # configurable - https://github.com/bbatsov/rubbycop/issues/1485
+            # we should ignore lambdas & procs
+            return if proc_node?(send_or_super)
+            return if %i[lambda proc].include?(block_method_name)
+            return if ignored_method?(block_method_name)
+            return unless can_shorten?(block_args, block_body)
+
+            offense(node, method, block_method_name)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            block_send_or_super, _block_args, block_body = *node
+            _receiver, method_name, _args = *block_body
+
+            if super?(block_send_or_super)
+              args = *block_send_or_super
+            else
+              _breceiver, _bmethod_name, *args = *block_send_or_super
+            end
+            autocorrect_method(corrector, node, args, method_name)
+          end
+        end
+
+        private
+
+        def resolve_block_method_name(block_send_or_super)
+          return :super if super?(block_send_or_super)
+
+          _receiver, method_name, _args = *block_send_or_super
+          method_name
+        end
+
+        def offense(node, method_name, block_method_name)
+          block_start = node.loc.begin.begin_pos
+          block_end = node.loc.end.end_pos
+          range = range_between(block_start, block_end)
+
+          add_offense(node,
+                      range,
+                      format(MSG,
+                             method_name,
+                             block_method_name))
+        end
+
+        def autocorrect_method(corrector, node, args, method_name)
+          if args.empty?
+            autocorrect_no_args(corrector, node, method_name)
+          else
+            autocorrect_with_args(corrector, node, args, method_name)
+          end
+        end
+
+        def autocorrect_no_args(corrector, node, method_name)
+          corrector.replace(block_range_with_space(node), "(&:#{method_name})")
+        end
+
+        def autocorrect_with_args(corrector, node, args, method_name)
+          arg_range = args.last.source_range
+          arg_range = range_with_surrounding_comma(arg_range, :right)
+          replacement = " &:#{method_name}"
+          replacement = ',' + replacement unless arg_range.source.end_with?(',')
+          corrector.insert_after(arg_range, replacement)
+          corrector.remove(block_range_with_space(node))
+        end
+
+        def block_range_with_space(node)
+          block_range = range_between(begin_pos_for_replacement(node),
+                                      node.loc.end.end_pos)
+          range_with_surrounding_space(block_range, :left)
+        end
+
+        def begin_pos_for_replacement(node)
+          block_send_or_super, _block_args, _block_body = *node
+          expr = block_send_or_super.source_range
+
+          if (paren_pos = (expr.source =~ /\(\s*\)$/))
+            expr.begin_pos + paren_pos
+          else
+            node.loc.begin.begin_pos
+          end
+        end
+
+        def ignored_methods
+          cop_config['IgnoredMethods']
+        end
+
+        def ignored_method?(name)
+          ignored_methods.include?(name.to_s)
+        end
+
+        def can_shorten?(block_args, block_body)
+          argument_matches_receiver?(block_args, block_body)
+        end
+
+        # TODO: This might be clearer as a node matcher with unification
+        def argument_matches_receiver?(block_args, block_body)
+          receiver, = *block_body
+
+          block_arg_name, = *block_args.children.first
+          receiver_name, = *receiver
+
+          block_arg_name == receiver_name
+        end
+
+        def super?(node)
+          SUPER_TYPES.include?(node.type)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for the presence of parentheses around ternary
+      # conditions. It is configurable to enforce inclusion or omission of
+      # parentheses using `EnforcedStyle`. Omission is only enforced when
+      # removing the parentheses won't cause a different behavior.
+      #
+      # @example
+      #
+      #   EnforcedStyle: require_no_parentheses (default)
+      #
+      #   @bad
+      #   foo = (bar?) ? a : b
+      #   foo = (bar.baz?) ? a : b
+      #   foo = (bar && baz) ? a : b
+      #
+      #   @good
+      #   foo = bar? ? a : b
+      #   foo = bar.baz? ? a : b
+      #   foo = bar && baz ? a : b
+      #
+      # @example
+      #
+      #   EnforcedStyle: require_parentheses
+      #
+      #   @bad
+      #   foo = bar? ? a : b
+      #   foo = bar.baz? ? a : b
+      #   foo = bar && baz ? a : b
+      #
+      #   @good
+      #   foo = (bar?) ? a : b
+      #   foo = (bar.baz?) ? a : b
+      #   foo = (bar && baz) ? a : b
+      #
+      # @example
+      #
+      #   EnforcedStyle: require_parentheses_when_complex
+      #
+      #   @bad
+      #   foo = (bar?) ? a : b
+      #   foo = (bar.baz?) ? a : b
+      #   foo = bar && baz ? a : b
+      #
+      #   @good
+      #   foo = bar? ? a : b
+      #   foo = bar.baz? ? a : b
+      #   foo = (bar && baz) ? a : b
+      class TernaryParentheses < Cop
+        include SafeAssignment
+        include ConfigurableEnforcedStyle
+        include SurroundingSpace
+
+        MSG = '%s parentheses for ternary conditions.'.freeze
+        MSG_COMPLEX = '%s parentheses for ternary expressions with' \
+          ' complex conditions.'.freeze
+
+        def on_if(node)
+          return unless node.ternary? && !infinite_loop? && offense?(node)
+
+          add_offense(node, node.source_range, message(node))
+        end
+
+        private
+
+        def offense?(node)
+          condition = node.condition
+
+          if safe_assignment?(condition)
+            !safe_assignment_allowed?
+          else
+            parens = parenthesized?(condition)
+            case style
+            when :require_parentheses_when_complex
+              complex_condition?(condition) ? !parens : parens
+            else
+              require_parentheses? ? !parens : parens
+            end
+          end
+        end
+
+        def autocorrect(node)
+          condition = node.condition
+
+          return nil if parenthesized?(condition) &&
+                        (safe_assignment?(condition) ||
+                        unsafe_autocorrect?(condition))
+
+          if parenthesized?(condition)
+            correct_parenthesized(condition)
+          else
+            correct_unparenthesized(condition)
+          end
+        end
+
+        # If the condition is parenthesized we recurse and check for any
+        # complex expressions within it.
+        def complex_condition?(condition)
+          if condition.type == :begin
+            condition.to_a.any? { |x| complex_condition?(x) }
+          else
+            non_complex_type?(condition) ? false : true
+          end
+        end
+
+        # Anything that is not a variable, constant, or method/.method call
+        # will be counted as a complex expression.
+        def non_complex_type?(condition)
+          condition.variable? || condition.const_type? ||
+            (condition.send_type? && !operator?(condition.method_name)) ||
+            condition.defined_type? || condition.yield_type? ||
+            square_brackets?(condition)
+        end
+
+        def message(node)
+          if require_parentheses_when_complex?
+            omit = parenthesized?(node.condition) ? 'Only use' : 'Use'
+            format(MSG_COMPLEX, omit)
+          else
+            verb = require_parentheses? ? 'Use' : 'Omit'
+            format(MSG, verb)
+          end
+        end
+
+        def require_parentheses?
+          style == :require_parentheses
+        end
+
+        def require_parentheses_when_complex?
+          style == :require_parentheses_when_complex
+        end
+
+        def redundant_parentheses_enabled?
+          @config.for_cop('Style/RedundantParentheses').fetch('Enabled')
+        end
+
+        def parenthesized?(node)
+          node.begin_type?
+        end
+
+        # When this cop is configured to enforce parentheses and the
+        # `RedundantParentheses` cop is enabled, it will cause an infinite loop
+        # as they compete to add and remove the parentheses respectively.
+        def infinite_loop?
+          require_parentheses? &&
+            redundant_parentheses_enabled?
+        end
+
+        def unsafe_autocorrect?(condition)
+          condition.children.any? do |child|
+            unparenthesized_method_call?(child)
+          end
+        end
+
+        def unparenthesized_method_call?(child)
+          argument = method_call_argument(child)
+          argument && argument !~ /^\(/
+        end
+
+        def_node_matcher :method_call_argument, <<-PATTERN
+          {(:defined? $...)
+           (send {_ nil} _ $(send nil _)...)}
+        PATTERN
+
+        def_node_matcher :square_brackets?,
+                         '(send {(send _recv _msg) str array hash} :[] ...)'
+
+        def correct_parenthesized(condition)
+          lambda do |corrector|
+            corrector.remove(condition.loc.begin)
+            corrector.remove(condition.loc.end)
+
+            # Ruby allows no space between the question mark and parentheses.
+            # If we remove the parentheses, we need to add a space or we'll
+            # generate invalid code.
+            unless whitespace_after?(condition)
+              corrector.insert_after(condition.loc.end, ' ')
+            end
+          end
+        end
+
+        def correct_unparenthesized(condition)
+          lambda do |corrector|
+            corrector.insert_before(condition.source_range, '(')
+            corrector.insert_after(condition.source_range, ')')
+          end
+        end
+
+        def whitespace_after?(node)
+          index = index_of_last_token(node)
+          last_token, next_token = processed_source.tokens[index, 2]
+          space_between?(last_token, next_token)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for trailing comma in argument lists.
+      #
+      # @example
+      #   # always bad
+      #   method(1, 2,)
+      #
+      #   # good if EnforcedStyleForMultiline is consistent_comma
+      #   method(
+      #     1, 2,
+      #     3,
+      #   )
+      #
+      #   # good if EnforcedStyleForMultiline is comma or consistent_comma
+      #   method(
+      #     1,
+      #     2,
+      #   )
+      #
+      #   # good if EnforcedStyleForMultiline is no_comma
+      #   method(
+      #     1,
+      #     2
+      #   )
+      class TrailingCommaInArguments < Cop
+        include TrailingComma
+
+        def on_send(node)
+          return unless node.arguments? && node.parenthesized?
+
+          check(node, node.arguments, 'parameter of %s method call',
+                node.last_argument.source_range.end_pos,
+                node.source_range.end_pos)
+        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/rubbycop/cop/style/trailing_comma_in_literal.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for trailing comma in array and hash literals.
+      #
+      # @example
+      #   # always bad
+      #   a = [1, 2,]
+      #
+      #   # good if EnforcedStyleForMultiline is consistent_comma
+      #   a = [
+      #     1, 2,
+      #     3,
+      #   ]
+      #
+      #   # good if EnforcedStyleForMultiline is comma or consistent_comma
+      #   a = [
+      #     1,
+      #     2,
+      #   ]
+      #
+      #   # good if EnforcedStyleForMultiline is no_comma
+      #   a = [
+      #     1,
+      #     2
+      #   ]
+      class TrailingCommaInLiteral < Cop
+        include ArraySyntax
+        include TrailingComma
+
+        def on_array(node)
+          check_literal(node, 'item of %s array') if node.square_brackets?
+        end
+
+        def on_hash(node)
+          check_literal(node, 'item of %s hash')
+        end
+
+        private
+
+        def check_literal(node, kind)
+          return if node.children.empty?
+          # A braceless hash is the last parameter of a method call and will be
+          # checked as such.
+          return unless brackets?(node)
+
+          check(node, node.children, kind,
+                node.children.last.source_range.end_pos,
+                node.loc.end.begin_pos)
+        end
+      end
+    end
+  end
+end