rubocop 0.38.0 → 0.39.0

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

@@ -21,28 +21,42 @@ module RuboCop
           file_path = processed_source.buffer.name
           return if config.file_to_include?(file_path)
 
+          for_bad_filename(file_path) do |range, msg|
+            add_offense(nil, range, msg)
+          end
+        end
+
+        private
+
+        def for_bad_filename(file_path)
           basename = File.basename(file_path)
-          if filename_good?(basename)
-            return unless expect_matching_definition?
-            return if find_class_or_module(processed_source.ast,
-                                           to_namespace(file_path))
-            range = source_range(processed_source.buffer, 1, 0)
-            msg   = format(MSG_NO_DEFINITION,
-                           basename,
-                           to_namespace(file_path).join('::'))
-          else
-            first_line = processed_source.lines.first
-            return if cop_config['IgnoreExecutableScripts'] &&
-                      shebang?(first_line)
+          msg = if filename_good?(basename)
+                  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)
+                  other_message(basename)
+                end
+
+          yield source_range(processed_source.buffer, 1, 0), msg
+        end
 
-            range = source_range(processed_source.buffer, 1, 0)
-            msg = regex ? format(MSG_REGEX, basename, regex) : MSG_SNAKE_CASE
-          end
+        def first_line
+          processed_source.lines.first
+        end
 
-          add_offense(nil, range, msg)
+        def no_definition_message(basename, file_path)
+          format(MSG_NO_DEFINITION,
+                 basename,
+                 to_namespace(file_path).join('::'))
         end
 
-        private
+        def other_message(basename)
+          regex ? format(MSG_REGEX, basename, regex) : MSG_SNAKE_CASE
+        end
 
         def shebang?(line)
           line && line.start_with?('#!')

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

@@ -26,6 +26,7 @@ module RuboCop
           return if if_else?(node)
           return if node.chained?
           return unless fit_within_line_as_modifier_form?(node)
+          return if nested_conditional?(node)
           add_offense(node, :keyword, message(node.loc.keyword.source))
         end
 
@@ -64,6 +65,13 @@ module RuboCop
 
           ->(corrector) { corrector.replace(node.source_range, oneline) }
         end
+
+        private
+
+        # returns false if the then or else children are conditionals
+        def nested_conditional?(node)
+          node.children[1, 2].any? { |child| child && child.type == :if }
+        end
       end
     end
   end

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for if and unless statements used as modifers of other if or
+      # unless statements.
+      #
+      # @example
+      #
+      #  # bad
+      #  tired? ? 'stop' : 'go faster' if running?
+      #
+      #  # bad
+      #  if tired?
+      #    "please stop"
+      #  else
+      #    "keep going"
+      #  end if running?
+      #
+      #  # good
+      #  if running?
+      #    tired? ? 'stop' : 'go faster'
+      #  end
+      class IfUnlessModifierOfIfUnless < Cop
+        include StatementModifier
+
+        MESSAGE = 'Avoid modifier `%s` after another conditional.'.freeze
+
+        def message(keyword)
+          format(MESSAGE, keyword)
+        end
+
+        def on_if(node)
+          return unless modifier_if?(node)
+          _cond, body, _else = if_node_parts(node)
+          if body.type == :if
+            add_offense(node, :keyword, message(node.loc.keyword.source))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -126,9 +126,10 @@ module RuboCop
 
         def operation_rhs(node)
           receiver, = *node
-          receiver.each_ancestor.select(&:send_type?).each do |a|
+          receiver.each_ancestor(:send) do |a|
             _, method, args = *a
-            return args if operator?(method) && within_node?(receiver, args)
+            return args if operator?(method) && args &&
+                           within_node?(receiver, args)
           end
           nil
         end

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

@@ -146,9 +146,14 @@ module RuboCop
         end
 
         def cond_range(node, cond)
+          end_pos = if node.loc.begin
+                      node.loc.begin.end_pos # after "then"
+                    else
+                      cond.source_range.end_pos
+                    end
           Parser::Source::Range.new(node.source_range.source_buffer,
                                     node.source_range.begin_pos,
-                                    cond.source_range.end_pos)
+                                    end_pos)
         end
 
         def end_range(node)

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

@@ -28,18 +28,47 @@ module RuboCop
         end
 
         def replacement(node)
+          return ternary(node) unless node.parent
+          return "(#{ternary(node)})" if [:and, :or].include?(node.parent.type)
+
+          if node.parent.send_type? && operator?(node.parent.method_name)
+            return "(#{ternary(node)})"
+          end
+
+          ternary(node)
+        end
+
+        def ternary(node)
           cond, body, else_clause = *node
