rubocop 0.35.1 → 0.36.0

data/lib/rubocop/config_loader.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 require 'yaml'
 require 'pathname'
@@ -10,18 +11,22 @@ module RuboCop
   # during a run of the rubocop program, if files in several
   # directories are inspected.
   class ConfigLoader
-    DOTFILE = '.rubocop.yml'
+    DOTFILE = '.rubocop.yml'.freeze
     RUBOCOP_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
     DEFAULT_FILE = File.join(RUBOCOP_HOME, 'config', 'default.yml')
-    AUTO_GENERATED_FILE = '.rubocop_todo.yml'
+    AUTO_GENERATED_FILE = '.rubocop_todo.yml'.freeze
 
     class << self
-      attr_accessor :debug, :auto_gen_config, :exclude_limit
+      attr_accessor :debug, :auto_gen_config
       attr_writer :root_level # The upwards search is stopped at this level.
       attr_writer :default_configuration
 
-      alias_method :debug?, :debug
-      alias_method :auto_gen_config?, :auto_gen_config
+      alias debug? debug
+      alias auto_gen_config? auto_gen_config
+
+      def clear_options
+        @debug = @auto_gen_config = @root_level = nil
+      end
 
       def load_file(path)
         path = File.absolute_path(path)
@@ -40,7 +45,7 @@ module RuboCop
         end
 
         config.add_missing_namespaces
-        config.warn_unless_valid
+        config.validate
         config.make_excludes_absolute
         config
       end
@@ -60,9 +65,8 @@ module RuboCop
 
       def base_configs(path, inherit_from)
         configs = Array(inherit_from).compact.map do |f|
-          if f =~ URI.regexp
+          if f =~ /\A#{URI.regexp(%w(http https))}\z/
             f = RemoteConfig.new(f).file
-            load_file(f)
           else
             f = File.expand_path(f, File.dirname(path))
 
@@ -72,8 +76,8 @@ module RuboCop
             end
 
             print 'Inheriting ' if debug?
-            load_file(f)
           end
+          load_file(f)
         end
 
         configs.compact
@@ -129,7 +133,7 @@ module RuboCop
       private
 
       # Returns a new hash where the parameters of the given config hash have
-      # been replaced by parmeters returned by the given block.
+      # been replaced by parameters returned by the given block.
       def transform(config)
         Hash[config.map { |cop, params| [cop, yield(params)] }]
       end
@@ -174,8 +178,14 @@ module RuboCop
 
       def resolve_inheritance_from_gems(hash, gems)
         (gems || {}).each_pair do |gem_name, config_path|
+          if gem_name == 'rubocop'
+            fail ArgumentError,
+                 "can't inherit configuration from the rubocop gem"
+          end
+
           hash['inherit_from'] = Array(hash['inherit_from'])
-          hash['inherit_from'] << gem_config_path(gem_name, config_path)
+          # Put gem configuration first so local configuration overrides it.
+          hash['inherit_from'].unshift gem_config_path(gem_name, config_path)
         end
       end
 
@@ -204,9 +214,8 @@ module RuboCop
       end
 
       def old_auto_config_file_warning
-        warn Rainbow('Attention: rubocop-todo.yml has been renamed to ' \
-                     "#{AUTO_GENERATED_FILE}").red
-        exit(1)
+        fail RuboCop::Error, 'rubocop-todo.yml is obsolete; it must be called' \
+                             " #{AUTO_GENERATED_FILE} instead"
       end
     end
   end

data/lib/rubocop/config_store.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   # Handles caching of configurations and association of inspected

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -1,8 +1,9 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
-    # This module encapsulates the logic for autocorrect behaviour for a cop
+    # This module encapsulates the logic for autocorrect behavior for a cop.
     module AutocorrectLogic
       def autocorrect?
         autocorrect_requested? && support_autocorrect? && autocorrect_enabled?

data/lib/rubocop/cop/commissioner.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -86,11 +87,8 @@ module RuboCop
       def with_cop_error_handling(cop)
         yield
       rescue => e
-        if @options[:raise_error]
-          raise e
-        else
-          @errors[cop] << e
-        end
+        raise e if @options[:raise_error]
+        @errors[cop] << e
       end
     end
   end

data/lib/rubocop/cop/cop.rb

@@ -1,15 +1,15 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
-    class AmbiguousCopName < Exception; end
+    class AmbiguousCopName < RuboCop::Error; end
 
     # Store for all cops with helper functions
     class CopStore < ::Array
       # @return [Array<String>] list of types for current cops.
       def types
-        @types = map(&:cop_type).uniq! unless defined? @types
-        @types
+        @types ||= map(&:cop_type).uniq!
       end
 
       # @return [Array<Cop>] Cops for that specific type.
@@ -32,7 +32,8 @@ module RuboCop
         case found_ns.size
         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 fail AmbiguousCopName, "`#{basename}` used in #{origin}"
