rubocop 0.47.1 → 0.48.0

data/lib/rubocop/cop/performance/times_map.rb

@@ -45,11 +45,11 @@ module RuboCop
         def autocorrect(node)
           send_node = node.send_type? ? node : node.each_descendant(:send).first
 
-          receiver, _method_name, *args = *send_node
-          count, = *receiver
+          count, = *send_node.receiver
 
-          replacement = "Array.new(#{count.source}" \
-                        "#{args.map { |arg| ", #{arg.source}" }.join})"
+          replacement =
+            "Array.new(#{count.source}" \
+            "#{send_node.arguments.map { |arg| ", #{arg.source}" }.join})"
 
           lambda do |corrector|
             corrector.replace(send_node.loc.expression, replacement)

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

@@ -7,42 +7,48 @@ module RuboCop
       #
       # The cop is configurable and can enforce the use of the older
       # something_filter methods or the newer something_action methods.
+      #
+      # If the TargetRailsVersion is set to less than 4.0, the cop will enforce
+      # the use of filter methods.
       class ActionFilter < Cop
+        extend TargetRailsVersion
         include ConfigurableEnforcedStyle
 
         MSG = 'Prefer `%s` over `%s`.'.freeze
 
-        FILTER_METHODS = [
-          :after_filter,
-          :append_after_filter,
-          :append_around_filter,
-          :append_before_filter,
-          :around_filter,
-          :before_filter,
-          :prepend_after_filter,
-          :prepend_around_filter,
-          :prepend_before_filter,
-          :skip_after_filter,
-          :skip_around_filter,
-          :skip_before_filter,
-          :skip_filter
-        ].freeze
-
-        ACTION_METHODS = [
-          :after_action,
-          :append_after_action,
-          :append_around_action,
-          :append_before_action,
-          :around_action,
-          :before_action,
-          :prepend_after_action,
-          :prepend_around_action,
-          :prepend_before_action,
-          :skip_after_action,
-          :skip_around_action,
-          :skip_before_action,
-          :skip_action_callback
-        ].freeze
+        FILTER_METHODS = %i(
+          after_filter
+          append_after_filter
+          append_around_filter
+          append_before_filter
+          around_filter
+          before_filter
+          prepend_after_filter
+          prepend_around_filter
+          prepend_before_filter
+          skip_after_filter
+          skip_around_filter
+          skip_before_filter
+          skip_filter
+        ).freeze
+
+        ACTION_METHODS = %i(
+          after_action
+          append_after_action
+          append_around_action
+          append_before_action
+          around_action
+          before_action
+          prepend_after_action
+          prepend_around_action
+          prepend_before_action
+          skip_after_action
+          skip_around_action
+          skip_before_action
+          skip_action_callback
+        ).freeze
+
+        minimum_target_rails_version 4.0
 
         def on_block(node)
           method, _args, _body = *node
@@ -51,9 +57,7 @@ module RuboCop
         end
 
         def on_send(node)
-          receiver, _method_name, *_args = *node
-
-          check_method_node(node) if receiver.nil?
+          check_method_node(node) unless node.receiver
         end
 
         def autocorrect(node)
@@ -66,17 +70,13 @@ module RuboCop
         private
 
         def check_method_node(node)
-          _receiver, method_name, *_args = *node
-          return unless offending_method?(method_name)
+          return unless bad_methods.include?(node.method_name)
 
-          add_offense(node, :selector,
-                      format(MSG,
-                             preferred_method(method_name),
-                             method_name))
+          add_offense(node, :selector)
         end
 