-          ternary = "#{cond.source} ? #{body.source} : #{else_clause.source}"
+          "#{expr_replacement(cond)} ? #{expr_replacement(body)} : " +
+            expr_replacement(else_clause)
+        end
+
+        def expr_replacement(node)
+          requires_parentheses?(node) ? "(#{node.source})" : node.source
+        end
 
-          return ternary unless node.parent
-          return "(#{ternary})" if [:and, :or].include?(node.parent.type)
+        def requires_parentheses?(node)
+          return true if [:and, :or, :if].include?(node.type)
+          return true if node.assignment?
+          return true if method_call_with_changed_precedence?(node)
 
-          if node.parent.send_type?
-            _receiver, method_name, = *node.parent
-            return "(#{ternary})" if operator?(method_name)
-          end
+          keyword_with_changed_precedence?(node)
+        end
+
+        def method_call_with_changed_precedence?(node)
+          return false unless node.send_type?
+          return false if node.method_args.empty?
+          return false if parenthesized_call?(node)
+
+          !operator?(node.method_name)
+        end
+
+        def keyword_with_changed_precedence?(node)
+          return false unless node.keyword?
+          return true if node.keyword_not?
 
-          ternary
+          !parenthesized_call?(node)
         end
       end
     end

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

@@ -69,6 +69,8 @@ module RuboCop
             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
         end
@@ -115,6 +117,13 @@ module RuboCop
           _receiver, _method_name, *args = *send_node
           node.equal?(args.first)
         end
+
+        def call_chain_starts_with_int?(begin_node, send_node)
+          recv = first_part_of_call_chain(send_node)
+          recv && recv.int_type? && (parent = begin_node.parent) &&
+            parent.send_type? &&
+            (parent.method_name == :-@ || parent.method_name == :+@)
+        end
       end
     end
   end

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

@@ -120,7 +120,7 @@ module RuboCop
         end
 
         def keyword?(method_name)
