rubocop 0.40.0 → 0.41.0

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

@@ -30,7 +30,14 @@ module RuboCop
 
         def autocorrect(node)
           expr = node.source_range
-          ->(corrector) { corrector.replace(expr, "#{expr.source}.freeze") }
+          lambda do |corrector|
+            if node.array_type? && node.loc.begin.nil? && node.loc.end.nil?
+              corrector.insert_before(expr, '[')
+              corrector.insert_after(expr, '].freeze')
+            else
+              corrector.insert_after(expr, '.freeze')
+            end
+          end
         end
 
         private

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

@@ -51,7 +51,7 @@ module RuboCop
         def modifier_while_or_until?(node)
           node.loc.respond_to?(:keyword) &&
             %w(while until).include?(node.loc.keyword.source) &&
-            node.loc.respond_to?(:end) && node.loc.end.nil?
+            node.modifier_form?
         end
 
         def autocorrect(node)

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

@@ -81,18 +81,22 @@ module RuboCop
         end
 
         def simple_if_without_break?(node)
-          return false unless node.if_type?
-          return false if ternary?(node)
-          return false if if_else?(node)
+          return false unless if_without_else?(node)
           return false if style == :skip_modifier_ifs && modifier_if?(node)
           return false if !modifier_if?(node) && !min_body_length?(node)
 
-          # The `if` node must have only `if` body since we excluded `if` with
-          # `else` above.
+          !exit_body_type?(node)
+        end
+
+        def if_without_else?(node)
+          node.if_type? && !ternary?(node) && !if_else?(node)
+        end
+
+        def exit_body_type?(node)
           _conditional, if_body, _else_body = *node
-          return true unless if_body
+          return false unless if_body
 
-          !EXIT_TYPES.include?(if_body.type)
+          EXIT_TYPES.include?(if_body.type)
         end
 
         def offense_node(body)
@@ -135,10 +139,10 @@ module RuboCop
           corrector.remove(cond_range(node, cond))
           corrector.remove(end_range(node))
 
-          # end_range starts with the final newline of the if body
-          reindent_lines = (node.source_range.line + 1)...node.loc.end.line
-          reindent_lines = reindent_lines.to_a - heredoc_lines(node)
-          reindent(reindent_lines, cond, corrector)
+          lines = reindentable_lines(node)
+          return if lines.empty?
+
+          reindent(lines, cond, corrector)
         end
 
         def opposite_kw(if_body)
@@ -170,42 +174,50 @@ module RuboCop
           source_buffer.source[end_pos..-1] =~ /\A\s*$/
         end
 
+        def reindentable_lines(node)
+          buffer = node.source_range.source_buffer
+
+          # end_range starts with the final newline of the if body
+          lines = (node.source_range.line + 1)...node.loc.end.line
+          lines = lines.to_a - heredoc_lines(node)
+          # Skip blank lines
+          lines.reject { |lineno| buffer.source_line(lineno) =~ /\A\s*\z/ }
+        end
+
         # Adjust indentation of `lines` to match `node`
         def reindent(lines, node, corrector)
           range  = node.source_range
           buffer = range.source_buffer
 
           target_indent = range.source_line =~ /\S/
-
-          # Skip blank lines
-          lines.reject! { |lineno| buffer.source_line(lineno) =~ /\A\s*\z/ }
-          return if lines.empty?
-
-          actual_indent = lines.map do |lineno|
-            buffer.source_line(lineno) =~ /\S/
-          end.min
-
-          delta = actual_indent - target_indent
+          delta = actual_indent(lines, buffer) - target_indent
           lines.each do |lineno|
-            adjustment = delta
-            adjustment += @reindented_lines[lineno]
-            @reindented_lines[lineno] = adjustment
-
-            if adjustment > 0
-              corrector.remove_leading(buffer.line_range(lineno), adjustment)
-            elsif adjustment < 0
-              corrector.insert_before(buffer.line_range(lineno),
-                                      ' ' * -adjustment)
-            end
+            reindent_line(corrector, lineno, delta, buffer)
           end
         end
 
