rubocop 0.71.0 → 0.75.1

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

@@ -1,91 +0,0 @@
-# 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

@@ -1,161 +0,0 @@
-# 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 |relevant:, deprecated:|
-            next unless node.method_name == deprecated.to_sym
-
-            add_offense(node, location: :selector,
-                              message: format(DEPRECATED_MSG,
-                                              deprecated: deprecated,
-                                              relevant: 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

@@ -1,132 +0,0 @@
-# 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_name == 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

@@ -1,37 +0,0 @@
-# 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

@@ -1,91 +0,0 @@
-# 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://github.com/rubocop-hq/rails-style-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