rubocop 0.65.0 → 0.66.0

data/lib/rubocop/cop/rails/link_to_blank.rb

@@ -18,7 +18,7 @@ module RuboCop
         MSG = 'Specify a `:rel` option containing noopener.'.freeze
 
         def_node_matcher :blank_target?, <<-PATTERN
-          (pair {(sym :target) (str "target")} (str "_blank"))
+          (pair {(sym :target) (str "target")} {(str "_blank") (sym :_blank)})
         PATTERN
 
         def_node_matcher :includes_noopener?, <<-PATTERN

data/lib/rubocop/cop/rails/output.rb

@@ -21,11 +21,28 @@ module RuboCop
           (send nil? {:ap :p :pp :pretty_print :print :puts} ...)
         PATTERN
 
+        def_node_matcher :io_output?, <<-PATTERN
+          (send
+            {
+              (gvar #match_gvar?)
+              {(const nil? :STDOUT) (const nil? :STDERR)}
+            }
+            {:binwrite :syswrite :write :write_nonblock}
+            ...)
+        PATTERN
+
         def on_send(node)
-          return unless output?(node) && node.arguments?
+          return unless (output?(node) || io_output?(node)) &&
+                        node.arguments?
 
           add_offense(node, location: :selector)
         end
+
+        private
+
+        def match_gvar?(sym)
+          %i[$stdout $stderr].include?(sym)
+        end
       end
     end
   end

data/lib/rubocop/cop/rails/reflection_class_name.rb

@@ -21,7 +21,7 @@ module RuboCop
         PATTERN
 
         def_node_search :reflection_class_name, <<-PATTERN
-          (pair (sym :class_name) !str)
+          (pair (sym :class_name) [!str !sym])
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/rails/time_zone.rb

@@ -78,6 +78,16 @@ module RuboCop
           check_time_node(klass, node.parent) if TIMECLASS.include?(klass)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            if acceptable?
+              corrector.insert_after(node.source_range, '.in_time_zone')
+            else
+              corrector.insert_after(node.children[0].source_range, '.zone')
+            end
+          end
+        end
+
         private
 
         def check_time_node(klass, node)

data/lib/rubocop/cop/rails/validation.rb

@@ -87,8 +87,9 @@ module RuboCop
               "#{validate_type}: #{braced_options(last_argument)}"
             )
           else
-            corrector.insert_after(node.loc.expression,
-                                   ", #{validate_type}: true")
+            range = last_argument.source_range
+
+            corrector.insert_after(range, ", #{validate_type}: true")
           end
         end
 

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

@@ -60,6 +60,30 @@ module RuboCop
       #     x
       #   }.inspect
       #
+      #   # The AllowBracesOnProceduralOneLiners option is ignored unless the
+      #   # EnforcedStyle is set to `semantic`. If so:
+      #
+      #   # If the AllowBracesOnProceduralOneLiners option is unspecified, or
+      #   # set to `false` or any other falsey value, then semantic purity is
+      #   # maintained, so one-line procedural blocks must use do-end, not
+      #   # braces.
+      #
+      #   # bad
+      #   collection.each { |element| puts element }
+      #
+      #   # good
+      #   collection.each do |element| puts element end
+      #
+      #   # If the AllowBracesOnProceduralOneLiners option is set to `true`, or
+      #   # any other truthy value, then one-line procedural blocks may use
+      #   # either style. (There is no setting for requiring braces on them.)
+      #
+      #   # good
+      #   collection.each { |element| puts element }
+      #
+      #   # also good
+      #   collection.each do |element| puts element end
+      #
       # @example EnforcedStyle: braces_for_chaining
       #   # bad
       #   words.each do |word|
@@ -216,7 +240,8 @@ module RuboCop
           method_name = node.method_name
 
           if node.braces?
-            functional_method?(method_name) || functional_block?(node)
+            functional_method?(method_name) || functional_block?(node) ||
+              (procedural_oneliners_may_have_braces? && !node.multiline?)
           else
             procedural_method?(method_name) || !return_value_used?(node)
           end
@@ -250,6 +275,10 @@ module RuboCop
           return_value_used?(node) || return_value_of_scope?(node)
         end
 
+        def procedural_oneliners_may_have_braces?
+          cop_config['AllowBracesOnProceduralOneLiners']
+        end
+
         def procedural_method?(method_name)
           cop_config['ProceduralMethods'].map(&:to_sym).include?(method_name)
         end

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

@@ -350,6 +350,8 @@ module RuboCop
         end
 
         def lhs_all_match?(branches)