+        else fail AmbiguousCopName, "Ambiguous cop name `#{basename}` used in" \
+                                    "#{origin} needs namespace qualifier."
         end
       end
 
@@ -65,8 +66,9 @@ module RuboCop
     #     end
     #   end
     class Cop
-      extend AST::Sexp
+      extend RuboCop::Sexp
       extend NodePattern::Macros
+      include RuboCop::Sexp
       include Util
       include IgnoredNode
       include AutocorrectLogic
@@ -104,8 +106,13 @@ module RuboCop
         cop_type == :lint
       end
 
-      def self.rails?
-        cop_type == :rails
+      # Returns true if the cop name or the cop namespace matches any of the
+      # given names.
+      def self.match?(given_names)
+        return false unless given_names
+
+        given_names.include?(cop_name) ||
+          given_names.include?(cop_type.to_s.capitalize)
       end
 
       def initialize(config = nil, options = nil)
@@ -144,15 +151,6 @@ module RuboCop
           config['AllCops'] && config['AllCops']['ExtraDetails']
       end
 
-      # Returns true if the cop name or the cop namespace matches any of the
-      # given names.
-      def self.match?(given_names)
-        return false unless given_names
-
-        given_names.include?(cop_name) ||
-          given_names.include?(cop_type.to_s.capitalize)
-      end
-
       def message(_node = nil)
         self.class::MSG
       end
@@ -194,11 +192,19 @@ module RuboCop
           hash
       end
 
+      def target_ruby_version
+        @config['AllCops'] && @config['AllCops']['TargetRubyVersion']
+      end
+
+      def parse(source, path = nil)
+        ProcessedSource.new(source, target_ruby_version, path)
+      end
+
       def cop_name
         self.class.cop_name
       end
 
-      alias_method :name, :cop_name
+      alias name cop_name
 
       def relevant_file?(file)
         file_name_matches_any?(file, 'Include', true) &&

data/lib/rubocop/cop/corrector.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -79,6 +80,30 @@ module RuboCop
       def replace(range, content)
         @source_rewriter.replace(range, content)
       end
+
+      # Removes `size` characters prior to the source range.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [Integer] size
+      def remove_preceding(range, size)
+        to_remove = Parser::Source::Range.new(range.source_buffer,
+                                              range.begin_pos - size,
+                                              range.begin_pos)
+        @source_rewriter.remove(to_remove)
+      end
+
+      # Removes `size` characters from the beginning of the given range.
+      # If `size` is greater than the size of `range`, the removed region can
+      # overrun the end of `range`.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [Integer] size
+      def remove_leading(range, size)
+        to_remove = Parser::Source::Range.new(range.source_buffer,
+                                              range.begin_pos,
+                                              range.begin_pos + size)
+        @source_rewriter.remove(to_remove)
+      end
     end
   end
 end

data/lib/rubocop/cop/force.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop

data/lib/rubocop/cop/ignored_node.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -10,7 +11,7 @@ module RuboCop
 
       def part_of_ignored_node?(node)
         ignored_nodes.map(&:loc).any? do |ignored_loc|
-          if ignored_loc.expression.begin_pos > node.loc.expression.begin_pos
+          if ignored_loc.expression.begin_pos > node.source_range.begin_pos
             next false
           end
 
@@ -19,7 +20,7 @@ module RuboCop
                             else
                               ignored_loc.expression.end_pos
                             end
-          ignored_end_pos >= node.loc.expression.end_pos
+          ignored_end_pos >= node.source_range.end_pos
         end
       end
 

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -31,7 +32,7 @@ module RuboCop
         MSG_FORMAT = 'Ambiguous %{actual} operator. Parenthesize the method ' \
                      "arguments if it's surely a %{actual} operator, or add " \
                      'a whitespace to the right of the `%{operator}` if it ' \
-                     'should be a %{possible}.'
+                     'should be a %{possible}.'.freeze
 
         private
 

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -19,7 +20,7 @@ module RuboCop
 
         MSG = 'Ambiguous regexp literal. Parenthesize the method arguments ' \
               "if it's surely a regexp literal, or add a whitespace to the " \
-              'right of the `/` if it should be a division.'
+              'right of the `/` if it should be a division.'.freeze
 
         private
 

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -8,8 +9,8 @@ module RuboCop
       class AssignmentInCondition < Cop
         include SafeAssignment
 
-        MSG = 'Assignment in condition - you probably meant to use `==`.'
-        ASGN_TYPES = [:begin, *EQUALS_ASGN_NODES, :send]
+        MSG = 'Assignment in condition - you probably meant to use `==`.'.freeze
+        ASGN_TYPES = [:begin, *EQUALS_ASGN_NODES, :send].freeze
 
         def on_if(node)
           check(node)
@@ -54,7 +55,7 @@ module RuboCop
           # 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?(Astrolabe::Node)
