rubocop 0.46.0 → 0.47.0

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

@@ -40,51 +40,42 @@ module RuboCop
               'expression.'.freeze
 
         def on_case(case_node)
-          condition_node = case_node.children.first
+          return if case_node.condition
 
-          add_offense(case_node, :keyword, MSG) if condition_node.nil?
+          add_offense(case_node, :keyword, MSG)
         end
 
         private
 
         def autocorrect(case_node)
-          lambda do |corrector|
-            _cond_node, *when_nodes, _else_node = *case_node
-
-            correct_case_whens(corrector, case_node, when_nodes)
+          when_branches = case_node.when_branches
 
-            correct_multiple_alternative_whens(corrector, when_nodes)
+          lambda do |corrector|
+            correct_case_when(corrector, case_node, when_branches)
+            correct_when_conditions(corrector, when_branches)
           end
         end
 
-        def correct_case_whens(corrector, case_node, when_nodes)
-          case_to_first_when =
-            case_node.loc.keyword.join(when_nodes.first.loc.keyword)
+        def correct_case_when(corrector, case_node, when_nodes)
+          case_range = case_node.loc.keyword.join(when_nodes.shift.loc.keyword)
 
-          corrector.replace(case_to_first_when, 'if')
+          corrector.replace(case_range, 'if')
 
-          when_nodes.drop(1).each do |when_node|
+          when_nodes.each do |when_node|
             corrector.replace(when_node.loc.keyword, 'elsif')
           end
         end
 
-        # Since an if condition containing commas is not syntactically valid, we
-        # correct `when x, y` to `if x || y`.
-        def correct_multiple_alternative_whens(corrector, when_nodes)
+        def correct_when_conditions(corrector, when_nodes)
           when_nodes.each do |when_node|
-            # In `when a; r` we have two children: [a, r].
-            # In `when a, b, c; r` we have 4.
-            # In `when a, b then r` we have 3.
-            *children, _ = when_node.children
+            conditions = when_node.conditions
 
-            next unless children.size > 1
+            next unless conditions.size > 1
 
-            first = children.first
-            last = children.last
-            range = range_between(first.loc.expression.begin_pos,
-                                  last.loc.expression.end_pos)
+            range = range_between(conditions.first.loc.expression.begin_pos,
+                                  conditions.last.loc.expression.end_pos)
 
-            corrector.replace(range, children.map(&:source).join(' || '))
+            corrector.replace(range, conditions.map(&:source).join(' || '))
           end
         end
       end

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

@@ -76,38 +76,38 @@ module RuboCop
         MSG = 'Redundant `else`-clause.'.freeze
 
         def on_normal_if_unless(node)
-          check(node, if_else_clause(node))
+          check(node)
         end
 
         def on_case(node)
-          check(node, case_else_clause(node))
+          check(node)
         end
 
         private
 
-        def check(node, else_clause)
-          case style
-          when :empty
-            empty_check(node, else_clause)
-          when :nil
-            nil_check(node, else_clause)
-          when :both
-            both_check(node, else_clause)
-          end
+        def check(node)
+          empty_check(node) if empty_style?
+          nil_check(node) if nil_style?
+        end
+
+        def nil_style?
+          style == :nil || style == :both
         end
 
-        def empty_check(node, else_clause)
-          add_offense(node, :else, MSG) if node.loc.else && else_clause.nil?
+        def empty_style?
+          style == :empty || style == :both
         end
 
-        def nil_check(node, else_clause)
-          return unless else_clause && else_clause.nil_type?
+        def empty_check(node)
+          return unless node.else? && !node.else_branch
+
           add_offense(node, :else, MSG)
         end
 
-        def both_check(node, else_clause)
-          empty_check(node, else_clause)
-          nil_check(node, else_clause)
+        def nil_check(node)
+          return unless node.else_branch && node.else_branch.nil_type?
+
+          add_offense(node, :else, MSG)
         end
 
         def autocorrect(node)