+          return true if branches.empty?
+
           first_lhs = lhs(branches.first)
           branches.all? { |branch| lhs(branch) == first_lhs }
         end
@@ -372,7 +374,7 @@ module RuboCop
         def allowed_statements?(branches)
           return false unless branches.all?
 
-          statements = branches.map { |branch| tail(branch) }
+          statements = branches.map { |branch| tail(branch) }.compact
 
           lhs_all_match?(statements) && statements.none?(&:masgn_type?) &&
             assignment_types_match?(*statements)

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks that constants defined in classes and modules have
+      # an explicit visibility declaration. By default, Ruby makes all class-
+      # and module constants public, which litters the public API of the
+      # class or module. Explicitly declaring a visibility makes intent more
+      # clear, and prevents outside actors from touching private state.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     BAR = 42
+      #     BAZ = 43
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     BAR = 42
+      #     private_constant :BAR
+      #
+      #     BAZ = 43
+      #     public_constant :BAZ
+      #   end
+      #
+      class ConstantVisibility < Cop
+        MSG = 'Explicitly make `%<constant_name>s` public or private using ' \
+              'either `#public_constant` or `#private_constant`.'.freeze
+
+        def on_casgn(node)
+          return unless class_or_module_scope?(node)
+          return if visibility_declaration?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def message(node)
+          _namespace, constant_name, _value = *node
+
+          format(MSG, constant_name: constant_name)
+        end
+
+        def class_or_module_scope?(node)
+          node.parent && %i[class module].include?(node.parent.type)
+        end
+
+        def visibility_declaration?(node)
+          _namespace, constant_name, _value = *node
+
+          node.parent.each_child_node(:send).any? do |child|
+            visibility_declaration_for?(child, constant_name)
+          end
+        end
+
+        def_node_matcher :visibility_declaration_for?, <<-PATTERN
+          (send nil? {:public_constant :private_constant} ({sym str} %1))
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -69,11 +69,6 @@ module RuboCop
           return if node.elsif?
 
           branches = expand_elses(node.else_branch).unshift(node.if_branch)
-
-          # return if any branch is empty. An empty branch can be an `if`
-          # without an `else` or a branch that contains only comments.
-          return if branches.any?(&:nil?)
-
           check_branches(branches)
         end
 
@@ -81,19 +76,20 @@ module RuboCop
           return unless node.else? && node.else_branch
 
           branches = node.when_branches.map(&:body).push(node.else_branch)
-
-          return if branches.any?(&:nil?)
-
           check_branches(branches)
         end
 
         private
 
         def check_branches(branches)
-          tails = branches.compact.map { |branch| tail(branch) }
-          check_expressions(tails)
-          heads = branches.compact.map { |branch| head(branch) }
-          check_expressions(heads)
+          # return if any branch is empty. An empty branch can be an `if`
+          # without an `else` or a branch that contains only comments.
+          return if branches.any?(&:nil?)
+
+          tails = branches.map { |branch| tail(branch) }
+          check_expressions(tails) if tails.none?(&:nil?)
+          heads = branches.map { |branch| head(branch) }
+          check_expressions(heads) if tails.none?(&:nil?)
         end
 
         def check_expressions(expressions)

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
     module Style
@@ -8,7 +9,11 @@ module RuboCop
       #
       # In the default style (require_parentheses), macro methods are ignored.
       # Additional methods can be added to the `IgnoredMethods` list. This
-      # option is valid only in the default style.
+      # option is valid only in the default style. Macros can be included by
+      # either setting `IgnoreMacros` to false or adding specific macros to
+      # the `IncludedMacros` list. If a method is listed in both
+      # `IncludedMacros` and `IgnoredMethods`, then the latter takes
+      # precedence (that is, the method is ignored).
       #
       # In the alternative style (omit_parentheses), there are three additional
       # options.
@@ -206,11 +211,17 @@ module RuboCop
         end
 
         def eligible_for_parentheses_omission?(node)
-          node.operator_method? || node.setter_method? || ignore_macros?(node)
+          node.operator_method? || node.setter_method? || ignored_macro?(node)
         end
 
-        def ignore_macros?(node)
-          cop_config['IgnoreMacros'] && node.macro?
+        def included_macros_list
+          cop_config.fetch('IncludedMacros', []).map(&:to_sym)
+        end
+
+        def ignored_macro?(node)
+          cop_config['IgnoreMacros'] &&
+            node.macro? &&
+            !included_macros_list.include?(node.method_name)
         end
 
         def args_begin(node)
@@ -354,3 +365,4 @@ module RuboCop
     end
   end
 end
+# rubocop:enable Metrics/ClassLength

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

