rubocop 0.47.1 → 0.48.0

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

@@ -30,14 +30,11 @@ module RuboCop
         include TrailingComma
 
         def on_send(node)
-          _receiver, _method_name, *args = *node
-          return if args.empty?
-          # It's impossible for a method call without parentheses to have
-          # a trailing comma.
-          return unless brackets?(node)
+          return unless node.arguments? && node.parenthesized?
 
-          check(node, args, 'parameter of %s method call',
-                args.last.source_range.end_pos, node.source_range.end_pos)
+          check(node, node.arguments, 'parameter of %s method call',
+                node.last_argument.source_range.end_pos,
+                node.source_range.end_pos)
         end
 
         private
@@ -51,7 +48,7 @@ module RuboCop
         # of the last argument.
         def braces_will_be_removed?(args)
           brace_config = config.for_cop('Style/BracesAroundHashParameters')
-          return false unless brace_config['Enabled']
+          return false unless brace_config.fetch('Enabled')
           return false if brace_config['AutoCorrect'] == false
 
           brace_style = brace_config['EnforcedStyle']
@@ -59,7 +56,7 @@ module RuboCop
 
           return false unless brace_style == 'context_dependent'
 
-          args.size == 1 || !args[-2].hash_type?
+          args.one? || !args[-2].hash_type?
         end
       end
     end

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

@@ -12,11 +12,14 @@ module RuboCop
       #   a, _, _ = foo()
       #   a, _, _, = foo()
       #
-      #   #good
+      #   # 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
 

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

@@ -95,7 +95,7 @@ module RuboCop
 
         def looks_like_trivial_writer?(args, body)
           args.children.one? &&
-            ![:restarg, :blockarg].include?(args.children[0].type) &&
+            !%i(restarg blockarg).include?(args.children[0].type) &&
             body && body.ivasgn_type? &&
             body.children[1] && body.children[1].lvar_type?
         end

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

@@ -25,8 +25,7 @@ module RuboCop
         def requires_interpolation?(node)
           node.child_nodes.any? do |string|
             string.dstr_type? ||
-              double_quotes_acceptable?(string.str_content) ||
-              string.source == '\s'
+              double_quotes_required?(string.source)
           end
         end
 

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

@@ -88,7 +88,7 @@ module RuboCop
           src = node.source
           src.include?(QUOTE) &&
             (src =~ STRING_INTERPOLATION_REGEXP ||
-            (node.str_type? && double_quotes_acceptable?(node.str_content)))
+            (node.str_type? && double_quotes_required?(src)))
         end
       end
     end

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

@@ -10,11 +10,17 @@ module RuboCop
       # which do not want to include that syntax.
       class WordArray < Cop
         include ArraySyntax
+        include ConfigurableEnforcedStyle
+        include PercentLiteral
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'.freeze
         ARRAY_MSG = 'Use `[]` for an array of words.'.freeze
         QUESTION_MARK_SIZE = '?'.size
 
+        class << self
+          attr_accessor :largest_brackets
+        end
+
         def on_array(node)
           if bracketed_array_of?(:str, node)
             check_bracketed(node)
@@ -25,7 +31,7 @@ module RuboCop
 
         def autocorrect(node)
           if style == :percent
-            correct_percent(node)
+            correct_percent(node, 'w')
           else
             correct_bracketed(node)
           end
@@ -68,27 +74,12 @@ module RuboCop
           end
         end
 
-        def style
-          cop_config['EnforcedStyle'].to_sym
-        end
-
         def min_size
           cop_config['MinSize']
         end
 
         def word_regex
-          cop_config['WordRegex']
-        end
-
-        def correct_percent(node)
-          words = node.children
-          escape = words.any? { |w| needs_escaping?(w.children[0]) }
-          char = escape ? 'W' : 'w'
-          contents = autocorrect_words(words, escape, node.loc.line)
-
-          lambda do |corrector|
-            corrector.replace(node.source_range, "%#{char}(#{contents})")
-          end
+          Regexp.new(cop_config['WordRegex'])
         end
 
         def correct_bracketed(node)
@@ -99,19 +90,6 @@ module RuboCop
           end
         end
 