@@ -121,13 +121,11 @@ module RuboCop
         end
 
         def base_if_node(node)
-          parent_node = node
-          parent_node = parent_node.parent until parent_node.loc.end
-          parent_node
+          node.each_ancestor(:if).find { |parent| parent.loc.end } || node
         end
 
         def autocorrect_forbidden?(type)
-          [type, 'both'].include? missing_else_style
+          [type, 'both'].include?(missing_else_style)
         end
 
         def missing_else_style

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

@@ -27,7 +27,7 @@ module RuboCop
           end
 
           str_node(node) do
-            return if frozen_string_literals_enabled?(processed_source)
+            return if frozen_string_literals_enabled?
 
             add_offense(node, :expression,
                         format(STR_MSG, preferred_string_literal))
@@ -54,7 +54,7 @@ module RuboCop
           config.for_cop('Style/StringLiterals')
         end
 
-        def first_arg_in_method_call_without_parentheses?(node)
+        def first_argument_unparenthesized?(node)
           return false unless node.parent && node.parent.send_type?
 
           _receiver, _method_name, *args = *node.parent
@@ -63,7 +63,7 @@ module RuboCop
 
         def replacement_range(node)
           if hash_node(node) &&
-             first_arg_in_method_call_without_parentheses?(node)
+             first_argument_unparenthesized?(node)
             # `some_method {}` is not same as `some_method Hash.new`
             # because the braces are interpreted as a block. We will have
             # to rewrite the arguments to wrap them in parenthesis.
@@ -83,7 +83,7 @@ module RuboCop
           elsif str_node(node)
             preferred_string_literal
           elsif hash_node(node)
-            if first_arg_in_method_call_without_parentheses?(node)
+            if first_argument_unparenthesized?(node)
               # `some_method {}` is not same as `some_method Hash.new`
               # because the braces are interpreted as a block. We will have
               # to rewrite the arguments to wrap them in parenthesis.

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # This cop checks for the formatting of empty method definitions.
       # By default it enforces empty method definitions to go on a single
-      # line (compact style), but it cah be configured to enforce the `end`
+      # line (compact style), but it can be configured to enforce the `end`
       # to go on its own line (expanded style.)
       #
       # Note: A method definition is not considered empty if it contains
@@ -18,31 +18,36 @@ module RuboCop
       #   @bad
       #   def foo(bar)
       #   end
+      #   def self.foo(bar)
+      #   end
       #
       #   @good
       #   def foo(bar); end
       #   def foo(bar)
       #     # baz
       #   end
+      #   def self.foo(bar); end
       #
       #   EnforcedStyle: expanded
       #
       #   @bad
       #   def foo(bar); end
+      #   def self.foo(bar); end
       #
       #   @good
       #   def foo(bar)
       #   end
+      #   def self.foo(bar)
+      #   end
       class EmptyMethod < Cop
+        include OnMethodDef
         include ConfigurableEnforcedStyle
 
         MSG_COMPACT = 'Put empty method definitions on a single line.'.freeze
         MSG_EXPANDED = 'Put the `end` of empty method definitions on the ' \
                        'next line.'.freeze
 
-        def on_def(node)
-          _method_name, _args, body = *node
-
+        def on_method_def(node, _method_name, _args, body)
           return if body || comment_lines?(node)
           return if compact_style? && compact?(node)
           return if expanded_style? && expanded?(node)
@@ -63,12 +68,13 @@ module RuboCop
         end
 
         def corrected(node)
-          method_name, args, _body = *node
+          method_name, args, _body, scope = method_def_node_parts(node)
 
           arguments = args.source unless args.children.empty?
           joint = compact_style? ? '; ' : "\n"
+          scope = scope ? 'self.' : ''
 
-          ["def #{method_name}#{arguments}", 'end'].join(joint)
+          ["def #{scope}#{method_name}#{arguments}", 'end'].join(joint)
         end
 
         def comment_lines?(node)

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