@@ -32,6 +32,7 @@ module RuboCop
 
         MSG = 'Use underscores(_) as thousands separator and ' \
               'separate every 3 digits with them.'.freeze
+        DELIMITER_REGEXP = /[eE.]/.freeze
 
         def on_int(node)
           check(node)
@@ -75,7 +76,20 @@ module RuboCop
         end
 
         def format_number(node)
-          int_part, float_part = node.source.split('.')
+          source = node.source.gsub(/\s+/, '')
+          int_part, additional_part = source.split(DELIMITER_REGEXP, 2)
+          formatted_int = format_int_part(int_part)
+          delimiter = source[DELIMITER_REGEXP]
+
+          if additional_part
+            formatted_int + delimiter + additional_part
+          else
+            formatted_int
+          end
+        end
+
+        # @param int_part [String]
+        def format_int_part(int_part)
           int_part = Integer(int_part)
           formatted_int = int_part
                           .abs
@@ -84,12 +98,7 @@ module RuboCop
                           .gsub(/...(?=.)/, '\&_')
                           .reverse
           formatted_int.insert(0, '-') if int_part < 0
-
-          if float_part
-            format('%<int>s.%<float>s', int: formatted_int, float: float_part)
-          else
-            formatted_int
-          end
+          formatted_int
         end
 
         def min_digits

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

@@ -28,6 +28,7 @@ module RuboCop
 
         def on_args(node)
           return if super_used?(node)
+          return if whitelist.include?(node.parent.method_name.to_s)
 
           option_hash(node) do |options|
             add_offense(options)
@@ -36,6 +37,10 @@ module RuboCop
 
         private
 
+        def whitelist
+          cop_config['Whitelist'] || []
+        end
+
         def suspicious_name?(arg_name)
           cop_config.key?('SuspiciousParamNames') &&
             cop_config['SuspiciousParamNames'].include?(arg_name.to_s)

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

@@ -19,7 +19,8 @@ module RuboCop
 
         def on_send(node)
           return unless node.receiver && node.method?(:freeze) &&
-                        immutable_literal?(node.receiver)
+                        (immutable_literal?(node.receiver) ||
+                         operation_produces_immutable_object?(node.receiver))
 
           add_offense(node)
         end
@@ -49,6 +50,17 @@ module RuboCop
             node
           end
         end
+
+        def_node_matcher :operation_produces_immutable_object?, <<-PATTERN
+          {
+            (begin (send {float int} {:+ :- :* :** :/ :% :<<} _))
+            (begin (send _ {:+ :- :* :** :/ :%} {float int}))
+            (begin (send _ {:== :=== :!= :<= :>= :< :>} _))
+            (send (const nil? :ENV) :[] _)
+            (send _ {:count :length :size} ...)
+            (block (send _ {:count :length :size} ...) ...)
+          }
+        PATTERN
       end
     end
   end

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

@@ -43,6 +43,7 @@ module RuboCop
       #   end
       class RedundantSelf < Cop
         MSG = 'Redundant `self` detected.'.freeze
+        KERNEL_METHODS = Kernel.methods(false)
 
         def self.autocorrect_incompatible_with
           [ColonMethodCall]
@@ -117,7 +118,8 @@ module RuboCop
 
         def allowed_send_node?(node)
           @allowed_send_nodes.include?(node) ||
-            @local_variables_scopes[node].include?(node.method_name)
+            @local_variables_scopes[node].include?(node.method_name) ||
+            KERNEL_METHODS.include?(node.method_name)
         end
 
         def regular_method_call?(node)

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

@@ -22,7 +22,7 @@ module RuboCop
 
         def_node_matcher :stderr_puts?, <<-PATTERN
           (send
-            (gvar #stderr_gvar?) :puts
+            (gvar #stderr_gvar?) :puts $_
             ...)
         PATTERN
 

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

@@ -70,7 +70,15 @@ module RuboCop
         end
 
         def correct_bracketed(node)
-          syms = node.children.map { |c| to_symbol_literal(c.value.to_s) }
+          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.source_range, "[#{syms.join(', ')}]")

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

@@ -31,6 +31,7 @@ module RuboCop
         MSG = 'Use `attr_%<kind>s` to define trivial %<kind>s methods.'.freeze
 
         def on_def(node)
+          return if top_level_node?(node)
           return if in_module_or_instance_eval?(node)
           return if ignore_class_methods? && node.defs_type?
 
@@ -180,6 +181,10 @@ module RuboCop
             )
           end
         end
+
+        def top_level_node?(node)
+          node.parent.nil?
+        end
       end
     end
   end