rubocop 0.47.1 → 0.48.0

data/lib/rubocop/ast/node/when_node.rb

@@ -44,7 +44,7 @@ module RuboCop
 
       # Returns the body of the `when` node.
       #
-      # @return [Node] the body of the `when` node
+      # @return [Node, nil] the body of the `when` node
       def body
         node_parts[-1]
       end

data/lib/rubocop/ast/traversal.rb

@@ -13,21 +13,21 @@ module RuboCop
         nil
       end
 
-      NO_CHILD_NODES    = [:true, :false, :nil, :int, :float, :complex,
-                           :rational, :str, :sym, :regopt, :self, :lvar,
-                           :ivar, :cvar, :gvar, :nth_ref, :back_ref, :cbase,
-                           :arg, :restarg, :blockarg, :shadowarg,
-                           :kwrestarg, :zsuper, :lambda, :redo, :retry].freeze
-      ONE_CHILD_NODE    = [:splat, :kwsplat, :block_pass, :not, :break, :next,
-                           :preexe, :postexe, :match_current_line, :defined?,
-                           :arg_expr].freeze
-      MANY_CHILD_NODES  = [:dstr, :dsym, :xstr, :regexp, :array, :hash, :pair,
-                           :irange, :erange, :mlhs, :masgn, :or_asgn, :and_asgn,
-                           :undef, :alias, :args, :super, :yield, :or, :and,
-                           :while_post, :until_post, :iflipflop, :eflipflop,
-                           :match_with_lvasgn, :begin, :kwbegin, :return].freeze
-      SECOND_CHILD_ONLY = [:lvasgn, :ivasgn, :cvasgn, :gvasgn, :optarg, :kwarg,
-                           :kwoptarg].freeze
+      NO_CHILD_NODES    = %i(true false nil int float complex
+                             rational str sym regopt self lvar
+                             ivar cvar gvar nth_ref back_ref cbase
+                             arg restarg blockarg shadowarg
+                             kwrestarg zsuper lambda redo retry).freeze
+      ONE_CHILD_NODE    = %i(splat kwsplat block_pass not break next
+                             preexe postexe match_current_line defined?
+                             arg_expr).freeze
+      MANY_CHILD_NODES  = %i(dstr dsym xstr regexp array hash pair
+                             irange erange mlhs masgn or_asgn and_asgn
+                             undef alias args super yield or and
+                             while_post until_post iflipflop eflipflop
+                             match_with_lvasgn begin kwbegin return).freeze
+      SECOND_CHILD_ONLY = %i(lvasgn ivasgn cvasgn gvasgn optarg kwarg
+                             kwoptarg).freeze
 
       NO_CHILD_NODES.each do |type|
         module_eval("def on_#{type}(node); end")

data/lib/rubocop/comment_config.rb

@@ -11,7 +11,7 @@ module RuboCop
     COPS_PATTERN = "(all|#{COP_NAMES_PATTERN})".freeze
 
     COMMENT_DIRECTIVE_REGEXP = Regexp.new(
-      ('\A# rubocop : ((?:dis|en)able)\b ' + COPS_PATTERN).gsub(' ', '\s*')
+      ('# rubocop : ((?:dis|en)able)\b ' + COPS_PATTERN).gsub(' ', '\s*')
     )
 
     CopAnalysis = Struct.new(:line_ranges, :start_line_number)

data/lib/rubocop/config.rb

@@ -18,6 +18,7 @@ module RuboCop
     # 2.1 is the oldest officially supported Ruby version.
     DEFAULT_RUBY_VERSION = 2.1
     KNOWN_RUBIES = [1.9, 2.0, 2.1, 2.2, 2.3, 2.4].freeze