@@ -72,7 +72,7 @@ module RuboCop
         end
 
         def encoding_present?(line)
-          line =~ ENCODING_PATTERN
+          MagicComment.parse(line).encoding
         end
 
         def encoding_omitable?

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

@@ -34,10 +34,10 @@ module RuboCop
                   return unless expect_matching_definition?
                   return if find_class_or_module(processed_source.ast,
                                                  to_namespace(file_path))
+
                   no_definition_message(basename, file_path)
                 else
-                  return if cop_config['IgnoreExecutableScripts'] &&
-                            shebang?(first_line)
+                  return if ignore_executable_scripts? && shebang?(first_line)
                   other_message(basename)
                 end
 
@@ -66,6 +66,10 @@ module RuboCop
           line && line.start_with?('#!')
         end
 
+        def ignore_executable_scripts?
+          cop_config['IgnoreExecutableScripts']
+        end
+
         def expect_matching_definition?
           cop_config['ExpectMatchingDefinition']
         end
@@ -74,6 +78,10 @@ module RuboCop
           cop_config['Regex']
         end
 
+        def allowed_acronyms
+          cop_config['AllowedAcronyms'] || []
+        end
+
         def filename_good?(basename)
           basename = basename.sub(/\.[^\.]+$/, '')
           basename =~ (regex || SNAKE_CASE)
@@ -87,11 +95,12 @@ module RuboCop
             next unless (const = child.defined_module)
 
             const_namespace, const_name = *const
-            next unless name == const_name
+            next if name != const_name && !match_acronym?(name, const_name)
 
             return node if namespace.empty?
             return node if match_namespace(child, const_namespace, namespace)
           end
+
           nil
         end
 
@@ -115,7 +124,9 @@ module RuboCop
 
               namespace, name = *namespace
 
-              expected.pop if name == expected.last
+              if name == expected.last || match_acronym?(expected.last, name)
+                expected.pop
+              end
             end
 
             false
@@ -126,6 +137,15 @@ module RuboCop
           expected.empty? || expected == [:Object]
         end
 
+        def match_acronym?(expected, name)
+          expected = expected.to_s
+          name = name.to_s
+
+          allowed_acronyms.any? do |acronym|
+            expected.gsub(acronym.capitalize, acronym) == name
+          end
+        end
+
         def to_namespace(path)
           components = Pathname(path).each_filename.to_a
           # To convert a pathname to a Ruby namespace, we need a starting point

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

@@ -36,7 +36,7 @@ module RuboCop
           # ...then each key/value pair is treated as a method 'argument'
           # when determining where line breaks should appear.
           if (last_arg = args.last)
-            if last_arg.hash_type? && !last_arg.loc.begin # no explicit {
+            if last_arg.hash_type? && !last_arg.braces?
               args = args.concat(args.pop.children)
             end
           end

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

@@ -13,62 +13,31 @@ module RuboCop
       class FormatString < Cop
         include ConfigurableEnforcedStyle
 
-        def on_send(node)
-          add_offense(node, :selector) if offending_node?(node)
-        end
+        MSG = 'Favor `%s` over `%s`.'.freeze
 
-        private
-
-        def offending_node?(node)
-          case style
-          when :format
-            sprintf?(node) || percent?(node)
-          when :sprintf
-            format?(node) || percent?(node)
-          when :percent
-            format?(node) || sprintf?(node)
-          end
-        end
+        def_node_matcher :formatter, <<-PATTERN
+        {
+          (send nil ${:sprintf :format} _ _ ...)
+          (send {str dstr} $:% ... )
+          (send !nil $:% {array hash})
+        }
+        PATTERN
 
-        def format_method?(name, node)
-          receiver, method_name, *args = *node
-
-          # commands have no explicit receiver
-          return false unless !receiver && method_name == name
-
-          # we do an argument count check to reduce false positives
-          args.size >= 2
-        end
+        def on_send(node)
+          return unless (selector = formatter(node))
 