-        def autocorrect_words(word_nodes, escape, base_line_number)
-          previous_node_line_number = base_line_number
-          word_nodes.map do |node|
-            number_of_line_breaks = node.loc.line - previous_node_line_number
-            line_breaks = "\n" * number_of_line_breaks
-            previous_node_line_number = node.loc.line
-            content = node.children.first
-            content = escape ? escape_string(content) : content
-            content.gsub!(/\)/, '\\)')
-            line_breaks + content
-          end.join(' ')
-        end
-
         def style_detected(style, ary_size)
           cfg = config_to_allow_offenses
           return if cfg['Enabled'] == false
@@ -132,13 +110,13 @@ module RuboCop
         end
 
         def largest_brackets_size(style, ary_size)
-          @largest_brackets ||= -Float::INFINITY
+          self.class.largest_brackets ||= -Float::INFINITY
 
-          if style == :brackets && ary_size > @largest_brackets
-            @largest_brackets = ary_size
+          if style == :brackets && ary_size > self.class.largest_brackets
+            self.class.largest_brackets = ary_size
           end
 
-          @largest_brackets
+          self.class.largest_brackets
         end
 
         def smallest_percent_size(style, ary_size)

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

@@ -3,21 +3,28 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for receiver.length == 0 predicates and the
-      # negated versions receiver.length > 0 and receiver.length != 0.
-      # These can be replaced with receiver.empty? and
-      # !receiver.empty? respectively.
+      # This cop checks for numeric comparisons that can be replaced
+      # by a predicate method, such as receiver.length == 0,
+      # receiver.length > 0, receiver.length != 0,
+      # receiver.length < 1 and receiver.size == 0 that can be
+      # replaced by receiver.empty? and !receiver.empty.
       #
       # @example
       #
       #   @bad
       #   [1, 2, 3].length == 0
       #   0 == "foobar".length
+      #   array.length < 1
+      #   {a: 1, b: 2}.length != 0
+      #   string.length > 0
       #   hash.size > 0
       #
       #   @good
       #   [1, 2, 3].empty?
       #   "foobar".empty?
+      #   array.empty?
+      #   !{a: 1, b: 2}.empty?
+      #   !string.empty?
       #   !hash.empty?
       class ZeroLengthPredicate < Cop
         ZERO_MSG = 'Use `empty?` instead of `%s %s %s`.'.freeze

data/lib/rubocop/cop/team.rb

@@ -10,7 +10,10 @@ module RuboCop
         Style::SymbolProc => [Style::SpaceBeforeBlockBraces],
         Style::SpaceBeforeBlockBraces => [Style::SymbolProc],
         Style::LineEndConcatenation => [Style::UnneededInterpolation],
-        Style::UnneededInterpolation => [Style::LineEndConcatenation]
+        Style::UnneededInterpolation => [Style::LineEndConcatenation],
+        Style::SelfAssignment => [Style::SpaceAroundOperators],
+        Style::SpaceAroundOperators => [Style::SelfAssignment],
+        Style::BracesAroundHashParameters => [Style::MultilineHashBraceLayout]
       }.freeze
 
       DEFAULT_OPTIONS = {

data/lib/rubocop/cop/util.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
-# rubocop:disable Metrics/ModuleLength
 
+# rubocop:disable Metrics/ModuleLength
 module RuboCop
   module Cop
     # This module contains a collection of useful utility methods.
@@ -10,14 +10,14 @@ module RuboCop
 
       BYTE_ORDER_MARK = 0xfeff # The Unicode codepoint
 
-      EQUALS_ASGN_NODES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn,
-                           :casgn, :masgn].freeze
-      SHORTHAND_ASGN_NODES = [:op_asgn, :or_asgn, :and_asgn].freeze
+      EQUALS_ASGN_NODES = %i(lvasgn ivasgn cvasgn gvasgn
+                             casgn masgn).freeze
+      SHORTHAND_ASGN_NODES = %i(op_asgn or_asgn and_asgn).freeze
       ASGN_NODES = (EQUALS_ASGN_NODES + SHORTHAND_ASGN_NODES).freeze
 
-      MODIFIER_NODES = [:if, :while, :until].freeze
+      MODIFIER_NODES = %i(if while until).freeze
       CONDITIONAL_NODES = (MODIFIER_NODES + [:case]).freeze