+        def actual_indent(lines, buffer)
+          lines.map { |lineno| buffer.source_line(lineno) =~ /\S/ }.min
+        end
+
         def heredoc_lines(node)
           node.each_node(:dstr)
               .select { |n| n.loc.respond_to?(:heredoc_body) }
               .map { |n| n.loc.heredoc_body }
               .flat_map { |b| (b.line...b.last_line).to_a }
         end
+
+        def reindent_line(corrector, lineno, delta, buffer)
+          adjustment = delta + @reindented_lines[lineno]
+          @reindented_lines[lineno] = adjustment
+
+          if adjustment > 0
+            corrector.remove_leading(buffer.line_range(lineno), adjustment)
+          elsif adjustment < 0
+            corrector.insert_before(buffer.line_range(lineno),
+                                    ' ' * -adjustment)
+          end
+        end
       end
     end
   end

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

@@ -31,22 +31,42 @@ module RuboCop
           range = range_with_surrounding_space(node.loc.selector, :right)
           child = node.children.first
 
-          if child.send_type? && OPPOSITE_METHODS.key?(child.method_name)
-            lambda do |corrector|
-              corrector.remove(range)
-              corrector.replace(child.loc.selector,
-                                OPPOSITE_METHODS[child.method_name].to_s)
-            end
-          elsif child.and_type? || child.or_type? || child.binary_operation? ||
-                ternary?(child)
-            lambda do |corrector|
-              corrector.replace(range, '!(')
-              corrector.insert_after(node.source_range, ')')
-            end
+          if opposite_method?(child)
+            correct_opposite_method(range, child)
+          elsif requires_parens?(child)
+            correct_with_parens(range, node)
           else
-            ->(corrector) { corrector.replace(range, '!') }
+            correct_without_parens(range)
           end
         end
+
+        def opposite_method?(child)
+          child.send_type? && OPPOSITE_METHODS.key?(child.method_name)
+        end
+
+        def requires_parens?(child)
+          child.and_type? || child.or_type? || child.binary_operation? ||
+            ternary?(child)
+        end
+
+        def correct_opposite_method(range, child)
+          lambda do |corrector|
+            corrector.remove(range)
+            corrector.replace(child.loc.selector,
+                              OPPOSITE_METHODS[child.method_name].to_s)
+          end
+        end
+
+        def correct_with_parens(range, node)
+          lambda do |corrector|
+            corrector.replace(range, '!(')
+            corrector.insert_after(node.source_range, ')')
+          end
+        end
+
+        def correct_without_parens(range)
+          ->(corrector) { corrector.replace(range, '!') }
+        end
       end
     end
   end

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

