rubocop 0.47.1 → 0.48.0

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

@@ -26,15 +26,15 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          read_write_attribute?(node) do
-            add_offense(node, :selector)
-          end
+          return unless read_write_attribute?(node)
+
+          add_offense(node, :selector)
         end
 
-        def message(node)
-          _receiver, method_name, *_args = *node
+        private
 
-          if method_name == :read_attribute
+        def message(node)
+          if node.method?(:read_attribute)
             format(MSG, 'self[:attr]', 'read_attribute(:attr)')
           else
             format(MSG, 'self[:attr] = val', 'write_attribute(:attr, val)')
@@ -42,9 +42,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          _receiver, method_name, _body = *node
-
-          case method_name
+          case node.method_name
           when :read_attribute
             replacement = read_attribute_replacement(node)
           when :write_attribute
@@ -54,19 +52,12 @@ module RuboCop
           ->(corrector) { corrector.replace(node.source_range, replacement) }
         end
 
-        private
-
         def read_attribute_replacement(node)
-          _receiver, _method_name, body = *node
-
-          "self[#{body.source}]"
+          "self[#{node.first_argument.source}]"
         end
 
         def write_attribute_replacement(node)
-          _receiver, _method_name, *args = *node
-          name, value = *args
-
-          "self[#{name.source}] = #{value.source}"
+          "self[#{node.first_argument.source}] = #{node.last_argument.source}"
         end
       end
     end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks whether constant value isn't relative date.
+      # Because the relative date will be evaluated only once.
+      #
+      # @example
+      #   # bad
+      #   class SomeClass
+      #     EXPIRED_AT = 1.week.since
+      #   end
+      #
+      #   # good
+      #   class SomeClass
+      #     def self.expired_at
+      #       1.week.since
+      #     end
+      #   end
+      class RelativeDateConstant < Cop
+        MSG = 'Do not assign %s to constants as it will be evaluated only ' \
+              'once.'.freeze
+
+        RELATIVE_DATE_METHODS = %i(ago from_now since until).freeze
+
+        def on_casgn(node)
+          bad_node = node.descendants.find { |n| bad_method?(n) }
+          return unless bad_node
+
+          add_offense(node, :expression, format(MSG, bad_node.method_name))
+        end
+
+        private
+
+        def bad_method?(node)
+          node.send_type? &&
+            RELATIVE_DATE_METHODS.include?(node.method_name) &&
+            node.method_args.empty?
+        end
+
+        def autocorrect(node)
+          _scope, const_name, value = *node
+          indent = ' ' * node.loc.column
+          new_code = ["def self.#{const_name.downcase}",
+                      "#{indent}#{value.source}",
+                      'end'].join("\n#{indent}")
+          ->(corrector) { corrector.replace(node.source_range, new_code) }
+        end
+      end
+    end
+  end
+end

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

@@ -8,13 +8,16 @@ module RuboCop
       class RequestReferer < Cop
         include ConfigurableEnforcedStyle
 
+        MSG = 'Use `request.%s` instead of `request.%s`.'.freeze
+
         def_node_matcher :referer?, <<-PATTERN
-          (send (send nil :request) ${:referer :referrer})
+          (send (send nil :request) {:referer :referrer})
         PATTERN
 
         def on_send(node)
-          referer?(node) do |method_name|
-            return unless method_name == wrong_method_name
+          referer?(node) do
+            return unless node.method?(wrong_method_name)
+
             add_offense(node.source_range, node.source_range, message)
           end
         end
@@ -26,7 +29,7 @@ module RuboCop
         private
 
         def message
-          "Use `request.#{style}` instead of `request.#{wrong_method_name}`."
+          format(MSG, style, wrong_method_name)
         end
 
         def wrong_method_name

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

@@ -202,8 +202,7 @@ module RuboCop
         end
 
         def all_hash_key?(args, *keys)
-          return false unless args
-          return false unless args.hash_type?
+          return false unless args && args.hash_type?
 
           hash_keys = args.to_a.map do |arg|
             arg.to_a.first.children.first.to_sym

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

@@ -63,8 +63,9 @@ module RuboCop
         private
 
         def autocorrect(node)
-          _receiver, _try, method_node, *params = *node
+          method_node, *params = *node.arguments
           method = method_node.source[1..-1]
+
           range = range_between(node.loc.dot.begin_pos,
                                 node.loc.expression.end_pos)
 

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

@@ -44,9 +44,10 @@ module RuboCop
         CREATE_CONDITIONAL_MSG = '`%s` returns a model which is always truthy.'
                                  .freeze
 