-      LOGICAL_OPERATOR_NODES = [:and, :or].freeze
+      LOGICAL_OPERATOR_NODES = %i(and or).freeze
 
       # http://phrogz.net/programmingruby/language.html#table_18.4
       # Backtick is added last just to help editors parse this code.
@@ -90,7 +90,7 @@ module RuboCop
       def source_range(source_buffer, line_number, column, length = 1)
         if column.is_a?(Range)
           column_index = column.begin
-          length = numeric_range_size(column)
+          length = column.size
         else
           column_index = column
         end
@@ -199,14 +199,6 @@ module RuboCop
         node
       end
 
-      # Range#size is not available prior to Ruby 2.0.
-      def numeric_range_size(range)
-        size = range.end - range.begin
-        size += 1 unless range.exclude_end?
-        size = 0 if size < 0
-        size
-      end
-
       # If converting a string to Ruby string literal source code, must
       # double quotes be used?
       def double_quotes_required?(string)
@@ -219,16 +211,6 @@ module RuboCop
         string =~ /'|(?<! \\) \\{2}* \\ (?![\\"])/x
       end
 
-      # If double quoted string literals are found in Ruby code, and they are
-      # not the preferred style, should they be flagged?
-      def double_quotes_acceptable?(string)
-        needs_escaping?(string) || hard_to_type?(string)
-      end
-
-      def hard_to_type?(string)
-        string.codepoints.any? { |cp| cp < 32 || cp > 126 }
-      end
-
       def needs_escaping?(string)
         double_quotes_required?(escape_string(string))
       end
@@ -246,7 +228,32 @@ module RuboCop
       end
 
       def to_symbol_literal(string)
-        ":#{string.to_sym}"
+        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
+        string =~ /\A[a-zA-Z_]\w*[!?]?\z/ ||
+          # instance / class variable
+          string =~ /\A\@\@?[a-zA-Z_]\w*\z/ ||
+          # global variable
+          string =~ /\A\$[1-9]\d*\z/ ||
+          string =~ /\A\$[a-zA-Z_]\w*\z/ ||
+          special_gvars.include?(string) ||
+          redefinable_operators.include?(string)
       end
 
       def interpret_string_escapes(string)

data/lib/rubocop/cop/variable_force.rb

@@ -35,7 +35,7 @@ module RuboCop
         :shadowarg # This means block local variable (obj.each { |arg; this| }).
       ].freeze
 
-      LOGICAL_OPERATOR_ASSIGNMENT_TYPES = [:or_asgn, :and_asgn].freeze
+      LOGICAL_OPERATOR_ASSIGNMENT_TYPES = %i(or_asgn and_asgn).freeze
       OPERATOR_ASSIGNMENT_TYPES =
         (LOGICAL_OPERATOR_ASSIGNMENT_TYPES + [:op_asgn]).freeze
 
@@ -43,15 +43,15 @@ module RuboCop
 
       VARIABLE_REFERENCE_TYPE = :lvar
 
-      POST_CONDITION_LOOP_TYPES = [:while_post, :until_post].freeze
-      LOOP_TYPES = (POST_CONDITION_LOOP_TYPES + [:while, :until, :for]).freeze
+      POST_CONDITION_LOOP_TYPES = %i(while_post until_post).freeze
+      LOOP_TYPES = (POST_CONDITION_LOOP_TYPES + %i(while until for)).freeze
 
       RESCUE_TYPE = :rescue
 
       ZERO_ARITY_SUPER_TYPE = :zsuper
 
-      TWISTED_SCOPE_TYPES = [:block, :class, :sclass, :defs].freeze
-      SCOPE_TYPES = (TWISTED_SCOPE_TYPES + [:module, :def]).freeze
+      TWISTED_SCOPE_TYPES = %i(block class sclass defs).freeze
+      SCOPE_TYPES = (TWISTED_SCOPE_TYPES + %i(module def)).freeze
 
       SEND_TYPE = :send
 
@@ -376,14 +376,14 @@ module RuboCop
       end
 
       # Hooks invoked by VariableTable.