@@ -0,0 +1,92 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for octal, hex, binary and decimal literals using
+      # uppercase prefixes and corrects them to lowercase prefix
+      # or no prefix (in case of decimals).
+      # eg. for octal use `0o` instead of `0` or `0O`.
+      #
+      # Can be configured to use `0` only for octal literals using
+      # `EnforcedOctalStyle` => `zero_only`
+      class NumericLiteralPrefix < Cop
+        include IntegerNode
+
+        OCTAL_ZERO_ONLY_REGEX = /^0[Oo][0-7]+$/
+        OCTAL_REGEX = /^0O?[0-7]+$/
+        HEX_REGEX = /^0X[0-9A-F]+$/
+        BINARY_REGEX = /^0B[01]+$/
+        DECIMAL_REGEX = /^0[dD][0-9]+$/
+
+        OCTAL_ZERO_ONLY_MSG = 'Use 0 for octal literals.'.freeze
+        OCTAL_MSG = 'Use 0o for octal literals.'.freeze
+        HEX_MSG = 'Use 0x for hexadecimal literals.'.freeze
+        BINARY_MSG = 'Use 0b for binary literals.'.freeze
+        DECIMAL_MSG = 'Do not use prefixes for decimal literals.'.freeze
+
+        def on_int(node)
+          type = literal_type(node)
+          return unless type
+
+          msg = self.class.const_get("#{type.upcase}_MSG")
+          add_offense(node, :expression, msg)
+        end
+
+        private
+
+        def autocorrect(node)
+          lambda do |corrector|
+            type = literal_type(node)
+            corrector.replace(node.source_range,
+                              send(:"format_#{type}", node.source))
+          end
+        end
+
+        def literal_type(node)
+          literal = integer_part(node)
+
+          if literal =~ OCTAL_ZERO_ONLY_REGEX && octal_zero_only?
+            return :octal_zero_only
+          elsif literal =~ OCTAL_REGEX && !octal_zero_only?
+            return :octal
+          end
+
+          case literal
+          when HEX_REGEX
+            :hex
+          when BINARY_REGEX
+            :binary
+          when DECIMAL_REGEX
+            :decimal
+          end
+        end
+
+        def octal_zero_only?
+          cop_config['EnforcedOctalStyle'] == 'zero_only'
+        end
+
+        def format_octal(source)
+          source.sub(/^0O?/, '0o')
+        end
+
+        def format_octal_zero_only(source)
+          source.sub(/^0[Oo]?/, '0')
+        end
+
+        def format_hex(source)
+          source.sub(/^0X/, '0x')
+        end
+
+        def format_binary(source)
+          source.sub(/^0B/, '0b')
+        end
+
+        def format_decimal(source)
+          source.sub(/^0[dD]/, '')
+        end
+      end
+    end
+  end
+end

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

@@ -11,6 +11,7 @@ module RuboCop
         # digits for which an offense can be registered), but essentially it's
         # a Max parameter (the maximum number of something that's allowed).
         include ConfigurableMax
+        include IntegerNode
 
         MSG = 'Separate every 3 digits in the integer portion of a number ' \
               'with underscores(_).'.freeze
@@ -70,10 +71,6 @@ module RuboCop
           end
         end
 
-        def integer_part(node)
-          node.source.sub(/^[+-]/, '').split('.').first
-        end
-
         def min_digits
           cop_config['MinDigits']
         end

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

@@ -147,13 +147,13 @@ module RuboCop
         def modifier_while?(node)
           node.loc.respond_to?(:keyword) &&
             %w(while until).include?(node.loc.keyword.source) &&
-            node.loc.respond_to?(:end) && node.loc.end.nil?
+            node.modifier_form?
         end
 
         def rescue_modifier?(node)
-          node &&
-            node.rescue_type? &&
-            (node.parent.nil? || !node.parent.kwbegin_type?)
+          node && node.rescue_type? &&
+            (node.parent.nil? || !(node.parent.kwbegin_type? ||
+            node.parent.ensure_type?))
         end
 
         # An internal class for correcting parallel assignment
@@ -202,6 +202,28 @@ module RuboCop
             _node, rescue_clause = *node.parent
             _, _, rescue_result = *rescue_clause
 
+            # If the parallel assignment uses a rescue modifier and it is the
+            # only contents of a method, then we want to make use of the
+            # implicit begin
+            if node.parent.parent && node.parent.parent.def_type?
+              super + def_correction(rescue_result)
+            else
+              begin_correction(rescue_result)
+            end
+          end
+
+          def correction_range
+            node.parent.source_range
+          end
+
+          private
+
+          def def_correction(rescue_result)
+            "\nrescue" \
+              "\n#{offset(node)}#{rescue_result.source}"
+          end
+
+          def begin_correction(rescue_result)
             "begin\n" \
               "#{indentation(node)}" \
               "#{assignment.join("\n#{indentation(node)}")}" \
@@ -209,10 +231,6 @@ module RuboCop
               "#{indentation(node)}#{rescue_result.source}" \
               "\n#{offset(node)}end"
           end
-
-          def correction_range
-            node.parent.source_range
-          end
         end
 
         # An internal class for correcting parallel assignment

