rubocop-rails 2.4.1

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks the migration for which timestamps are not included
+      # when creating a new table.
+      # In many cases, timestamps are useful information and should be added.
+      #
+      # @example
+      #   # bad
+      #   create_table :users
+      #
+      #   # bad
+      #   create_table :users do |t|
+      #     t.string :name
+      #     t.string :email
+      #   end
+      #
+      #   # good
+      #   create_table :users do |t|
+      #     t.string :name
+      #     t.string :email
+      #
+      #     t.timestamps
+      #   end
+      #
+      #   # good
+      #   create_table :users do |t|
+      #     t.string :name
+      #     t.string :email
+      #
+      #     t.datetime :created_at, default: -> { 'CURRENT_TIMESTAMP' }
+      #   end
+      #
+      #   # good
+      #   create_table :users do |t|
+      #     t.string :name
+      #     t.string :email
+      #
+      #     t.datetime :updated_at, default: -> { 'CURRENT_TIMESTAMP' }
+      #   end
+      class CreateTableWithTimestamps < Cop
+        MSG = 'Add timestamps when creating a new table.'
+
+        def_node_matcher :create_table_with_block?, <<~PATTERN
+          (block
+            (send nil? :create_table ...)
+            (args (arg _var))
+            _)
+        PATTERN
+
+        def_node_matcher :create_table_with_timestamps_proc?, <<~PATTERN
+          (send nil? :create_table (sym _) ... (block-pass (sym :timestamps)))
+        PATTERN
+
+        def_node_search :timestamps_included?, <<~PATTERN
+          (send _var :timestamps ...)
+        PATTERN
+
+        def_node_search :created_at_or_updated_at_included?, <<~PATTERN
+          (send _var :datetime
+            {(sym {:created_at :updated_at})(str {"created_at" "updated_at"})}
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return unless node.command?(:create_table)
+
+          parent = node.parent
+
+          if create_table_with_block?(parent)
+            if parent.body.nil? || !time_columns_included?(parent.body)
+              add_offense(parent)
+            end
+          elsif create_table_with_timestamps_proc?(node)
+            # nothing to do
+          else
+            add_offense(node)
+          end
+        end
+
+        private
+
+        def time_columns_included?(node)
+          timestamps_included?(node) || created_at_or_updated_at_included?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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`, and `tomorrow`
+      # are prohibited and the usage of both `to_time`
+      # and 'to_time_in_current_zone' are reported as warning.
+      #
+      # When EnforcedStyle is 'flexible' then only `Date.today` is prohibited
+      # and only `to_time` is reported as warning.
+      #
+      # @example EnforcedStyle: strict
+      #   # bad
+      #   Date.current
+      #   Date.yesterday
+      #   Date.today
+      #   date.to_time
+      #
+      #   # good
+      #   Time.zone.today
+      #   Time.zone.today - 1.day
+      #
+      # @example EnforcedStyle: flexible (default)
+      #   # bad
+      #   Date.today
+      #   date.to_time
+      #
+      #   # good
+      #   Time.zone.today
+      #   Time.zone.today - 1.day
+      #   Date.current
+      #   Date.yesterday
+      #   date.in_time_zone
+      #
+      class Date < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Do not use `Date.%<method_called>s` without zone. Use ' \
+              '`Time.zone.%<day>s` instead.'
+
+        MSG_SEND = 'Do not use `%<method>s` on Date objects, because they ' \
+                   'know nothing about the time zone in use.'
+
+        BAD_DAYS = %i[today current yesterday tomorrow].freeze
+
+        DEPRECATED_METHODS = [
+          { deprecated: 'to_time_in_current_zone', relevant: 'in_time_zone' }
+        ].freeze
+
+        DEPRECATED_MSG = '`%<deprecated>s` is deprecated. ' \
+                         'Use `%<relevant>s` instead.'
+
+        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)
+
+          check_deprecated_methods(node)
+
+          add_offense(node, location: :selector,
+                            message: format(MSG_SEND, method: node.method_name))
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_deprecated_methods(node)
+          DEPRECATED_METHODS.each do |method|
+            next unless node.method?(method[:deprecated].to_sym)
+
+            add_offense(node, location: :selector,
+                              message: format(DEPRECATED_MSG,
+                                              deprecated: method[:deprecated],
+                                              relevant: method[:relevant]))
+          end
+        end
+
+        def check_date_node(node)
+          chain = extract_method_chain(node)
+
+          return if (chain & bad_days).empty?
+
+          method_name = (chain & bad_days).join('.')
+
+          day = method_name
+          day = 'today' if method_name == 'current'
+
+          add_offense(node, location: :selector,
+                            message: format(MSG,
+                                            method_called: method_name,
+                                            day: day))
+        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&.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:]+|\dZ)\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
+          %i[to_time to_time_in_current_zone]
+        end
+
+        def good_methods
+          style == :strict ? [] : TimeZone::ACCEPTED_METHODS
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for delegations that could have been created
+      # automatically with the `delegate` method.
+      #
+      # Safe navigation `&.` is ignored because Rails' `allow_nil`
+      # option checks not just for nil but also delegates if nil
+      # responds to the delegated method.
+      #
+      # The `EnforceForPrefixed` option (defaulted to `true`) means that
+      # using the target object as a prefix of the method name
+      # without using the `delegate` method will be a violation.
+      # When set to `false`, this case is legal.
+      #
+      # @example
+      #   # bad
+      #   def bar
+      #     foo.bar
+      #   end
+      #
+      #   # good
+      #   delegate :bar, to: :foo
+      #
+      #   # good
+      #   def bar
+      #     foo&.bar
+      #   end
+      #
+      #   # good
+      #   private
+      #   def bar
+      #     foo.bar
+      #   end
+      #
+      # @example EnforceForPrefixed: true (default)
+      #   # bad
+      #   def foo_bar
+      #     foo.bar
+      #   end
+      #
+      #   # good
+      #   delegate :bar, to: :foo, prefix: true
+      #
+      # @example EnforceForPrefixed: false
+      #   # good
+      #   def foo_bar
+      #     foo.bar
+      #   end
+      #
+      #   # good
+      #   delegate :bar, to: :foo, prefix: true
+      class Delegate < Cop
+        MSG = 'Use `delegate` to define delegations.'
+
+        def_node_matcher :delegate?, <<~PATTERN
+          (def _method_name _args
+            (send (send nil? _) _ ...))
+        PATTERN
+
+        def on_def(node)
+          return unless trivial_delegate?(node)
+          return if private_or_protected_delegation(node)
+
+          add_offense(node, location: :keyword)
+        end
+
+        def autocorrect(node)
+          delegation = ["delegate :#{node.body.method_name}",
+                        "to: :#{node.body.receiver.method_name}"]
+
+          if node.method?(prefixed_method_name(node.body))
+            delegation << ['prefix: true']
+          end
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, delegation.join(', '))
+          end
+        end
+
+        private
+
+        def trivial_delegate?(def_node)
+          delegate?(def_node) &&
+            method_name_matches?(def_node.method_name, def_node.body) &&
+            arguments_match?(def_node.arguments, def_node.body)
+        end
+
+        def arguments_match?(arg_array, body)
+          argument_array = body.arguments
+
+          return false if arg_array.size != argument_array.size
+
+          arg_array.zip(argument_array).all? do |arg, argument|
+            arg.arg_type? &&
+              argument.lvar_type? &&
+              arg.children == argument.children
+          end
+        end
+
+        def method_name_matches?(method_name, body)
+          method_name == body.method_name ||
+            include_prefix_case? && method_name == prefixed_method_name(body)
+        end
+
+        def include_prefix_case?
+          cop_config['EnforceForPrefixed']
+        end
+
+        def prefixed_method_name(body)
+          [body.receiver.method_name, body.method_name].join('_').to_sym
+        end
+
+        def private_or_protected_delegation(node)
+          line = node.first_line
+          private_or_protected_before(line) ||
+            private_or_protected_inline(line)
+        end
+
+        def private_or_protected_before(line)
+          (processed_source[0..line].map(&:strip) & %w[private protected]).any?
+        end
+
+        def private_or_protected_inline(line)
+          processed_source[line - 1].strip =~ /\A(private )|(protected )/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for delegations that pass :allow_blank as an option
+      # instead of :allow_nil. :allow_blank is not a valid option to pass
+      # to ActiveSupport#delegate.
+      #
+      # @example
+      #   # bad
+      #   delegate :foo, to: :bar, allow_blank: true
+      #
+      #   # good
+      #   delegate :foo, to: :bar, allow_nil: true
+      class DelegateAllowBlank < Cop
+        MSG = '`allow_blank` is not a valid option, use `allow_nil`.'
+
+        def_node_matcher :allow_blank_option, <<~PATTERN
+          (send nil? :delegate _ (hash <$(pair (sym :allow_blank) true) ...>))
+        PATTERN
+
+        def on_send(node)
+          allow_blank_option(node) do |offending_node|
+            add_offense(offending_node)
+          end
+        end
+
+        def autocorrect(pair_node)
+          lambda do |corrector|
+            corrector.replace(pair_node.key.source_range, 'allow_nil')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks dynamic `find_by_*` methods.
+      # Use `find_by` instead of dynamic method.
+      # See. https://rails.rubystyle.guide#find_by
+      #
+      # @example
+      #   # bad
+      #   User.find_by_name(name)
+      #
+      #   # bad
+      #   User.find_by_name_and_email(name)
+      #
+      #   # bad
+      #   User.find_by_email!(name)
+      #
+      #   # good
+      #   User.find_by(name: name)
+      #
+      #   # good
+      #   User.find_by(name: name, email: email)
+      #
+      #   # good
+      #   User.find_by!(email: email)
+      class DynamicFindBy < Cop
+        MSG = 'Use `%<static_name>s` instead of dynamic `%<method>s`.'
+        METHOD_PATTERN = /^find_by_(.+?)(!)?$/.freeze
+
+        def on_send(node)
+          method_name = node.method_name.to_s
+
+          return if whitelist.include?(method_name)
+
+          static_name = static_method_name(method_name)
+
+          return unless static_name
+
+          add_offense(node,
+                      message: format(MSG, static_name: static_name,
+                                           method: node.method_name))
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          keywords = column_keywords(node.method_name)
+
+          return if keywords.size != node.arguments.size
+
+          lambda do |corrector|
+            autocorrect_method_name(corrector, node)
+            autocorrect_argument_keywords(corrector, node, keywords)
+          end
+        end
+
+        private
+
+        def autocorrect_method_name(corrector, node)
+          corrector.replace(node.loc.selector,
+                            static_method_name(node.method_name.to_s))
+        end
+
+        def autocorrect_argument_keywords(corrector, node, keywords)
+          keywords.each.with_index do |keyword, idx|
+            corrector.insert_before(node.arguments[idx].loc.expression, keyword)
+          end
+        end
+
+        def whitelist
+          cop_config['Whitelist']
+        end
+
+        def column_keywords(method)
+          keyword_string = method.to_s[METHOD_PATTERN, 1]
+          keyword_string.split('_and_').map { |keyword| "#{keyword}: " }
+        end
+
+        # Returns static method name.
+        # If code isn't wrong, returns nil
+        def static_method_name(method_name)
+          match = METHOD_PATTERN.match(method_name)
+          return nil unless match
+
+          match[2] ? 'find_by!' : 'find_by'
+        end
+      end
+    end
+  end
+end