-      [
-        :before_entering_scope,
-        :after_entering_scope,
-        :before_leaving_scope,
-        :after_leaving_scope,
-        :before_declaring_variable,
-        :after_declaring_variable
-      ].each do |hook|
+      %i(
+        before_entering_scope
+        after_entering_scope
+        before_leaving_scope
+        after_leaving_scope
+        before_declaring_variable
+        after_declaring_variable
+      ).each do |hook|
         define_method(hook) do |arg|
           # Invoke hook in cops.
           run_hook(hook, arg, variable_table)

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -5,10 +5,9 @@ module RuboCop
     class VariableForce
       # This class represents each assignment of a variable.
       class Assignment
-        include Locatable
+        include Branchable
 
         MULTIPLE_LEFT_HAND_SIDE_TYPE = :mlhs
-        REFERENCE_PENETRABLE_BRANCH_TYPES = %w(rescue_main ensure_main).freeze
 
         attr_reader :node, :variable, :referenced
         alias referenced? referenced
@@ -23,8 +22,6 @@ module RuboCop
           @node = node
           @variable = variable
           @referenced = false
-
-          super
         end
 
         def name
@@ -43,10 +40,6 @@ module RuboCop
           @variable.captured_by_block? || @referenced
         end
 
-        def reference_penetrable?
-          REFERENCE_PENETRABLE_BRANCH_TYPES.include?(branch_type)
-        end
-
         def regexp_named_capture?
           @node.type == REGEXP_NAMED_CAPTURE_TYPE
         end

