rubocop 0.53.0 → 0.54.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d333d0b4cd8b310bb068ffc26f524a194930c15a
-  data.tar.gz: 4f8e00e088adff5221918b4b1d91b7ada3f4e346
+  metadata.gz: b90da169ae8cd99e01c43d41be0a4d43911dcf77
+  data.tar.gz: 5c1db29014d29765ee9400b93d695a0beee04e4a
 SHA512:
-  metadata.gz: 34e929b669ad6134d57b4d57f4adb78aab3e3bf9d230678c2a95625b9d356fb29d45e44ee3992bd6cc767d790c182b99f8fbcbb6ae9c1f6f1a018601c840ac0a
-  data.tar.gz: ffe1738566882f2890c9532b4414e5733312e2d50fe7d112dcb30c91983a8ace89659f897e8fc497d27460886c98a84f4b7805aaea045a03903b9ccc3fd304da
+  metadata.gz: 750f559ae4fe5bdc11721d45907baf604f37b182602045ef38c62ca277302e3834a99bb7dab80ddd5eb70be9d358b309aeb37129a85aefeb0234ffdb54848f04
+  data.tar.gz: f3f987115edf268066df468d4077c1f1e160dce133b277b6ac6a261cf26a7e26e41f6f54fe24eecf626858931016a7562e9386b7f2a3180f1c31f0500dfe2f67

data/README.md

@@ -52,7 +52,7 @@ haven't reached version 1.0 yet). To prevent an unwanted RuboCop update you
 might want to use a conservative version locking in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 0.53.0', require: false
+gem 'rubocop', '~> 0.54.0', require: false
 ```
 
 ## Quickstart

data/config/default.yml

@@ -115,9 +115,15 @@ AllCops:
   AllowSymlinksInCacheRootDirectory: false
   # What MRI version of the Ruby interpreter is the inspected code intended to
   # run on? (If there is more than one, set this to the lowest version.)
-  # If a value is specified for TargetRubyVersion then it is used.
-  # Else if .ruby-version exists and it contains an MRI version it is used.
-  # Otherwise we fallback to the oldest officially supported Ruby version (2.1).
+  # If a value is specified for TargetRubyVersion then it is used. Acceptable
+  # values are specificed as a float (i.e. 2.5); the teeny version of Ruby
+  # should not be included. If the project specifies a Ruby version in the
+  # .ruby-version file, Gemfile or gems.rb file, RuboCop will try to determine
+  # the desired version of Ruby by inspecting the .ruby-version file first,
+  # followed by the Gemfile.lock or gems.locked file. (Although the Ruby version
+  # is specified in the Gemfile or gems.rb file, RuboCop reads the final value
+  # from the lock file.) If the Ruby version is still unresolved, RuboCop will
+  # use the oldest officially supported Ruby version (currently Ruby 2.1).
   TargetRubyVersion: ~
   # What version of Rails is the inspected code using?  If a value is specified
   # for TargetRailsVersion then it is used.  Acceptable values are specificed
@@ -762,6 +768,7 @@ Naming/UncommunicativeMethodParamName:
   AllowedNames:
     - io
     - id
+    - to
   # Blacklisted names that will register an offense
   ForbiddenNames: []
 
@@ -1666,6 +1673,12 @@ Rails/HasManyOrHasOneDependent:
   Include:
     - app/models/**/*.rb
 
+Rails/HttpStatus:
+  EnforcedStyle: symbolic
+  SupportedStyles:
+    - numeric
+    - symbolic
+
 Rails/InverseOf:
   Include:
     - app/models/**/*.rb

data/config/enabled.yml

@@ -1169,6 +1169,10 @@ Rails/HttpPositionalArguments:
     - 'spec/**/*'
     - 'test/**/*'
 
+Rails/HttpStatus:
+  Description: 'Enforces use of symbolic or numeric value to define HTTP status.'
+  Enabled: true
+
 Rails/InverseOf:
   Description: 'Checks for associations where the inverse cannot be determined automatically.'
   Enabled: true
@@ -2006,6 +2010,12 @@ Style/UnneededPercentQ:
   StyleGuide: '#percent-q'
   Enabled: true
 
+Style/UnpackFirst:
+  Description: >-
+                 Checks for accessing the first element of `String#unpack`
+                 instead of using `unpack1`
+  Enabled: true
+
 Style/VariableInterpolation:
   Description: >-
                  Don't interpolate global, instance and class variables

data/lib/rubocop.rb

@@ -522,6 +522,7 @@ require_relative 'rubocop/cop/style/unless_else'
 require_relative 'rubocop/cop/style/unneeded_capital_w'
 require_relative 'rubocop/cop/style/unneeded_interpolation'
 require_relative 'rubocop/cop/style/unneeded_percent_q'
