rubocop 0.51.0 → 0.87.0

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

@@ -1,128 +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, 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, location: :selector,
-                            message: 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, location: :selector,
-                            message: 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:]+|\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
-          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

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

@@ -1,135 +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
-      #
-      #   # EnforceForPrefixed: true
-      #   # bad
-      #   def foo_bar
-      #     foo.bar
-      #   end
-      #
-      #   # good
-      #   delegate :bar, to: :foo, prefix: true
-      #
-      #   # 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.'.freeze
-
-        def on_def(node)
-          method_name, args, body = *node
-          return unless trivial_delegate?(method_name, args, body)
-          return if private_or_protected_delegation(node)
-          add_offense(node, location: :keyword)
-        end
-
-        private
-
-        def autocorrect(node)
-          method_name, _args, body = *node
-          delegation = ["delegate :#{body.children[1]}",
-                        "to: :#{body.children[0].children[1]}"]
-          if method_name == prefixed_method_name(body)
-            delegation << ['prefix: true']
-          end
-
-          lambda do |corrector|
-            corrector.replace(node.source_range, delegation.join(', '))
-          end
-        end
-
-        def trivial_delegate?(method_name, args, body)
-          body && delegate?(body) && !body.csend_type? &&
-            method_name_matches?(method_name, body) &&
-            arguments_match?(args, body)
-        end
-
-        def delegate?(body)
-          receiver, = *body
-          receiver.respond_to?(:type) && receiver.send_type? &&
-            receiver.child_nodes.empty?
-        end
-
-        def arguments_match?(args, body)
-          _receiver, _method_name, *arguments = *body
-          arg_array = Array(args)
-          argument_array = Array(arguments)
-          arg_array.size == argument_array.size && (
-            arg_array == argument_array ||
-            arg_array.map(&:children) == argument_array.map(&:children)
-          )
-        end
-
-        def method_name_matches?(method_name, body)
-          _receiver, property_name, *_args = *body
-          method_name == property_name ||
-            (include_prefix_case? &&
-              method_name == prefixed_method_name(body))
-        end
-
-        def include_prefix_case?
-          cop_config['EnforceForPrefixed']
-        end
-
-        def prefixed_method_name(body)
-          receiver, property_name, *_args = *body
-          _receiver, target, *_args = *receiver
-          [target, property_name].join('_').to_sym
-        end
-
-        def private_or_protected_delegation(node)
-          line = node.loc.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,51 +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`.'.freeze
-
-        def_node_matcher :delegate_options, <<-PATTERN
-          (send nil? :delegate _ $hash)
-        PATTERN
-
-        def_node_matcher :allow_blank_option?, <<-PATTERN
-          (pair (sym :allow_blank) true)
-        PATTERN
-
-        def on_send(node)
-          offending_node = allow_blank_option(node)
-
-          return unless offending_node
-
-          add_offense(offending_node)
-        end
-
-        private
-
-        def autocorrect(pair_node)
-          lambda do |corrector|
-            corrector.replace(pair_node.key.source_range, 'allow_nil')
-          end
-        end
-
-        def allow_blank_option(node)
-          delegate_options(node) do |hash|
-            hash.pairs.find { |opt| allow_blank_option?(opt) }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,81 +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/bbatsov/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 `%s` instead of dynamic `%s`.'.freeze
-        METHOD_PATTERN = /^find_by_(.+?)(!)?$/
-
-        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, node.method_name))
-        end
-
-        def autocorrect(node)
-          _receiver, method, *args = *node
-          static_name = static_method_name(method.to_s)
-          keywords = column_keywords(method)
-
-          return if keywords.size != args.size
-
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, static_name)
-            keywords.each.with_index do |keyword, idx|
-              corrector.insert_before(args[idx].loc.expression, keyword)
-            end
-          end
-        end
-
-        private
-
-        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

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

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop looks for duplicate values in enum declarations.
-      #
-      # @example
-      #   # bad
-      #   enum status: { active: 0, archived: 0 }
-      #
-      #   # good
-      #   enum status: { active: 0, archived: 1 }
-      #
-      #   # bad
-      #   enum status: [:active, :archived, :active]
-      #
-      #   # good
-      #   enum status: [:active, :archived]
-      class EnumUniqueness < Cop
-        include Duplication
-
-        MSG = 'Duplicate value `%s` found in `%s` enum declaration.'.freeze
-
-        def_node_matcher :enum_declaration, <<-PATTERN
-          (send nil? :enum (hash (pair (_ $_) ${array hash})))
-        PATTERN
-
-        def on_send(node)
-          enum_declaration(node) do |name, args|
-            items = args.values
-
-            return unless duplicates?(items)
-
-            consecutive_duplicates(items).each do |item|
-              add_offense(item, message: format(MSG, item.source, name))
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop enforces that 'exit' calls are not used within a rails app.
-      # Valid options are instead to raise an error, break, return or some
-      # other form of stopping execution of current request.
-      #
-      # There are two obvious cases where 'exit' is particularly harmful:
-      #
-      # - Usage in library code for your application. Even though rails will
-      # rescue from a SystemExit and continue on, unit testing that library
-      # code will result in specs exiting (potentially silently if exit(0)
-      # is used.)
-      # - Usage in application code outside of the web process could result in
-      # the program exiting, which could result in the code failing to run and
-      # do its job.
-      class Exit < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Do not use `exit` in Rails applications.'.freeze
-        TARGET_METHODS = %i[exit exit!].freeze
-        EXPLICIT_RECEIVERS = %i[Kernel Process].freeze
-
-        def on_send(node)
-          add_offense(node, location: :selector) if offending_node?(node)
-        end
-
-        private
-
-        def offending_node?(node)
-          right_method_name?(node.method_name) &&
-            right_argument_count?(node.arguments) &&
-            right_receiver?(node.receiver)
-        end
-
-        def right_method_name?(method_name)
-          TARGET_METHODS.include?(method_name)
-        end
-
-        # More than 1 argument likely means it is a different
-        # `exit` implementation than the one we are preventing.
-        def right_argument_count?(arg_nodes)
-          arg_nodes.size <= 1
-        end
-
-        # Only register if exit is being called explicitly on
-        # Kernel or Process or if receiver node is nil for plain
-        # `exit` calls.
-        def right_receiver?(receiver_node)
-          return true unless receiver_node
-
-          _a, receiver_node_class, _c = *receiver_node
-
-          EXPLICIT_RECEIVERS.include?(receiver_node_class)
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop is used to identify usages of file path joining process
-      # to use `Rails.root.join` clause.
-      #
-      # @example
-      #  # bad
-      #  Rails.root.join('app/models/goober')
-      #  File.join(Rails.root, 'app/models/goober')
-      #  "#{Rails.root}/app/models/goober"
-      #
-      #  # good
-      #  Rails.root.join('app', 'models', 'goober')
-      class FilePath < Cop
-        MSG = 'Please use `Rails.root.join(\'path\', \'to\')` instead.'.freeze
-
-        def_node_matcher :file_join_nodes?, <<-PATTERN
-          (send (const nil? :File) :join ...)
-        PATTERN
-
-        def_node_search :rails_root_nodes?, <<-PATTERN
-          (send (const nil? :Rails) :root)
-        PATTERN
-
-        def_node_matcher :rails_root_join_nodes?, <<-PATTERN
-          (send (send (const nil? :Rails) :root) :join ...)
-        PATTERN
-
-        def on_dstr(node)
-          return unless rails_root_nodes?(node)
-          register_offense(node)
-        end
-
-        def on_send(node)
-          check_for_file_join_with_rails_root(node)
-          check_for_rails_root_join_with_slash_separated_path(node)
-        end
-
-        private
-
-        def check_for_file_join_with_rails_root(node)
-          return unless file_join_nodes?(node)
-          return unless node.arguments.any? { |e| rails_root_nodes?(e) }
-
-          register_offense(node)
-        end
-
-        def check_for_rails_root_join_with_slash_separated_path(node)
-          return unless rails_root_nodes?(node)
-          return unless rails_root_join_nodes?(node)
-          return unless node.arguments.any? { |arg| string_with_slash?(arg) }
-
-          register_offense(node)
-        end
-
-        def string_with_slash?(node)
-          node.str_type? && node.source =~ %r{/}
-        end
-
-        def register_offense(node)
-          line_range = node.loc.column...node.loc.last_column
-          source_range = source_range(processed_source.buffer, node.loc.line,
-                                      line_range)
-          add_offense(node, location: source_range)
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop is used to identify usages of `where.first` and
-      # change them to use `find_by` instead.
-      #
-      # @example
-      #   # bad
-      #   User.where(name: 'Bruce').first
-      #   User.where(name: 'Bruce').take
-      #
-      #   # good
-      #   User.find_by(name: 'Bruce')
-      class FindBy < Cop
-        MSG = 'Use `find_by` instead of `where.%s`.'.freeze
-        TARGET_SELECTORS = %i[first take].freeze
-
-        def_node_matcher :where_first?, <<-PATTERN
-          (send (send _ :where ...) {:first :take})
-        PATTERN
-
-        def on_send(node)
-          return unless where_first?(node)
-
-          range = range_between(node.receiver.loc.selector.begin_pos,
-                                node.loc.selector.end_pos)
-
-          add_offense(node, location: range,
-                            message: format(MSG, node.method_name))
-        end
-
-        def autocorrect(node)
-          # Don't autocorrect where(...).first, because it can return different
-          # results from find_by. (They order records differently, so the
-          # 'first' record can be different.)
-          return if node.method?(:first)
-
-          where_loc = node.receiver.loc.selector
-          first_loc = range_between(node.loc.dot.begin_pos,
-                                    node.loc.selector.end_pos)
-
-          lambda do |corrector|
-            corrector.replace(where_loc, 'find_by')
-            corrector.replace(first_loc, '')
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop is used to identify usages of `all.each` and
-      # change them to use `all.find_each` instead.
-      #
-      # @example
-      #   # bad
-      #   User.all.each
-      #
-      #   # good
-      #   User.all.find_each
-      class FindEach < Cop
-        MSG = 'Use `find_each` instead of `each`.'.freeze
-
-        SCOPE_METHODS = %i[all where not].freeze
-        IGNORED_METHODS = %i[order limit select].freeze
-
-        def on_send(node)
-          return unless node.receiver && node.method?(:each)
-
-          return unless SCOPE_METHODS.include?(node.receiver.method_name)
-          return if method_chain(node).any? { |m| ignored_by_find_each?(m) }
-
-          add_offense(node, location: :selector)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'find_each') }
-        end
-
-        private
-
-        def method_chain(node)
-          [*node.ancestors, node].map(&:method_name)
-        end
-
-        def ignored_by_find_each?(relation_method)
-          # Active Record's #find_each ignores various extra parameters
-          IGNORED_METHODS.include?(relation_method)
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for the use of the has_and_belongs_to_many macro.
-      class HasAndBelongsToMany < Cop
-        MSG = 'Prefer `has_many :through` to `has_and_belongs_to_many`.'.freeze
-
-        def on_send(node)
-          return unless node.command?(:has_and_belongs_to_many)
-
-          add_offense(node, location: :selector)
-        end
-      end
-    end
-  end
-end