rubocop 0.93.1 → 1.0.0

data/lib/rubocop.rb

@@ -471,8 +471,6 @@ require_relative 'rubocop/cop/style/redundant_fetch_block'
 require_relative 'rubocop/cop/style/redundant_file_extension_in_require'
 require_relative 'rubocop/cop/style/redundant_self_assignment'
 require_relative 'rubocop/cop/style/sole_nested_conditional'
-require_relative 'rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses'
-require_relative 'rubocop/cop/style/method_call_with_args_parentheses/require_parentheses'
 require_relative 'rubocop/cop/style/method_called_on_do_end_block'
 require_relative 'rubocop/cop/style/method_def_parentheses'
 require_relative 'rubocop/cop/style/min_max'

data/lib/rubocop/cli/command/version.rb

@@ -10,7 +10,7 @@ module RuboCop
 
         def run
           puts RuboCop::Version.version(debug: false) if @options[:version]
-          puts RuboCop::Version.version(debug: true) if @options[:verbose_version]
+          puts RuboCop::Version.version(debug: true, env: env) if @options[:verbose_version]
         end
       end
     end

data/lib/rubocop/config.rb

@@ -37,6 +37,10 @@ module RuboCop
       new(hash, path).check
     end
 
+    def loaded_features
+      @loaded_features ||= ConfigLoader.loaded_features
+    end
+
     def check
       deprecation_check do |deprecation_message|
         warn("#{loaded_path} - #{deprecation_message}")

data/lib/rubocop/config_loader.rb

@@ -35,12 +35,13 @@ module RuboCop
       end
 
       def load_file(file)
-        path = File.absolute_path(file.is_a?(RemoteConfig) ? file.file : file)
+        path = file_path(file)
 
         hash = load_yaml_configuration(path)
 
         # Resolve requires first in case they define additional cops
-        resolver.resolve_requires(path, hash)
+        loaded_features = resolver.resolve_requires(path, hash)
+        add_loaded_features(loaded_features)
 
         add_missing_namespaces(path, hash)
 
@@ -172,8 +173,24 @@ module RuboCop
         resolver.merge_with_default(config, config_file, unset_nil: unset_nil)
       end
 
+      def loaded_features
+        @loaded_features.flatten.compact
+      end
+
       private
 
+      def file_path(file)
+        File.absolute_path(file.is_a?(RemoteConfig) ? file.file : file)
+      end
+
+      def add_loaded_features(loaded_features)
+        if instance_variable_defined?(:@loaded_features)
+          instance_variable_get(:@loaded_features) << loaded_features
+        else
+          instance_variable_set(:@loaded_features, [loaded_features])
+        end
+      end
+
       def find_project_dotfile(target_dir)
         find_file_upwards(DOTFILE, target_dir, project_root)
       end

data/lib/rubocop/config_loader_resolver.rb

@@ -9,11 +9,13 @@ module RuboCop
   class ConfigLoaderResolver
     def resolve_requires(path, hash)
       config_dir = File.dirname(path)
-      Array(hash.delete('require')).each do |r|
-        if r.start_with?('.')
-          require(File.join(config_dir, r))
-        else
-          require(r)
+      hash.delete('require').tap do |loaded_features|
+        Array(loaded_features).each do |feature|
+          if feature.start_with?('.')
+            require(File.join(config_dir, feature))
+          else
+            require(feature)
+          end
         end
       end
     end

data/lib/rubocop/config_validator.rb

@@ -18,6 +18,11 @@ module RuboCop
     # @api private
     NEW_COPS_VALUES = %w[pending disable enable].freeze
 
+    # @api private
+    CONFIG_CHECK_KEYS = %w[Enabled Safe SafeAutoCorrect AutoCorrect].to_set.freeze
+    CONFIG_CHECK_DEPARTMENTS = %w[pending override_department].freeze
+    private_constant :CONFIG_CHECK_KEYS, :CONFIG_CHECK_DEPARTMENTS
+
     def_delegators :@config, :smart_loaded_path, :for_all_cops
 
     def initialize(config)
