rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -15,37 +14,32 @@ module RuboCop
       #   # good
       #   User.find_by(name: 'Bruce')
       class FindBy < Cop
-        MSG = 'Use `find_by` instead of `where.%s`.'.freeze
-        TARGET_SELECTORS = [:first, :take].freeze
+        MSG = 'Use `find_by` instead of `where.%<method>s`.'.freeze
+        TARGET_SELECTORS = %i[first take].freeze
 
-        def_node_matcher :where_first, <<-PATTERN
-          (send $(send _ :where ...) ${:first :take})
+        def_node_matcher :where_first?, <<-PATTERN
+          (send (send _ :where ...) {:first :take})
         PATTERN
 
         def on_send(node)
-          return unless (recv_and_method = where_first(node))
-          receiver, second_method = *recv_and_method
+          return unless where_first?(node)
 
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            receiver.loc.selector.begin_pos,
-                                            node.loc.selector.end_pos)
+          range = range_between(node.receiver.loc.selector.begin_pos,
+                                node.loc.selector.end_pos)
 
-          add_offense(node, range, format(MSG, second_method))
+          add_offense(node, location: range,
+                            message: format(MSG, method: node.method_name))
         end
 
         def autocorrect(node)
-          receiver, second_method = where_first(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 second_method == :first
-
-          where_loc = receiver.loc.selector
-          first_loc = Parser::Source::Range.new(
-            node.source_range.source_buffer,
-            node.loc.dot.begin_pos,
-            node.loc.selector.end_pos
-          )
+          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')

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -16,43 +15,31 @@ module RuboCop
       class FindEach < Cop
         MSG = 'Use `find_each` instead of `each`.'.freeze
 
-        SCOPE_METHODS = [:all, :where, :not].freeze
+        SCOPE_METHODS = %i[all where not].freeze
+        IGNORED_METHODS = %i[order limit select].freeze
 
         def on_send(node)
-          receiver, second_method, _selector = *node
-          return unless second_method == :each
-          return if receiver.nil?
+          return unless node.receiver && node.method?(:each)
 
-          _model, first_method = *receiver
-          return unless SCOPE_METHODS.include?(first_method)
+          return unless SCOPE_METHODS.include?(node.receiver.method_name)
           return if method_chain(node).any? { |m| ignored_by_find_each?(m) }
 
-          add_offense(node, node.loc.selector, MSG)
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)
-          each_loc = node.loc.selector
-
-          ->(corrector) { corrector.replace(each_loc, 'find_each') }
+          ->(corrector) { corrector.replace(node.loc.selector, 'find_each') }
         end
 
         private
 
         def method_chain(node)
-          if (node.send_type? || node.block_type?) && !node.receiver.nil?
-            if node.parent
-              method_chain(node.parent) << node.method_name
-            else
-              [node.method_name]
-            end
-          else
-            []
-          end
+          [*node.ancestors, node].map(&:method_name)
         end
 
         def ignored_by_find_each?(relation_method)
           # Active Record's #find_each ignores various extra parameters
-          [:order, :limit, :select].include?(relation_method)
+          IGNORED_METHODS.include?(relation_method)
         end
       end
     end

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

@@ -1,16 +1,23 @@
-# encoding: utf-8
 # 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`.'.freeze
 
         def on_send(node)
           return unless node.command?(:has_and_belongs_to_many)
-          add_offense(node, :selector)
+
+          add_offense(node, location: :selector)
         end
       end
     end

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

