rubocop 0.51.0 → 0.87.0

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

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks whether constant value isn't relative date.
-      # Because the relative date will be evaluated only once.
-      #
-      # @example
-      #   # bad
-      #   class SomeClass
-      #     EXPIRED_AT = 1.week.since
-      #   end
-      #
-      #   # good
-      #   class SomeClass
-      #     def self.expired_at
-      #       1.week.since
-      #     end
-      #   end
-      class RelativeDateConstant < Cop
-        MSG = 'Do not assign %s to constants as it will be evaluated only ' \
-              'once.'.freeze
-
-        RELATIVE_DATE_METHODS = %i[ago from_now since until].freeze
-
-        def on_casgn(node)
-          _scope, _constant, rhs = *node
-
-          # rhs would be nil in a or_asgn node
-          return unless rhs
-
-          check_node(rhs)
-        end
-
-        def on_masgn(node)
-          lhs, rhs = *node
-
-          return unless rhs && rhs.array_type?
-
-          lhs.children.zip(rhs.children).each do |(name, value)|
-            check_node(value) if name.casgn_type?
-          end
-        end
-
-        def on_or_asgn(node)
-          lhs, rhs = *node
-
-          return unless lhs.casgn_type?
-
-          check_node(rhs)
-        end
-
-        private
-
-        def check_node(node)
-          return unless node.irange_type? ||
-                        node.erange_type? ||
-                        node.send_type?
-
-          # for range nodes we need to check both their boundaries
-          nodes = node.send_type? ? [node] : node.children
-
-          nodes.each do |n|
-            if relative_date_method?(n)
-              add_offense(node.parent, message: format(MSG, n.method_name))
-            end
-          end
-        end
-
-        def relative_date_method?(node)
-          node.send_type? &&
-            RELATIVE_DATE_METHODS.include?(node.method_name) &&
-            !node.arguments?
-        end
-
-        def autocorrect(node)
-          _scope, const_name, value = *node
-          indent = ' ' * node.loc.column
-          new_code = ["def self.#{const_name.downcase}",
-                      "#{indent}#{value.source}",
-                      'end'].join("\n#{indent}")
-          ->(corrector) { corrector.replace(node.source_range, new_code) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for consistent uses of `request.referer` or
-      # `request.referrer`, depending on the cop's configuration.
-      #
-      # @example
-      #   # EnforcedStyle: referer
-      #   # bad
-      #   request.referrer
-      #
-      #   # good
-      #   request.referer
-      #
-      #   # EnforcedStyle: referrer
-      #   # bad
-      #   request.referer
-      #
-      #   # good
-      #   request.referrer
-      class RequestReferer < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Use `request.%s` instead of `request.%s`.'.freeze
-
-        def_node_matcher :referer?, <<-PATTERN
-          (send (send nil? :request) {:referer :referrer})
-        PATTERN
-
-        def on_send(node)
-          referer?(node) do
-            return unless node.method?(wrong_method_name)
-
-            add_offense(node.source_range, location: node.source_range)
-          end
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node, "request.#{style}") }
-        end
-
-        private
-
-        def message(_node)
-          format(MSG, style, wrong_method_name)
-        end
-
-        def wrong_method_name
-          style == :referer ? :referrer : :referer
-        end
-      end
-    end
-  end
-end

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

