rubocop-rails 2.4.1

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

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

@@ -0,0 +1,106 @@
+# 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/helper_instance_variable.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for use of the helper methods which reference
+      # instance variables.
+      #
+      # Relying on instance variables makes it difficult to re-use helper
+      # methods.
+      #
+      # If it seems awkward to explicitly pass in each dependent
+      # variable, consider moving the behaviour elsewhere, for
+      # example to a model, decorator or presenter.
+      #
+      # @example
+      #   # bad
+      #   def welcome_message
+      #     "Hello #{@user.name}"
+      #   end
+      #
+      #   # good
+      #   def welcome_message(user)
+      #     "Hello #{user.name}"
+      #   end
+      class HelperInstanceVariable < Cop
+        MSG = 'Do not use instance variables in helpers.'
+
+        def on_ivar(node)
+          add_offense(node)
+        end
+
+        def on_ivasgn(node)
+          add_offense(node, location: :name)
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,160 @@
+# 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
+        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 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
+            format(MSG, prefer: preferred_style, current: number.to_s)
+          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
+            format(MSG, prefer: preferred_style, current: symbol.inspect)
+          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