rubocop 0.48.1 → 0.49.0

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

@@ -107,11 +107,16 @@ module RuboCop
 
         def persisted_referenced?(assignment)
           return unless assignment.referenced?
+
           assignment.variable.references.any? do |reference|
-            reference.node.parent.method?(:persisted?)
+            call_to_persisted?(reference.node.parent)
           end
         end
 
+        def call_to_persisted?(node)
+          node.send_type? && node.method?(:persisted?)
+        end
+
         def check_used_in_conditional(node)
           return false unless conditional?(node)
 
@@ -130,7 +135,7 @@ module RuboCop
         end
 
         def last_call_of_method?(node)
-          node.parent && node.parent.children.count == node.sibling_index + 1
+          node.parent && node.parent.children.size == node.sibling_index + 1
         end
 
         # Ignore simple assignment or if condition

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

@@ -22,6 +22,7 @@ module RuboCop
       #
       #   # good
       #   user.update_attributes(website: 'example.com')
+      #   FileUtils.touch('file')
       class SkipsModelValidations < Cop
         MSG = 'Avoid using `%s` because it skips validations.'.freeze
 
@@ -36,6 +37,10 @@ module RuboCop
                                     update_columns
                                     update_counters].freeze
 
+        def_node_matcher :good_touch?, <<-PATTERN
+          (send (const nil :FileUtils) :touch ...)
+        PATTERN
+
         def on_send(node)
           return unless blacklist.include?(node.method_name.to_s)
 
@@ -45,6 +50,8 @@ module RuboCop
             return
           end
 
+          return if good_touch?(node)
+
           add_offense(node, :selector)
         end
 

data/lib/rubocop/cop/registry.rb

@@ -62,17 +62,18 @@ module RuboCop
       # @example gives back a correctly qualified cop name
       #
       #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('Style/IndentArray') # => 'Style/IndentArray'
+      #   cops.
+      #     qualified_cop_name('Layout/IndentArray') # => 'Layout/IndentArray'
       #
       # @example fixes incorrect namespaces
       #
       #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('Lint/IndentArray') # => 'Style/IndentArray'
+      #   cops.qualified_cop_name('Lint/IndentArray') # => 'Layout/IndentArray'
       #
       # @example namespaces bare cop identifiers
       #
       #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('IndentArray') # => 'Style/IndentArray'
+      #   cops.qualified_cop_name('IndentArray') # => 'Layout/IndentArray'
       #
       # @example passes back unrecognized cop names
       #

data/lib/rubocop/cop/security/eval.rb

@@ -3,20 +3,26 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of *Kernel#eval*.
+      # This cop checks for the use of `Kernel#eval` and `Binding#eval`.
       #
       # @example
       #
       #   # bad
       #
       #   eval(something)
+      #   binding.eval(something)
       class Eval < Cop
         MSG = 'The use of `eval` is a serious security risk.'.freeze
 
-        def_node_matcher :eval?, '(send nil :eval $!str ...)'
+        def_node_matcher :eval?, <<-END
+          (send {nil (send nil :binding)} :eval $!str ...)
+        END
 
         def on_send(node)
-          eval?(node) { add_offense(node, :selector) }
+          eval?(node) do |code|
+            return if code.dstr_type? && code.recursive_literal?
+            add_offense(node, :selector)
+          end
         end
       end
     end

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

@@ -108,7 +108,7 @@ module RuboCop
         end
 
         def correctable_send?(node)
-          !node.parenthesized? && node.arguments?
+          !node.parenthesized? && !node.method?(:[]) && node.arguments?
         end
 
         def whitespace_before_arg(node)

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

@@ -71,7 +71,7 @@ module RuboCop
         def autocorrect(node)
           return if correction_would_break_code?(node)
 
-          if node.loc.begin.is?('{')
+          if node.braces?
             replace_braces_with_do_end(node.loc)
           else
             replace_do_end_with_braces(node.loc)
@@ -97,17 +97,18 @@ module RuboCop
 
           lambda do |corrector|
             corrector.insert_after(b, ' ') unless whitespace_after?(b, 2)
+
             corrector.replace(b, '{')
             corrector.replace(e, '}')
           end
         end
 
-        def whitespace_before?(node)
-          node.source_buffer.source[node.begin_pos - 1, 1] =~ /\s/
+        def whitespace_before?(range)
+          range.source_buffer.source[range.begin_pos - 1, 1] =~ /\s/
         end
 
-        def whitespace_after?(node, length = 1)
-          node.source_buffer.source[node.begin_pos + length, 1] =~ /\s/
+        def whitespace_after?(range, length = 1)
+          range.source_buffer.source[range.begin_pos + length, 1] =~ /\s/
         end
 
         def get_blocks(node, &block)
