rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for redundant receiver in `with_options`.
+      # Receiver is implicit from Rails 4.2 or higher.
+      #
+      # @example
+      #   # bad
+      #   class Account < ApplicationRecord
+      #     with_options dependent: :destroy do |assoc|
+      #       assoc.has_many :customers
+      #       assoc.has_many :products
+      #       assoc.has_many :invoices
+      #       assoc.has_many :expenses
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Account < ApplicationRecord
+      #     with_options dependent: :destroy do
+      #       has_many :customers
+      #       has_many :products
+      #       has_many :invoices
+      #       has_many :expenses
+      #     end
+      #   end
+      #
+      # @example
+      #   # bad
+      #   with_options options: false do |merger|
+      #     merger.invoke(merger.something)
+      #   end
+      #
+      #   # good
+      #   with_options options: false do
+      #     invoke(something)
+      #   end
+      #
+      #   # good
+      #   client = Client.new
+      #   with_options options: false do |merger|
+      #     client.invoke(merger.something, something)
+      #   end
+      #
+      #   # ok
+      #   # When `with_options` includes a block, all scoping scenarios
+      #   # cannot be evaluated. Thus, it is ok to include the explicit
+      #   # receiver.
+      #   with_options options: false do |merger|
+      #     merger.invoke
+      #     with_another_method do |another_receiver|
+      #       merger.invoke(another_receiver)
+      #     end
+      #   end
+      class RedundantReceiverInWithOptions < Cop
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 4.2
+
+        MSG = 'Redundant receiver in `with_options`.'.freeze
+
+        def_node_matcher :with_options?, <<-PATTERN
+          (block
+            (send nil? :with_options
+              (...))
+            (args
+              $_arg)
+            $_body)
+        PATTERN
+
+        def_node_search :all_block_nodes_in, <<-PATTERN
+          (block ...)
+        PATTERN
+
+        def_node_search :all_send_nodes_in, <<-PATTERN
+          (send ...)
+        PATTERN
+
+        def on_block(node)
+          with_options?(node) do |arg, body|
+            return unless all_block_nodes_in(body).count.zero?
+            send_nodes = all_send_nodes_in(body)
+
+            if send_nodes.all? { |n| same_value?(arg, n.receiver) }
+              send_nodes.each do |send_node|
+                receiver = send_node.receiver
+                add_offense(send_node, location: receiver.source_range)
+              end
+            end
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.receiver.source_range)
+            corrector.remove(node.loc.dot)
+            corrector.remove(block_argument_range(node))
+          end
+        end
+
+        private
+
+        def block_argument_range(node)
+          block_node = node.each_ancestor(:block).first
+          block_argument = block_node.children[1].source_range
+
+          range_between(
+            search_begin_pos_of_space_before_block_argument(
+              block_argument.begin_pos
+            ),
+            block_argument.end_pos
+          )
+        end
+
+        def search_begin_pos_of_space_before_block_argument(begin_pos)
+          position = begin_pos - 1
+
+          if processed_source.raw_source[position] == ' '
+            search_begin_pos_of_space_before_block_argument(position)
+          else
+            begin_pos
+          end
+        end
+
+        def same_value?(arg_node, recv_node)
+          recv_node && recv_node.children[0] == arg_node.children[0]
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -1,17 +1,38 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for consistent uses of request.referrer or
-      # request.referrer, depending on configuration.
+      # This cop checks for consistent uses of `request.referer` or
+      # `request.referrer`, depending on the cop's configuration.
+      #
+      # @example EnforcedStyle: referer (default)
+      #   # bad
+      #   request.referrer
+      #
+      #   # good
+      #   request.referer
+      #
+      # @example 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)
-          if offense?(node)
-            add_offense(node.source_range, node.source_range, message)
+          referer?(node) do
+            return unless node.method?(wrong_method_name)
+
+            add_offense(node.source_range, location: node.source_range)
           end
         end
 
@@ -21,14 +42,8 @@ module RuboCop
 
         private
 
-        def offense?(node)
-          return false unless node.receiver
-          receiver_name = node.receiver.method_name
-          receiver_name == :request && node.method_name == wrong_method_name
-        end
-
-        def message
-          "Use `request.#{style}` instead of `request.#{wrong_method_name}`."
+        def message(_node)
+          format(MSG, style, wrong_method_name)
         end
 
         def wrong_method_name

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

@@ -0,0 +1,281 @@
+# 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|
+            ancestor.method?(: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.keys.map do |key|
+            key.children.first.to_sym
+          end
+
+          hash_keys & keys == keys
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# 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, dispatch|
+            return if try_method == :try && !cop_config['ConvertTry']
+            return unless dispatch.sym_type? && dispatch.value =~ /\w+[=!?]?/
+
+            add_offense(node, message: format(MSG, try_method))
+          end
+        end
+
+        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
+
+        private
+
+        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