@@ -202,13 +207,9 @@ module RuboCop
       hash.each do |key, value|
         check_cop_config_value(value, key) if value.is_a?(Hash)
 
-        next unless %w[Enabled
-                       Safe
-                       SafeAutoCorrect
-                       AutoCorrect].include?(key) && value.is_a?(String)
+        next unless CONFIG_CHECK_KEYS.include?(key) && value.is_a?(String)
 
-        next if key == 'Enabled' &&
-                %w[pending override_department].include?(value)
+        next if key == 'Enabled' && CONFIG_CHECK_DEPARTMENTS.include?(value)
 
         raise ValidationError, msg_not_boolean(parent, key, value)
       end

data/lib/rubocop/cop/badge.rb

@@ -10,37 +10,22 @@ module RuboCop
     # allow for badge references in source files that omit the department for
     # RuboCop to infer.
     class Badge
-      # Error raised when a badge parse fails.
-      class InvalidBadge < Error
-        MSG = 'Invalid badge %<badge>p. ' \
-              'Expected `Department/CopName` or `CopName`.'
-
-        def initialize(token)
-          super(format(MSG, badge: token))
-        end
-      end
-
       attr_reader :department, :cop_name
 
       def self.for(class_name)
-        new(*class_name.split('::').last(2))
+        parts = class_name.split('::')
+        name_deep_enough = parts.length >= 4
+        new(name_deep_enough ? parts[2..-1] : parts.last(2))
       end
 
       def self.parse(identifier)
-        parts = identifier.split('/', 2)
-
-        raise InvalidBadge, identifier if parts.size > 2
-
-        if parts.one?
-          new(nil, *parts)
-        else
-          new(*parts)
-        end
+        new(identifier.split('/'))
       end
 
-      def initialize(department, cop_name)
-        @department = department.to_sym if department
-        @cop_name   = cop_name
+      def initialize(class_name_parts)
+        department_parts = class_name_parts[0...-1]
+        @department = (department_parts.join('/').to_sym unless department_parts.empty?)
+        @cop_name = class_name_parts.last
       end
 
       def ==(other)
@@ -66,7 +51,7 @@ module RuboCop
       end
 
       def with_department(department)
-        self.class.new(department, cop_name)
+        self.class.new([department.to_s.split('/'), cop_name].flatten)
       end
     end
   end

data/lib/rubocop/cop/base.rb

@@ -261,6 +261,21 @@ module RuboCop
           'they are returned as the result of the investigation'
       end
 
+      ### Reserved for Commissioner
+
+      # @api private
+      def callbacks_needed
+        self.class.callbacks_needed
+      end
+
+      # @api private
+      def self.callbacks_needed
+        @callbacks_needed ||= public_instance_methods.select do |m|
+          m.match?(/^on_|^after_/) &&
+            !Base.method_defined?(m) # exclude standard "callbacks" like 'on_begin_investigation'
+        end
+      end
+
       private
 
       ### Reserved for Cop::Cop
@@ -291,7 +306,7 @@ module RuboCop
       end
 
       private_class_method def self.restrict_on_send
-        @restrict_on_send ||= self::RESTRICT_ON_SEND.to_set.freeze
+        @restrict_on_send ||= self::RESTRICT_ON_SEND.to_a.freeze
       end
 
       # Called before any investigation

data/lib/rubocop/cop/commissioner.rb

@@ -7,7 +7,7 @@ module RuboCop
     class Commissioner
       include RuboCop::AST::Traversal
 
-      RESTRICTED_CALLBACKS = %i[on_send on_csend].freeze
+      RESTRICTED_CALLBACKS = %i[on_send on_csend after_send after_csend].freeze
       private_constant :RESTRICTED_CALLBACKS
 
       # How a Commissioner returns the results of the investigation
@@ -45,8 +45,7 @@ module RuboCop
         @cops = cops
         @forces = forces
         @options = options
-        @callbacks = Hash.new { |h, k| h[k] = cops_callbacks_for(k) }
-        @restricted_map = {}
+        initialize_callbacks
 
         reset
       end
@@ -61,16 +60,18 @@ module RuboCop
         method_name = :"on_#{node_type}"
         next unless method_defined?(method_name)
 