@@ -120,7 +121,7 @@ module RuboCop
             # A hash which is passed as method argument may have no braces
             # In that case, one of the K/V pairs could contain a block node
             # which could change in meaning if do...end replaced {...}
-            return if node.loc.begin
+            return if node.braces?
             node.each_child_node { |child| get_blocks(child, &block) }
           when :pair
             node.each_child_node { |child| get_blocks(child, &block) }
@@ -139,16 +140,13 @@ module RuboCop
         end
 
         def line_count_based_block_style?(node)
-          block_begin = node.loc.begin.source
-
-          (block_length(node) > 0) ^ (block_begin == '{')
+          node.multiline? ^ node.braces?
         end
 
         def semantic_block_style?(node)
           method_name = node.method_name
-          block_begin = node.loc.begin.source
 
-          if block_begin == '{'
+          if node.braces?
             functional_method?(method_name) || functional_block?(node)
           else
             procedural_method?(method_name) || !return_value_used?(node)
@@ -171,13 +169,9 @@ module RuboCop
         end
 
         def correction_would_break_code?(node)
-          return unless node.loc.begin.is?('do')
-
-          # Converting `obj.method arg do |x| end` to use `{}` would cause
-          # a syntax error.
-          send = node.children.first
+          return unless node.keywords?
 
-          send.arguments? && !send.parenthesized?
+          node.send_node.arguments? && !node.send_node.parenthesized?
         end
 
         def ignored_method?(method_name)

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

@@ -45,7 +45,7 @@ module RuboCop
         MSG = '%s curly braces around a hash parameter.'.freeze
 
         def on_send(node)
-          return if node.asgn_method_call? || node.operator_method?
+          return if node.assignment_method? || node.operator_method?
 
           return unless node.arguments? && node.last_argument.hash_type? &&
                         !node.last_argument.empty?

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

@@ -15,9 +15,7 @@ module RuboCop
         MSG = 'Prefer `%s` over `%s`.'.freeze
 
         def on_block(node)
-          method, _args, _body = *node
-
-          check_method_node(method)
+          check_method_node(node.send_node)
         end
 
         def on_send(node)

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

@@ -209,7 +209,7 @@ module RuboCop
         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

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

@@ -8,8 +8,8 @@ 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

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

@@ -43,7 +43,7 @@ module RuboCop
       #     end
       #   end
       #
-      #   # Documenation
+      #   # Documentation
       #   def foo.bar
       #     puts baz
       #   end

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

@@ -29,7 +29,8 @@ module RuboCop
         def on_block(node)
           return unless offending_each_range(node)
 
-          send_node, = *node
+          send_node = node.send_node
+
           range = send_node.receiver.source_range.join(send_node.loc.selector)
 
           add_offense(node, range)

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

@@ -38,20 +38,24 @@ module RuboCop
           end
         end
 
+        private
+
+        # rubocop:disable Metrics/AbcSize
         def autocorrect(node)
           lambda do |corrector|
-            method, args, body = *node
-            corrector.replace(method.loc.selector, 'each_with_object')
-            first_arg, second_arg = *args
+            corrector.replace(node.send_node.loc.selector, 'each_with_object')
+
+            first_arg, second_arg = *node.arguments
+
             corrector.replace(first_arg.loc.expression, second_arg.source)
             corrector.replace(second_arg.loc.expression, first_arg.source)
 
-            return_value = return_value(body)
+            return_value = return_value(node.body)
+
             corrector.remove(return_value.loc.expression)
           end
         end
-
-        private
+        # rubocop:endable Metrics/AbcSize
 
         def simple_method_arg?(method_arg)
           method_arg && method_arg.basic_literal?

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

@@ -57,11 +57,11 @@ module RuboCop
         end
 
         def correct_case_when(corrector, case_node, when_nodes)
-          case_range = case_node.loc.keyword.join(when_nodes.shift.loc.keyword)
+          case_range = case_node.loc.keyword.join(when_nodes.first.loc.keyword)
 
           corrector.replace(case_range, 'if')
 
-          when_nodes.each do |when_node|
+          when_nodes[1..-1].each do |when_node|
             corrector.replace(when_node.loc.keyword, 'elsif')
           end
         end

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

@@ -22,14 +22,13 @@ module RuboCop
         end
 
         def on_block(node)
-          return if block_length(node).zero?
+          return if node.single_line?
 
-          method, _args, _body = *node
-          return unless method.send_type? && method.method?(:each) &&
-                        !method.arguments?
+          return unless node.send_node.method?(:each) &&
+                        !node.send_node.arguments?
 
           if style == :for
-            incorrect_style_detected(method)
+            incorrect_style_detected(node.send_node)
           else
             correct_style_detected
           end

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