data/lib/rubocop/cop/variable_force/branch.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class VariableForce
+      # Namespace for branch classes for each control structure.
+      module Branch
+        def self.of(target_node, scope: nil)
+          ([target_node] + target_node.ancestors).each do |node|
+            return nil unless node.parent
+            return nil unless scope.include?(node)
+            klass = CLASSES_BY_TYPE[node.parent.type]
+            next unless klass
+            branch = klass.new(node, scope)
+            return branch if branch.branched?
+          end
+
+          nil
+        end
+
+        # rubocop:disable Metrics/BlockLength
+
+        # Abstract base class for branch classes.
+        # A branch represents a conditional branch in a scope.
+        #
+        # @example
+        #   def some_scope
+        #     do_something     # no branch
+        #
+        #     if foo
+        #       do_something   # branch A
+        #       do_something   # branch A
+        #     else
+        #       do_something   # branch B
+        #       if bar
+        #         do_something # branch C (whose parent is branch B)
+        #       end
+        #     end
+        #
+        #     do_something     # no branch
+        #   end
+        Base = Struct.new(:child_node, :scope) do
+          # rubocop:enable Metrics/BlockLength
+
+          def self.classes
+            @classes ||= []
+          end
+
+          def self.inherited(subclass)
+            classes << subclass
+          end
+
+          def self.type
+            name.split('::').last.gsub(/(.)([A-Z])/, '\1_\2').downcase.to_sym
+          end
+
+          def self.define_predicate(name, child_index: nil)
+            define_method(name) do
+              target_node = control_node.children[child_index]
+
+              # We don't use Kernel#Array here
+              # because it invokes Node#to_a rather than wrapping with an array.
+              if target_node.is_a?(Array)
+                target_node.any? { |node| node.equal?(child_node) }
+              else
+                target_node.equal?(child_node)
+              end
+            end
+          end
+
+          def control_node
+            child_node.parent
+          end
+
+          def parent
+            return @parent if instance_variable_defined?(:@parent)
+            @branch = Branch.of(control_node, scope: scope)
+          end
+
+          def each_ancestor(include_self: false, &block)
+            unless block_given?
+              return to_enum(__method__, include_self: include_self)
+            end
+
+            yield self if include_self
+            scan_ancestors(&block)
+            self
+          end
+
+          def branched?
+            !always_run?
+          end
+
+          def always_run?
+            raise NotImplementedError
+          end
+
+          def may_jump_to_other_branch?
+            false
+          end
+
+          def may_run_incompletely?
+            false
+          end
+
+          def exclusive_with?(other)
+            return false unless other
+            return false if may_jump_to_other_branch?
+
+            other.each_ancestor(include_self: true) do |other_ancestor|
+              if control_node.equal?(other_ancestor.control_node)
+                return !child_node.equal?(other_ancestor.child_node)
+              end
+            end
+
+            if parent
+              parent.exclusive_with?(other)
+            else
+              false
+            end
+          end
+
+          def ==(other)
+            return false unless other
+            control_node.equal?(other.control_node) &&
+              child_node.equal?(other.child_node)
+          end
+
+          alias_method :eql?, :==
+
+          def hash
+            control_node.object_id.hash ^ child_node.object_id.hash
+          end
+
+          private
+
+          def scan_ancestors
+            branch = self
+
+            while (branch = branch.parent)
+              yield branch
+            end
+          end
+        end
+
+        # Mix-in module for simple conditional control structures.
+        module SimpleConditional
+          def conditional_clause?
+            raise NotImplementedError
+          end
+
+          def always_run?
+            conditional_clause?
+          end
+        end
+
+        # if conditional_clause
+        #   truthy_body
+        # else
+        #   falsey_body
+        # end
+        #
+        # unless conditional_clause
+        #   falsey_body
+        # else
+        #   truthy_body
+        # end
+        class If < Base
+          include SimpleConditional
+
+          define_predicate :conditional_clause?, child_index: 0
+          define_predicate :truthy_body?,        child_index: 1
+          define_predicate :falsey_body?,        child_index: 2
+        end
+
+        # while conditional_clause
+        #   loop_body
+        # end
+        class While < Base
+          include SimpleConditional
+
+          define_predicate :conditional_clause?, child_index: 0
+          define_predicate :loop_body?,          child_index: 1
+        end
+
+        # until conditional_clause
+        #   loop_body
+        # end
+        class Until < Base
+          include SimpleConditional
+
+          define_predicate :conditional_clause?, child_index: 0
+          define_predicate :loop_body?,          child_index: 1
+        end
+
+        # begin
+        #   loop_body
+        # end while conditional_clause
+        class WhilePost < Base
+          include SimpleConditional
+
+          define_predicate :conditional_clause?, child_index: 0
+          define_predicate :loop_body?,          child_index: 1
+        end
+
+        # begin
+        #   loop_body
+        # end until conditional_clause
+        class UntilPost < Base
+          include SimpleConditional
+
+          define_predicate :conditional_clause?, child_index: 0
+          define_predicate :loop_body?,          child_index: 1
+        end
+
+        # case target
+        # when /pattern/ # when_clause
+        # else
+        #   else_body
+        # end
+        class Case < Base
+          define_predicate :target?,      child_index: 0
+          define_predicate :when_clause?, child_index: 1..-2
+          define_predicate :else_body?,   child_index: -1
+
+          def always_run?
+            target?
+          end
+        end
+
+        # for element in collection
+        #   loop_body
+        # end
+        class For < Base
+          define_predicate :element?,    child_index: 0
+          define_predicate :collection?, child_index: 1
+          define_predicate :loop_body?,  child_index: 2
+
+          def always_run?
+            element? || collection?
+          end
+        end
+
+        # Mix-in module for logical operator control structures.
+        module LogicalOperator
+          def always_run?
+            left_body?
+          end
+        end
+
+        # left_body && right_body
+        class And < Base
+          include LogicalOperator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # left_body || right_body
+        class Or < Base
+          include LogicalOperator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # Mix-in module for exception handling control structures.
+        module ExceptionHandler
+          def may_jump_to_other_branch?
+            main_body?
+          end
+
+          def may_run_incompletely?
+            main_body?
+          end
+        end
+
+        #   begin
+        #     main_body
+        #   rescue StandardError => error # rescue_clause
+        #   else
+        #     else_body
+        #   end
+        class Rescue < Base
+          include ExceptionHandler
+
+          define_predicate :main_body?,     child_index: 0
+          define_predicate :rescue_clause?, child_index: 1..-2
+          define_predicate :else_body?,     child_index: -1
+
+          def always_run?
+            false
+          end
+        end
+
+        #   begin
+        #     main_body
+        #   ensure
+        #     ensure_body
+        #   end
+        class Ensure < Base
+          include ExceptionHandler
+
+          define_predicate :main_body?,   child_index: 0
+          define_predicate :ensure_body?, child_index: -1
+
+          def always_run?
+            ensure_body?
+          end
+        end
+
+        CLASSES_BY_TYPE = Base.classes.each_with_object({}) do |klass, classes|
+          classes[klass.type] = klass
+        end
+      end
+    end
+  end
+end