rubocop 0.87.1

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop can check for array literals made up of symbols that are not
+      # using the %i() syntax.
+      #
+      # Alternatively, it checks for symbol arrays using the %i() syntax on
+      # projects which do not want to use that syntax.
+      #
+      # Configuration option: MinSize
+      # If set, arrays with fewer elements than this value will not trigger the
+      # cop. For example, a `MinSize` of `3` will not enforce a style on an
+      # array of 2 or fewer elements.
+      #
+      # @example EnforcedStyle: percent (default)
+      #   # good
+      #   %i[foo bar baz]
+      #
+      #   # bad
+      #   [:foo, :bar, :baz]
+      #
+      # @example EnforcedStyle: brackets
+      #   # good
+      #   [:foo, :bar, :baz]
+      #
+      #   # bad
+      #   %i[foo bar baz]
+      class SymbolArray < Cop
+        include ArrayMinSize
+        include ArraySyntax
+        include ConfigurableEnforcedStyle
+        include PercentArray
+
+        PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
+        ARRAY_MSG = 'Use `[]` for an array of symbols.'
+
+        class << self
+          attr_accessor :largest_brackets
+        end
+
+        def on_array(node)
+          if bracketed_array_of?(:sym, node)
+            return if symbols_contain_spaces?(node)
+
+            check_bracketed_array(node)
+          elsif node.percent_literal?(:symbol)
+            check_percent_array(node)
+          end
+        end
+
+        def autocorrect(node)
+          if style == :percent
+            PercentLiteralCorrector
+              .new(@config, @preferred_delimiters)
+              .correct(node, 'i')
+          else
+            correct_bracketed(node)
+          end
+        end
+
+        private
+
+        def symbols_contain_spaces?(node)
+          node.children.any? do |sym|
+            content, = *sym
+            / /.match?(content)
+          end
+        end
+
+        def correct_bracketed(node)
+          syms = node.children.map do |c|
+            if c.dsym_type?
+              string_literal = to_string_literal(c.source)
+
+              ':' + trim_string_interporation_escape_character(string_literal)
+            else
+              to_symbol_literal(c.value.to_s)
+            end
+          end
+
+          lambda do |corrector|
+            corrector.replace(node, "[#{syms.join(', ')}]")
+          end
+        end
+
+        def to_symbol_literal(string)
+          if symbol_without_quote?(string)
+            ":#{string}"
+          else
+            ":#{to_string_literal(string)}"
+          end
+        end
+
+        def symbol_without_quote?(string)
+          special_gvars = %w[
+            $! $" $$ $& $' $* $+ $, $/ $; $: $. $< $= $> $? $@ $\\ $_ $` $~ $0
+            $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
+          ]
+          redefinable_operators = %w(
+            | ^ & <=> == === =~ > >= < <= << >>
+            + - * / % ** ~ +@ -@ [] []= ` ! != !~
+          )
+
+          # method name
+          /\A[a-zA-Z_]\w*[!?]?\z/.match?(string) ||
+            # instance / class variable
+            /\A@@?[a-zA-Z_]\w*\z/.match?(string) ||
+            # global variable
+            /\A\$[1-9]\d*\z/.match?(string) ||
+            /\A\$[a-zA-Z_]\w*\z/.match?(string) ||
+            special_gvars.include?(string) ||
+            redefinable_operators.include?(string)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks symbol literal syntax.
+      #
+      # @example
+      #
+      #   # bad
+      #   :"symbol"
+      #
+      #   # good
+      #   :symbol
+      class SymbolLiteral < Cop
+        MSG = 'Do not use strings for word-like symbol literals.'
+
+        def on_sym(node)
+          return unless /\A:["'][A-Za-z_]\w*["']\z/.match?(node.source)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, node.source.delete(%q('")))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use symbols as procs when possible.
+      #
+      # @example
+      #   # bad
+      #   something.map { |s| s.upcase }
+      #
+      #   # good
+      #   something.map(&:upcase)
+      class SymbolProc < Cop
+        include RangeHelp
+        include IgnoredMethods
+
+        MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` ' \
+              'instead of a block.'
+        SUPER_TYPES = %i[super zsuper].freeze
+
+        def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
+        def_node_matcher :symbol_proc?, <<~PATTERN
+          (block
+            ${(send ...) (super ...) zsuper}
+            $(args (arg _var))
+            (send (lvar _var) $_))
+        PATTERN
+
+        def self.autocorrect_incompatible_with
+          [Layout::SpaceBeforeBlockBraces]
+        end
+
+        def on_block(node)
+          symbol_proc?(node) do |dispatch_node, arguments_node, method_name|
+            # TODO: Rails-specific handling that we should probably make
+            # configurable - https://github.com/rubocop-hq/rubocop/issues/1485
+            # we should ignore lambdas & procs
+            return if proc_node?(dispatch_node)
+            return if %i[lambda proc].include?(dispatch_node.method_name)
+            return if ignored_method?(dispatch_node.method_name)
+            return if destructuring_block_argument?(arguments_node)
+
+            register_offense(node, method_name, dispatch_node.method_name)
+          end
+        end
+
+        def destructuring_block_argument?(argument_node)
+          argument_node.one? && argument_node.source.include?(',')
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.send_node.arguments?
+              autocorrect_with_args(corrector, node,
+                                    node.send_node.arguments,
+                                    node.body.method_name)
+            else
+              autocorrect_without_args(corrector, node)
+            end
+          end
+        end
+
+        private
+
+        def register_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,
+                      location: range,
+                      message: format(MSG,
+                                      method: method_name,
+                                      block_method: block_method_name))
+        end
+
+        def autocorrect_without_args(corrector, node)
+          corrector.replace(block_range_with_space(node),
+                            "(&:#{node.body.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(range: block_range, side: :left)
+        end
+
+        def begin_pos_for_replacement(node)
+          expr = node.send_node.source_range
+
+          if (paren_pos = (expr.source =~ /\(\s*\)$/))
+            expr.begin_pos + paren_pos
+          else
+            node.loc.begin.begin_pos
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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.
+      #
+      # `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 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
+      #
+      # @example AllowSafeAssignment: true (default)
+      #   # good
+      #   foo = (bar = baz) ? a : b
+      #
+      # @example AllowSafeAssignment: false
+      #   # bad
+      #   foo = (bar = baz) ? a : b
+      #
+      class TernaryParentheses < Cop
+        include SafeAssignment
+        include ConfigurableEnforcedStyle
+        include SurroundingSpace
+
+        VARIABLE_TYPES = AST::Node::VARIABLES
+        NON_COMPLEX_TYPES = [*VARIABLE_TYPES, :const, :defined?, :yield].freeze
+
+        MSG = '%<command>s parentheses for ternary conditions.'
+        MSG_COMPLEX = '%<command>s parentheses for ternary expressions with' \
+          ' complex conditions.'
+
+        def on_if(node)
+          return if only_closing_parenthesis_is_last_line?(node.condition)
+          return unless node.ternary? && !infinite_loop? && offense?(node)
+
+          add_offense(node, location: node.source_range)
+        end
+
+        def only_closing_parenthesis_is_last_line?(condition)
+          condition.source.split("\n").last == ')'
+        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
+
+        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
+
+        # If the condition is parenthesized we recurse and check for any
+        # complex expressions within it.
+        def complex_condition?(condition)
+          if condition.begin_type?
+            condition.to_a.any? { |x| complex_condition?(x) }
+          else
+            non_complex_expression?(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_expression?(condition)
+          NON_COMPLEX_TYPES.include?(condition.type) ||
+            non_complex_send?(condition)
+        end
+
+        def non_complex_send?(node)
+          return false unless node.call_type?
+
+          !node.operator_method? || node.method?(:[])
+        end
+
+        def message(node)
+          if require_parentheses_when_complex?
+            command = parenthesized?(node.condition) ? 'Only use' : 'Use'
+            format(MSG_COMPLEX, command: command)
+          else
+            command = require_parentheses? ? 'Use' : 'Omit'
+            format(MSG, command: command)
+          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? || require_parentheses_when_complex?) &&
+            redundant_parentheses_enabled?
+        end
+
+        def unsafe_autocorrect?(condition)
+          condition.children.any? do |child|
+            unparenthesized_method_call?(child) ||
+              below_ternary_precedence?(child)
+          end
+        end
+
+        def unparenthesized_method_call?(child)
+          /^[a-z]/i.match?(method_name(child)) && !child.parenthesized?
+        end
+
+        def below_ternary_precedence?(child)
+          # Handle English "or", e.g. 'foo or bar ? a : b'
+          (child.or_type? && child.semantic_operator?) ||
+            # Handle English "and", e.g. 'foo and bar ? a : b'
+            (child.and_type? && child.semantic_operator?) ||
+            # Handle English "not", e.g. 'not foo ? a : b'
+            (child.send_type? && child.prefix_not?)
+        end
+
+        def_node_matcher :method_name, <<~PATTERN
+          {($:defined? (send nil? _) ...)
+           (send {_ nil?} $_ _ ...)}
+        PATTERN
+
+        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.
+            corrector.insert_after(condition.loc.end, ' ') unless whitespace_after?(condition)
+          end
+        end
+
+        def correct_unparenthesized(condition)
+          lambda do |corrector|
+            corrector.wrap(condition, '(', ')')
+          end
+        end
+
+        def whitespace_after?(node)
+          index = index_of_last_token(node)
+          last_token = processed_source.tokens[index]
+          last_token.space_after?
+        end
+      end
+    end
+  end
+end