-        CREATE_PERSIST_METHODS = [:create,
-                                  :first_or_create, :find_or_create_by].freeze
-        MODIFY_PERSIST_METHODS = [:save, :update, :destroy].freeze
+        CREATE_PERSIST_METHODS = %i(create
+                                    first_or_create find_or_create_by).freeze
+        MODIFY_PERSIST_METHODS = %i(save
+                                    update update_attributes destroy).freeze
         PERSIST_METHODS = (CREATE_PERSIST_METHODS +
                            MODIFY_PERSIST_METHODS).freeze
 
@@ -107,7 +108,7 @@ module RuboCop
         def persisted_referenced?(assignment)
           return unless assignment.referenced?
           assignment.variable.references.any? do |reference|
-            reference.node.parent.method_name == :persisted?
+            reference.node.parent.method?(:persisted?)
           end
         end
 
@@ -129,8 +130,7 @@ module RuboCop
         end
 
         def last_call_of_method?(node)
-          !node.parent.nil? &&
-            node.parent.children.count == node.sibling_index + 1
+          node.parent && node.parent.children.count == node.sibling_index + 1
         end
 
         # Ignore simple assignment or if condition
@@ -143,11 +143,11 @@ module RuboCop
 
         # Check argument signature as no arguments or one hash
         def expected_signature?(node)
-          node.method_args.empty? ||
-            (node.method_args.length == 1 &&
+          !node.arguments? ||
+            (node.arguments.one? &&
               node.method_name != :destroy &&
-              (node.method_args.first.hash_type? ||
-              !node.method_args.first.literal?))
+              (node.first_argument.hash_type? ||
+              !node.first_argument.literal?))
         end
       end
     end

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

@@ -25,20 +25,37 @@ module RuboCop
       class SkipsModelValidations < Cop
         MSG = 'Avoid using `%s` because it skips validations.'.freeze
 
+        METHODS_WITH_ARGUMENTS = %w(decrement!
+                                    decrement_counter
+                                    increment!
+                                    increment_counter
+                                    toggle!
+                                    update_all
+                                    update_attribute
+                                    update_column
+                                    update_columns
+                                    update_counters).freeze
+
         def on_send(node)
-          _receiver, method_name = *node
+          return unless blacklist.include?(node.method_name.to_s)
+
+          _receiver, method_name, *args = *node
 
-          return unless blacklist.include?(method_name.to_s)
+          if METHODS_WITH_ARGUMENTS.include?(method_name.to_s) && args.empty?
+            return
+          end
 
-          add_offense(node,
-                      node.loc.selector,
-                      format(MSG, method_name))
+          add_offense(node, :selector)
         end
 
         private
 
+        def message(node)
+          format(MSG, node.method_name)
+        end
+
         def blacklist
-          cop_config['Blacklist']
+          cop_config['Blacklist'] || []
         end
       end
     end

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

@@ -23,7 +23,7 @@ module RuboCop
       #   Time.zone.now
       #   Time.zone.parse('2015-03-02 19:05:37')
       #
-      #   # no offense only if style is 'acceptable'
+      #   # no offense only if style is 'flexible'
       #   Time.current
       #   DateTime.strptime(str, "%Y-%m-%d %H:%M %Z").in_time_zone
       #   Time.at(timestamp).in_time_zone
@@ -40,14 +40,16 @@ module RuboCop
 
         MSG_CURRENT = 'Do not use `%s`. Use `Time.zone.now` instead.'.freeze
 
-        TIMECLASS = [:Time, :DateTime].freeze
+        TIMECLASS = %i(Time DateTime).freeze
 
-        DANGEROUS_METHODS = [:now, :local, :new, :strftime,
-                             :parse, :at, :current].freeze
+        GOOD_METHODS = %i(zone zone_default find_zone find_zone!).freeze
 
-        ACCEPTED_METHODS = [:in_time_zone, :utc, :getlocal,
-                            :iso8601, :jisx0301, :rfc3339,
-                            :to_i, :to_f].freeze
+        DANGEROUS_METHODS = %i(now local new strftime
+                               parse at current).freeze
+
+        ACCEPTED_METHODS = %i(in_time_zone utc getlocal
+                              iso8601 jisx0301 rfc3339
+                              to_i to_f).freeze
 
         def on_const(node)
           mod, klass = *node
@@ -127,25 +129,26 @@ module RuboCop
         end
 
         def safe_method(method_name, node)
-          _receiver, _method_name, *args = *node
           return method_name unless method_name == 'new'
 
-          if args.empty?
-            'now'
-          else
+          if node.arguments?
             'local'
+          else
+            'now'
           end
         end
 
         def check_localtime(node)
           selector_node = node
-          while !node.nil? && node.send_type?
+
+          while node && node.send_type?
             break if extract_method(node) == :localtime
             node = node.parent
           end
-          _receiver, _method, args = *node
 