data/lib/rubocop/cop/style/{deprecated_hash_methods.rb → preferred_hash_methods.rb}

@@ -4,22 +4,22 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of the deprecated methods Hash#has_key?
-      # and Hash#has_value?
-      class DeprecatedHashMethods < Cop
-        MSG = '`Hash#%s` is deprecated in favor of `Hash#%s`.'.freeze
+      # This cop checks for uses of methods Hash#has_key? and Hash#has_value?
+      # Prefer to use Hash#key? and Hash#value? instead
+      class PreferredHashMethods < Cop
+        MSG = 'Use `Hash#%s` instead of `Hash#%s`.'.freeze
 
-        DEPRECATED_METHODS = [:has_key?, :has_value?].freeze
+        PREFERRED_METHODS = [:has_key?, :has_value?].freeze
 
         def on_send(node)
           _receiver, method_name, *args = *node
           return unless args.size == 1 &&
-                        DEPRECATED_METHODS.include?(method_name)
+                        PREFERRED_METHODS.include?(method_name)
 
           add_offense(node, :selector,
                       format(MSG,
-                             method_name,
-                             proper_method_name(method_name)))
+                             proper_method_name(method_name),
+                             method_name))
         end
 
         def autocorrect(node)

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

@@ -32,17 +32,16 @@ module RuboCop
         end
 
         def parens_allowed?(node)
-          child  = node.children.first
-          parent = node.parent
-
-          # don't flag `break(1)`, etc
-          (keyword_ancestor?(node) && parens_required?(node)) ||
+          # don't flag `()`
+          empty_parentheses?(node) ||
+            # don't flag `break(1)`, etc
+            (keyword_ancestor?(node) && parens_required?(node)) ||
             # don't flag `method ({key: value})`
-            (child.hash_type? && first_arg?(node) && !parentheses?(parent)) ||
+            hash_literal_as_first_arg?(node) ||
             # don't flag `rescue(ExceptionClass)`
             rescue?(node) ||
             # don't flag `method (arg) { }`
-            (arg_in_call_with_block?(node) && !parentheses?(parent)) ||
+            (arg_in_call_with_block?(node) && !parentheses?(node.parent)) ||
             # don't flag
             # ```
             # { a: (1
@@ -51,6 +50,15 @@ module RuboCop
             allowed_array_or_hash_element?(node)
         end
 
+        def empty_parentheses?(node)
+          node.children.empty?
+        end
+
+        def hash_literal_as_first_arg?(node)
+          child = node.children.first
+          child.hash_type? && first_arg?(node) && !parentheses?(node.parent)
+        end
+
         def check(begin_node)
           node = begin_node.children.first
           if keyword_with_redundant_parentheses?(node)
@@ -63,22 +71,24 @@ module RuboCop
         end
 
         def check_send(begin_node, node)
-          if node.unary_operation?
-            return if begin_node.chained?
+          return check_unary(begin_node, node) if node.unary_operation?
 
-            # parens are not redundant in `(!recv.method arg)`
-            node = node.children.first while node.unary_operation?
-            if node.send_type?
-              return unless method_call_with_redundant_parentheses?(node)
-            end
+          return unless method_call_with_redundant_parentheses?(node)
+          return if call_chain_starts_with_int?(begin_node, node)
 
-            offense(begin_node, 'an unary operation')
-          else
-            return unless method_call_with_redundant_parentheses?(node)
-            return if call_chain_starts_with_int?(begin_node, node)
+          offense(begin_node, 'a method call')
+        end
+
+        def check_unary(begin_node, node)
+          return if begin_node.chained?
 
-            offense(begin_node, 'a method call')
+          # parens are not redundant in `(!recv.method arg)`
+          node = node.children.first while node.unary_operation?
+          if node.send_type?
+            return unless method_call_with_redundant_parentheses?(node)
           end
+
+          offense(begin_node, 'an unary operation')
         end
 
         def offense(node, msg)