@@ -1,282 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks whether the change method of the migration file is
-      # reversible.
-      #
-      # @example
-      #   # bad
-      #   def change
-      #     change_table :users do |t|
-      #       t.remove :name
-      #     end
-      #   end
-      #
-      #   # good
-      #   def change
-      #     create_table :users do |t|
-      #       t.string :name
-      #     end
-      #   end
-      #
-      #   # good
-      #   def change
-      #     reversible do |dir|
-      #       change_table :users do |t|
-      #         dir.up do
-      #           t.column :name, :string
-      #         end
-      #
-      #         dir.down do
-      #           t.remove :name
-      #         end
-      #       end
-      #     end
-      #   end
-      #
-      # @example
-      #   # drop_table
-      #
-      #   # bad
-      #   def change
-      #     drop_table :users
-      #   end
-      #
-      #   # good
-      #   def change
-      #     drop_table :users do |t|
-      #       t.string :name
-      #     end
-      #   end
-      #
-      # @example
-      #   # change_column_default
-      #
-      #   # bad
-      #   def change
-      #     change_column_default(:suppliers, :qualification, 'new')
-      #   end
-      #
-      #   # good
-      #   def change
-      #     change_column_default(:posts, :state, from: nil, to: "draft")
-      #   end
-      #
-      # @example
-      #   # remove_column
-      #
-      #   # bad
-      #   def change
-      #     remove_column(:suppliers, :qualification)
-      #   end
-      #
-      #   # good
-      #   def change
-      #     remove_column(:suppliers, :qualification, :string)
-      #   end
-      #
-      # @example
-      #   # remove_foreign_key
-      #
-      #   # bad
-      #   def change
-      #     remove_foreign_key :accounts, column: :owner_id
-      #   end
-      #
-      #   # good
-      #   def change
-      #     remove_foreign_key :accounts, :branches
-      #   end
-      #
-      # @example
-      #   # change_table
-      #
-      #   # bad
-      #   def change
-      #     change_table :users do |t|
-      #       t.remove :name
-      #       t.change_default :authorized, 1
-      #       t.change :price, :string
-      #     end
-      #   end
-      #
-      #   # good
-      #   def change
-      #     change_table :users do |t|
-      #       t.string :name
-      #     end
-      #   end
-      #
-      #   # good
-      #   def change
-      #     reversible do |dir|
-      #       change_table :users do |t|
-      #         dir.up do
-      #           t.change :price, :string
-      #         end
-      #
-      #         dir.down do
-      #           t.change :price, :integer
-      #         end
-      #       end
-      #     end
-      #   end
-      #
-      # @see http://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html
-      class ReversibleMigration < Cop
-        MSG = '%s is not reversible.'.freeze
-        IRREVERSIBLE_CHANGE_TABLE_CALLS = %i[
-          change change_default remove
-        ].freeze
-
-        def_node_matcher :irreversible_schema_statement_call, <<-PATTERN
-          (send nil? ${:change_table_comment :execute :remove_belongs_to} ...)
-        PATTERN
-
-        def_node_matcher :drop_table_call, <<-PATTERN
-          (send nil? :drop_table ...)
-        PATTERN
-
-        def_node_matcher :change_column_default_call, <<-PATTERN
-          (send nil? :change_column_default _ _ $...)
-        PATTERN
-
-        def_node_matcher :remove_column_call, <<-PATTERN
-          (send nil? :remove_column $...)
-        PATTERN
-
-        def_node_matcher :remove_foreign_key_call, <<-PATTERN
-          (send nil? :remove_foreign_key _ $_)
-        PATTERN
-
-        def_node_matcher :change_table_call, <<-PATTERN
-          (send nil? :change_table $_ ...)
-        PATTERN
-
-        def on_send(node)
-          return unless within_change_method?(node)
-          return if within_reversible_block?(node)
-
-          check_irreversible_schema_statement_node(node)
-          check_drop_table_node(node)
-          check_change_column_default_node(node)
-          check_remove_column_node(node)
-          check_remove_foreign_key_node(node)
-        end
-
-        def on_block(node)
-          return unless within_change_method?(node)
-          return if within_reversible_block?(node)
-
-          check_change_table_node(node.send_node, node.body)
-        end
-
-        private
-
-        def check_irreversible_schema_statement_node(node)
-          irreversible_schema_statement_call(node) do |method_name|
-            add_offense(node, message: format(MSG, method_name))
-          end
-        end
-
-        def check_drop_table_node(node)
-          drop_table_call(node) do
-            unless node.parent.block_type?
-              add_offense(
-                node,
-                message: format(MSG, 'drop_table(without block)')
-              )
-            end
-          end
-        end
-
-        def check_change_column_default_node(node)
-          change_column_default_call(node) do |args|
-            unless all_hash_key?(args.first, :from, :to)
-              add_offense(
-                node,
-                message: format(
-                  MSG, 'change_column_default(without :from and :to)'
-                )
-              )
-            end
-          end
-        end
-
-        def check_remove_column_node(node)
-          remove_column_call(node) do |args|
-            if args.to_a.size < 3
-              add_offense(
-                node,
-                message: format(MSG, 'remove_column(without type)')
-              )
-            end
-          end
-        end
-
-        def check_remove_foreign_key_node(node)
-          remove_foreign_key_call(node) do |arg|
-            if arg.hash_type?
-              add_offense(
-                node,
-                message: format(MSG, 'remove_foreign_key(without table)')
-              )
-            end
-          end
-        end
-
-        def check_change_table_node(node, block)
-          change_table_call(node) do |arg|
-            if target_rails_version < 4.0
-              add_offense(
-                node,
-                message: format(MSG, 'change_table')
-              )
-            elsif block.send_type?
-              check_change_table_offense(arg, block)
-            else
-              block.each_child_node do |child_node|
-                check_change_table_offense(arg, child_node)
-              end
-            end
-          end
-        end
-
-        def check_change_table_offense(receiver, node)
-          method_name = node.method_name
-          return if receiver != node.receiver &&
-                    !IRREVERSIBLE_CHANGE_TABLE_CALLS.include?(method_name)
-          add_offense(
-            node,
-            message: format(MSG, "change_table(with #{method_name})")
-          )
-        end
-
-        def within_change_method?(node)
-          node.each_ancestor(:def).any? do |ancestor|
-            method_name, = *ancestor
-            method_name == :change
-          end
-        end
-
-        def within_reversible_block?(node)
-          node.each_ancestor(:block).any? do |ancestor|
-            ancestor.block_type? && ancestor.send_node.method?(:reversible)
-          end
-        end
-
-        def all_hash_key?(args, *keys)
-          return false unless args && args.hash_type?
-
-          hash_keys = args.to_a.map do |arg|
-            arg.to_a.first.children.first.to_sym
-          end
-
-          hash_keys & keys == keys
-        end
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop converts usages of `try!` to `&.`. It can also be configured
-      # to convert `try`. It will convert code to use safe navigation if the
-      # target Ruby version is set to 2.3+
-      #
-      # @example
-      #   # ConvertTry: false
-      #     # bad
-      #     foo.try!(:bar)
-      #     foo.try!(:bar, baz)
-      #     foo.try!(:bar) { |e| e.baz }
-      #
-      #     foo.try!(:[], 0)
-      #
-      #     # good
-      #     foo.try(:bar)
-      #     foo.try(:bar, baz)
-      #     foo.try(:bar) { |e| e.baz }
-      #
-      #     foo&.bar
-      #     foo&.bar(baz)
-      #     foo&.bar { |e| e.baz }
-      #
-      #
-      #   # ConvertTry: true
-      #     # bad
-      #     foo.try!(:bar)
-      #     foo.try!(:bar, baz)
-      #     foo.try!(:bar) { |e| e.baz }
-      #     foo.try(:bar)
-      #     foo.try(:bar, baz)
-      #     foo.try(:bar) { |e| e.baz }
-      #
-      #     # good
-      #     foo&.bar
-      #     foo&.bar(baz)
-      #     foo&.bar { |e| e.baz }
-      class SafeNavigation < Cop
-        extend TargetRubyVersion
-
-        MSG = 'Use safe navigation (`&.`) instead of `%s`.'.freeze
-
-        def_node_matcher :try_call, <<-PATTERN
-          (send !nil? ${:try :try!} $_ ...)
-        PATTERN
-
-        minimum_target_ruby_version 2.3
-
-        def on_send(node)
-          try_call(node) do |try_method, method_to_try|
-            return if try_method == :try && !cop_config['ConvertTry']
-            return unless method_to_try.sym_type?
-            method, = *method_to_try
-            return unless method =~ /\w+[=!?]?/
-            add_offense(node, message: format(MSG, try_method))
-          end
-        end
-
-        private
-
-        def autocorrect(node)
-          method_node, *params = *node.arguments
-          method = method_node.source[1..-1]
-
-          range = range_between(node.loc.dot.begin_pos,
-                                node.loc.expression.end_pos)
-
-          lambda do |corrector|
-            corrector.replace(range, replacement(method, params))
-          end
-        end
-
-        def replacement(method, params)
-          new_params = params.map(&:source).join(', ')
-
-          if method.end_with?('=')
-            "&.#{method[0...-1]} = #{new_params}"
-          elsif params.empty?
-            "&.#{method}"
-          else
-            "&.#{method}(#{new_params})"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop identifies possible cases where Active Record save! or related
-      # should be used instead of save because the model might have failed to
-      # save and an exception is better than unhandled failure.
-      #
-      # This will ignore calls that return a boolean for success if the result
-      # is assigned to a variable or used as the condition in an if/unless
-      # statement.  It will also ignore calls that return a model assigned to a
-      # variable that has a call to `persisted?`. Finally, it will ignore any
-      # call with more than 2 arguments as that is likely not an Active Record
-      # call or a Model.update(id, attributes) call.
-      #
-      # @example
-      #
-      #   # bad
-      #   user.save
-      #   user.update(name: 'Joe')
-      #   user.find_or_create_by(name: 'Joe')
-      #   user.destroy
-      #
-      #   # good
-      #   unless user.save
-      #      . . .
-      #   end
-      #   user.save!
-      #   user.update!(name: 'Joe')
-      #   user.find_or_create_by!(name: 'Joe')
-      #   user.destroy!
-      #
-      #   user = User.find_or_create_by(name: 'Joe')
-      #   unless user.persisted?
-      #      . . .
-      #   end
-      class SaveBang < Cop
-        MSG = 'Use `%s` instead of `%s` if the return value is not checked.'
-              .freeze
-        CREATE_MSG = (MSG +
-                      ' Or check `persisted?` on model returned from `%s`.')
-                     .freeze
-        CREATE_CONDITIONAL_MSG = '`%s` returns a model which is always truthy.'
-                                 .freeze
-
-        CREATE_PERSIST_METHODS = %i[create
-                                    first_or_create find_or_create_by].freeze
-        MODIFY_PERSIST_METHODS = %i[save
-                                    update update_attributes destroy].freeze
-        PERSIST_METHODS = (CREATE_PERSIST_METHODS +
-                           MODIFY_PERSIST_METHODS).freeze
-
-        def join_force?(force_class)
-          force_class == VariableForce
-        end
-
-        def after_leaving_scope(scope, _variable_table)
-          scope.variables.each_value do |variable|
-            variable.assignments.each do |assignment|
-              check_assignment(assignment)
-            end
-          end
-        end
-
-        def check_assignment(assignment)
-          node = right_assignment_node(assignment)
-          return unless node
-          return unless CREATE_PERSIST_METHODS.include?(node.method_name)
-          return unless expected_signature?(node)
-          return if persisted_referenced?(assignment)
-
-          add_offense(node, location: :selector,
-                            message: format(CREATE_MSG,
-                                            "#{node.method_name}!",
-                                            node.method_name.to_s,
-                                            node.method_name.to_s))
-        end
-
-        def on_send(node)
-          return unless PERSIST_METHODS.include?(node.method_name)
-          return unless expected_signature?(node)
-          return if return_value_assigned?(node)
-          return if check_used_in_conditional(node)
-          return if last_call_of_method?(node)
-
-          add_offense(node, location: :selector,
-                            message: format(MSG,
-                                            "#{node.method_name}!",
-                                            node.method_name.to_s))
-        end
-
-        def autocorrect(node)
-          save_loc = node.loc.selector
-          new_method = "#{node.method_name}!"
-
-          ->(corrector) { corrector.replace(save_loc, new_method) }
-        end
-
-        private
-
-        def right_assignment_node(assignment)
-          node = assignment.node.child_nodes.first
-          return node unless node && node.block_type?
-          node.child_nodes.first
-        end
-
-        def persisted_referenced?(assignment)
-          return unless assignment.referenced?
-
-          assignment.variable.references.any? do |reference|
-            call_to_persisted?(reference.node.parent)
-          end
-        end
-
-        def call_to_persisted?(node)
-          node.send_type? && node.method?(:persisted?)
-        end
-
-        def check_used_in_conditional(node)
-          return false unless conditional?(node)
-
-          unless MODIFY_PERSIST_METHODS.include?(node.method_name)
-            add_offense(node, location: :selector,
-                              message: format(CREATE_CONDITIONAL_MSG,
-                                              node.method_name.to_s))
-          end
-
-          true
-        end
-
-        def conditional?(node)
-          node.parent && (
-            node.parent.if_type? || node.parent.case_type? ||
-            node.parent.or_type? || node.parent.and_type?
-          )
-        end
-
-        def last_call_of_method?(node)
-          node.parent && node.parent.children.size == node.sibling_index + 1
-        end
-
-        # Ignore simple assignment or if condition
-        def return_value_assigned?(node)
-          return false unless node.parent
-          node.parent.lvasgn_type? ||
-            (node.parent.block_type? && node.parent.parent &&
-              node.parent.parent.lvasgn_type?)
-        end
-
-        # Check argument signature as no arguments or one hash
-        def expected_signature?(node)
-          !node.arguments? ||
-            (node.arguments.one? &&
-              node.method_name != :destroy &&
-              (node.first_argument.hash_type? ||
-              !node.first_argument.literal?))
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for scope calls where it was passed
-      # a method (usually a scope) instead of a lambda/proc.
-      #
-      # @example
-      #
-      #   # bad
-      #   scope :something, where(something: true)
-      #
-      #   # good
-      #   scope :something, -> { where(something: true) }
-      class ScopeArgs < Cop
-        MSG = 'Use `lambda`/`proc` instead of a plain method call.'.freeze
-
-        def_node_matcher :scope?, '(send nil? :scope _ $send)'
-
-        def on_send(node)
-          scope?(node) do |second_arg|
-            add_offense(second_arg)
-          end
-        end
-      end
-    end
-  end
-end