rubocop 0.35.1 → 0.36.0

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -38,12 +39,12 @@ module RuboCop
       class Date < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Do not use `%s` without zone. Use `%s` instead.'
+        MSG = 'Do not use `%s` without zone. Use `%s` instead.'.freeze
 
-        MSG_SEND =  'Do not use `%s` on Date objects, ' \
-                    'because they know nothing about the time zone in use.'
+        MSG_SEND = 'Do not use `%s` on Date objects, because they ' \
+                   'know nothing about the time zone in use.'.freeze
 
-        BAD_DAYS = [:today, :current, :yesterday, :tomorrow]
+        BAD_DAYS = [:today, :current, :yesterday, :tomorrow].freeze
 
         def on_const(node)
           mod, klass = *node.children

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -29,7 +30,7 @@ module RuboCop
       #     foo.bar
       #   end
       class Delegate < Cop
-        MSG = 'Use `delegate` to define delegations.'
+        MSG = 'Use `delegate` to define delegations.'.freeze
 
         def on_def(node)
           method_name, args, body = *node
@@ -49,7 +50,7 @@ module RuboCop
           end
 
           lambda do |corrector|
-            corrector.replace(node.loc.expression, delegation.join(', '))
+            corrector.replace(node.source_range, delegation.join(', '))
           end
         end
 

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -14,29 +15,34 @@ module RuboCop
       #   # good
       #   User.find_by(name: 'Bruce')
       class FindBy < Cop
-        MSG = 'Use `find_by` instead of `where.%s`.'
-        TARGET_SELECTORS = [:first, :take]
+        MSG = 'Use `find_by` instead of `where.%s`.'.freeze
+        TARGET_SELECTORS = [:first, :take].freeze
+
+        def_node_matcher :where_first, <<-PATTERN
+          (send $(send _ :where ...) ${:first :take})
+        PATTERN
 
         def on_send(node)
-          receiver, second_method, _selector = *node
-          return unless TARGET_SELECTORS.include?(second_method)
-          return if receiver.nil?
-          _scope, first_method = *receiver
-          return unless first_method == :where
-          begin_of_offense = receiver.loc.selector.begin_pos
-          end_of_offense = node.loc.selector.end_pos
-          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                            begin_of_offense,
-                                            end_of_offense)
+          return unless (recv_and_method = where_first(node))
+          receiver, second_method = *recv_and_method
+
+          range = Parser::Source::Range.new(node.source_range.source_buffer,
+                                            receiver.loc.selector.begin_pos,
+                                            node.loc.selector.end_pos)
 
           add_offense(node, range, format(MSG, second_method))
         end
 
         def autocorrect(node)
-          receiver, = *node
+          receiver, second_method = where_first(node)
+          # Don't autocorrect where(...).first, because it can return different
+          # results from find_by. (They order records differently, so the
+          # 'first' record can be different.)
+          return if second_method == :first
+
           where_loc = receiver.loc.selector
           first_loc = Parser::Source::Range.new(
-            node.loc.expression.source_buffer,
+            node.source_range.source_buffer,
             node.loc.dot.begin_pos,
             node.loc.selector.end_pos
           )

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -13,9 +14,9 @@ module RuboCop
       #   # good
       #   User.all.find_each
       class FindEach < Cop
-        MSG = 'Use `find_each` instead of `each`.'
+        MSG = 'Use `find_each` instead of `each`.'.freeze
 
-        SCOPE_METHODS = [:all, :where]
+        SCOPE_METHODS = [:all, :where].freeze
 
         def on_send(node)
           receiver, second_method, _selector = *node
@@ -24,6 +25,7 @@ module RuboCop
 
           _model, first_method = *receiver
           return unless SCOPE_METHODS.include?(first_method)
+          return if method_chain(node).any? { |m| ignored_by_find_each?(m) }
 
           add_offense(node, node.loc.selector, MSG)
         end
@@ -33,6 +35,25 @@ module RuboCop
 
           ->(corrector) { corrector.replace(each_loc, 'find_each') }
         end
+
+        private
+
+        def method_chain(node)
+          if (node.send_type? || node.block_type?) && !node.receiver.nil?
+            if node.parent
+              method_chain(node.parent) << node.method_name
+            else
+              [node.method_name]
+            end
+          else
+            []
+          end
+        end
+
+        def ignored_by_find_each?(relation_method)
+          # Active Record's #find_each ignores various extra parameters
+          [:order, :limit, :select].include?(relation_method)
+        end
       end
     end
   end

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

