rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -7,9 +6,11 @@ module RuboCop
       # Helper module to provide common methods to classes needed for the
       # ConditionalAssignment Cop.
       module ConditionalAssignmentHelper
+        extend NodePattern::Macros
+
         EQUAL = '='.freeze
         END_ALIGNMENT = 'Lint/EndAlignment'.freeze
-        ALIGN_WITH = 'AlignWith'.freeze
+        ALIGN_WITH = 'EnforcedStyleAlignWith'.freeze
         KEYWORD = 'keyword'.freeze
 
         # `elsif` branches show up in the `node` as an `else`. We need
@@ -32,16 +33,15 @@ module RuboCop
           branch.begin_type? ? [*branch].last : branch
         end
 
+        # rubocop:disable Metrics/AbcSize
         def lhs(node)
           case node.type
           when :send
             lhs_for_send(node)
           when :op_asgn
             "#{node.children[0].source} #{node.children[1]}= "
-          when :and_asgn
-            "#{node.children[0].source} &&= "
-          when :or_asgn
-            "#{node.children[0].source} ||= "
+          when :and_asgn, :or_asgn
+            "#{node.children[0].source} #{node.loc.operator.source} "
           when :casgn
             "#{node.children[1]} = "
           when *ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES
@@ -50,17 +50,21 @@ module RuboCop
             node.source
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def indent(cop, source)
-          if cop.config[END_ALIGNMENT] &&
-             cop.config[END_ALIGNMENT][ALIGN_WITH] &&
-             cop.config[END_ALIGNMENT][ALIGN_WITH] == KEYWORD
+          conf = cop.config.for_cop(END_ALIGNMENT)
+          if conf[ALIGN_WITH] == KEYWORD
             ' ' * source.length
           else
             ''
           end
         end
 
+        def end_with_eq?(sym)
+          sym.to_s.end_with?(EQUAL)
+        end
+
         private
 
         def expand_elsif(node, elsif_branches = [])
@@ -76,27 +80,35 @@ module RuboCop
         end
 
         def lhs_for_send(node)
-          receiver = node.receiver.nil? ? '' : node.receiver.source
+          receiver = node.receiver ? node.receiver.source : ''
 
-          if node.method_name == :[]=
-            indices = node.children[2...-1].map(&:source).join(', ')
+          if node.method?(:[]=)
+            indices = node.arguments[0...-1].map(&:source).join(', ')
             "#{receiver}[#{indices}] = "
-          elsif node.method_name.to_s.end_with?(EQUAL) &&
-                ![:!=, :==, :===, :>=, :<=].include?(node.method_name)
+          elsif node.setter_method?
             "#{receiver}.#{node.method_name[0...-1]} = "
           else
             "#{receiver} #{node.method_name} "
           end
         end
+
+        def setter_method?(method_name)
+          method_name.to_s.end_with?(EQUAL) &&
+            !%i[!= == === >= <=].include?(method_name)
+        end
+
+        def assignment_rhs_exist?(node)
+          parent = node.parent
+          return true unless parent
+          !(parent.mlhs_type? || parent.resbody_type?)
+        end
       end
 
       # Check for `if` and `case` statements where each branch is used for
       # assignment to the same variable when using the return of the
       # condition can be used instead.
       #
-      # @example
-      #   EnforcedStyle: assign_to_condition
-      #
+      # @example EnforcedStyle: assign_to_condition (default)
       #   # bad
       #   if foo
       #     bar = 1
@@ -141,7 +153,7 @@ module RuboCop
       #            2
       #          end
       #
-      #   EnforcedStyle: assign_inside_condition
+      # @example EnforcedStyle: assign_inside_condition
       #   # bad
       #   bar = if foo
       #           1
@@ -186,7 +198,6 @@ module RuboCop
       #     bar = 2
       #   end
       class ConditionalAssignment < Cop
-        include IfNode
         include ConditionalAssignmentHelper
         include ConfigurableEnforcedStyle
         include IgnoredNode
@@ -196,24 +207,30 @@ module RuboCop
         ASSIGN_TO_CONDITION_MSG =
           'Assign variables inside of conditionals'.freeze
         VARIABLE_ASSIGNMENT_TYPES =
-          [:casgn, :cvasgn, :gvasgn, :ivasgn, :lvasgn].freeze
-        ASSIGNMENT_TYPES =
-          VARIABLE_ASSIGNMENT_TYPES + [:and_asgn, :or_asgn, :op_asgn].freeze
-        IF = 'if'.freeze
-        UNLESS = 'unless'.freeze
+          %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
+        ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES +
+                           %i[and_asgn or_asgn op_asgn masgn].freeze
         LINE_LENGTH = 'Metrics/LineLength'.freeze