@@ -40,6 +40,55 @@ module RuboCop
         def method_name(style_name)
           style_name == :percent ? 'String#%' : style_name
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            _receiver, detected_method = *node
+
+            case detected_method
+            when :%
+              autocorrect_from_percent(corrector, node)
+            when :format, :sprintf
+              case style
+              when :percent
+                autocorrect_to_percent(corrector, node)
+              when :format, :sprintf
+                corrector.replace(node.loc.selector, style.to_s)
+              end
+            end
+          end
+        end
+
+        private
+
+        def autocorrect_from_percent(corrector, node)
+          receiver, _method, args = *node
+          format = receiver.source
+          args = if args.array_type? || args.hash_type?
+                   args.children.map(&:source).join(', ')
+                 else
+                   args.source
+                 end
+          corrected = "#{style}(#{format}, #{args})"
+          corrector.replace(node.loc.expression, corrected)
+        end
+
+        def autocorrect_to_percent(corrector, node)
+          _nil, _method, format, *args = *node
+          format = format.source
+          args   = if args.one?
+                     arg = args.first
+                     if arg.hash_type?
+                       "{ #{arg.source} }"
+                     else
+                       arg.source
+                     end
+                   else
+                     "[#{args.map(&:source).join(', ')}]"
+                   end
+          corrected = "#{format} % #{args}"
+          corrector.replace(node.loc.expression, corrected)
+        end
       end
     end
   end

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use a consistent style for named format string tokens.
+      #
+      # @example
+      #
+      #   EnforcedStyle: annotated
+      #
+      #   # bad
+      #
+      #   format('%{greeting}', greeting: 'Hello')
+      #   format('%s', 'Hello')
+      #
+      #   # good
+      #
+      #   format('%<greeting>s', greeting: 'Hello')
+      #
+      # @example
+      #
+      #   EnforcedStyle: template
+      #
+      #   # bad
+      #
+      #   format('%<greeting>s', greeting: 'Hello')
+      #   format('%s', 'Hello')
+      #
+      #   # good
+      #
+      #   format('%{greeting}', greeting: 'Hello')
+      class FormatStringToken < Cop
+        include ConfigurableEnforcedStyle
+
+        FIELD_CHARACTERS = Regexp.union(%w[A B E G X a b c d e f g i o p s u x])
+
+        STYLE_PATTERNS = {
+          annotated: /(?<token>%<[^>]+>#{FIELD_CHARACTERS})/,
+          template:  /(?<token>%\{[^\}]+\})/
+        }.freeze
+
+        TOKEN_PATTERN = Regexp.union(STYLE_PATTERNS.values)
+
+        def on_str(node)
+          return if node.each_ancestor(:xstr).any?
+
+          tokens(node) do |detected_style, token_range|
+            if detected_style == style
+              correct_style_detected
+            else
+              style_detected(detected_style)
+              add_offense(node, token_range, message(detected_style))
+            end
+          end
+        end
+
+        private
+
+        def message(detected_style)
+          "Prefer #{message_text(style)} over #{message_text(detected_style)}."
+        end
+
+        # rubocop:disable FormatStringToken
+        def message_text(style)
+          case style
+          when :annotated then 'annotated tokens (like `%<foo>s`)'
+          when :template  then 'template tokens (like `%{foo}`)'
+          end
+        end
+        # rubocop:enable FormatStringToken
+
+        def tokens(str_node, &block)
+          return if str_node.source == '__FILE__'
+
+          token_ranges(str_contents(str_node.loc), &block)
+        end
+
+        def str_contents(source_map)
+          if source_map.is_a?(Parser::Source::Map::Heredoc)
+            source_map.heredoc_body
+          elsif source_map.begin
+            slice_source(
+              source_map.expression,
+              source_map.expression.begin_pos + 1,
+              source_map.expression.end_pos - 1
+            )
+          else
+            source_map.expression
+          end
+        end
+
+        def token_ranges(contents)
+          while (offending_match = match_token(contents))
+            detected_style, *range = *offending_match
+            token, contents = split_token(contents, *range)
+            yield(detected_style, token)
+          end
+        end
+
+        def match_token(source_range)
+          supported_styles.each do |style_name|
+            pattern = STYLE_PATTERNS.fetch(style_name)
+            match = source_range.source.match(pattern)
+            next unless match
+
+            return [style_name, match.begin(:token), match.end(:token)]
+          end
+
+          nil
+        end
+
+        def split_token(source_range, match_begin, match_end)
+          token =
+            slice_source(
+              source_range,
+              source_range.begin_pos + match_begin,
+              source_range.begin_pos + match_end
+            )
+
+          remainder =
+            slice_source(
+              source_range,
+              source_range.begin_pos + match_end,
+              source_range.end_pos
+            )
+
+          [token, remainder]
+        end
+
+        def slice_source(source_range, new_begin, new_end)
+          Parser::Source::Range.new(
+            source_range.source_buffer,
+            new_begin,
+            new_end
+          )
+        end
+      end
+    end
+  end
+end