-        def format?(node)
-          format_method?(:format, node)
-        end
+          detected_style = selector == :% ? :percent : selector
+          return if detected_style == style
 
-        def sprintf?(node)
-          format_method?(:sprintf, node)
+          add_offense(node, :selector, message(detected_style))
         end
 
-        def percent?(node)
-          receiver_node, method_name, *arg_nodes = *node
-
-          method_name == :% &&
-            ([:str, :dstr].include?(receiver_node.type) ||
-             arg_nodes.first.array_type?)
+        def message(detected_style)
+          format(MSG, method_name(style), method_name(detected_style))
         end
 
-        def message(node)
-          _receiver_node, method_name, *_arg_nodes = *node
-
-          preferred =
-            if style == :percent
-              'String#%'
-            else
-              style
-            end
-
-          method_name = 'String#%' if method_name == :%
-
-          "Favor `#{preferred}` over `#{method_name}`."
+        def method_name(style_name)
+          style_name == :percent ? 'String#%' : style_name
         end
       end
     end

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

@@ -13,32 +13,47 @@ module RuboCop
         include FrozenStringLiteral
 
         MSG = 'Missing frozen string literal comment.'.freeze
+        MSG_UNNECESSARY = 'Unnecessary frozen string literal comment.'.freeze
         SHEBANG = '#!'.freeze
 
         def investigate(processed_source)
           return if style == :when_needed && target_ruby_version < 2.3
           return if processed_source.tokens.empty?
 
-          return if frozen_string_literal_comment_exists?(processed_source)
-
-          offense(processed_source)
+          if frozen_string_literal_comment_exists?
+            check_for_no_comment(processed_source)
+          else
+            check_for_comment(processed_source)
+          end
         end
 
-        def autocorrect(_node)
+        def autocorrect(node)
           lambda do |corrector|
-            last_special_comment = last_special_comment(processed_source)
-            if last_special_comment.nil?
-              corrector.insert_before(processed_source.tokens[0].pos,
-                                      "#{FROZEN_STRING_LITERAL_ENABLED}\n")
+            if style == :never
+              corrector.remove(range_with_surrounding_space(node.pos, :right))
             else
-              corrector.insert_after(last_special_comment.pos,
-                                     "\n#{FROZEN_STRING_LITERAL_ENABLED}")
+              last_special_comment = last_special_comment(processed_source)
+              if last_special_comment.nil?
+                corrector.insert_before(processed_source.tokens[0].pos,
+                                        "#{FROZEN_STRING_LITERAL_ENABLED}\n")
+              else
+                corrector.insert_after(last_special_comment.pos,
+                                       "\n#{FROZEN_STRING_LITERAL_ENABLED}")
+              end
             end
           end
         end
 
         private
 
+        def check_for_no_comment(processed_source)
+          unnecessary_comment_offense(processed_source) if style == :never
+        end
+
+        def check_for_comment(processed_source)
+          offense(processed_source) unless style == :never
+        end
+
         def last_special_comment(processed_source)
           token_number = 0
           if processed_source.tokens[token_number].text.start_with?(SHEBANG)
@@ -54,13 +69,27 @@ module RuboCop
           token
         end
 
+        def frozen_string_literal_comment(processed_source)
+          processed_source.tokens.find do |token|
+            token.text.start_with?(FrozenStringLiteral::FROZEN_STRING_LITERAL)
+          end
+        end
+
         def offense(processed_source)
           last_special_comment = last_special_comment(processed_source)
-          last_special_comment ||= processed_source.tokens[0]
           range = source_range(processed_source.buffer, 0, 0)
 
           add_offense(last_special_comment, range, MSG)
         end
+
+        def unnecessary_comment_offense(processed_source)
+          frozen_string_literal_comment =
+            frozen_string_literal_comment(processed_source)
+
+          add_offense(frozen_string_literal_comment,
+                      frozen_string_literal_comment.pos,
+                      MSG_UNNECESSARY)
+        end
       end
     end
   end