@@ -1,14 +1,15 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Rails
       # This cop checks for the use of the has_and_belongs_to_many macro.
       class HasAndBelongsToMany < Cop
-        MSG = 'Prefer `has_many :through` to `has_and_belongs_to_many`.'
+        MSG = 'Prefer `has_many :through` to `has_and_belongs_to_many`.'.freeze
 
         def on_send(node)
-          return unless command?(:has_and_belongs_to_many, node)
+          return unless node.command?(:has_and_belongs_to_many)
           add_offense(node, :selector)
         end
       end

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

@@ -1,17 +1,19 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Rails
       # This cop checks for the use of output calls like puts and print
       class Output < Cop
-        MSG = 'Do not write to stdout. Use Rails\' logger if you want to log.'
+        MSG = 'Do not write to stdout. ' \
+              'Use Rails\' logger if you want to log.'.freeze
 
         BLACKLIST = [:puts,
                      :print,
                      :p,
                      :pp,
-                     :pretty_print]
+                     :pretty_print].freeze
 
         def on_send(node)
           receiver, method_name, *args = *node

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -22,11 +23,11 @@ module RuboCop
                                       week: :weeks,
                                       fortnight: :fortnights,
                                       month: :months,
-                                      year: :years }
+                                      year: :years }.freeze
 
         PLURAL_DURATION_METHODS = SINGULAR_DURATION_METHODS.invert
 
-        MSG = 'Prefer `%s.%s`.'
+        MSG = 'Prefer `%s.%s`.'.freeze
 
         def on_send(node)
           receiver, method_name, *_args = *node

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -16,7 +17,7 @@ module RuboCop
       #   x = self[:attr]
       #   self[:attr] = val
       class ReadWriteAttribute < Cop
-        MSG = 'Prefer `%s` over `%s`.'
+        MSG = 'Prefer `%s` over `%s`.'.freeze
 
         def on_send(node)
           receiver, method_name, *_args = *node
@@ -47,7 +48,7 @@ module RuboCop
             replacement = write_attribute_replacement(node)
           end
 
-          ->(corrector) { corrector.replace(node.loc.expression, replacement) }
+          ->(corrector) { corrector.replace(node.source_range, replacement) }
         end
 
         private
@@ -55,17 +56,14 @@ module RuboCop
         def read_attribute_replacement(node)
           _receiver, _method_name, body = *node
 
-          "self[#{body.loc.expression.source}]"
+          "self[#{body.source}]"
         end
 
         def write_attribute_replacement(node)
           _receiver, _method_name, *args = *node
           name, value = *args
 
-          name_source = name.loc.expression.source
-          value_source = value.loc.expression.source
-
-          "self[#{name_source}] = #{value_source}"
+          "self[#{name.source}] = #{value.source}"
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -14,10 +15,10 @@ module RuboCop
       #   # good
       #   scope :something, -> { where(something: true) }
       class ScopeArgs < Cop
-        MSG = 'Use `lambda`/`proc` instead of a plain method call.'
+        MSG = 'Use `lambda`/`proc` instead of a plain method call.'.freeze
 
         def on_send(node)
-          return unless command?(:scope, node)
+          return unless node.command?(:scope)
 
           _receiver, _method_name, *args = *node
 

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -30,22 +31,24 @@ module RuboCop
       class TimeZone < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Do not use `%s` without zone. Use `%s` instead.'
+        MSG = 'Do not use `%s` without zone. Use `%s` instead.'.freeze
 
-        MSG_ACCEPTABLE = 'Do not use `%s` without zone. Use one of %s instead.'
+        MSG_ACCEPTABLE = 'Do not use `%s` without zone. ' \
+                         'Use one of %s instead.'.freeze
 
-        MSG_LOCALTIME = 'Do not use `Time.localtime` without offset or zone.'
+        MSG_LOCALTIME = 'Do not use `Time.localtime` without ' \
+                        'offset or zone.'.freeze
 
-        MSG_CURRENT = 'Do not use `%s`. Use `Time.zone.now` instead.'
+        MSG_CURRENT = 'Do not use `%s`. Use `Time.zone.now` instead.'.freeze
 