-        def offending_method?(method_name)
-          bad_methods.include?(method_name)
+        def message(node)
+          format(MSG, preferred_method(node.method_name), node.method_name)
         end
 
         def bad_methods

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that ActiveSupport aliases to core ruby methods
+      # are not used.
+      #
+      # @example
+      #   # good
+      #   'some_string'.start_with?('prefix')
+      #   'some_string'.end_with?('suffix')
+      #   [1, 2, 'a'] << 'b'
+      #   [1, 2, 'a'].unshift('b')
+      #
+      #   # bad
+      #   'some_string'.starts_with?('prefix')
+      #   'some_string'.ends_with?('suffix')
+      #   [1, 2, 'a'].append('b')
+      #   [1, 2, 'a'].prepend('b')
+      #
+      class ActiveSupportAliases < Cop
+        MSG = 'Use `%s` instead of `%s`.'.freeze
+
+        ALIASES = {
+          starts_with?: {
+            original: :start_with?, matcher: '(send str :starts_with? _)'
+          },
+          ends_with?: {
+            original: :end_with?, matcher: '(send str :ends_with? _)'
+          },
+          append: { original: :<<, matcher: '(send array :append _)' },
+          prepend: { original: :unshift, matcher: '(send array :prepend _)' }
+        }.freeze
+
+        ALIASES.each do |aliased_method, options|
+          def_node_matcher aliased_method, options[:matcher]
+        end
+
+        def on_send(node)
+          ALIASES.keys.each do |aliased_method|
+            register_offense(node, aliased_method) if
+              public_send(aliased_method, node)
+          end
+        end
+
+        private
+
+        def autocorrect(node)
+          return false if append(node)
+          lambda do |corrector|
+            method_name = node.loc.selector.source
+            replacement = ALIASES[method_name.to_sym][:original]
+            corrector.replace(node.loc.selector, replacement.to_s)
+          end
+        end
+
+        def register_offense(node, method_name)
+          add_offense(
+            node,
+            :expression,
+            format(MSG, ALIASES[method_name][:original], method_name)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cops checks for code that can be changed to `blank?`.
+      # Settings:
+      #   NilOrEmpty: Convert checks for `nil` or `empty?` to `blank?`
+      #   NotPresent: Convert usages of not `present?` to `blank?`
+      #   UnlessPresent: Convert usages of `unless` `present?` to `blank?`
+      #
+      # @example
+      #   # NilOrEmpty: true
+      #     # bad
+      #     foo.nil? || foo.empty?
+      #     foo == nil || foo.empty?
+      #
+      #     # good
+      #     foo.blank?
+      #
+      #   # NotPresent: true
+      #     # bad
+      #     !foo.present?
+      #
+      #     # good
+      #     foo.blank?
+      #
+      #   # UnlessPresent: true
+      #     # bad
+      #     something unless foo.present?
+      #     unless foo.present?
+      #       something
+      #     end
+      #
+      #     # good
+      #     something if foo.blank?
+      #     if foo.blank?
+      #       something
+      #     end
+      class Blank < Cop
+        MSG_NIL_OR_EMPTY = 'Use `%s.blank?` instead of `%s`.'.freeze
+        MSG_NOT_PRESENT = 'Use `%s.blank?` instead of `%s`.'.freeze
+        MSG_UNLESS_PRESENT = 'Use `if %s.blank?` instead of `%s`.'.freeze
+
+        def_node_matcher :nil_or_empty?, <<-PATTERN
+          (or
+              {
+                (send $_ :!)
+                (send $_ :nil?)
+                (send $_ :== (:nil))
+                (send (:nil) :== $_)
+              }
+              {
+                (send $_ :empty?)
+                (send (send (send $_ :empty?) :!) :!)
+              }
+          )
+        PATTERN
+
+        def_node_matcher :not_present?, '(send (send $_ :present?) :!)'
+
+        def_node_matcher :unless_present?, <<-PATTERN
+          (:if $(send $_ :present?) {nil (...)} ...)
+        PATTERN
+
+        def on_send(node)
+          return unless cop_config['NotPresent']
+
+          not_present?(node) do |receiver|
+            add_offense(node,
+                        :expression,
+                        format(MSG_NOT_PRESENT, receiver.source, node.source))
+          end
+        end
+
+        def on_or(node)
+          return unless cop_config['NilOrEmpty']
+
+          nil_or_empty?(node) do |variable1, variable2|
+            return unless variable1 == variable2
+
+            add_offense(node,
+                        :expression,
+                        format(MSG_NIL_OR_EMPTY, variable1.source, node.source))
+          end
+        end
+
+        def on_if(node)
+          return unless cop_config['UnlessPresent']
+          return unless node.unless?
+
+          unless_present?(node) do |method_call, receiver|
+            range = unless_condition(node, method_call)
+
+            add_offense(node,
+                        range,
+                        format(MSG_UNLESS_PRESENT,
+                               receiver.source,
+                               range.source))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            method_call, variable1 = unless_present?(node)
+
+            if method_call && variable1
+              corrector.replace(node.loc.keyword, 'if')
+              range = method_call.loc.expression
+            else
+              variable1, _variable2 = nil_or_empty?(node) || not_present?(node)
+              range = node.loc.expression
+            end
+
+            corrector.replace(range, "#{variable1.source}.blank?")
+          end
+        end
+
+        private
+
+        def unless_condition(node, method_call)
+          if node.modifier_form?
+            node.loc.keyword.join(node.loc.expression.end)
+          else
+            node.loc.expression.begin.join(method_call.loc.expression)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -25,7 +25,7 @@ module RuboCop
       #   Time.zone.today
       #   Time.zone.today - 1.day
       #
-      #   # acceptable
+      #   # flexible
       #   Date.current
       #   Date.yesterday
       #
@@ -43,7 +43,7 @@ module RuboCop
         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].freeze