+require_relative 'rubocop/cop/style/unpack_first'
 require_relative 'rubocop/cop/style/variable_interpolation'
 require_relative 'rubocop/cop/style/when_then'
 require_relative 'rubocop/cop/style/while_until_do'
@@ -550,6 +551,7 @@ require_relative 'rubocop/cop/rails/find_each'
 require_relative 'rubocop/cop/rails/has_and_belongs_to_many'
 require_relative 'rubocop/cop/rails/has_many_or_has_one_dependent'
 require_relative 'rubocop/cop/rails/http_positional_arguments'
+require_relative 'rubocop/cop/rails/http_status'
 require_relative 'rubocop/cop/rails/inverse_of'
 require_relative 'rubocop/cop/rails/lexically_scoped_action_filter'
 require_relative 'rubocop/cop/rails/not_null_column'

data/lib/rubocop/cli.rb

@@ -41,7 +41,7 @@ module RuboCop
       execute_runners(paths)
     rescue RuboCop::ConfigNotFoundError => e
       warn e.message
-      e.status
+      STATUS_ERROR
     rescue RuboCop::Error => e
       warn Rainbow("Error: #{e.message}").red
       STATUS_ERROR
@@ -258,6 +258,8 @@ module RuboCop
       warn <<-WARNING.strip_indent
         Errors are usually caused by RuboCop bugs.
         Please, report your problems to RuboCop's issue tracker.
+        #{Gem.loaded_specs['rubocop'].metadata['bug_tracker_uri']}
+
         Mention the following information in the issue report:
         #{RuboCop::Version.version(true)}
       WARNING

data/lib/rubocop/config.rb

@@ -425,6 +425,10 @@ module RuboCop
           @target_ruby_version_source = :ruby_version_file
 
           target_ruby_version_from_version_file
+        elsif target_ruby_version_from_bundler_lock_file
+          @target_ruby_version_source = :bundler_lock_file
+
+          target_ruby_version_from_bundler_lock_file
         else
           DEFAULT_RUBY_VERSION
         end
@@ -557,6 +561,8 @@ module RuboCop
       case @target_ruby_version_source
       when :ruby_version_file
         "`#{RUBY_VERSION_FILENAME}`"
+      when :bundler_lock_file
+        "`#{bundler_lock_file_path}`"
       when :rubocop_yml
         "`TargetRubyVersion` parameter (in #{smart_loaded_path})"
       end
@@ -577,6 +583,37 @@ module RuboCop
         end
     end
 
+    def target_ruby_version_from_bundler_lock_file
+      @target_ruby_version_from_bundler_lock_file ||=
+        read_ruby_version_from_bundler_lock_file
+    end
+
+    def read_ruby_version_from_bundler_lock_file
+      lock_file_path = bundler_lock_file_path
+      return nil unless lock_file_path
+
+      in_ruby_section = false
+      File.foreach(lock_file_path) do |line|
+        # If ruby is in Gemfile.lock or gems.lock, there should be two lines
+        # towards the bottom of the file that look like:
+        #     RUBY VERSION
+        #       ruby W.X.YpZ
+        # We ultimately want to match the "ruby W.X.Y.pZ" line, but there's
+        # extra logic to make sure we only start looking once we've seen the
+        # "RUBY VERSION" line.
+        in_ruby_section ||= line.match(/^\s*RUBY\s*VERSION\s*$/)
+        next unless in_ruby_section
+        # We currently only allow this feature to work with MRI ruby.  If jruby
+        # (or something else) is used by the project, it's lock file will have a
+        # line that looks like:
+        #     RUBY VERSION
+        #       ruby W.X.YpZ (jruby x.x.x.x)
+        # The regex won't match in this situation.
+        result = line.match(/^\s*ruby\s+(\d+\.\d+)[p.\d]*\s*$/)
+        return result.captures.first.to_f if result
+      end
+    end
+
     def target_rails_version_from_bundler_lock_file
       @target_rails_version_from_bundler_lock_file ||=
         read_rails_version_from_bundler_lock_file
@@ -587,9 +624,9 @@ module RuboCop
       return nil unless lock_file_path
 
       File.foreach(lock_file_path) do |line|
-        # If rails is in the Gemfile, the lock file should have a line like:
+        # If rails is in Gemfile.lock or gems.lock, there should be a line like:
         #         rails (X.X.X)