-        TIMECLASS = [:Time, :DateTime]
+        TIMECLASS = [:Time, :DateTime].freeze
 
         DANGEROUS_METHODS = [:now, :local, :new, :strftime,
-                             :parse, :at, :current]
+                             :parse, :at, :current].freeze
 
-        ACCEPTED_METHODS = [:current, :in_time_zone, :utc, :getlocal,
+        ACCEPTED_METHODS = [:in_time_zone, :utc, :getlocal,
                             :iso8601, :jisx0301, :rfc3339,
-                            :to_i, :to_f]
+                            :to_i, :to_f].freeze
 
         def on_const(node)
           mod, klass = *node
@@ -151,12 +154,13 @@ module RuboCop
         end
 
         def good_methods
-          style == :strict ? [:zone] : [:zone] + ACCEPTED_METHODS
+          style == :strict ? [:zone] : [:zone, :current] + ACCEPTED_METHODS
         end
 
         def acceptable_methods(klass, method_name, node)
           acceptable = [
-            "`Time.zone.#{safe_method(method_name, node)}`"
+            "`Time.zone.#{safe_method(method_name, node)}`",
+            "`#{klass}.current`"
           ]
 
           ACCEPTED_METHODS.each do |am|

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

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Rails
       # This cop checks for the use of old-style attribute validation macros.
       class Validation < Cop
-        MSG = 'Prefer the new style validations `%s` over `%s`.'
+        MSG = 'Prefer the new style validations `%s` over `%s`.'.freeze
 
         BLACKLIST = [:validates_acceptance_of,
                      :validates_confirmation_of,
@@ -16,7 +17,7 @@ module RuboCop
                      :validates_numericality_of,
                      :validates_presence_of,
                      :validates_size_of,
-                     :validates_uniqueness_of]
+                     :validates_uniqueness_of].freeze
 
         WHITELIST = [
           'validates :column, acceptance: value',
@@ -29,7 +30,7 @@ module RuboCop
           'validates :column, presence: value',
           'validates :column, size: value',
           'validates :column, uniqueness: value'
-        ]
+        ].freeze
 
         def on_send(node)
           receiver, method_name, *_args = *node

data/lib/rubocop/cop/severity.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -7,11 +8,11 @@ module RuboCop
       include Comparable
 
       # @api private
-      NAMES = [:refactor, :convention, :warning, :error, :fatal]
+      NAMES = [:refactor, :convention, :warning, :error, :fatal].freeze
 
       # @api private
       CODE_TABLE = { R: :refactor, C: :convention,
-                     W: :warning, E: :error, F: :fatal }
+                     W: :warning, E: :error, F: :fatal }.freeze
 
       # @api public
       #
@@ -55,11 +56,11 @@ module RuboCop
 
       # @api private
       def ==(other)
-        if other.is_a?(Symbol)
-          @name == other
-        else
-          @name == other.name
-        end
+        @name == if other.is_a?(Symbol)
+                   other
+                 else
+                   other.name
+                 end
       end
 
       # @api private

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -10,7 +11,7 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include AccessModifierNode
 
-        MSG = '%s access modifiers like `%s`.'
+        MSG = '%s access modifiers like `%s`.'.freeze
 
         def on_class(node)
           _name, _base_class, body = *node
@@ -29,7 +30,7 @@ module RuboCop
 
         def on_block(node)
           _method, _args, body = *node
-          check_body(body, node) if class_constructor?(node)
+          check_body(body, node) if node.class_constructor?
         end
 
         private
@@ -38,13 +39,13 @@ module RuboCop
           return if body.nil? # Empty class etc.
 
           modifiers = body.children.select { |c| modifier_node?(c) }
-          class_column = node.loc.expression.column
+          class_column = node.source_range.column
 
           modifiers.each { |modifier| check_modifier(modifier, class_column) }
         end
 
         def check_modifier(send_node, class_start_col)
-          access_modifier_start_col = send_node.loc.expression.column
+          access_modifier_start_col = send_node.source_range.column
           offset = access_modifier_start_col - class_start_col
 
           @column_delta = expected_indent_offset - offset

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

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

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