-          [:alias, :and, :begin, :break, :case, :class, :def, :defined, :do,
+          [:alias, :and, :begin, :break, :case, :class, :def, :defined?, :do,
            :else, :elsif, :end, :ensure, :false, :for, :if, :in, :module,
            :next, :nil, :not, :or, :redo, :rescue, :retry, :return, :self,
            :super, :then, :true, :undef, :unless, :until, :when, :while,

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

@@ -32,6 +32,8 @@ module RuboCop
         DO = 'do'.freeze
         ACCEPT_LEFT_PAREN =
           %w(break defined? next not rescue return super yield).freeze
+        ACCEPT_LEFT_SQUARE_BRACKET =
+          %w(super yield).freeze
 
         def on_and(node)
           check(node, [:operator].freeze) if node.keyword?
@@ -177,7 +179,10 @@ module RuboCop
           pos = range.end_pos
           char = range.source_buffer.source[pos]
           return false unless char
-          return false if accept_left_parenthesis?(range) && char == '('.freeze
+          return false if accept_left_parenthesis?(range) &&
+                          char == '('.freeze
+          return false if accept_left_square_bracket?(range) &&
+                          char == '['.freeze
 
           char !~ /[\s;,#\\\)\}\]\.]/
         end
@@ -186,6 +191,10 @@ module RuboCop
           ACCEPT_LEFT_PAREN.include?(range.source)
         end
 
+        def accept_left_square_bracket?(range)
+          ACCEPT_LEFT_SQUARE_BRACKET.include?(range.source)
+        end
+
         def preceded_by_operator?(node, _range)
           # regular dotted method calls bind more tightly than operators
           # so we need to climb up the AST past them

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

@@ -104,25 +104,28 @@ module RuboCop
                   node.parent.children.one?
               node = node.parent
             end
-            parent_type = node.parent && node.parent.type
-
-            if [:dstr, :xstr, :regexp].include?(parent_type)
-              if style == :use_english_names
-                corrector.replace(node.source_range,
-                                  "{#{preferred_names(global_var).first}}")
-              else
-                corrector.replace(node.source_range,
-                                  "##{preferred_names(global_var).first}")
-              end
-            else
-              corrector.replace(node.source_range,
-                                preferred_names(global_var).first.to_s)
-            end
+
+            corrector.replace(node.source_range, replacement(node, global_var))
           end
         end
 
         private
 
+        def replacement(node, global_var)
+          parent_type = node.parent && node.parent.type
+          preferred_name = preferred_names(global_var).first
+
+          unless [:dstr, :xstr, :regexp].include?(parent_type)
+            return preferred_name.to_s
+          end
+
+          if style == :use_english_names
+            return english_name_replacement(preferred_name, node)
+          end
+
+          "##{preferred_name}"
+        end
+
         def preferred_names(global)
           if style == :use_english_names
             ENGLISH_VARS[global]
@@ -130,6 +133,12 @@ module RuboCop
             PERL_VARS[global]
           end
         end
+
+        def english_name_replacement(preferred_name, node)
+          return "\#{#{preferred_name}}" if node.begin_type?
+
+          "{#{preferred_name}}"
+        end
       end
     end
   end

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

@@ -51,6 +51,31 @@ module RuboCop
           {(send (send _ ${:length :size}) ${:> :!=} (int $0))
            (send (int $0) ${:< :!=} (send _ ${:length :size}))}
         END
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, replacement(node))
+          end
+        end
+
+        def replacement(node)
+          receiver = zero_length_receiver(node)
+          return "#{receiver.source}.empty?" if receiver
+
+          "!#{other_receiver(node).source}.empty?"
+        end
+
+        def_node_matcher :zero_length_receiver, <<-END
+          {(send (send $_ _) :== (int 0))
+           (send (int 0) :== (send $_ _))
+           (send (send $_ _) :<  (int 1))
+           (send (int 1) :> (send $_ _))}
+        END
+
+        def_node_matcher :other_receiver, <<-END
+          {(send (send $_ _) _ _)
+           (send _ _ (send $_ _))}
+        END
       end
     end
   end

data/lib/rubocop/formatter/html_formatter.rb

@@ -9,11 +9,11 @@ require 'rubocop/formatter/text_util'
 
 module RuboCop
   module Formatter
-    # This formatter saves the output as a html file.
+    # This formatter saves the output as an html file.
     class HTMLFormatter < BaseFormatter
       ELLIPSES = '<span class="extra-code">...</span>'.freeze
-      TEMPLATE_PATH =
-        File.expand_path('../../../../assets/output.html.erb', __FILE__)
+      TEMPLATE_PATH = File.expand_path('../../../../assets/output.html.erb',
+                                       __FILE__).encode('utf-8')
 
       Color = Struct.new(:red, :green, :blue, :alpha) do
         def to_s

data/lib/rubocop/result_cache.rb

@@ -24,7 +24,7 @@ module RuboCop
       return unless File.exist?(cache_root)
 
       files, dirs = Find.find(cache_root).partition { |path| File.file?(path) }
-      if files.length > config_store.for('.')['AllCops']['MaxFilesInCache'] &&
+      if files.length > config_store.for('.').for_all_cops['MaxFilesInCache'] &&
          files.length > 1
         # Add 1 to half the number of files, so that we remove the file if
         # there's only 1 left.
@@ -51,7 +51,7 @@ module RuboCop
     end
 
     def self.cache_root(config_store)
-      root = config_store.for('.')['AllCops']['CacheRootDirectory']
+      root = config_store.for('.').for_all_cops['CacheRootDirectory']
       if root == '/tmp'
         tmpdir = File.realpath(Dir.tmpdir)
         # Include user ID in the path to make sure the user has write access.

data/lib/rubocop/runner.rb

@@ -122,7 +122,7 @@ module RuboCop
       @cached_run ||=
         (@options[:cache] == 'true' ||
          @options[:cache] != 'false' &&
-         @config_store.for(Dir.pwd)['AllCops']['UseCache']) &&
+         @config_store.for(Dir.pwd).for_all_cops['UseCache']) &&
         # When running --auto-gen-config, there's some processing done in the
         # cops related to calculating the Max parameters for Metrics cops. We
         # need to do that processing and can not use caching.
@@ -240,7 +240,7 @@ module RuboCop
     end
 
     def style_guide_cops_only?(config)
-      @options[:only_guide_cops] || config['AllCops']['StyleGuideCopsOnly']
+      @options[:only_guide_cops] || config.for_all_cops['StyleGuideCopsOnly']
     end
 
     def formatter_set
@@ -271,7 +271,7 @@ module RuboCop
     end
 
     def get_processed_source(file)
-      ruby_version = @config_store.for(file)['AllCops']['TargetRubyVersion']
+      ruby_version = @config_store.for(file).for_all_cops['TargetRubyVersion']
 
       if @options[:stdin]
         ProcessedSource.new(@options[:stdin], ruby_version, file)

data/lib/rubocop/target_finder.rb

@@ -110,7 +110,7 @@ module RuboCop
     end
 
     def excluded_dirs(base_dir)
-      all_cops_config = @config_store.for(base_dir)['AllCops']
+      all_cops_config = @config_store.for(base_dir).for_all_cops
       dir_tree_excludes = all_cops_config['Exclude'].select do |pattern|
         pattern.is_a?(String) && pattern.end_with?('/**/*')
       end
@@ -127,11 +127,7 @@ module RuboCop
     end
 
     def process_explicit_path(path)
-      files = if path.include?('*')
-                Dir[path]
-              else
-                [path]
-              end
+      files = path.include?('*') ? Dir[path] : [path]
 
       return files unless force_exclusion?