-        if RESTRICTED_CALLBACKS.include?(method_name)
-          trigger_restricted = "trigger_restricted_cops(:on_#{node_type}, node)"
-        end
+        # Hacky: Comment-out code as needed
+        r = '#' unless RESTRICTED_CALLBACKS.include?(method_name) # has Restricted?
+        c = '#' if NO_CHILD_NODES.include?(node_type) # has Children?
 
         class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-          def on_#{node_type}(node)
-            trigger_responding_cops(:on_#{node_type}, node)
-            #{trigger_restricted}
-            #{'super(node)' unless NO_CHILD_NODES.include?(node_type)}
-          end
+                  def on_#{node_type}(node)
+                    trigger_responding_cops(:on_#{node_type}, node)
+              #{r}  trigger_restricted_cops(:on_#{node_type}, node)
+          #{c}      super(node)
+          #{c}      trigger_responding_cops(:after_#{node_type}, node)
+          #{c}#{r}  trigger_restricted_cops(:after_#{node_type}, node)
+                  end
         RUBY
       end
 
@@ -94,7 +95,7 @@ module RuboCop
       private
 
       def trigger_responding_cops(callback, node)
-        @callbacks[callback].each do |cop|
+        @callbacks[callback]&.each do |cop|
           with_cop_error_handling(cop, node) do
             cop.send(callback, node)
           end
@@ -105,19 +106,32 @@ module RuboCop
         @errors = []
       end
 
-      def cops_callbacks_for(callback)
-        callbacks = @cops.select do |cop|
-          cop.respond_to?(callback)
-        end
-        if RESTRICTED_CALLBACKS.include?(callback)
-          @restricted_map[callback] = restricted_map(callbacks)
+      def initialize_callbacks
+        @callbacks = build_callbacks(@cops)
+        @restricted_map = restrict_callbacks(@callbacks)
+      end
+
+      def build_callbacks(cops)
+        callbacks = {}
+        cops.each do |cop|
+          cop.callbacks_needed.each do |callback|
+            (callbacks[callback] ||= []) << cop
+          end
         end
         callbacks
       end
 
+      def restrict_callbacks(callbacks)
+        restricted = {}
+        RESTRICTED_CALLBACKS.each do |callback|
+          restricted[callback] = restricted_map(callbacks[callback])
+        end
+        restricted
+      end
+
       def trigger_restricted_cops(event, node)
         name = node.method_name
-        @restricted_map.fetch(event)[name]&.each do |cop|
+        @restricted_map[event][name]&.each do |cop|
           with_cop_error_handling(cop, node) do
             cop.send(event, node)
           end
@@ -127,7 +141,7 @@ module RuboCop
       # Note: mutates `callbacks` in place
       def restricted_map(callbacks)
         map = {}
-        callbacks.select! do |cop|
+        callbacks&.select! do |cop|
           restrictions = cop.class.send :restrict_on_send
           restrictions.each do |name|
             (map[name] ||= []) << cop

data/lib/rubocop/cop/correctors/percent_literal_corrector.rb

@@ -89,7 +89,7 @@ module RuboCop
         begin_line_num = previous_line_num - base_line_num + 1
         end_line_num = node.first_line - base_line_num + 1
         lines = source_in_lines[begin_line_num...end_line_num]
-        "\n#{(lines.join("\n").split(node.source).first || '')}"
+        "\n#{lines.join("\n").split(node.source).first || ''}"
       end
 
       def fix_escaped_content(word_node, escape, delimiters)

data/lib/rubocop/cop/layout/class_structure.rb

@@ -265,6 +265,9 @@ module RuboCop
         end
 
         def end_position_for(node)
+          heredoc = find_heredoc(node)
+          return heredoc.location.heredoc_end.end_pos + 1 if heredoc
+
           end_line = buffer.line_for_position(node.loc.expression.end_pos)
           buffer.line_range(end_line).end_pos
         end
@@ -284,6 +287,10 @@ module RuboCop
           buffer.line_range(node.loc.line).begin_pos - 1
         end
 
+        def find_heredoc(node)
+          node.each_node(:str, :dstr, :xstr).find(&:heredoc?)
+        end
+
         def buffer
           processed_source.buffer
         end

data/lib/rubocop/cop/layout/space_around_operators.rb

@@ -5,6 +5,8 @@ module RuboCop
     module Layout
       # Checks that operators have space around them, except for ** which
       # should or shouldn't have surrounding space depending on configuration.
+      # It allows vertical alignment consisting of one or more whitespace
+      # around operators.
       #
       # This cop has `AllowForAlignment` option. When `true`, allows most
       # uses of extra spacing if the intent is to align with an operator on
@@ -207,7 +209,8 @@ module RuboCop
           token            = Token.new(operator, nil, operator.source)
           align_preceding  = aligned_with_preceding_assignment(token)
 
-          return align_preceding == :no unless align_preceding == :none
+          return false if align_preceding == :yes ||
+                          aligned_with_subsequent_assignment(token) == :none
 
           aligned_with_subsequent_assignment(token) != :yes
         end

data/lib/rubocop/cop/layout/trailing_whitespace.rb

@@ -14,14 +14,25 @@ module RuboCop
       #   # good
       #   x = 0
       #
-      # @example AllowInHeredoc: false
+      # @example AllowInHeredoc: false (default)
       #   # The line in this example contains spaces after the 0.
       #   # bad
       #   code = <<~RUBY
       #     x = 0
       #   RUBY
       #
-      # @example AllowInHeredoc: true (default)
+      #   # ok
+      #   code = <<~RUBY
+      #     x = 0 #{}
+      #   RUBY
+      #
+      #   # good
+      #   trailing_whitespace = ' '
+      #   code = <<~RUBY
+      #     x = 0#{trailing_whitespace}
+      #   RUBY
+      #
+      # @example AllowInHeredoc: true
       #   # The line in this example contains spaces after the 0.
       #   # good
       #   code = <<~RUBY
@@ -35,36 +46,49 @@ module RuboCop
         MSG = 'Trailing whitespace detected.'
 
         def on_new_investigation
-          heredoc_ranges = extract_heredoc_ranges(processed_source.ast)
+          @heredocs = extract_heredocs(processed_source.ast)
           processed_source.lines.each_with_index do |line, index|
-            lineno = index + 1
-
             next unless line.end_with?(' ', "\t")
-            next if skip_heredoc? && inside_heredoc?(heredoc_ranges, lineno)
 
-            range = offense_range(lineno, line)
-            add_offense(range) do |corrector|
+            process_line(line, index + 1)
+          end
+        end
+
+        private
+
+        def process_line(line, lineno)
+          heredoc = find_heredoc(lineno)
+          return if skip_heredoc? && heredoc
+
+          range = offense_range(lineno, line)
+          add_offense(range) do |corrector|
+            if heredoc
+              corrector.insert_after(range, '#{}') unless static?(heredoc) # rubocop:disable Lint/InterpolationCheck
+            else
               corrector.remove(range)
             end
           end
         end
 
-        private
+        def static?(heredoc)
+          heredoc.loc.expression.source.end_with? "'"
+        end
 
         def skip_heredoc?
           cop_config.fetch('AllowInHeredoc', false)
         end
 
-        def inside_heredoc?(heredoc_ranges, line_number)
-          heredoc_ranges.any? { |r| r.include?(line_number) }
+        def find_heredoc(line_number)
+          @heredocs.each { |node, r| return node if r.include?(line_number) }
+          nil
         end
 
-        def extract_heredoc_ranges(ast)
+        def extract_heredocs(ast)
           return [] unless ast
 
           ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
             body = node.location.heredoc_body
-            (body.first_line...body.last_line)
+            [node, body.first_line...body.last_line]
           end
         end
 

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

@@ -31,7 +31,7 @@ module RuboCop
       class ToJSON < Base
         extend AutoCorrector
 
-        MSG = ' `#to_json` requires an optional argument to be parsable ' \
+        MSG = '`#to_json` requires an optional argument to be parsable ' \
           'via JSON.generate(obj).'
 
         def on_def(node)