@@ -1,46 +1,106 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # The purpose of the this cop is advise the use of
-      # alias_method over the alias keyword whenever possible.
+      # This cop finds uses of `alias` where `alias_method` would be more
+      # appropriate (or is simply preferred due to configuration), and vice
+      # versa.
+      # It also finds uses of `alias :symbol` rather than `alias bareword`.
       class Alias < Cop
-        MSG = 'Use `alias_method` instead of `alias`.'
+        include ConfigurableEnforcedStyle
 
-        def on_block(node)
-          method, _args, body = *node
-          _receiver, method_name = *method
+        MSG_ALIAS = 'Use `alias_method` instead of `alias`.'.freeze
+        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` %s.'.freeze
+        MSG_SYMBOL_ARGS  = 'Use `alias %s` instead of `alias %s`.'.freeze
 
-          # using alias is the only option in certain scenarios
-          # in such scenarios we don't want to report an offense
-          return unless method_name == :instance_exec
-          return unless body
+        def on_send(node)
+          return unless node.method_name == :alias_method && node.receiver.nil?
+          return if style == :prefer_alias_method
+          return if scope_type(node) == :dynamic
 
-          body.each_node(:alias) { |n| ignore_node(n) }
+          msg = format(MSG_ALIAS_METHOD, lexical_scope_type(node))
+          add_offense(node, :selector, msg)
         end
 
         def on_alias(node)
-          return if ignored_node?(node)
-
           # alias_method can't be used with global variables
-          new, old = *node
-
-          return if new.type == :gvar && old.type == :gvar
+          return if node.children.any?(&:gvar_type?)
 
-          add_offense(node, :keyword)
+          if scope_type(node) == :dynamic || style == :prefer_alias_method
+            add_offense(node, :keyword, MSG_ALIAS)
+          elsif node.children.none? { |arg| bareword?(arg) }
+            existing_args  = node.children.map(&:source).join(' ')
+            preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
+            arg_ranges     = node.children.map(&:source_range)
+            msg            = format(MSG_SYMBOL_ARGS, preferred_args,
+                                    existing_args)
+            add_offense(node, arg_ranges.reduce(&:join), msg)
+          end
         end
 
         def autocorrect(node)
+          if node.send_type?
+            correct_alias_method_to_alias(node)
+          elsif scope_type(node) == :dynamic || style == :prefer_alias_method
+            correct_alias_to_alias_method(node)
+          else
+            correct_alias_with_symbol_args(node)
+          end
+        end
+
+        private
+
+        # In this expression, will `self` be the same as the innermost enclosing
+        # class or module block (:lexical)? Or will it be something else
+        # (:dynamic)?
+        def scope_type(node)
+          while (parent = node.parent)
+            case parent.type
+            when :class, :module
+              return :lexical
+            when :def, :defs, :block
+              return :dynamic
+            end
+            node = parent
+          end
+          :lexical
+        end
+
+        def lexical_scope_type(node)
+          node.each_ancestor(:class, :module) do |ancestor|
+            return ancestor.class_type? ? 'in a class body' : 'in a module body'
+          end
+          'at the top level'
+        end
+
+        def bareword?(sym_node)
+          sym_node.source[0] != ':'
+        end
+
+        def correct_alias_method_to_alias(node)
+          lambda do |corrector|
+            new, old = *node.method_args
+            replacement = "alias #{new.children.first} #{old.children.first}"
+            corrector.replace(node.source_range, replacement)
+          end
+        end
+
+        def correct_alias_to_alias_method(node)
+          lambda do |corrector|
+            new, old = *node
+            replacement = "alias_method :#{new.children.first}, " \
+                          ":#{old.children.first}"
+            corrector.replace(node.source_range, replacement)
+          end
+        end
+
+        def correct_alias_with_symbol_args(node)
           lambda do |corrector|
-            # replace alias with alias_method
-            corrector.replace(node.loc.keyword, 'alias_method')
-            # insert a comma
             new, old = *node
-            corrector.insert_after(new.loc.expression, ',')
-            # convert bareword arguments to symbols
-            corrector.replace(new.loc.expression, ":#{new.children.first}")
-            corrector.replace(old.loc.expression, ":#{old.children.first}")
+            corrector.replace(new.source_range, new.children.first.to_s)
+            corrector.replace(old.source_range, old.children.first.to_s)
           end
         end
       end