+        BAD_DAYS = %i(today current yesterday tomorrow).freeze
 
         def on_const(node)
           mod, klass = *node.children
@@ -54,23 +54,18 @@ module RuboCop
         end
 
         def on_send(node)
-          receiver, method_name, *args = *node
-          return unless receiver && bad_methods.include?(method_name)
+          return unless node.receiver && bad_methods.include?(node.method_name)
 
-          chain = extract_method_chain(node)
-          return if safe_chain?(chain)
-
-          return if method_name == :to_time && args.length == 1
+          return if safe_chain?(node) || safe_to_time?(node)
 
-          add_offense(node, :selector,
-                      format(MSG_SEND,
-                             method_name))
+          add_offense(node, :selector, format(MSG_SEND, node.method_name))
         end
 
         private
 
         def check_date_node(node)
           chain = extract_method_chain(node)
+
           return if (chain & bad_days).empty?
 
           method_name = (chain & bad_days).join('.')
@@ -82,17 +77,7 @@ module RuboCop
         end
 
         def extract_method_chain(node)
-          chain = []
-          while !node.nil? && node.send_type?
-            chain << extract_method(node)
-            node = node.parent
-          end
-          chain
-        end
-
-        def extract_method(node)
-          _receiver, method_name, *_args = *node
-          method_name
+          [node, *node.each_ancestor(:send)].map(&:method_name)
         end
 
         # checks that parent node of send_type
@@ -100,17 +85,29 @@ module RuboCop
         def method_send?(node)
           return false unless node.parent && node.parent.send_type?
 
-          receiver, _method_name, *_args = *node.parent
-
-          receiver == node
+          node.parent.receiver == node
         end
 
-        def safe_chain?(chain)
+        def safe_chain?(node)
+          chain = extract_method_chain(node)
+
           (chain & bad_methods).empty? || !(chain & good_methods).empty?
         end
 
+        def safe_to_time?(node)
+          return unless node.method?(:to_time)
+
+          if node.receiver.str_type?
+            zone_regexp = /[+-][\d:]+\z/
+
+            node.receiver.str_content.match(zone_regexp)
+          else
+            node.arguments.one?
+          end
+        end
+
         def good_days
-          style == :strict ? [] : [:current, :yesterday, :tomorrow]
+          style == :strict ? [] : %i(current yesterday tomorrow)
         end
 
         def bad_days
@@ -118,7 +115,7 @@ module RuboCop
         end
 
         def bad_methods
-          style == :strict ? [:to_time, :to_time_in_current_zone] : [:to_time]
+          style == :strict ? %i(to_time to_time_in_current_zone) : [:to_time]
         end
 
         def good_methods

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

@@ -16,7 +16,7 @@ module RuboCop
       class DelegateAllowBlank < Cop
         MSG = '`allow_blank` is not a valid option, use `allow_nil`.'.freeze
 
-        def_node_matcher :delegate, <<-PATTERN
+        def_node_matcher :delegate_options, <<-PATTERN
           (send nil :delegate _ $hash)
         PATTERN
 
@@ -29,7 +29,7 @@ module RuboCop
 
           return unless offending_node
 
-          add_offense(offending_node, :expression, MSG)
+          add_offense(offending_node, :expression)
         end
 
         private
@@ -41,11 +41,9 @@ module RuboCop
         end
 
         def allow_blank_option(node)
-          options_hash = delegate(node)
-
-          return unless options_hash
-
-          options_hash.pairs.find { |opt| allow_blank_option?(opt) }
+          delegate_options(node) do |hash|
+            hash.pairs.find { |opt| allow_blank_option?(opt) }
+          end
         end
       end
     end