-          add_offense(selector_node, :selector, MSG_LOCALTIME) if args.nil?
+          return if node.arguments?
+
+          add_offense(selector_node, :selector, MSG_LOCALTIME)
         end
 
         def danger_chain?(chain)
@@ -162,9 +165,9 @@ module RuboCop
 
         def good_methods
           if style == :strict
-            [:zone, :zone_default]
+            GOOD_METHODS
           else
-            [:zone, :zone_default, :current] + ACCEPTED_METHODS
+            GOOD_METHODS + [:current] + ACCEPTED_METHODS
           end
         end
 
@@ -186,8 +189,7 @@ module RuboCop
         # Example:
         # Time.new(1988, 3, 15, 3, 0, 0, "-05:00")
         def offset_provided?(node)
-          _, _, *args = *node
-          args.length >= 7
+          node.arguments.size >= 7
         end
       end
     end

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

@@ -59,10 +59,11 @@ module RuboCop
         end
 
         def autocorrect(node)
-          send_pluck, method, *_args = *node
           lambda do |corrector|
+            method = node.method_name
+
             corrector.remove(dot_method_with_whitespace(method, node))
-            corrector.insert_before(send_pluck.loc.dot.begin, ".#{method}")
+            corrector.insert_before(node.receiver.loc.dot.begin, ".#{method}")
           end
         end
 

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

@@ -21,22 +21,20 @@ module RuboCop
         ).freeze
 
         BLACKLIST = TYPES.map { |p| "validates_#{p}_of".to_sym }.freeze
-
         WHITELIST = TYPES.map { |p| "validates :column, #{p}: value" }.freeze
 
         def on_send(node)
-          receiver, method_name, *_args = *node
-          return unless receiver.nil? && BLACKLIST.include?(method_name)
+          return unless !node.receiver && BLACKLIST.include?(node.method_name)
 
-          add_offense(node,
-                      :selector,
-                      format(MSG,
-                             preferred_method(method_name),
-                             method_name))
+          add_offense(node, :selector)
         end
 
         private
 
+        def message(node)
+          format(MSG, preferred_method(node.method_name), node.method_name)
+        end
+
         def preferred_method(method)
           WHITELIST[BLACKLIST.index(method.to_sym)]
         end
@@ -49,9 +47,8 @@ module RuboCop
         end
 
         def correct_validate_type(corrector, node)
-          _receiver, method_name, *args = *node
-          options = args.find { |arg| !arg.sym_type? }
-          validate_type = method_name.to_s.split('_')[1]
+          options = node.arguments.find { |arg| !arg.sym_type? }
+          validate_type = node.method_name.to_s.split('_')[1]
 
           if options
             corrector.replace(options.loc.expression,

data/lib/rubocop/cop/registry.rb

@@ -72,7 +72,7 @@ module RuboCop
       # @example namespaces bare cop identifiers
       #
       #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('IndentArray') # => 'IndentArray'
+      #   cops.qualified_cop_name('IndentArray') # => 'Style/IndentArray'
       #
       # @example passes back unrecognized cop names
       #
@@ -80,7 +80,7 @@ module RuboCop
       #   cops.qualified_cop_name('NotACop') # => 'NotACop'
       #
       # @param name [String] Cop name extracted from config
-      # @param path [String] Path of file that `name` was extracted from
+      # @param path [String, nil] Path of file that `name` was extracted from
       #
       # @raise [AmbiguousCopName]
       #   if a bare identifier with two possible namespaces is provided
@@ -115,7 +115,7 @@ module RuboCop
 
       def enabled(config, only)
         select do |cop|
-          config.cop_enabled?(cop) || only.include?(cop.cop_name)
+          config.for_cop(cop).fetch('Enabled') || only.include?(cop.cop_name)
         end
       end
 

data/lib/rubocop/cop/security/json_load.rb

@@ -26,7 +26,7 @@ module RuboCop
         MSG = 'Prefer `JSON.parse` over `JSON.%s`.'.freeze
 
         def_node_matcher :json_load, <<-END
-          (send (const nil :JSON) ${:load :restore} ...)
+          (send (const {nil cbase} :JSON) ${:load :restore} ...)
         END
 
         def on_send(node)

data/lib/rubocop/cop/security/marshal_load.rb

@@ -15,11 +15,15 @@ module RuboCop
       #   # good
       #   Marshal.dump("{}")
       #
+      #   # okish - deep copy hack
+      #   Marshal.load(Marshal.dump({}))
+      #
       class MarshalLoad < Cop
         MSG = 'Avoid using `Marshal.%s`.'.freeze
 
         def_node_matcher :marshal_load, <<-END
-          (send (const nil :Marshal) ${:load :restore} ...)
+          (send (const {nil cbase} :Marshal) ${:load :restore}
+          !(send (const {nil cbase} :Marshal) :dump ...))
         END
 
         def on_send(node)