rubocop 0.42.0 → 0.43.0

data/lib/rubocop/cli.rb

@@ -19,7 +19,7 @@ module RuboCop
     # Entry point for the application logic. Here we
     # do the command line arguments processing and inspect
     # the target files
-    # @return [Fixnum] UNIX exit code
+    # @return [Integer] UNIX exit code
     def run(args = ARGV)
       @options, paths = Options.new.parse(args)
       act_on_options
@@ -95,10 +95,10 @@ module RuboCop
         [[formatter, @options[:output_path]]]
       end
 
-      if @options[:auto_gen_config]
-        @options[:formatters] << [Formatter::DisabledConfigFormatter,
-                                  ConfigLoader::AUTO_GENERATED_FILE]
-      end
+      return unless @options[:auto_gen_config]
+
+      @options[:formatters] << [Formatter::DisabledConfigFormatter,
+                                ConfigLoader::AUTO_GENERATED_FILE]
     end
 
     def print_available_cops

data/lib/rubocop/config.rb

@@ -11,7 +11,7 @@ module RuboCop
   # file from which it was read. Several different Configs can be used
   # during a run of the rubocop program, if files in several
   # directories are inspected.
-  class Config < Hash
+  class Config
     include PathUtil
 
     COMMON_PARAMS = %w(Exclude Include Severity
@@ -48,11 +48,55 @@ module RuboCop
       @for_cop = Hash.new do |h, cop|
         h[cop] = self[Cop::Cop.qualified_cop_name(cop, loaded_path)] || {}
       end
-      replace(hash)
+      @hash = hash
+    end
+
+    def [](key)
+      @hash[key]
+    end
+
+    def []=(key, value)
+      @hash[key] = value
+    end
+
+    def delete(key)
+      @hash.delete(key)
+    end
+
+    def each(&block)
+      @hash.each(&block)
+    end
+
+    def key?(key)
+      @hash.key?(key)
+    end
+
+    def keys
+      @hash.keys
+    end
+
+    def map(&block)
+      @hash.map(&block)
+    end
+
+    def merge(other_hash)
+      @hash.merge(other_hash)
+    end
+
+    def to_h
+      @hash
+    end
+
+    def to_hash
+      @hash
+    end
+
+    def to_s
+      @to_s ||= @hash.to_s
     end
 
     def make_excludes_absolute
-      each_key do |key|
+      each do |key, _|
         validate_section_presence(key)
         next unless self[key]['Exclude']
 
@@ -156,7 +200,9 @@ module RuboCop
     # Returns true if there's a chance that an Include pattern matches hidden
     # files, false if that's definitely not possible.
     def possibly_include_hidden?
-      @possibly_include_hidden ||= patterns_to_include.any? do |s|
+      return @possibly_include_hidden if defined?(@possibly_include_hidden)
+
+      @possibly_include_hidden = patterns_to_include.any? do |s|
         s.is_a?(Regexp) || s.start_with?('.') || s.include?('/.')
       end
     end
@@ -169,11 +215,11 @@ module RuboCop
     end
 
     def patterns_to_include
-      @patterns_to_include ||= for_all_cops['Include']
+      for_all_cops['Include']
     end
 
     def patterns_to_exclude
-      @patterns_to_exclude ||= for_all_cops['Exclude']
+      for_all_cops['Exclude']
     end
 
     def path_relative_to_config(path)
@@ -274,11 +320,11 @@ module RuboCop
     end
 
     def check_obsolete_parameter(cop, parameter, alternative = nil)
-      if self[cop] && self[cop].key?(parameter)
-        raise ValidationError, "obsolete parameter #{parameter} (for #{cop}) " \
-                              "found in #{loaded_path}" \
-                              "#{"\n" if alternative}#{alternative}"
-      end
+      return unless self[cop] && self[cop].key?(parameter)
+
+      raise ValidationError, "obsolete parameter #{parameter} (for #{cop}) " \
+                            "found in #{loaded_path}" \
+                            "#{"\n" if alternative}#{alternative}"
     end
 
     def reject_obsolete_cops
@@ -291,23 +337,21 @@ module RuboCop
     end
 
     def check_target_ruby
-      return unless target_ruby_version
+      return if KNOWN_RUBIES.include?(target_ruby_version)
 
-      unless KNOWN_RUBIES.include?(target_ruby_version)
-        msg = "Unknown Ruby version #{target_ruby_version.inspect} found "
+      msg = "Unknown Ruby version #{target_ruby_version.inspect} found "
 
-        msg +=
-          case @target_ruby_version_source
-          when :dot_ruby_version
-            'in `.ruby-version`.'
-          when :rubocop_yml
-            "in `TargetRubyVersion` parameter (in #{loaded_path})." \
-          end
+      msg +=
+        case @target_ruby_version_source
+        when :dot_ruby_version
+          'in `.ruby-version`.'
+        when :rubocop_yml
+          "in `TargetRubyVersion` parameter (in #{loaded_path})." \
+        end
 
-        msg += "\nKnown versions: #{KNOWN_RUBIES.join(', ')}"
+      msg += "\nKnown versions: #{KNOWN_RUBIES.join(', ')}"
 
-        raise ValidationError, msg
-      end
+      raise ValidationError, msg
     end
   end
 end

data/lib/rubocop/config_loader.rb

@@ -33,12 +33,6 @@ module RuboCop
       def load_file(path)
         path = File.absolute_path(path)
         hash = load_yaml_configuration(path)
-
-        resolve_inheritance_from_gems(hash, hash.delete('inherit_gem'))
-        resolve_inheritance(path, hash)
-        resolve_requires(path, hash)
-
-        hash.delete('inherit_from')
         config = Config.new(hash, path)
 
         config.deprecation_check do |deprecation_message|
@@ -46,6 +40,13 @@ module RuboCop
         end
 
         config.add_missing_namespaces
+
+        resolve_inheritance_from_gems(config, config.delete('inherit_gem'))
+        resolve_inheritance(path, config)
+        resolve_requires(path, config)
+
+        config.delete('inherit_from')
+
         config.validate
         config.make_excludes_absolute
         config
@@ -140,7 +141,7 @@ module RuboCop
 
       def load_yaml_configuration(absolute_path)
         yaml_code = IO.read(absolute_path, encoding: 'UTF-8')
-        hash = yaml_safe_load(yaml_code) || {}
+        hash = yaml_safe_load(yaml_code, absolute_path) || {}
 
         puts "configuration from #{absolute_path}" if debug?
 
@@ -151,15 +152,16 @@ module RuboCop
         hash
       end
 
-      def yaml_safe_load(yaml_code)
+      def yaml_safe_load(yaml_code, filename)
         if YAML.respond_to?(:safe_load) # Ruby 2.1+
           if defined?(SafeYAML) && SafeYAML.respond_to?(:load)
-            SafeYAML.load(yaml_code, nil, whitelisted_tags: %w(!ruby/regexp))
+            SafeYAML.load(yaml_code, filename,
+                          whitelisted_tags: %w(!ruby/regexp))
           else
-            YAML.safe_load(yaml_code, [Regexp])
+            YAML.safe_load(yaml_code, [Regexp], [], false, filename)
           end
         else
-          YAML.load(yaml_code)
+          YAML.load(yaml_code, filename)
         end
       end
 

data/lib/rubocop/config_loader_resolver.rb

@@ -34,8 +34,10 @@ module RuboCop
         end
 
         hash['inherit_from'] = Array(hash['inherit_from'])
-        # Put gem configuration first so local configuration overrides it.
-        hash['inherit_from'].unshift gem_config_path(gem_name, config_path)
+        Array(config_path).reverse.each do |path|
+          # Put gem configuration first so local configuration overrides it.
+          hash['inherit_from'].unshift gem_config_path(gem_name, path)
+        end
       end
     end
   end

data/lib/rubocop/cop/cop.rb

@@ -24,6 +24,8 @@ module RuboCop
 
       def qualified_cop_name(name, origin)
         @cop_names ||= Set.new(map(&:cop_name))
+        return name if @cop_names.include?(name)
+
         basename = File.basename(name)
         found_ns = types.map(&:capitalize).select do |ns|
           @cop_names.include?("#{ns}/#{basename}")
@@ -33,8 +35,9 @@ module RuboCop
         when 0 then name # No namespace found. Deal with it later in caller.
         when 1 then cop_name_with_namespace(name, origin, basename, found_ns[0])
         else raise AmbiguousCopName,
-                   "Ambiguous cop name `#{basename}` used in" \
-                   "#{origin} needs namespace qualifier."
+                   "Ambiguous cop name `#{name}` used in #{origin} needs " \
+                   'namespace qualifier. Did you mean ' \
+                   "#{found_ns.map { |ns| "#{ns}/#{basename}" }.join(' or ')}"
         end
       end
 
@@ -156,10 +159,9 @@ module RuboCop
       end
 
       def add_offense(node, loc, message = nil, severity = nil)
-        location = loc.is_a?(Symbol) ? node.loc.public_send(loc) : loc
+        location = find_location(node, loc)
 
-        # Don't include the same location twice for one cop.
-        return if @offenses.any? { |o| o.location == location }
+        return if duplicate_location?(location)
 
         severity = custom_severity || severity || default_severity
 
@@ -172,6 +174,15 @@ module RuboCop
         yield if block_given? && status != :disabled
       end
 
+      def find_location(node, loc)
+        # Location can be provided as a symbol, e.g.: `:keyword`
+        loc.is_a?(Symbol) ? node.loc.public_send(loc) : loc
+      end
+
+      def duplicate_location?(location)
+        @offenses.any? { |o| o.location == location }
+      end
+
       def correct(node)
         return :unsupported unless support_autocorrect?
         return :uncorrected unless autocorrect?

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -29,34 +29,35 @@ module RuboCop
         def check(node)
           condition, = *node
 
-          # assignments inside blocks are not what we're looking for
-          return if condition.type == :block
+          return if condition.block_type?
+
           traverse_node(condition, ASGN_TYPES) do |asgn_node|
-            if asgn_node.type == :send
-              _receiver, method_name, *_args = *asgn_node
-              next :skip_children if method_name !~ /=\z/
-            end
-
-            # skip safe assignment nodes if safe assignment is allowed
-            if safe_assignment_allowed? && safe_assignment?(asgn_node)
-              next :skip_children
-            end
-
-            # assignment nodes from shorthand ops like ||= don't have operator
-            if asgn_node.type != :begin && asgn_node.loc.operator
-              add_offense(asgn_node, :operator)
-            end
+            next :skip_children if skip_children?(asgn_node)
+            next if allowed_construct?(asgn_node)
+
+            add_offense(asgn_node, :operator)
           end
         end
 
+        def allowed_construct?(asgn_node)
+          asgn_node.begin_type? || conditional_assignment?(asgn_node)
+        end
+
+        def conditional_assignment?(asgn_node)
+          !asgn_node.loc.operator
+        end
+
+        def skip_children?(asgn_node)
+          safe_assignment_allowed? && safe_assignment?(asgn_node)
+        end
+
         # each_node/visit_descendants_with_types with :skip_children
         def traverse_node(node, types, &block)
           result = yield node if types.include?(node.type)
-          # return to skip all descendant nodes
+
           return if result == :skip_children
-          node.children.each do |child|
-            traverse_node(child, types, &block) if child.is_a?(Node)
-          end
+
+          node.each_child_node { |child| traverse_node(child, types, &block) }
         end
       end
     end

data/lib/rubocop/cop/lint/block_alignment.rb

@@ -181,8 +181,7 @@ module RuboCop
           if delta > 0
             add_space_before(loc_end, delta)
           elsif delta < 0
-            source = node.source_range.source_buffer
-            remove_space_before(loc_end.begin_pos, -delta, source)
+            remove_space_before(loc_end.begin_pos, -delta)
           end
         end
 
@@ -190,8 +189,8 @@ module RuboCop
           ->(corrector) { corrector.insert_before(loc, ' ' * delta) }
         end
 
-        def remove_space_before(end_pos, delta, source)
-          range = Parser::Source::Range.new(source, end_pos - delta, end_pos)
+        def remove_space_before(end_pos, delta)
+          range = range_between(end_pos - delta, end_pos)
           ->(corrector) { corrector.remove(range) }
         end
       end

data/lib/rubocop/cop/lint/def_end_alignment.rb

@@ -32,9 +32,8 @@ module RuboCop
           _, _, method_def = *node
           expr = node.source_range
 
-          line_start = Parser::Source::Range.new(expr.source_buffer,
-                                                 expr.begin_pos,
-                                                 method_def.loc.keyword.end_pos)
+          line_start = range_between(expr.begin_pos,
+                                     method_def.loc.keyword.end_pos)
           align_with = {
             def: method_def.loc.keyword,
             start_of_line: line_start

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -41,18 +41,28 @@ module RuboCop
           receiver, name, = *node
           if receiver.const_type?
             _, const_name = *receiver
-            if (qualified = lookup_constant(node, const_name))
-              found_method(node, "#{qualified}.#{name}")
-            end
+            check_const_receiver(node, name, const_name)
           elsif receiver.self_type?
-            if (enclosing = node.parent_module_name)
-              found_method(node, "#{enclosing}.#{name}")
-            end
+            check_self_receiver(node, name)
           end
         end
 
         private
 
+        def check_const_receiver(node, name, const_name)
+          qualified = lookup_constant(node, const_name)
+          return unless qualified
+
+          found_method(node, "#{qualified}.#{name}")
+        end
+
+        def check_self_receiver(node, name)
+          enclosing = node.parent_module_name
+          return unless enclosing
+
+          found_method(node, "#{enclosing}.#{name}")
+        end
+
         def message_for_dup(node, method_name)
           format(MSG, method_name, @definitions[method_name],
                  source_location(node))

data/lib/rubocop/cop/lint/else_layout.rb

@@ -37,7 +37,7 @@ module RuboCop
 
         def check_else(node)
           _cond, _if_branch, else_branch = *node
-          return unless else_branch && else_branch.type == :begin
+          return unless else_branch && else_branch.begin_type?
 
           first_else_expr = else_branch.children.first
           return unless first_else_expr.source_range.line == node.loc.else.line

data/lib/rubocop/cop/lint/empty_interpolation.rb

@@ -13,7 +13,7 @@ module RuboCop
         MSG = 'Empty interpolation detected.'.freeze
 
         def on_dstr(node)
-          node.children.select { |n| n.type == :begin }.each do |begin_node|
+          node.each_child_node(:begin) do |begin_node|
             add_offense(begin_node, :expression) if begin_node.children.empty?
           end
         end

data/lib/rubocop/cop/lint/end_alignment.rb

@@ -84,9 +84,7 @@ module RuboCop
 
           align_with[:variable] =
             if !line_break_before_keyword?(expr, inner_node)
-              Parser::Source::Range.new(expr.source_buffer,
-                                        expr.begin_pos,
-                                        inner_node.loc.keyword.end_pos)
+              range_between(expr.begin_pos, inner_node.loc.keyword.end_pos)
             else
               inner_node.loc.keyword
             end
@@ -130,9 +128,9 @@ module RuboCop
           buffer = expr.source_buffer
           source = buffer.source_line(expr.line)
           range  = buffer.line_range(expr.line)
-          Parser::Source::Range.new(buffer,
-                                    range.begin_pos + (source =~ /\S/),
-                                    range.begin_pos + (source =~ /\s*\z/))
+
+          range_between(range.begin_pos + (source =~ /\S/),
+                        range.begin_pos + (source =~ /\s*\z/))
         end
       end
     end