-        INDENTATION_WIDTH = 'Style/IndentationWidth'.freeze
+        INDENTATION_WIDTH = 'Layout/IndentationWidth'.freeze
         ENABLED = 'Enabled'.freeze
         MAX = 'Max'.freeze
         SINGLE_LINE_CONDITIONS_ONLY = 'SingleLineConditionsOnly'.freeze
         WIDTH = 'Width'.freeze
-        METHODS = [:[]=, :<<, :=~, :!~, :<=>].freeze
-        CONDITION_TYPES = [:if, :case].freeze
+
+        def_node_matcher :condition?, '{if case}'
+
+        # The shovel operator `<<` does not have its own type. It is a `send`
+        # type.
+        def_node_matcher :assignment_type?, <<-PATTERN
+          {
+            #{ASSIGNMENT_TYPES.join(' ')}
+            (send _recv {:[]= :<< :=~ :!~ :<=> #end_with_eq?} ...)
+          }
+        PATTERN
 
         ASSIGNMENT_TYPES.each do |type|
           define_method "on_#{type}" do |node|
             return if part_of_ignored_node?(node)
-            return unless style == :assign_inside_condition
 
             check_assignment_to_condition(node)
           end
@@ -221,45 +238,30 @@ module RuboCop
 
         def on_send(node)
           return unless assignment_type?(node)
-          return unless style == :assign_inside_condition
 
           check_assignment_to_condition(node)
         end
 
-        def check_assignment_to_condition(node)
-          ignore_node(node)
-
-          assignment = assignment_node(node)
-          return unless condition?(assignment)
-
-          _condition, *branches, else_branch = *assignment
-          return unless else_branch # empty else
-          return if single_line_conditions_only? &&
-                    [*branches, else_branch].any?(&:begin_type?)
-
-          add_offense(node, :expression, ASSIGN_TO_CONDITION_MSG)
-        end
-
         def on_if(node)
           return unless style == :assign_to_condition
-          return if elsif?(node)
+          return if node.elsif?
 
-          _condition, if_branch, else_branch = *node
+          else_branch = node.else_branch
           elsif_branches, else_branch = expand_elses(else_branch)
-          return unless else_branch # empty else
 
-          branches = [if_branch, *elsif_branches, else_branch]
+          return unless else_branch
+
+          branches = [node.if_branch, *elsif_branches, else_branch]
 
           check_node(node, branches)
         end
 
         def on_case(node)
           return unless style == :assign_to_condition
-          _condition, *when_branches, else_branch = *node
-          return unless else_branch # empty else
+          return unless node.else_branch
 
-          when_branches = expand_when_branches(when_branches)
-          branches = [*when_branches, else_branch]
+          when_branches = expand_when_branches(node.when_branches)
+          branches = [*when_branches, node.else_branch]
 
           check_node(node, branches)
         end
@@ -274,35 +276,65 @@ module RuboCop
 
         private
 
+        def check_assignment_to_condition(node)
+          return unless candidate_node?(node)
+
+          ignore_node(node)
+
+          assignment = assignment_node(node)
+          return unless candidate_condition?(assignment)
+
+          _condition, *branches, else_branch = *assignment
+
+          return unless else_branch
+          return if allowed_single_line?([*branches, else_branch])
+
+          add_offense(node, message: ASSIGN_TO_CONDITION_MSG)
+        end
+
+        def candidate_node?(node)
+          style == :assign_inside_condition && assignment_rhs_exist?(node)
+        end
+
+        def_node_matcher :candidate_condition?, '[{if case} !#allowed_ternary?]'
+
+        def allowed_ternary?(assignment)
+          assignment.if_type? && assignment.ternary? && !include_ternary?
+        end
+
+        def allowed_single_line?(branches)
+          single_line_conditions_only? && branches.any?(&:begin_type?)
+        end
+
         def assignment_node(node)
           *_variable, assignment = *node
 
-          if assignment.begin_type? && assignment.children.size == 1
+          # ignore pseudo-assignments without rhs in for nodes
+          return if node.parent && node.parent.for_type?
+
+          if assignment.begin_type? && assignment.children.one?
             assignment, = *assignment
           end
 
           assignment
         end
 
-        def condition?(node)
-          CONDITION_TYPES.include?(node.type)
-        end
-
         def move_assignment_outside_condition(node)
-          if ternary?(node)
+          if node.case_type?
+            CaseCorrector.correct(self, node)
+          elsif node.ternary?
             TernaryCorrector.correct(node)
-          elsif node.loc.keyword.is?(IF)
+          elsif node.if?
             IfCorrector.correct(self, node)
-          elsif node.loc.keyword.is?(UNLESS)
+          elsif node.unless?
             UnlessCorrector.correct(self, node)
-          else
-            CaseCorrector.correct(self, node)
           end
         end
 
         def move_assignment_inside_condition(node)
           *_assignment, condition = *node
-          if ternary?(condition) || ternary?(condition.children[0])
+
+          if ternary_condition?(condition)
             TernaryCorrector.move_assignment_inside_condition(node)
           elsif condition.case_type?
             CaseCorrector.move_assignment_inside_condition(node)
@@ -311,6 +343,10 @@ module RuboCop
           end
         end
 
+        def ternary_condition?(node)
+          [node, node.children.first].any? { |n| n.if_type? && n.ternary? }
+        end
+
         def lhs_all_match?(branches)
           first_lhs = lhs(branches.first)
           branches.all? { |branch| lhs(branch) == first_lhs }
@@ -318,35 +354,26 @@ module RuboCop
 
         def assignment_types_match?(*nodes)
           return unless assignment_type?(nodes.first)
-          first_type = nodes.first.type
-          nodes.all? { |node| node.type == first_type }
-        end
 
-        # The shovel operator `<<` does not have its own type. It is a `send`
-        # type.
-        def assignment_type?(branch)
-          return true if ASSIGNMENT_TYPES.include?(branch.type)
+          nodes.map(&:type).uniq.one?
+        end
 
-          if branch.send_type?
-            _receiver, method, = *branch
-            return true if METHODS.include?(method)
-            return true if method.to_s.end_with?(EQUAL)
-          end
+        def check_node(node, branches)
+          return if allowed_ternary?(node)
+          return unless allowed_statements?(branches)
+          return if allowed_single_line?(branches)
+          return if correction_exceeds_line_limit?(node, branches)
 
-          false
+          add_offense(node)
         end
 
-        def check_node(node, branches)
-          return unless branches.all?
-          last_statements = branches.map { |branch| tail(branch) }
-          return unless lhs_all_match?(last_statements)
-          return if last_statements.any?(&:masgn_type?)
-          return unless assignment_types_match?(*last_statements)
+        def allowed_statements?(branches)
+          return false unless branches.all?
 
-          return if single_line_conditions_only? && branches.any?(&:begin_type?)
-          return if correction_exceeds_line_limit?(node, branches)
+          statements = branches.map { |branch| tail(branch) }
 
-          add_offense(node, :expression)
+          lhs_all_match?(statements) && statements.none?(&:masgn_type?) &&
+            assignment_types_match?(*statements)
         end
 
         # If `Metrics/LineLength` is enabled, we do not want to introduce an
@@ -357,37 +384,45 @@ module RuboCop
         # of the longest line + the length of the corrected assignment is
         # greater than the max configured line length
         def correction_exceeds_line_limit?(node, branches)
-          return false unless config.for_cop(LINE_LENGTH)[ENABLED]
+          return false unless line_length_cop_enabled?
+
           assignment = lhs(tail(branches[0]))
-          max_line_length = config.for_cop(LINE_LENGTH)[MAX]
-          indentation_width = config.for_cop(INDENTATION_WIDTH)[WIDTH] || 2
-          return true if longest_rhs(branches) + indentation_width +
-                         assignment.length > max_line_length
 
+          longest_line_exceeds_line_limit?(node, assignment)
+        end
+
+        def longest_line_exceeds_line_limit?(node, assignment)
           longest_line(node, assignment).length > max_line_length
         end
 
         def longest_line(node, assignment)
-          assignment_regex = /#{Regexp.escape(assignment).gsub(' ', '\s*')}/
+          assignment_regex = /\s*#{Regexp.escape(assignment).gsub('\ ', '\s*')}/
           lines = node.source.lines.map do |line|
             line.chomp.sub(assignment_regex, '')
           end
           longest_line = lines.max_by(&:length)
-          longest_line + assignment
+          assignment + longest_line
         end
 
-        def longest_rhs(branches)
-          branches.map { |branch| branch.children.last.source.length }.max
+        def line_length_cop_enabled?
+          config.for_cop(LINE_LENGTH)[ENABLED]
         end
 
-        def lines_with_numbers(node)
-          line_nos = node.loc.line..node.loc.last_line
-          node.source.lines.zip(line_nos)
+        def max_line_length
+          config.for_cop(LINE_LENGTH)[MAX]
+        end
+
+        def indentation_width
+          config.for_cop(INDENTATION_WIDTH)[WIDTH] || 2
         end
 
         def single_line_conditions_only?
           cop_config[SINGLE_LINE_CONDITIONS_ONLY]
         end
+
+        def include_ternary?
+          cop_config['IncludeTernaryExpressions']
+        end
       end
 
       # Helper module to provide common methods to ConditionalAssignment
@@ -432,7 +467,15 @@ module RuboCop
 
         def replace_branch_assignment(corrector, branch)
           _variable, *_operator, assignment = *branch
-          corrector.replace(branch.source_range, assignment.source)
+          source = assignment.source
+
+          replacement = if assignment.array_type? && !assignment.bracketed?
+                          "[#{source}]"
+                        else
+                          source
+                        end
+
+          corrector.replace(branch.source_range, replacement)
         end
 
         def correct_branches(corrector, branches)
@@ -450,21 +493,8 @@ module RuboCop
           include ConditionalCorrectorHelper
 
           def correct(node)
-            condition, if_branch, else_branch = *node
-            _variable, *_operator, if_rhs = *if_branch
-            _else_variable, *_operator, else_rhs = *else_branch
-            condition = condition.source
-            if_rhs = if_rhs.source
-            else_rhs = else_rhs.source
-
-            ternary = "#{condition} ? #{if_rhs} : #{else_rhs}"
-            if if_branch.send_type? && if_branch.method_name != :[]=
-              ternary = "(#{ternary})"
-            end
-            correction = "#{lhs(if_branch)}#{ternary}"
-
             lambda do |corrector|
-              corrector.replace(node.source_range, correction)
+              corrector.replace(node.source_range, correction(node))
             end
           end
 
@@ -484,9 +514,28 @@ module RuboCop
 
           private
 
+          def correction(node)
+            condition, if_branch, else_branch = *node
+
+            "#{lhs(if_branch)}#{ternary(condition, if_branch, else_branch)}"
+          end
+
+          def ternary(condition, if_branch, else_branch)
+            _variable, *_operator, if_rhs = *if_branch
+            _else_variable, *_operator, else_rhs = *else_branch
+
+            expr = "#{condition.source} ? #{if_rhs.source} : #{else_rhs.source}"
+
+            element_assignment?(if_branch) ? "(#{expr})" : expr
+          end
+
+          def element_assignment?(node)
+            node.send_type? && node.method_name != :[]=
+          end
+
           def extract_branches(node)
             *_var, rhs = *node
-            condition, = *rhs if rhs.begin_type? && rhs.children.size == 1
+            condition, = *rhs if rhs.begin_type? && rhs.children.one?
             _condition, if_branch, else_branch = *(condition || rhs)
 
             [if_branch, else_branch]

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,19 +8,43 @@ module RuboCop
       # The default regexp for an acceptable copyright notice can be found in
       # config/default.yml.  The default can be changed as follows:
       #
-      # Style/Copyright:
-      #   Notice: '^Copyright (\(c\) )?2\d{3} Acme Inc'
+      #     Style/Copyright:
+      #       Notice: '^Copyright (\(c\) )?2\d{3} Acme Inc'
       #
       # This regex string is treated as an unanchored regex.  For each file
       # that RuboCop scans, a comment that matches this regex must be found or
       # an offense is reported.
       #
       class Copyright < Cop
-        def message
-          "Include a copyright notice matching /#{notice}/" \
-          'before any code.'
+        MSG = 'Include a copyright notice matching /%<notice>s/ before ' \
+              'any code.'.freeze
+        AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in' \
+                                    'your RuboCop config'.freeze
+
+        def investigate(processed_source)
+          return if notice.empty?
+          return if notice_found?(processed_source)
+          range = source_range(processed_source.buffer, 1, 0)
+          add_offense(insert_notice_before(processed_source),
+                      location: range, message: format(MSG, notice: notice))
         end
 
+        def autocorrect(token)
+          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
+          regex = Regexp.new(notice)
+          unless autocorrect_notice =~ regex
+            raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
+                           "match Notice /#{notice}/"
+          end
+
+          lambda do |corrector|
+            range = token.nil? ? range_between(0, 0) : token.pos
+            corrector.insert_before(range, "#{autocorrect_notice}\n")
+          end
+        end
+
+        private
+
         def notice
           cop_config['Notice']
         end
@@ -30,13 +53,6 @@ module RuboCop
           cop_config['AutocorrectNotice']
         end
 
-        def investigate(processed_source)
-          return if notice.empty?
-          return if notice_found?(processed_source)
-          range = source_range(processed_source.buffer, 1, 0)
-          add_offense(insert_notice_before(processed_source), range, message)
-        end
-
         def insert_notice_before(processed_source)
           token_index = 0
           token_index += 1 if shebang_token?(processed_source, token_index)
@@ -47,43 +63,25 @@ module RuboCop
         def shebang_token?(processed_source, token_index)
           return false if token_index >= processed_source.tokens.size
           token = processed_source.tokens[token_index]
-          token.type == :tCOMMENT && token.text =~ /^#!.*$/
+          token.comment? && token.text =~ /^#!.*$/
         end
 
         def encoding_token?(processed_source, token_index)
           return false if token_index >= processed_source.tokens.size
           token = processed_source.tokens[token_index]
-          token.type == :tCOMMENT &&
-            token.text =~ /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/
+          token.comment? && token.text =~ /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/
         end
 
         def notice_found?(processed_source)
           notice_found = false
           notice_regexp = Regexp.new(notice)
           processed_source.tokens.each do |token|
-            break unless token.type == :tCOMMENT
+            break unless token.comment?
             notice_found = !(token.text =~ notice_regexp).nil?
             break if notice_found
           end
           notice_found
         end
-
-        def autocorrect(token)
-          raise Warning, 'An AutocorrectNotice must be defined in ' \
-            'your RuboCop config' if autocorrect_notice.empty?
-          regex = Regexp.new(notice)
-          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
-            "match Notice /#{notice}/" unless autocorrect_notice =~ regex
-
-          lambda do |corrector|
-            range = if token.nil?
-                      Parser::Source::Range.new('', 0, 0)
-                    else
-                      token.pos
-                    end
-            corrector.insert_before(range, "#{autocorrect_notice}\n")
-          end
-        end
       end
     end
   end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of `DateTime` that should be replaced by
+      # `Date` or `Time`.
+      #
+      # @example
+      #
+      #   # bad - uses `DateTime` for current time
+      #   DateTime.now
+      #
+      #   # good - uses `Time` for current time
+      #   Time.now
+      #
+      #   # bad - uses `DateTime` for modern date
+      #   DateTime.iso8601('2016-06-29')
+      #
+      #   # good - uses `Date` for modern date
+      #   Date.iso8601('2016-06-29')
+      #
+      #   # good - uses `DateTime` with start argument for historical date
+      #   DateTime.iso8601('1751-04-23', Date::ENGLAND)
+      class DateTime < Cop
+        MSG = 'Prefer Date or Time over DateTime.'.freeze
+
+        def_node_matcher :date_time?, <<-PATTERN
+          (send (const {nil? (cbase)} :DateTime) ...)
+        PATTERN
+
+        def_node_matcher :historic_date?, <<-PATTERN
+          (send _ _ _ (const (const nil? :Date) _))
+        PATTERN
+
+        def on_send(node)
+          return unless date_time?(node)
+          return if historic_date?(node)
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -7,20 +6,44 @@ module RuboCop
       # This cop checks for parentheses in the definition of a method,
       # that does not take any arguments. Both instance and
       # class/singleton methods are checked.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo()
+      #     # does a thing
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     # does a thing
+      #   end
+      #
+      #   # also good
+      #   def foo() does_a_thing end
+      #
+      # @example
+      #
+      #   # bad
+      #   def Baz.foo()
+      #     # does a thing
+      #   end
+      #
+      #   # good
+      #   def Baz.foo
+      #     # does a thing
+      #   end
       class DefWithParentheses < Cop
-        include OnMethodDef
-
         MSG = "Omit the parentheses in defs when the method doesn't accept " \
               'any arguments.'.freeze
 
-        def on_method_def(node, _method_name, args, _body)
-          start_line = node.loc.keyword.line
-          end_line = node.loc.end.line
-
-          return if start_line == end_line
+        def on_def(node)
+          return if node.single_line?
+          return unless !node.arguments? && node.arguments.loc.begin
 
-          add_offense(args, :begin) if args.children == [] && args.loc.begin
+          add_offense(node.arguments, location: :begin)
         end
+        alias on_defs on_def
 
         def autocorrect(node)
           lambda do |corrector|