-        result = line.match(/^\s+rails\s+\((\d\.\d\.\d)/)
+        result = line.match(/^\s+rails\s+\((\d+\.\d+)/)
         return result.captures.first.to_f if result
       end
     end
@@ -598,8 +635,8 @@ module RuboCop
       return nil unless loaded_path
       base_path = base_dir_for_path_parameters
       ['gems.locked', 'Gemfile.lock'].each do |file_name|
-        path = File.join(base_path, file_name)
-        return path if File.file?(path)
+        path = find_file_upwards(file_name, base_path)
+        return path if path
       end
       nil
     end

data/lib/rubocop/config_loader.rb

@@ -35,7 +35,6 @@ module RuboCop
       end
 
       def load_file(file)
-        return if file.nil?
         path = File.absolute_path(file.is_a?(RemoteConfig) ? file.file : file)
 
         hash = load_yaml_configuration(path)
@@ -47,7 +46,7 @@ module RuboCop
         target_ruby_version_to_f!(hash)
 
         resolver.resolve_inheritance_from_gems(hash, hash.delete('inherit_gem'))
-        resolver.resolve_inheritance(path, hash, file)
+        resolver.resolve_inheritance(path, hash, file, debug?)
 
         hash.delete('inherit_from')
         hash.delete('inherit_mode')

data/lib/rubocop/config_loader_resolver.rb

@@ -17,7 +17,7 @@ module RuboCop
       end
     end
 
-    def resolve_inheritance(path, hash, file)
+    def resolve_inheritance(path, hash, file, debug)
       inherited_files = Array(hash['inherit_from'])
       base_configs(path, inherited_files, file)
         .reverse.each_with_index do |base_config, index|
@@ -25,7 +25,7 @@ module RuboCop
           next unless v.is_a?(Hash)
           if hash.key?(k)
             v = merge(v, hash[k],
-                      cop_name: k, file: file,
+                      cop_name: k, file: file, debug: debug,
                       inherited_file: inherited_files[index],
                       inherit_mode: determine_inherit_mode(hash, k))
           end
@@ -86,7 +86,7 @@ module RuboCop
           result[key] = merge(base_hash[key], derived_hash[key])
         elsif should_union?(base_hash, key, opts[:inherit_mode])
           result[key] = base_hash[key] | derived_hash[key]
-        else
+        elsif opts[:debug]
           warn_on_duplicate_setting(base_hash, derived_hash, key, opts)
         end
       end
@@ -112,9 +112,9 @@ module RuboCop
       return if base_hash[key].is_a?(Array) &&
                 inherit_mode && inherit_mode.include?(key)
 
-      warn("#{PathUtil.smart_path(opts[:file])}: " \
+      puts "#{PathUtil.smart_path(opts[:file])}: " \
            "#{opts[:cop_name]}:#{key} overrides " \
-           "the same parameter in #{opts[:inherited_file]}")
+           "the same parameter in #{opts[:inherited_file]}"
     end
 
     def determine_inherit_mode(hash, key)

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

@@ -58,7 +58,7 @@ module RuboCop
 
         def previous_declaration(node)
           declarations = gem_declarations(processed_source.ast)
-          node_index = declarations.find_index(node)
+          node_index = declarations.map(&:location).find_index(node.location)
           declarations.to_a[node_index - 1]
         end
 

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

@@ -40,7 +40,7 @@ module RuboCop
           return if ignored_node?(node)
           return unless node.else? && begins_its_line?(node.loc.else)
 
-          check_alignment(base_range(node, base), node.loc.else)
+          check_alignment(base_range_of_if(node, base), node.loc.else)
 
           return unless node.elsif_conditional?
 
@@ -50,14 +50,7 @@ module RuboCop
         def on_rescue(node)
           return unless node.loc.respond_to?(:else) && node.loc.else
 
-          parent = node.parent
-          parent = parent.parent if parent.ensure_type?
-          base = case parent.type
-                 when :def, :defs then base_for_method_definition(parent)
-                 when :kwbegin then parent.loc.begin
-                 else node.loc.keyword
-                 end
-          check_alignment(base, node.loc.else)
+          check_alignment(base_range_of_rescue(node), node.loc.else)
         end
 
         def on_case(node)
@@ -77,7 +70,7 @@ module RuboCop
           ignore_node(node)
         end
 
-        def base_range(node, base)
+        def base_range_of_if(node, base)
           if base
             base.source_range
           else
@@ -86,6 +79,17 @@ module RuboCop
           end
         end
 
+        def base_range_of_rescue(node)
+          parent = node.parent
+          parent = parent.parent if parent.ensure_type?
+          case parent.type
+          when :def, :defs then base_for_method_definition(parent)
+          when :kwbegin then parent.loc.begin
+          when :block then parent.send_node.source_range
+          else node.loc.keyword
+          end
+        end
+
         def base_for_method_definition(node)
           parent = node.parent
           if parent && parent.send_type?

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

@@ -87,8 +87,14 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            range = range_by_whole_lines(node.loc.expression,
-                                         include_final_newline: true)
+            previous_token = previous_token(node)
+            range = if previous_token && node.loc.line == previous_token.line
+                      range_with_surrounding_space(range: node.loc.expression,
+                                                   newlines: false)
+                    else
+                      range_by_whole_lines(node.loc.expression,
+                                           include_final_newline: true)
+                    end
 
             corrector.remove(range)
           end
@@ -134,6 +140,20 @@ module RuboCop
         def allow_margin_comment?
           cop_config['AllowMarginComment']
         end
+
+        def current_token(node)
+          processed_source.find_token do |token|
+            token.pos.column == node.loc.column &&
+              token.pos.last_column == node.loc.last_column &&
+              token.line == node.loc.line
+          end
+        end
+
+        def previous_token(node)
+          current_token = current_token(node)
+          index = processed_source.tokens.index(current_token)
+          index.zero? ? nil : processed_source.tokens[index - 1]
+        end
       end
     end
   end

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

@@ -90,7 +90,7 @@ module RuboCop
         end
 
         def body_end?(line)
-          line =~ /^\s*end/
+          line =~ /^\s*end\b/
         end
 
         def message(node)

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

@@ -73,9 +73,11 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include SafeMode
 
-        RUBY23_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
-                     'heredoc by using `<<~` instead of ' \
-                     '`%<current_indent_type>s`.'.freeze
+        RUBY23_TYPE_MSG = 'Use %<indentation_width>d spaces for indentation ' \
+                          'in a heredoc by using `<<~` instead of ' \
+                          '`%<current_indent_type>s`.'.freeze
+        RUBY23_WIDTH_MSG = 'Use %<indentation_width>d spaces for '\
+                           'indentation in a heredoc.'.freeze
         LIBRARY_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
                       'heredoc by using %<method>s.'.freeze
         STRIP_METHODS = {
@@ -148,13 +150,28 @@ module RuboCop
         end
 
         def ruby23_message(indentation_width, current_indent_type)
+          if current_indent_type == '<<~'
+            ruby23_width_message(indentation_width)
+          else
+            ruby23_type_message(indentation_width, current_indent_type)
+          end
+        end
+
+        def ruby23_type_message(indentation_width, current_indent_type)
           format(
-            RUBY23_MSG,
+            RUBY23_TYPE_MSG,
             indentation_width: indentation_width,
             current_indent_type: current_indent_type
           )
         end
 
+        def ruby23_width_message(indentation_width)
+          format(
+            RUBY23_WIDTH_MSG,
+            indentation_width: indentation_width
+          )
+        end
+
         def too_long_line?(node)
           return false if config.for_cop('Metrics/LineLength')['AllowHeredoc']
           body = heredoc_body(node)

data/lib/rubocop/cop/mixin/uncommunicative_name.rb

@@ -6,15 +6,15 @@ module RuboCop
     module UncommunicativeName
       CASE_MSG = 'Only use lowercase characters for %<name_type>s.'.freeze
       NUM_MSG = 'Do not end %<name_type>s with a number.'.freeze
-      LENGTH_MSG = '%<name_type>s must be longer than %<min>s ' \
-                   'characters.'.freeze
+      LENGTH_MSG = '%<name_type>s must be at least %<min>s ' \
+                   'characters long.'.freeze
       FORBIDDEN_MSG = 'Do not use %<name>s as a name for a ' \
                       '%<name_type>s.'.freeze
 
       def check(node, args)
         args.each do |arg|
           name = arg.children.first.to_s
-          next if arg.restarg_type? && name.empty?
+          next if (arg.restarg_type? || arg.kwrestarg_type?) && name.empty?
           next if allowed_names.include?(name)
           range = arg_range(arg, name.size)
           issue_offenses(node, range, name)

data/lib/rubocop/cop/naming/constant_name.rb

@@ -30,7 +30,12 @@ module RuboCop
         PATTERN
 
         def on_casgn(node)
-          _scope, const_name, value = *node
+          if node.parent && node.parent.or_asgn_type?
+            lhs, value = *node.parent
+            _scope, const_name = *lhs
+          else
+            _scope, const_name, value = *node
+          end
 
           # We cannot know the result of method calls like
           # NewClass = something_that_returns_a_class
@@ -39,15 +44,19 @@ module RuboCop
           # SomeClass = SomeOtherClass
           # SomeClass = Class.new(...)
           # SomeClass = Struct.new(...)
-          return if value && %i[block const casgn].include?(value.type) ||
-                    allowed_method_call_on_rhs?(value) ||
-                    class_or_struct_return_method?(value)
+          return if allowed_assignment?(value)
 
           add_offense(node, location: :name) if const_name !~ SNAKE_CASE
         end
 
         private
 
+        def allowed_assignment?(value)
+          value && %i[block const casgn].include?(value.type) ||
+            allowed_method_call_on_rhs?(value) ||
+            class_or_struct_return_method?(value)
+        end
+
         def allowed_method_call_on_rhs?(node)
           node && node.send_type? &&
             (node.receiver.nil? || !node.receiver.literal?)

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -34,7 +34,7 @@ module RuboCop
       #
       class MemoizedInstanceVariableName < Cop
         MSG = 'Memoized variable `%<var>s` does not match ' \
-          'method name `%<method>s`. Use `@%<method>s` instead.'.freeze
+          'method name `%<method>s`. Use `@%<suggested_var>s` instead.'.freeze
 
         def self.node_pattern
           memo_assign = '(or_asgn $(ivasgn _) _)'
@@ -55,6 +55,7 @@ module RuboCop
           msg = format(
             MSG,
             var: ivar_assign.children.first.to_s,
+            suggested_var: method_name.to_s.delete('!?'),
             method: method_name
           )
           add_offense(node, location: ivar_assign.source_range, message: msg)
@@ -65,7 +66,7 @@ module RuboCop
 
         def matches?(method_name, ivar_assign)
           return true if ivar_assign.nil? || method_name == :initialize
-          method_name = method_name.to_s.sub('?', '')
+          method_name = method_name.to_s.delete('!?')
           variable = ivar_assign.children.first
           variable_name = variable.to_s.sub('@', '')
           variable_name == method_name

data/lib/rubocop/cop/rails/http_status.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces use of symbolic or numeric value to define HTTP status.
+      #
+      # @example `EnforcedStyle: symbolic` (default)
+      #   # bad
+      #   render :foo, status: 200
+      #   render json: { foo: 'bar' }, status: 200
+      #   render plain: 'foo/bar', status: 304
+      #   redirect_to root_url, status: 301
+      #
+      #   # good
+      #   render :foo, status: :ok
+      #   render json: { foo: 'bar' }, status: :ok
+      #   render plain: 'foo/bar', status: :not_modified
+      #   redirect_to root_url, status: :moved_permanently
+      #
+      # @example `EnforcedStyle: numeric`
+      #   # bad
+      #   render :foo, status: :ok
+      #   render json: { foo: 'bar' }, status: :not_found
+      #   render plain: 'foo/bar', status: :not_modified
+      #   redirect_to root_url, status: :moved_permanently
+      #
+      #   # good
+      #   render :foo, status: 200
+      #   render json: { foo: 'bar' }, status: 404
+      #   render plain: 'foo/bar', status: 304
+      #   redirect_to root_url, status: 301
+      #
+      class HttpStatus < Cop
+        begin
+          require 'rack/utils'
+          RACK_LOADED = true
+        rescue LoadError
+          RACK_LOADED = false
+        end
+
+        include ConfigurableEnforcedStyle
+
+        def_node_matcher :http_status, <<-PATTERN
+          {
+            (send nil? {:render :redirect_to}
+              _
+              (hash
+                (pair
+                  (sym :status)
+                  ${int sym})))
+            (send nil? {:render}
+              (hash
+                _
+                (pair
+                  (sym :status)
+                  ${int sym})))
+          }
+        PATTERN
+
+        def on_send(node)
+          http_status(node) do |ast_node|
+            checker = checker_class.new(ast_node)
+            return unless checker.offensive?
+            add_offense(checker.node, message: checker.message)
+          end
+        end
+
+        def support_autocorrect?
+          RACK_LOADED
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            checker = checker_class.new(node)
+            corrector.replace(node.loc.expression, checker.preferred_style)
+          end
+        end
+
+        private
+
+        def checker_class
+          case style
+          when :symbolic
+            SymbolicStyleChecker
+          when :numeric
+            NumericStyleChecker
+          end
+        end
+
+        # :nodoc:
+        class SymbolicStyleChecker
+          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
+                'to define HTTP status code.'.freeze
+          DEFAULT_MSG = 'Prefer `symbolic` over `numeric` ' \
+                        'to define HTTP status code.'.freeze
+
+          attr_reader :node
+          def initialize(node)
+            @node = node
+          end
+
+          def offensive?
+            !node.sym_type? && !custom_http_status_code?
+          end
+
+          def message
+            if RACK_LOADED
+              format(MSG, prefer: preferred_style, current: number.to_s)
+            else
+              DEFAULT_MSG
+            end
+          end
+
+          def preferred_style
+            symbol.inspect
+          end
+
+          private
+
+          def symbol
+            ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number)
+          end
+
+          def number
+            node.children.first
+          end
+
+          def custom_http_status_code?
+            node.int_type? &&
+              !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(number)
+          end
+        end
+
+        # :nodoc:
+        class NumericStyleChecker
+          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
+                'to define HTTP status code.'.freeze
+          DEFAULT_MSG = 'Prefer `numeric` over `symbolic` ' \
+                        'to define HTTP status code.'.freeze
+          WHITELIST_STATUS = %i[error success missing redirect].freeze
+
+          attr_reader :node
+          def initialize(node)
+            @node = node
+          end
+
+          def offensive?
+            !node.int_type? && !whitelisted_symbol?
+          end
+
+          def message
+            if RACK_LOADED
+              format(MSG, prefer: preferred_style, current: symbol.inspect)
+            else
+              DEFAULT_MSG
+            end
+          end
+
+          def preferred_style
+            number.to_s
+          end
+
+          private
+
+          def number
+            ::Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol]
+          end
+
+          def symbol
+            node.value
+          end
+
+          def whitelisted_symbol?
+            node.sym_type? && WHITELIST_STATUS.include?(node.value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/skips_model_validations.rb

@@ -16,12 +16,12 @@ module RuboCop
       #   person.toggle :active
       #   product.touch
       #   Billing.update_all("category = 'authorized', author = 'David'")
-      #   user.update_attribute(website: 'example.com')
+      #   user.update_attribute(:website, 'example.com')
       #   user.update_columns(last_request_at: Time.current)
       #   Post.update_counters 5, comment_count: -1, action_count: 1
       #
       #   # good
-      #   user.update_attributes(website: 'example.com')
+      #   user.update(website: 'example.com')
       #   FileUtils.touch('file')
       class SkipsModelValidations < Cop
         MSG = 'Avoid using `%<method>s` because it skips validations.'.freeze

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

@@ -30,6 +30,7 @@ module RuboCop
         MSG = 'Missing top-level %<type>s documentation comment.'.freeze
 
         def_node_matcher :constant_definition?, '{class module casgn}'
+        def_node_search :outer_module, '(const (const nil? _) _)'
 
         def on_class(node)
           _, _, body = *node
@@ -50,6 +51,8 @@ module RuboCop
         def check(node, body, type)
           return if namespace?(body)
           return if documentation_comment?(node) || nodoc_comment?(node)
+          return if compact_namespace?(node) &&
+                    nodoc_comment?(outer_module(node).first)
 
           add_offense(node,
                       location: :keyword,
@@ -66,6 +69,10 @@ module RuboCop
           end
         end
 
+        def compact_namespace?(node)
+          node.loc.name.source =~ /::/
+        end
+
         # First checks if the :nodoc: comment is associated with the
         # class/module. Unless the element is tagged with :nodoc:, the search
         # proceeds to check its ancestors for :nodoc: all.

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

@@ -43,7 +43,8 @@ module RuboCop
         def on_if(node)
           return unless contains_guard_clause?(node)
 
-          return if node.parent.nil? || node.parent.single_line?
+          return if next_line_rescue_or_ensure?(node)
+          return if next_sibling_parent_empty_or_else?(node)
           return if next_sibling_empty_or_guard_clause?(node)
 
           return if next_line_empty?(node)
@@ -68,6 +69,20 @@ module RuboCop
           processed_source[node.last_line].blank?
         end
 
+        def next_line_rescue_or_ensure?(node)
+          parent = node.parent
+          parent.nil? || parent.rescue_type? || parent.ensure_type?
+        end
+
+        def next_sibling_parent_empty_or_else?(node)
+          next_sibling = node.parent.children[node.sibling_index + 1]
+          return true if next_sibling.nil?
+
+          parent = next_sibling.parent
+
+          parent && parent.if_type? && parent.else?
+        end
+
         def next_sibling_empty_or_guard_clause?(node)
           next_sibling = node.parent.children[node.sibling_index + 1]
           return true if next_sibling.nil?

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

@@ -51,6 +51,7 @@ module RuboCop
         }.freeze
 
         def on_str(node)
+          return if placeholder_argument?(node)
           return if node.each_ancestor(:xstr, :regexp).any?
 
           tokens(node) do |detected_style, token_range|
@@ -156,6 +157,13 @@ module RuboCop
             new_end
           )
         end
+
+        def placeholder_argument?(node)
+          return false unless node.parent
+          return true if node.parent.pair_type?
+
+          placeholder_argument?(node.parent)
+        end
       end
     end
   end

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

@@ -22,7 +22,9 @@ module RuboCop
 
         def investigate(processed_source)
           processed_source.each_comment do |comment|
-            next if comment_line?(processed_source[comment.loc.line - 1])
+            next if comment_line?(processed_source[comment.loc.line - 1]) ||
+                    comment.text.match(/\A# rubocop:(enable|disable)/)
+
             add_offense(comment)
           end
         end

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

@@ -27,18 +27,21 @@ module RuboCop
       #   foo != bar
       #   foo == bar
       #   !!('foo' =~ /^\w+$/)
+      #   !(foo.class < Numeric) # Checking class hierarchy is allowed
       class InverseMethods < Cop
         include IgnoredNode
 
         MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'.freeze
+        CLASS_COMPARISON_METHODS = %i[<= >= < >].freeze
         EQUALITY_METHODS = %i[== != =~ !~ <= >= < >].freeze
         NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
+        CAMEL_CASE = /[A-Z]+[a-z]+/
 
         def_node_matcher :inverse_candidate?, <<-PATTERN
           {
-            (send $(send (...) $_ ...) :!)
-            (send (block $(send (...) $_) ...) :!)
-            (send (begin $(send (...) $_ ...)) :!)
+            (send $(send $(...) $_ $...) :!)
+            (send (block $(send $(...) $_) $...) :!)
+            (send (begin $(send $(...) $_ $...)) :!)
           }
         PATTERN
 
@@ -52,8 +55,9 @@ module RuboCop
 
         def on_send(node)
           return if part_of_ignored_node?(node)
-          inverse_candidate?(node) do |_method_call, method|
+          inverse_candidate?(node) do |_method_call, lhs, method, rhs|
             return unless inverse_methods.key?(method)
+            return if possible_class_hierarchy_check?(lhs, rhs, method)
             return if negated?(node)
 
             add_offense(node,
@@ -78,7 +82,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          method_call, method = inverse_candidate?(node)
+          method_call, _lhs, method, _rhs = inverse_candidate?(node)
 
           if method_call && method
             lambda do |corrector|
@@ -143,6 +147,19 @@ module RuboCop
                                     method_call.loc.expression.end_pos,
                                     node.loc.expression.end_pos)
         end
+
+        # When comparing classes, `!(Integer < Numeric)` is not the same as
+        # `Integer > Numeric`.
+        def possible_class_hierarchy_check?(lhs, rhs, method)
+          CLASS_COMPARISON_METHODS.include?(method) &&
+            (camel_case_constant?(lhs) ||
+             (rhs.size == 1 &&
+              camel_case_constant?(rhs.first)))
+        end
+
+        def camel_case_constant?(node)
+          node.const_type? && node.source =~ CAMEL_CASE
+        end
       end
     end
   end

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

@@ -9,6 +9,7 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
       #   def redundant
       #     begin
       #       ala
@@ -18,12 +19,31 @@ module RuboCop
       #     end
       #   end
       #
+      #   # good
       #   def preferred
       #     ala
       #     bala
       #   rescue StandardError => e
       #     something
       #   end
+      #
+      #   # bad
+      #   # When using Ruby 2.5 or later.
+      #   do_something do
+      #     begin
+      #       something
+      #     rescue => ex
+      #       anything
+      #     end
+      #   end
+      #
+      #   # good
+      #   # In Ruby 2.5 or later, you can omit `begin` in `do-end` block.
+      #   do_something do
+      #     something
+      #   rescue => ex
+      #     anything
+      #   end
       class RedundantBegin < Cop
         MSG = 'Redundant `begin` block detected.'.freeze
 

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

@@ -228,9 +228,10 @@ module RuboCop
           start_method.each_ancestor do |ancestor|
             break unless %i[send block].include?(ancestor.type)
             next unless ancestor.send_type?
-            break if ancestor == method_chain
 
             corrector.insert_before(ancestor.loc.dot, '&')
+
+            break if ancestor == method_chain
           end
         end
       end

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

@@ -39,6 +39,9 @@ module RuboCop
         alias on_defs on_def
 
         def autocorrect(node)
+          parent = node.parent
+          return if parent && parent.send_type?
+
           if node.def_type?
             autocorrect_instance(node)
           elsif node.defs_type? && node.children.first.self_type?

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for accessing the first element of `String#unpack`
+      # which can be replaced with the shorter method `unpack1`.
+      #
+      # @example
+      #
+      #   # bad
+      #   'foo'.unpack('h*').first
+      #   'foo'.unpack('h*')[0]
+      #   'foo'.unpack('h*').slice(0)
+      #   'foo'.unpack('h*').at(0)
+      #   'foo'.unpack('h*').take(1)
+      #
+      #   # good
+      #   'foo'.unpack1('h*')
+      #
+      class UnpackFirst < Cop
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.4
+
+        MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of '\
+          '`%<receiver>s.unpack(%<format>s)%<method>s`.'.freeze
+
+        def_node_matcher :unpack_and_first_element?, <<-PATTERN
+          {
+            (send $(send (...) :unpack $(...)) :first)
+            (send $(send (...) :unpack $(...)) {:[] :slice :at} (int 0))
+            (send $(send (...) :unpack $(...)) :take (int 1))
+          }
+        PATTERN
+
+        def on_send(node)
+          unpack_and_first_element?(node) do |unpack_call, unpack_arg|
+            range = first_element_range(node, unpack_call)
+            message = format(MSG,
+                             receiver:  unpack_call.receiver.source,
+                             format: unpack_arg.source,
+                             method: range.source)
+            add_offense(node, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          unpack_and_first_element?(node) do |unpack_call, _unpack_arg|
+            lambda do |corrector|
+              corrector.remove(first_element_range(node, unpack_call))
+              corrector.replace(unpack_call.loc.selector, 'unpack1')
+            end
+          end
+        end
+
+        private
+
+        def first_element_range(node, unpack_call)
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    unpack_call.loc.expression.end_pos,
+                                    node.loc.expression.end_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/util.rb

@@ -121,7 +121,7 @@ module RuboCop
           .sub('Style', 'Styles')
       end
 
-      def tokens(node) # rubocop:disable Metrics/AbcSize
+      def tokens(node)
         @tokens ||= {}
         return @tokens[node.object_id] if @tokens[node.object_id]
 
@@ -129,17 +129,9 @@ module RuboCop
         begin_pos = source_range.begin_pos
         end_pos = source_range.end_pos
 
-        tokens_to_node_end = processed_source.tokens.take_while do |token|
-          token.end_pos <= end_pos
+        @tokens[node.object_id] = processed_source.tokens.select do |token|
+          token.end_pos <= end_pos && token.begin_pos >= begin_pos
         end
-
-        node_tokens = []
-        tokens_to_node_end.reverse_each do |token|
-          break unless token.begin_pos >= begin_pos
-          node_tokens.unshift(token)
-        end
-
-        @tokens[node.object_id] = node_tokens
       end
 
       private

data/lib/rubocop/formatter/offense_count_formatter.rb

@@ -17,10 +17,27 @@ module RuboCop
       def started(target_files)
         super
         @offense_counts = Hash.new(0)
+
+        return unless output.tty?
+
+        file_phrase = target_files.count == 1 ? 'file' : 'files'
+
+        # 185/407 files |====== 45 ======>                    |  ETA: 00:00:04
+        # %c / %C       |       %w       >         %i         |       %e
+        bar_format = " %c/%C #{file_phrase} |%w>%i| %e "
+
+        @progressbar = ProgressBar.create(
+          output: output,
+          total: target_files.count,
+          format: bar_format,
+          autostart: false
+        )
+        @progressbar.start
       end
 
       def file_finished(_file, offenses)
         offenses.each { |o| @offense_counts[o.cop_name] += 1 }
+        @progressbar.increment if instance_variable_defined?(:@progressbar)
       end
 
       def finished(_inspected_files)

data/lib/rubocop/magic_comment.rb

@@ -190,7 +190,7 @@ module RuboCop
     class SimpleComment < MagicComment
       # Match `encoding` or `coding`
       def encoding
-        extract(/\b(?:en)?coding: (#{TOKEN})/i)
+        extract(/\#* \b(?:en)?coding: (#{TOKEN})/i)
       end
 
       private

data/lib/rubocop/target_finder.rb

@@ -121,7 +121,7 @@ module RuboCop
       end
 
       # Most recently modified file first.
-      target_files.sort_by! { |path| Integer(-File.mtime(path)) } if fail_fast?
+      target_files.sort_by! { |path| -Integer(File.mtime(path)) } if fail_fast?
 
       target_files
     end

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '0.53.0'.freeze
+    STRING = '0.54.0'.freeze
 
     MSG = '%<version>s (using Parser %<parser_version>s, running on ' \
           '%<ruby_engine>s %<ruby_version>s %<ruby_platform>s)'.freeze

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 0.53.0
+  version: 0.54.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-05 00:00:00.000000000 Z
+date: 2018-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -122,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |2
       Automatic Ruby code style checking tool.
       Aims to enforce the community-driven Ruby Style Guide.
@@ -500,6 +514,7 @@ files:
 - lib/rubocop/cop/rails/has_and_belongs_to_many.rb
 - lib/rubocop/cop/rails/has_many_or_has_one_dependent.rb
 - lib/rubocop/cop/rails/http_positional_arguments.rb
+- lib/rubocop/cop/rails/http_status.rb
 - lib/rubocop/cop/rails/inverse_of.rb
 - lib/rubocop/cop/rails/lexically_scoped_action_filter.rb
 - lib/rubocop/cop/rails/not_null_column.rb
@@ -678,6 +693,7 @@ files:
 - lib/rubocop/cop/style/unneeded_capital_w.rb
 - lib/rubocop/cop/style/unneeded_interpolation.rb
 - lib/rubocop/cop/style/unneeded_percent_q.rb
+- lib/rubocop/cop/style/unpack_first.rb
 - lib/rubocop/cop/style/variable_interpolation.rb
 - lib/rubocop/cop/style/when_then.rb
 - lib/rubocop/cop/style/while_until_do.rb