rubocop 0.70.0 → 0.72.0

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

@@ -1,55 +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
-        include RangeHelp
-
-        MSG = 'Use `find_by` instead of `where.%<method>s`.'
-        TARGET_SELECTORS = %i[first take].freeze
-
-        def_node_matcher :where_first?, <<-PATTERN
-          (send ({send csend} _ :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, method: node.method_name))
-        end
-        alias on_csend on_send
-
-        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,51 +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`.'
-
-        SCOPE_METHODS = %i[
-          all eager_load includes joins left_joins left_outer_joins not preload
-          references unscoped where
-        ].freeze
-        IGNORED_METHODS = %i[order limit select].freeze
-
-        def on_send(node)
-          return unless node.receiver&.send_type? &&
-                        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.each_node(:send).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,25 +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.
-      #
-      # @example
-      #   # bad
-      #   # has_and_belongs_to_many :ingredients
-      #
-      #   # good
-      #   # has_many :ingredients, through: :recipe_ingredients
-      class HasAndBelongsToMany < Cop
-        MSG = 'Prefer `has_many :through` to `has_and_belongs_to_many`.'
-
-        def on_send(node)
-          return unless node.command?(:has_and_belongs_to_many)
-
-          add_offense(node, location: :selector)
-        end
-      end
-    end
-  end
-end

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

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop looks for `has_many` or `has_one` associations that don't
-      # specify a `:dependent` option.
-      # It doesn't register an offense if `:through` option was specified.
-      #
-      # @example
-      #   # bad
-      #   class User < ActiveRecord::Base
-      #     has_many :comments
-      #     has_one :avatar
-      #   end
-      #
-      #   # good
-      #   class User < ActiveRecord::Base
-      #     has_many :comments, dependent: :restrict_with_exception
-      #     has_one :avatar, dependent: :destroy
-      #     has_many :patients, through: :appointments
-      #   end
-      class HasManyOrHasOneDependent < Cop
-        MSG = 'Specify a `:dependent` option.'
-
-        def_node_search :active_resource_class?, <<-PATTERN
-          (const (const nil? :ActiveResource) :Base)
-        PATTERN
-
-        def_node_matcher :association_without_options?, <<-PATTERN
-          (send nil? {:has_many :has_one} _)
-        PATTERN
-
-        def_node_matcher :association_with_options?, <<-PATTERN
-          (send nil? {:has_many :has_one} _ (hash $...))
-        PATTERN
-
-        def_node_matcher :dependent_option?, <<-PATTERN
-          (pair (sym :dependent) !nil)
-        PATTERN
-
-        def_node_matcher :present_option?, <<-PATTERN
-          (pair (sym :through) !nil)
-        PATTERN
-
-        def_node_matcher :with_options_block, <<-PATTERN
-          (block
-            (send nil? :with_options
-              (hash $...))
-            (args) ...)
-        PATTERN
-
-        def on_send(node)
-          return if active_resource?(node.parent)
-
-          unless association_without_options?(node)
-            return if valid_options?(association_with_options?(node))
-          end
-
-          return if valid_options_in_with_options_block?(node)
-
-          add_offense(node, location: :selector)
-        end
-
-        private
-
-        def valid_options_in_with_options_block?(node)
-          return true unless node.parent
-
-          n = node.parent.begin_type? ? node.parent.parent : node.parent
-
-          contain_valid_options_in_with_options_block?(n)
-        end
-
-        def contain_valid_options_in_with_options_block?(node)
-          if with_options_block(node)
-            return true if valid_options?(with_options_block(node))
-
-            return false unless node.parent
-
-            return true if contain_valid_options_in_with_options_block?(
-              node.parent.parent
-            )
-          end
-
-          false
-        end
-
-        def valid_options?(options)
-          return true unless options
-          return true if options.any? do |o|
-            dependent_option?(o) || present_option?(o)
-          end
-
-          false
-        end
-
-        def active_resource?(node)
-          return false if node.nil?
-
-          active_resource_class?(node)
-        end
-      end
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop is used to identify usages of http methods like `get`, `post`,
-      # `put`, `patch` without the usage of keyword arguments in your tests and
-      # change them to use keyword args. This cop only applies to Rails >= 5.
-      # If you are running Rails < 5 you should disable the
-      # Rails/HttpPositionalArguments cop or set your TargetRailsVersion in your
-      # .rubocop.yml file to 4.0, etc.
-      #
-      # @example
-      #   # bad
-      #   get :new, { user_id: 1}
-      #
-      #   # good
-      #   get :new, params: { user_id: 1 }
-      class HttpPositionalArguments < Cop
-        extend TargetRailsVersion
-
-        MSG = 'Use keyword arguments instead of ' \
-              'positional arguments for http call: `%<verb>s`.'
-        KEYWORD_ARGS = %i[
-          method params session body flash xhr as headers env
-        ].freeze
-        HTTP_METHODS = %i[get post put patch delete head].freeze
-
-        minimum_target_rails_version 5.0
-
-        def_node_matcher :http_request?, <<-PATTERN
-          (send nil? {#{HTTP_METHODS.map(&:inspect).join(' ')}} !nil? $_ ...)
-        PATTERN
-
-        def on_send(node)
-          http_request?(node) do |data|
-            return unless needs_conversion?(data)
-
-            add_offense(node, location: :selector,
-                              message: format(MSG, verb: node.method_name))
-          end
-        end
-
-        # given a pre Rails 5 method: get :new, {user_id: @user.id}, {}
-        #
-        # @return lambda of auto correct procedure
-        # the result should look like:
-        #     get :new, params: { user_id: @user.id }, session: {}
-        # the http_method is the method used to call the controller
-        # the controller node can be a symbol, method, object or string
-        # that represents the path/action on the Rails controller
-        # the data is the http parameters and environment sent in
-        # the Rails 5 http call
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, correction(node))
-          end
-        end
-
-        private
-
-        def needs_conversion?(data)
-          return true unless data.hash_type?
-
-          data.each_pair.none? do |pair|
-            special_keyword_arg?(pair.key) ||
-              format_arg?(pair.key) && data.pairs.one?
-          end
-        end
-
-        def special_keyword_arg?(node)
-          node.sym_type? && KEYWORD_ARGS.include?(node.value)
-        end
-
-        def format_arg?(node)
-          node.sym_type? && node.value == :format
-        end
-
-        def convert_hash_data(data, type)
-          return '' if data.hash_type? && data.empty?
-
-          hash_data = if data.hash_type?
-                        format('{ %<data>s }',
-                               data: data.pairs.map(&:source).join(', '))
-                      else
-                        # user supplies an object,
-                        # no need to surround with braces
-                        data.source
-                      end
-
-          format(', %<type>s: %<hash_data>s', type: type, hash_data: hash_data)
-        end
-
-        def correction(node)
-          http_path, *data = *node.arguments
-
-          controller_action = http_path.source
-          params = convert_hash_data(data.first, 'params')
-          session = convert_hash_data(data.last, 'session') if data.size > 1
-
-          format(correction_template(node), name: node.method_name,
-                                            action: controller_action,
-                                            params: params,
-                                            session: session)
-        end
-
-        def correction_template(node)
-          if parentheses?(node)
-            '%<name>s(%<action>s%<params>s%<session>s)'
-          else
-            '%<name>s %<action>s%<params>s%<session>s'
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,179 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces use of symbolic or numeric value to define HTTP status.
-      #
-      # @example EnforcedStyle: symbolic (default)
-      #   # bad
-      #   render :foo, status: 200
-      #   render json: { foo: 'bar' }, status: 200
-      #   render plain: 'foo/bar', status: 304
-      #   redirect_to root_url, status: 301
-      #
-      #   # good
-      #   render :foo, status: :ok
-      #   render json: { foo: 'bar' }, status: :ok
-      #   render plain: 'foo/bar', status: :not_modified
-      #   redirect_to root_url, status: :moved_permanently
-      #
-      # @example EnforcedStyle: numeric
-      #   # bad
-      #   render :foo, status: :ok
-      #   render json: { foo: 'bar' }, status: :not_found
-      #   render plain: 'foo/bar', status: :not_modified
-      #   redirect_to root_url, status: :moved_permanently
-      #
-      #   # good
-      #   render :foo, status: 200
-      #   render json: { foo: 'bar' }, status: 404
-      #   render plain: 'foo/bar', status: 304
-      #   redirect_to root_url, status: 301
-      #
-      class HttpStatus < Cop
-        begin
-          require 'rack/utils'
-          RACK_LOADED = true
-        rescue LoadError
-          RACK_LOADED = false
-        end
-
-        include ConfigurableEnforcedStyle
-
-        def_node_matcher :http_status, <<-PATTERN
-          {
-            (send nil? {:render :redirect_to} _ $hash)
-            (send nil? {:render :redirect_to} $hash)
-          }
-        PATTERN
-
-        def_node_matcher :status_code, <<-PATTERN
-          (hash <(pair (sym :status) ${int sym}) ...>)
-        PATTERN
-
-        def on_send(node)
-          http_status(node) do |hash_node|
-            status = status_code(hash_node)
-            return unless status
-
-            checker = checker_class.new(status)
-            return unless checker.offensive?
-
-            add_offense(checker.node, message: checker.message)
-          end
-        end
-
-        def support_autocorrect?
-          RACK_LOADED
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            checker = checker_class.new(node)
-            corrector.replace(node.loc.expression, checker.preferred_style)
-          end
-        end
-
-        private
-
-        def checker_class
-          case style
-          when :symbolic
-            SymbolicStyleChecker
-          when :numeric
-            NumericStyleChecker
-          end
-        end
-
-        # :nodoc:
-        class SymbolicStyleChecker
-          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                'to define HTTP status code.'
-          DEFAULT_MSG = 'Prefer `symbolic` over `numeric` ' \
-                        'to define HTTP status code.'
-
-          attr_reader :node
-          def initialize(node)
-            @node = node
-          end
-
-          def offensive?
-            !node.sym_type? && !custom_http_status_code?
-          end
-
-          def message
-            if RACK_LOADED
-              format(MSG, prefer: preferred_style, current: number.to_s)
-            else
-              DEFAULT_MSG
-            end
-          end
-
-          def preferred_style
-            symbol.inspect
-          end
-
-          private
-
-          def symbol
-            ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number)
-          end
-
-          def number
-            node.children.first
-          end
-
-          def custom_http_status_code?
-            node.int_type? &&
-              !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(number)
-          end
-        end
-
-        # :nodoc:
-        class NumericStyleChecker
-          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                'to define HTTP status code.'
-          DEFAULT_MSG = 'Prefer `numeric` over `symbolic` ' \
-                        'to define HTTP status code.'
-          PERMITTED_STATUS = %i[error success missing redirect].freeze
-
-          attr_reader :node
-          def initialize(node)
-            @node = node
-          end
-
-          def offensive?
-            !node.int_type? && !permitted_symbol?
-          end
-
-          def message
-            if RACK_LOADED
-              format(MSG, prefer: preferred_style, current: symbol.inspect)
-            else
-              DEFAULT_MSG
-            end
-          end
-
-          def preferred_style
-            number.to_s
-          end
-
-          private
-
-          def number
-            ::Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol]
-          end
-
-          def symbol
-            node.value
-          end
-
-          def permitted_symbol?
-            node.sym_type? && PERMITTED_STATUS.include?(node.value)
-          end
-        end
-      end
-    end
-  end
-end