@@ -0,0 +1,84 @@
+# 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.'.freeze
+
+        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)
+          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
+
+          if with_options_block(n)
+            return true if valid_options?(with_options_block(n))
+          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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# 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`.'.freeze
+        KEYWORD_ARGS = %i[
+          headers env params body flash as xhr session method
+        ].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 }, headers: {}
+        # 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)
+          http_path, *data = *node.arguments
+
+          controller_action = http_path.source
+          params = convert_hash_data(data.first, 'params')
+          headers = convert_hash_data(data.last, 'headers') if data.size > 1
+          # the range of the text to replace, which is the whole line
+          code_to_replace = node.loc.expression
+          # what to replace with
+          format = parentheses?(node) ? '%s(%s%s%s)' : '%s %s%s%s'
+          new_code = format(format, node.method_name, controller_action,
+                            params, headers)
+          ->(corrector) { corrector.replace(code_to_replace, new_code) }
+        end
+
+        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('{ %s }', data.pairs.map(&:source).join(', '))
+                      else
+                        # user supplies an object,
+                        # no need to surround with braces
+                        data.source
+                      end
+
+          format(', %s: %s', type, hash_data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for has_(one|many) and belongs_to associations where
+      # ActiveRecord can't automatically determine the inverse association
+      # because of a scope or the options used. This can result in unnecessary
+      # queries in some circumstances. `:inverse_of` must be manually specified
+      # for associations to work in both ways, or set to `false` to opt-out.
+      #
+      # @example
+      #   # good
+      #   class Blog < ApplicationRecord
+      #     has_many :posts
+      #   end
+      #
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog
+      #   end
+      #
+      # @example
+      #   # bad
+      #   class Blog < ApplicationRecord
+      #     has_many :posts, -> { order(published_at: :desc) }
+      #   end
+      #
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog
+      #   end
+      #
+      #   # good
+      #   class Blog < ApplicationRecord
+      #     has_many(:posts,
+      #       -> { order(published_at: :desc) },
+      #       inverse_of: :blog
+      #     )
+      #   end
+      #
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog
+      #   end
+      #
+      #   # good
+      #   class Blog < ApplicationRecord
+      #     with_options inverse_of: :blog do
+      #       has_many :posts, -> { order(published_at: :desc) }
+      #     end
+      #   end
+      #
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog
+      #   end
+      #
+      # @example
+      #   # bad
+      #   class Picture < ApplicationRecord
+      #     belongs_to :imageable, polymorphic: true
+      #   end
+      #
+      #   class Employee < ApplicationRecord
+      #     has_many :pictures, as: :imageable
+      #   end
+      #
+      #   class Product < ApplicationRecord
+      #     has_many :pictures, as: :imageable
+      #   end
+      #
+      #   # good
+      #   class Picture < ApplicationRecord
+      #     belongs_to :imageable, polymorphic: true
+      #   end
+      #
+      #   class Employee < ApplicationRecord
+      #     has_many :pictures, as: :imageable, inverse_of: :imageable
+      #   end
+      #
+      #   class Product < ApplicationRecord
+      #     has_many :pictures, as: :imageable, inverse_of: :imageable
+      #   end
+      #
+      # @example
+      #   # bad
+      #   # However, RuboCop can not detect this pattern...
+      #   class Physician < ApplicationRecord
+      #     has_many :appointments
+      #     has_many :patients, through: :appointments
+      #   end
+      #
+      #   class Appointment < ApplicationRecord
+      #     belongs_to :physician
+      #     belongs_to :patient
+      #   end
+      #
+      #   class Patient < ApplicationRecord
+      #     has_many :appointments
+      #     has_many :physicians, through: :appointments
+      #   end
+      #
+      #   # good
+      #   class Physician < ApplicationRecord
+      #     has_many :appointments
+      #     has_many :patients, through: :appointments
+      #   end
+      #
+      #   class Appointment < ApplicationRecord
+      #     belongs_to :physician, inverse_of: :appointments
+      #     belongs_to :patient, inverse_of: :appointments
+      #   end
+      #
+      #   class Patient < ApplicationRecord
+      #     has_many :appointments
+      #     has_many :physicians, through: :appointments
+      #   end
+      #
+      # @see http://guides.rubyonrails.org/association_basics.html#bi-directional-associations
+      # @see http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Setting+Inverses
+      class InverseOf < Cop
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 4.1
+
+        MSG = 'Specify an `:inverse_of` option.'.freeze
+
+        def_node_matcher :association_recv_arguments, <<-PATTERN
+          (send $_ {:has_many :has_one :belongs_to} _ $...)
+        PATTERN
+
+        def_node_matcher :options_from_argument, <<-PATTERN
+          (hash $...)
+        PATTERN
+
+        def_node_matcher :conditions_option?, <<-PATTERN
+          (pair (sym :conditions) !nil)
+        PATTERN
+
+        def_node_matcher :through_option?, <<-PATTERN
+          (pair (sym :through) !nil)
+        PATTERN
+
+        def_node_matcher :polymorphic_option?, <<-PATTERN
+          (pair (sym :polymorphic) !nil)
+        PATTERN
+
+        def_node_matcher :as_option?, <<-PATTERN
+          (pair (sym :as) !nil)
+        PATTERN
+
+        def_node_matcher :class_name_option?, <<-PATTERN
+          (pair (sym :class_name) !nil)
+        PATTERN
+
+        def_node_matcher :foreign_key_option?, <<-PATTERN
+          (pair (sym :foreign_key) !nil)
+        PATTERN
+
+        def_node_matcher :inverse_of_option?, <<-PATTERN
+          (pair (sym :inverse_of) !nil)
+        PATTERN
+
+        def on_send(node)
+          recv, arguments = association_recv_arguments(node)
+          return unless arguments
+          with_options = with_options_arguments(recv, node)
+
+          options = arguments.concat(with_options).flat_map do |arg|
+            options_from_argument(arg)
+          end
+          return if options_ignoring_inverse_of?(options)
+
+          return unless scope?(arguments) ||
+                        options_requiring_inverse_of?(options)
+
+          return if options_contain_inverse_of?(options)
+          add_offense(node, location: :selector)
+        end
+
+        def scope?(arguments)
+          arguments.any?(&:block_type?)
+        end
+
+        def options_requiring_inverse_of?(options)
+          required = options.any? do |opt|
+            conditions_option?(opt) ||
+              class_name_option?(opt) ||
+              foreign_key_option?(opt)
+          end
+
+          return required if target_rails_version >= 5.2
+          required || options.any? { |opt| as_option?(opt) }
+        end
+
+        def options_ignoring_inverse_of?(options)
+          options.any? do |opt|
+            through_option?(opt) || polymorphic_option?(opt)
+          end
+        end
+
+        def options_contain_inverse_of?(options)
+          options.any? { |opt| inverse_of_option?(opt) }
+        end
+
+        def with_options_arguments(recv, node)
+          blocks = node.each_ancestor(:block).select do |block|
+            block.send_node.command?(:with_options) &&
+              same_context_in_with_options?(block.arguments.first, recv)
+          end
+          blocks.flat_map { |n| n.send_node.arguments }
+        end
+
+        def same_context_in_with_options?(arg, recv)
+          return true if arg.nil? && recv.nil?
+          arg && recv && arg.children[0] == recv.children[0]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that methods specified in the filter's `only`
+      # or `except` options are explicitly defined in the controller.
+      #
+      # You can specify methods of superclass or methods added by mixins
+      # on the filter, but these confuse developers. If you specify methods
+      # where are defined on another controller, you should define the filter
+      # in that controller.
+      #
+      # @example
+      #   # bad
+      #   class LoginController < ApplicationController
+      #     before_action :require_login, only: %i[index settings logout]
+      #
+      #     def index
+      #     end
+      #   end
+      #
+      #   # good
+      #   class LoginController < ApplicationController
+      #     before_action :require_login, only: %i[index settings logout]
+      #
+      #     def index
+      #     end
+      #
+      #     def settings
+      #     end
+      #
+      #     def logout
+      #     end
+      #   end
+      class LexicallyScopedActionFilter < Cop
+        MSG = '%<action>s not explicitly defined on the controller.'.freeze
+
+        FILTERS = %w[
+          :after_action
+          :append_after_action
+          :append_around_action
+          :append_before_action
+          :around_action
+          :before_action
+          :prepend_after_action
+          :prepend_around_action
+          :prepend_before_action
+          :skip_after_action
+          :skip_around_action
+          :skip_before_action
+          :skip_action_callback
+        ].freeze
+
+        def_node_matcher :only_or_except_filter_methods, <<-PATTERN
+          (send
+            nil?
+            {#{FILTERS.join(' ')}}
+            _
+            (hash
+              (pair
+                (sym {:only :except})
+                $_)))
+        PATTERN
+
+        def on_send(node)
+          methods_node = only_or_except_filter_methods(node)
+          return unless methods_node
+
+          defined_methods = node.parent.each_child_node(:def).map(&:method_name)
+          methods = array_values(methods_node).reject do |method|
+            defined_methods.include?(method)
+          end
+
+          add_offense(node, message: message(methods)) unless methods.empty?
+        end
+
+        private
+
+        # @param node [RuboCop::AST::Node]
+        # @return [Array<Symbol>]
+        def array_values(node) # rubocop:disable Metrics/MethodLength
+          case node.type
+          when :str
+            [node.str_content.to_sym]
+          when :sym
+            [node.value]
+          when :array
+            node.values.map do |v|
+              case v.type
+              when :str
+                v.str_content.to_sym
+              when :sym
+                v.value
+              end
+            end.compact
+          else
+            []
+          end
+        end
+
+        def message(methods)
+          if methods.size == 1
+            format(MSG, action: "`#{methods[0]}` is")
+          else
+            format(MSG, action: "`#{methods.join('`, `')}` are")
+          end
+        end
+      end
+    end
+  end
+end