+            traverse_node(child, types, &block) if child.is_a?(Node)
           end
         end
       end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -12,95 +13,46 @@ module RuboCop
       #     i
       #   end
       class BlockAlignment < Cop
-        include CheckAssignment
+        MSG = '`%s` at %d, %d is not aligned with `%s` at %d, %d%s.'.freeze
 
-        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d%s.'
+        def_node_matcher :block_end_align_target?, <<-PATTERN
+          {assignment?
+           splat
+           and
+           or
+           (send _ :<<  ...)
+           (send equal?(%1) !:[] ...)}
+        PATTERN
 
         def on_block(node)
-          return if ignored_node?(node)
-          check_block_alignment(node, node)
-        end
-
-        def on_and(node)
-          return if ignored_node?(node)
-
-          _left, right = *node
-          return unless right.type == :block
-
-          check_block_alignment(node, right)
-          ignore_node(right)
-        end
-
-        alias_method :on_or, :on_and
-
-        def on_op_asgn(node)
-          variable, _op, args = *node
-          check_assignment(variable, args)
-        end
-
-        def on_send(node)
-          _receiver, _method, *args = *node
-          check_assignment(node, args.last)
-        end
-
-        def on_masgn(node)
-          variables, args = *node
-          check_assignment(variables, args)
+          check_block_alignment(start_for_block_node(node), node)
         end
 
         private
 
-        def check_assignment(begin_node, other_node)
-          return unless other_node
-
-          block_node = find_block_node(other_node)
-          return unless block_node.type == :block
-
-          # If the block is an argument in a function call, align end with
-          # the block itself, and not with the function.
-          if begin_node.type == :send
-            _receiver, method, *_args = *begin_node
-            begin_node = block_node if method.to_s =~ /^\w+$/
-          end
+        def start_for_block_node(block_node)
+          # Which node should we align the 'end' with?
+          result = block_node
 
-          # Align with the expression that is on the same line
-          # where the block is defined
-          if begin_node.type != :mlhs && block_is_on_next_line?(begin_node,
-                                                                block_node)
-            return
+          while (parent = result.parent)
+            break if !parent || !parent.loc
+            break if parent.loc.line != block_node.loc.line &&
+                     !parent.masgn_type?
+            break unless block_end_align_target?(parent, result)
+            result = parent
           end
-          return if ignored_node?(block_node)
 
-          ignore_node(block_node)
-          check_block_alignment(begin_node, block_node)
-        end
-
-        def find_block_node(node)
-          while [:send, :lvasgn].include?(node.type)
-            n = case node.type
-                when :send
-                  find_block_or_send_node(node) || break
-                when :lvasgn
-                  _variable, value = *node
-                  value
-                end
-            node = n if n
-          end
-          node
-        end
-
-        def find_block_or_send_node(send_node)
-          receiver, _method, args = *send_node
-          [receiver, args].find do |subnode|
-            subnode && [:block, :send].include?(subnode.type)
-          end
+          # In offense message, we want to show the assignment LHS rather than
+          # the entire assignment
+          result, = *result while result.op_asgn_type? || result.masgn_type?
+          result
         end
 
         def check_block_alignment(start_node, block_node)
           end_loc = block_node.loc.end
           return unless begins_its_line?(end_loc)
 
-          start_loc = start_node.loc.expression
+          start_loc = start_node.source_range
           return unless start_loc.column != end_loc.column
 
           do_loc = block_node.loc.begin # Actually it's either do or {.
@@ -116,7 +68,7 @@ module RuboCop
 
           add_offense(block_node,
                       end_loc,
-                      format(MSG, end_loc.line, end_loc.column,
+                      format(MSG, end_loc.source, end_loc.line, end_loc.column,
                              start_loc.source.lines.to_a.first.chomp,
                              start_loc.line, start_loc.column,
                              alt_start_msg(match, start_loc, do_loc,
@@ -132,19 +84,12 @@ module RuboCop
           end
         end
 
-        def message
-        end
-
-        def block_is_on_next_line?(begin_node, block_node)
-          begin_node.loc.line != block_node.loc.line
-        end
-
         def autocorrect(node)
-          ancestor_node = ancestor_on_same_line(node)
-          source = node.loc.expression.source_buffer
+          ancestor_node = start_for_block_node(node)
+          source = node.source_range.source_buffer
 
           lambda do |corrector|
-            start_col = (ancestor_node || node).loc.expression.column
+            start_col = (ancestor_node || node).source_range.column
             starting_position_of_block_end = node.loc.end.begin_pos
             end_col = node.loc.end.column
 
@@ -159,13 +104,6 @@ module RuboCop
             end
           end
         end
-
-        def ancestor_on_same_line(node)
-          node.ancestors.reverse.find do |ancestor|
-            next unless ancestor.loc.respond_to?(:line)
-            ancestor.loc.line == node.loc.line
-          end
-        end
       end
     end
   end