+    DEFAULT_RAILS_VERSION = 5.0
     OBSOLETE_COPS = {
       'Style/TrailingComma' =>
         'The `Style/TrailingComma` cop no longer exists. Please use ' \
@@ -27,7 +28,7 @@ module RuboCop
         'The `Rails/DefaultScope` cop no longer exists.',
       'Style/SingleSpaceBeforeFirstArg' =>
         'The `Style/SingleSpaceBeforeFirstArg` cop has been renamed to ' \
-        '`Style/SpaceBeforeFirstArg.`',
+        '`Style/SpaceBeforeFirstArg`.',
       'Lint/SpaceBeforeFirstArg' =>
         'The `Lint/SpaceBeforeFirstArg` cop has been removed, since it was a ' \
         'duplicate of `Style/SpaceBeforeFirstArg`. Please use ' \
@@ -96,7 +97,10 @@ module RuboCop
     def initialize(hash = {}, loaded_path = nil)
       @loaded_path = loaded_path
       @for_cop = Hash.new do |h, cop|
-        h[cop] = self[Cop::Cop.qualified_cop_name(cop, loaded_path)] || {}
+        qualified_cop_name = Cop::Cop.qualified_cop_name(cop, loaded_path)
+        cop_options = self[qualified_cop_name] || {}
+        cop_options['Enabled'] = enable_cop?(qualified_cop_name, cop_options)
+        h[cop] = cop_options
       end
       @hash = hash
     end
@@ -192,14 +196,6 @@ module RuboCop
       @for_all_cops ||= self['AllCops'] || {}
     end
 
-    def cop_enabled?(cop)
-      if (dept_config = self[cop.department.to_s])
-        return false if dept_config['Enabled'] == false
-      end
-
-      for_cop(cop).empty? || for_cop(cop).fetch('Enabled', true)
-    end
-
     def validate
       # Don't validate RuboCop's own files. Avoids infinite recursion.
       base_config_path = File.expand_path(File.join(ConfigLoader::RUBOCOP_HOME,
@@ -215,6 +211,7 @@ module RuboCop
       check_target_ruby
       validate_parameter_names(valid_cop_names)
       validate_enforced_styles(valid_cop_names)
+      reject_mutually_exclusive_defaults
     end
 
     def file_to_include?(file)
@@ -263,15 +260,14 @@ module RuboCop
       relative_path(path, base_dir_for_path_parameters)
     end
 
-    # Paths specified in .rubocop.yml and .rubocop_todo.yml files are relative
-    # to the directory where that file is. Paths in other config files are
-    # relative to the current directory. This is so that paths in
+    # Paths specified in configuration files starting with .rubocop are
+    # relative to the directory where that file is. Paths in other config files
+    # are relative to the current directory. This is so that paths in
     # config/default.yml, for example, are not relative to RuboCop's config
     # directory since that wouldn't work.
     def base_dir_for_path_parameters
-      config_files = [ConfigLoader::DOTFILE, ConfigLoader::AUTO_GENERATED_FILE]
       @base_dir_for_path_parameters ||=
-        if config_files.include?(File.basename(loaded_path)) &&
+        if File.basename(loaded_path).start_with?('.rubocop') &&
            loaded_path != File.join(Dir.home, ConfigLoader::DOTFILE)
           File.expand_path(File.dirname(loaded_path))
         else
@@ -296,6 +292,11 @@ module RuboCop
         end
     end
 
+    def target_rails_version
+      @target_rails_version ||=
+        for_all_cops.fetch('TargetRailsVersion', DEFAULT_RAILS_VERSION)
+    end
+
     private
 
     def warn_about_unrecognized_cops(invalid_cop_names)
@@ -400,5 +401,28 @@ module RuboCop
 
       raise ValidationError, msg
     end
+
+    def reject_mutually_exclusive_defaults
+      disabled_by_default = for_all_cops['DisabledByDefault']
+      enabled_by_default = for_all_cops['EnabledByDefault']
+      return unless disabled_by_default && enabled_by_default
+
+      msg = 'Cops cannot be both enabled by default and disabled by default'
+      raise ValidationError, msg
+    end
+
+    def enable_cop?(qualified_cop_name, cop_options)
+      cop_department, cop_name = qualified_cop_name.split('/')
+      department = cop_name.nil?
+
+      unless department
+        department_options = self[cop_department]
+        if department_options && department_options.fetch('Enabled') == false
+          return false
+        end
+      end
+
+      cop_options.fetch('Enabled', true)
+    end
   end
 end

data/lib/rubocop/config_loader.rb

@@ -37,11 +37,17 @@ module RuboCop
         resolve_requires(path, hash)
 
         add_missing_namespaces(path, hash)
+        target_ruby_version_to_f!(hash)
 
         resolve_inheritance_from_gems(hash, hash.delete('inherit_gem'))
         resolve_inheritance(path, hash)
 
         hash.delete('inherit_from')
+
+        create_config(hash, path)
+      end
+
+      def create_config(hash, path)
         config = Config.new(hash, path)
 
         config.deprecation_check do |deprecation_message|
@@ -125,20 +131,35 @@ module RuboCop
       # Merges the given configuration with the default one. If
       # AllCops:DisabledByDefault is true, it changes the Enabled params so
       # that only cops from user configuration are enabled.
+      # If AllCops::EnabledByDefault is true, it changes the Enabled params
+      # so that only cops explicitly disabled in user configuration are
+      # disabled.
       def merge_with_default(config, config_file)
-        configs =
-          if config.for_all_cops['DisabledByDefault']
-            disabled_default = transform(default_configuration) do |params|
-              params.merge('Enabled' => false) # Overwrite with false.
-            end
-            enabled_user_config = transform(config) do |params|
-              { 'Enabled' => true }.merge(params) # Set true if not set.
-            end
-            [disabled_default, enabled_user_config]
-          else
-            [default_configuration, config]
+        default_configuration = self.default_configuration
+
+        disabled_by_default = config.for_all_cops['DisabledByDefault']
+        enabled_by_default = config.for_all_cops['EnabledByDefault']
+
+        if disabled_by_default || enabled_by_default
+          default_configuration = transform(default_configuration) do |params|
+            params.merge('Enabled' => !disabled_by_default)
           end
-        Config.new(merge(configs.first, configs.last), config_file)
+        end
+
+        if disabled_by_default
+          config = transform(config) do |params|
+            { 'Enabled' => true }.merge(params) # Set true if not set.
+          end
+        end
+
+        Config.new(merge(default_configuration, config), config_file)
+      end
+
+      def target_ruby_version_to_f!(hash)
+        version = 'TargetRubyVersion'
+        return unless hash['AllCops'] && hash['AllCops'][version]
+
+        hash['AllCops'][version] = hash['AllCops'][version].to_f
       end
 
       private
@@ -168,7 +189,7 @@ module RuboCop
             SafeYAML.load(yaml_code, filename,
                           whitelisted_tags: %w(!ruby/regexp))
           else
-            YAML.safe_load(yaml_code, [Regexp], [], false, filename)
+            YAML.safe_load(yaml_code, [Regexp, Symbol], [], false, filename)
           end
         else
           YAML.load(yaml_code, filename) # rubocop:disable Security/YAMLLoad

data/lib/rubocop/cop/bundler/ordered_gems.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
+
 module RuboCop
   module Cop
     module Bundler
-      # Gems in consecutive lines should be alphabetically sorted
+      # Gems should be alphabetically sorted within groups.
+      #
       # @example
       #   # bad
       #   gem 'rubocop'
@@ -16,7 +18,15 @@ module RuboCop
       #   gem 'rubocop'
       #
       #   gem 'rspec'
+      #
+      #   # good only if TreatCommentsAsGroupSeparators is true
+      #   # For code quality
+      #   gem 'rubocop'
+      #   # For tests
+      #   gem 'rspec'
       class OrderedGems < Cop
+        include ConfigurableEnforcedStyle
+
         MSG = 'Gems should be sorted in an alphabetical order within their '\
               'section of the Gemfile. '\
               'Gem `%s` should appear before `%s`.'.freeze
@@ -34,11 +44,12 @@ module RuboCop
         end
 
         def case_insensitive_out_of_order?(string_a, string_b)
-          1 > string_a.casecmp(string_b)
+          string_a.downcase < string_b.downcase
         end
 
         def consecutive_lines(previous, current)
-          previous.source_range.last_line == current.source_range.first_line - 1
+          first_line = get_source_range(current).first_line
+          previous.source_range.last_line == first_line - 1
         end
 
         def register_offense(previous, current)
@@ -66,7 +77,7 @@ module RuboCop
 
         def declaration_with_comment(node)
           buffer = processed_source.buffer
-          begin_pos = node.loc.expression.begin_pos
+          begin_pos = get_source_range(node).begin_pos
           end_line = buffer.line_for_position(node.loc.expression.end_pos)
           end_pos = buffer.line_range(end_line).end_pos
           Parser::Source::Range.new(buffer, begin_pos, end_pos)
@@ -85,6 +96,14 @@ module RuboCop
           declarations.to_a[node_index - 1]
         end
 
+        def get_source_range(node)
+          unless cop_config['TreatCommentsAsGroupSeparators']
+            first_comment = processed_source.ast_with_comments[node].first
+            return first_comment.loc.expression unless first_comment.nil?
+          end
+          node.source_range
+        end
+
         def_node_search :gem_declarations, <<-PATTERN
           (:send, nil, :gem, ...)
         PATTERN

data/lib/rubocop/cop/commissioner.rb

@@ -73,6 +73,10 @@ module RuboCop
           cop.class.respond_to?(:support_target_ruby_version?) &&
             !cop.class.support_target_ruby_version?(cop.target_ruby_version)
         end
+        @cops.reject! do |cop|
+          cop.class.respond_to?(:support_target_rails_version?) &&
+            !cop.class.support_target_rails_version?(cop.target_rails_version)
+        end
       end
 
       def reset_callbacks

data/lib/rubocop/cop/cop.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'uri'
 
 module RuboCop
@@ -150,6 +151,10 @@ module RuboCop
         @config.target_ruby_version
       end
 
+      def target_rails_version
+        @config.target_rails_version
+      end
+
       def parse(source, path = nil)
         ProcessedSource.new(source, target_ruby_version, path)
       end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for ambiguous block association with method
+      # when param passed without parentheses.
+      #
+      # @example
+      #
+      #   # bad
+      #   some_method a { |val| puts val }
+      #
+      # @example
+      #
+      #   # good
+      #   # With parentheses, there's no ambiguity.
+      #   some_method(a) { |val| puts val }
+      class AmbiguousBlockAssociation < Cop
+        MSG = 'Parenthesize the param `%s` to make sure that the block will be'\
+              ' associated with the `%s` method call.'.freeze
+
+        def on_send(node)
+          return if node.parenthesized? || node.assignment? || node.method?(:[])
+
+          return unless method_with_block?(node.first_argument)
+          first_param = node.first_argument.children.first
+          return unless method_as_param?(first_param)
+
+          add_offense(node, :expression, message(first_param, node.method_name))
+        end
+
+        private
+
+        def method_with_block?(param)
+          return false unless param
+
+          param.block_type?
+        end
+
+        def method_as_param?(param)
+          return false unless param
+
+          param.send_type? && !param.arguments?
+        end
+
+        def message(param, method_name)
+          format(MSG, param.children[1], method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -53,7 +53,14 @@ module RuboCop
 
         def on_send(node)
           return unless debugger_call?(node) || binding_irb?(node)
-          add_offense(node, :expression, format(MSG, node.source))
+
+          add_offense(node, :expression)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, node.source)
         end
 
         def autocorrect(node)

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

@@ -48,7 +48,8 @@ module RuboCop
 
         def on_send(node)
           return unless modifier_and_def_on_same_line?(node)
-          _, _, method_def = *node
+
+          method_def = node.first_argument
           expr = node.source_range
 
           line_start = range_between(expr.begin_pos,

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

@@ -66,11 +66,9 @@ module RuboCop
         private
 
         def check(node)
-          receiver, method_name, *_args = *node
-
           DEPRECATED_METHODS_OBJECT.each do |data|
-            next unless data.class_nodes.include?(receiver)
-            next unless method_name == data.deprecated_method
+            next unless data.class_nodes.include?(node.receiver)
+            next unless node.method?(data.deprecated_method)
             yield data
           end
         end

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

@@ -22,7 +22,7 @@ module RuboCop
       #   # good
       #
       #   case x
-      #   when 'first
+      #   when 'first'
       #     do_something
       #   when 'second'
       #     do_something_else

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

@@ -28,7 +28,9 @@ module RuboCop
 
         def on_send(node)
           each_with_object?(node) do |arg|
-            add_offense(node, :expression) if arg.immutable_literal?
+            return unless arg.immutable_literal?
+
+            add_offense(node, :expression)
           end
         end
       end