rubbycop 0.49.0

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop enforces the consistent use of action filter methods.
+      #
+      # 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 = %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
+
+          check_method_node(method)
+        end
+
+        def on_send(node)
+          check_method_node(node) unless node.receiver
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              preferred_method(node.loc.selector.source).to_s)
+          end
+        end
+
+        private
+
+        def check_method_node(node)
+          return unless bad_methods.include?(node.method_name)
+
+          add_offense(node, :selector)
+        end
+
+        def message(node)
+          format(MSG, preferred_method(node.method_name), node.method_name)
+        end
+
+        def bad_methods
+          style == :action ? FILTER_METHODS : ACTION_METHODS
+        end
+
+        def good_methods
+          style == :action ? ACTION_METHODS : FILTER_METHODS
+        end
+
+        def preferred_method(method)
+          good_methods[bad_methods.index(method.to_sym)]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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/rubbycop/cop/rails/application_job.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop checks that jobs subclass ApplicationJob with Rails 5.0.
+      #
+      # @example
+      #
+      #  # good
+      #  class Rails5Job < ApplicationJob
+      #    ...
+      #  end
+      #
+      #  # bad
+      #  class Rails4Job < ActiveJob::Base
+      #    ...
+      #  end
+      class ApplicationJob < Cop
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.0
+
+        MSG = 'Jobs should subclass `ApplicationJob`.'.freeze
+        SUPERCLASS = 'ApplicationJob'.freeze
+        BASE_PATTERN = '(const (const nil :ActiveJob) :Base)'.freeze
+
+        include RubbyCop::Cop::EnforceSuperclass
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/rails/application_record.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop checks that models subclass ApplicationRecord with Rails 5.0.
+      #
+      # @example
+      #
+      #  # good
+      #  class Rails5Model < ApplicationRecord
+      #    ...
+      #  end
+      #
+      #  # bad
+      #  class Rails4Model < ActiveRecord::Base
+      #    ...
+      #  end
+      class ApplicationRecord < Cop
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.0
+
+        MSG = 'Models should subclass `ApplicationRecord`.'.freeze
+        SUPERCLASS = 'ApplicationRecord'.freeze
+        BASE_PATTERN = '(const (const nil :ActiveRecord) :Base)'.freeze
+
+        include RubbyCop::Cop::EnforceSuperclass
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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` 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,
+                               replacement(receiver),
+                               node.source))
+          end
+        end
+
+        def on_or(node)
+          return unless cop_config['NilOrEmpty']
+          return unless node.lhs.receiver && node.rhs.receiver
+
+          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, replacement(variable1))
+          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
+
+        def replacement(node)
+          node.respond_to?(:source) ? "#{node.source}.blank?" : 'blank?'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop checks for the correct use of Date methods,
+      # such as Date.today, Date.current etc.
+      #
+      # Using Date.today is dangerous, because it doesn't know anything about
+      # Rails time zone. You must use Time.zone.today instead.
+      #
+      # The cop also reports warnings when you are using 'to_time' method,
+      # because it doesn't know about Rails time zone either.
+      #
+      # Two styles are supported for this cop. When EnforcedStyle is 'strict'
+      # then the Date methods (today, current, yesterday, tomorrow)
+      # are prohibited and the usage of both 'to_time'
+      # and 'to_time_in_current_zone' is reported as warning.
+      #
+      # When EnforcedStyle is 'flexible' then only 'Date.today' is prohibited
+      # and only 'to_time' is reported as warning.
+      #
+      # @example
+      #   # no offense
+      #   Time.zone.today
+      #   Time.zone.today - 1.day
+      #
+      #   # flexible
+      #   Date.current
+      #   Date.yesterday
+      #
+      #   # always reports offense
+      #   Date.today
+      #   date.to_time
+      #
+      #   # reports offense only when style is 'strict'
+      #   date.to_time_in_current_zone
+      class Date < Cop
+        include ConfigurableEnforcedStyle
+
+        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.'.freeze
+
+        BAD_DAYS = %i[today current yesterday tomorrow].freeze
+
+        def on_const(node)
+          mod, klass = *node.children
+          # we should only check core Date class (`Date` or `::Date`)
+          return unless (mod.nil? || mod.cbase_type?) && method_send?(node)
+
+          check_date_node(node.parent) if klass == :Date
+        end
+
+        def on_send(node)
+          return unless node.receiver && bad_methods.include?(node.method_name)
+
+          return if safe_chain?(node) || safe_to_time?(node)
+
+          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('.')
+
+          add_offense(node, :selector,
+                      format(MSG,
+                             "Date.#{method_name}",
+                             "Time.zone.#{method_name}"))
+        end
+
+        def extract_method_chain(node)
+          [node, *node.each_ancestor(:send)].map(&:method_name)
+        end
+
+        # checks that parent node of send_type
+        # and receiver is the given node
+        def method_send?(node)
+          return false unless node.parent && node.parent.send_type?
+
+          node.parent.receiver == node
+        end
+
+        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 ? [] : %i[current yesterday tomorrow]
+        end
+
+        def bad_days
+          BAD_DAYS - good_days
+        end
+
+        def bad_methods
+          style == :strict ? %i[to_time to_time_in_current_zone] : [:to_time]
+        end
+
+        def good_methods
+          style == :strict ? [] : TimeZone::ACCEPTED_METHODS
+        end
+      end
+    end
+  end
+end