rubocop 0.51.0 → 0.87.0

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

@@ -1,72 +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.'.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)
-          if !association_without_options?(node)
-            return if valid_options?(association_with_options?(node))
-          elsif with_options_block(node.parent)
-            return if valid_options?(with_options_block(node.parent))
-          end
-
-          add_offense(node, location: :selector)
-        end
-
-        private
-
-        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

@@ -1,107 +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: `%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? $_data ...)
-        PATTERN
-
-        def on_send(node)
-          data = http_request?(node)
-          # if the data is nil then we don't need to add keyword arguments
-          # because there is no data to put in params or headers, so skip
-          return if data.nil?
-          return unless needs_conversion?(data)
-
-          add_offense(node, location: :selector,
-                            message: format(MSG, node.method_name))
-        end
-
-        # @return [Boolean] true if the line needs to be converted
-        def needs_conversion?(data)
-          return true unless data.hash_type?
-          children = data.child_nodes
-
-          value = children.find do |d|
-            special_keyword_arg?(d.children.first) ||
-              (format_arg?(d.children.first) && children.size == 1)
-          end
-
-          value.nil?
-        end
-
-        def special_keyword_arg?(node)
-          KEYWORD_ARGS.include?(node.children.first) if node.sym_type?
-        end
-
-        def format_arg?(node)
-          node.children.first == :format if node.sym_type?
-        end
-
-        def convert_hash_data(data, type)
-          # empty hash or no hash return empty string
-          return '' if data.nil? || data.children.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
-
-        # 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
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for add_column call with NOT NULL constraint
-      # in migration file.
-      #
-      # @example
-      #   # bad
-      #   add_column :users, :name, :string, null: false
-      #   add_reference :products, :category, null: false
-      #
-      #   # good
-      #   add_column :users, :name, :string, null: true
-      #   add_column :users, :name, :string, null: false, default: ''
-      #   add_reference :products, :category
-      #   add_reference :products, :category, null: false, default: 1
-      class NotNullColumn < Cop
-        MSG = 'Do not add a NOT NULL column without a default value.'.freeze
-
-        def_node_matcher :add_not_null_column?, <<-PATTERN
-          (send nil? :add_column _ _ _ (hash $...))
-        PATTERN
-
-        def_node_matcher :add_not_null_reference?, <<-PATTERN
-          (send nil? :add_reference _ _ (hash $...))
-        PATTERN
-
-        def_node_matcher :null_false?, <<-PATTERN
-          (pair (sym :null) (false))
-        PATTERN
-
-        def_node_matcher :default_option?, <<-PATTERN
-          (pair (sym :default) !nil)
-        PATTERN
-
-        def on_send(node)
-          check_add_column(node)
-          check_add_reference(node)
-        end
-
-        private
-
-        def check_add_column(node)
-          pairs = add_not_null_column?(node)
-          check_pairs(pairs)
-        end
-
-        def check_add_reference(node)
-          pairs = add_not_null_reference?(node)
-          check_pairs(pairs)
-        end
-
-        def check_pairs(pairs)
-          return unless pairs
-          return if pairs.any? { |pair| default_option?(pair) }
-
-          null_false = pairs.find { |pair| null_false?(pair) }
-          return unless null_false
-
-          add_offense(null_false)
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for the use of output calls like puts and print
-      class Output < Cop
-        MSG = 'Do not write to stdout. ' \
-              "Use Rails's logger if you want to log.".freeze
-
-        def_node_matcher :output?, <<-PATTERN
-          (send nil? {:ap :p :pp :pretty_print :print :puts} ...)
-        PATTERN
-
-        def on_send(node)
-          return unless output?(node) && node.arguments?
-
-          add_offense(node, location: :selector)
-        end
-      end
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for the use of output safety calls like html_safe,
-      # raw, and safe_concat. These methods do not escape content. They
-      # simply return a SafeBuffer containing the content as is. Instead,
-      # use safe_join to join content and escape it and concat to
-      # concatenate content and escape it, ensuring its safety.
-      #
-      # @example
-      #   user_content = "<b>hi</b>"
-      #
-      #   # bad
-      #   "<p>#{user_content}</p>".html_safe
-      #   => ActiveSupport::SafeBuffer
-      #   "<p><b>hi</b></p>"
-      #
-      #   # good
-      #   content_tag(:p, user_content)
-      #   => ActiveSupport::SafeBuffer
-      #   "<p>&lt;b&gt;hi&lt;/b&gt;</p>"
-      #
-      #   # bad
-      #   out = ""
-      #   out << "<li>#{user_content}</li>"
-      #   out << "<li>#{user_content}</li>"
-      #   out.html_safe
-      #   => ActiveSupport::SafeBuffer
-      #   "<li><b>hi</b></li><li><b>hi</b></li>"
-      #
-      #   # good
-      #   out = []
-      #   out << content_tag(:li, user_content)
-      #   out << content_tag(:li, user_content)
-      #   safe_join(out)
-      #   => ActiveSupport::SafeBuffer
-      #   "<li>&lt;b&gt;hi&lt;/b&gt;</li><li>&lt;b&gt;hi&lt;/b&gt;</li>"
-      #
-      #   # bad
-      #   out = "<h1>trusted content</h1>".html_safe
-      #   out.safe_concat(user_content)
-      #   => ActiveSupport::SafeBuffer
-      #   "<h1>trusted_content</h1><b>hi</b>"
-      #
-      #   # good
-      #   out = "<h1>trusted content</h1>".html_safe
-      #   out.concat(user_content)
-      #   => ActiveSupport::SafeBuffer
-      #   "<h1>trusted_content</h1>&lt;b&gt;hi&lt;/b&gt;"
-      #
-      #   # safe, though maybe not good style
-      #   out = "trusted content"
-      #   result = out.concat(user_content)
-      #   => String "trusted content<b>hi</b>"
-      #   # because when rendered in ERB the String will be escaped:
-      #   <%= result %>
-      #   => trusted content&lt;b&gt;hi&lt;/b&gt;
-      #
-      #   # bad
-      #   (user_content + " " + content_tag(:span, user_content)).html_safe
-      #   => ActiveSupport::SafeBuffer
-      #   "<b>hi</b> <span><b>hi</b></span>"
-      #
-      #   # good
-      #   safe_join([user_content, " ", content_tag(:span, user_content)])
-      #   => ActiveSupport::SafeBuffer
-      #   "&lt;b&gt;hi&lt;/b&gt; <span>&lt;b&gt;hi&lt;/b&gt;</span>"
-      #
-      class OutputSafety < Cop
-        MSG = 'Tagging a string as html safe may be a security risk.'.freeze
-
-        def on_send(node)
-          return unless looks_like_rails_html_safe?(node) ||
-                        looks_like_rails_raw?(node) ||
-                        looks_like_rails_safe_concat?(node)
-
-          add_offense(node, location: :selector)
-        end
-        alias on_csend on_send
-
-        private
-
-        def looks_like_rails_html_safe?(node)
-          node.receiver && node.method?(:html_safe) && !node.arguments?
-        end
-
-        def looks_like_rails_raw?(node)
-          node.command?(:raw) && node.arguments.one?
-        end
-
-        def looks_like_rails_safe_concat?(node)
-          node.method?(:safe_concat) && node.arguments.one?
-        end
-      end
-    end
-  end
-end

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

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for correct grammar when using ActiveSupport's
-      # core extensions to the numeric classes.
-      #
-      # @example
-      #   # bad
-      #   3.day.ago
-      #   1.months.ago
-      #
-      #   # good
-      #   3.days.ago
-      #   1.month.ago
-      class PluralizationGrammar < Cop
-        SINGULAR_DURATION_METHODS = { second: :seconds,
-                                      minute: :minutes,
-                                      hour: :hours,
-                                      day: :days,
-                                      week: :weeks,
-                                      fortnight: :fortnights,
-                                      month: :months,
-                                      year: :years }.freeze
-
-        PLURAL_DURATION_METHODS = SINGULAR_DURATION_METHODS.invert.freeze
-
-        MSG = 'Prefer `%s.%s`.'.freeze
-
-        def on_send(node)
-          return unless duration_method?(node.method_name)
-          return unless literal_number?(node.receiver)
-
-          return unless offense?(node)
-
-          add_offense(node)
-        end
-
-        private
-
-        def message(node)
-          number, = *node.receiver
-
-          format(MSG, number, correct_method(node.method_name.to_s))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            method_name = node.loc.selector.source
-
-            corrector.replace(node.loc.selector, correct_method(method_name))
-          end
-        end
-
-        def correct_method(method_name)
-          if plural_method?(method_name)
-            singularize(method_name)
-          else
-            pluralize(method_name)
-          end
-        end
-
-        def offense?(node)
-          number, = *node.receiver
-
-          singular_receiver?(number) && plural_method?(node.method_name) ||
-            plural_receiver?(number) && singular_method?(node.method_name)
-        end
-
-        def plural_method?(method_name)
-          method_name.to_s.end_with?('s')
-        end
-
-        def singular_method?(method_name)
-          !plural_method?(method_name)
-        end
-
-        def singular_receiver?(number)
-          number.abs == 1
-        end
-
-        def plural_receiver?(number)
-          !singular_receiver?(number)
-        end
-
-        def literal_number?(node)
-          node && (node.int_type? || node.float_type?)
-        end
-
-        def pluralize(method_name)
-          SINGULAR_DURATION_METHODS.fetch(method_name.to_sym).to_s
-        end
-
-        def singularize(method_name)
-          PLURAL_DURATION_METHODS.fetch(method_name.to_sym).to_s
-        end
-
-        def duration_method?(method_name)
-          SINGULAR_DURATION_METHODS.key?(method_name) ||
-            PLURAL_DURATION_METHODS.key?(method_name)
-        end
-      end
-    end
-  end
-end

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

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cops checks for code that can be changed to `blank?`.
-      # Settings:
-      #   NotNilAndNotEmpty: Convert checks for not `nil` and `not empty?`
-      #                      to `present?`
-      #   NotBlank: Convert usages of not `blank?` to `present?`
-      #   UnlessBlank: Convert usages of `unless` `blank?` to `if` `present?`
-      #
-      # @example
-      #   # NotNilAndNotEmpty: true
-      #     # bad
-      #     !foo.nil? && !foo.empty?
-      #     foo != nil && !foo.empty?
-      #     !foo.blank?
-      #
-      #     # good
-      #     foo.present?
-      #
-      #   # NotBlank: true
-      #     # bad
-      #     !foo.blank?
-      #     not foo.blank?
-      #
-      #     # good
-      #     foo.present?
-      #
-      #   # UnlessBlank: true
-      #     # bad
-      #     something unless foo.blank?
-      #
-      #     # good
-      #     something if  foo.present?
-      class Present < Cop
-        MSG_NOT_BLANK = 'Use `%s` instead of `%s`.'.freeze
-        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%s` instead of `%s`.'.freeze
-        MSG_UNLESS_BLANK = 'Use `if %s` instead of `%s`.'.freeze
-
-        def_node_matcher :exists_and_not_empty?, <<-PATTERN
-          (and
-              {
-                (send (send $_ :nil?) :!)
-                (send (send $_ :!) :!)
-                (send $_ :!= nil)
-                $_
-              }
-              {
-                (send (send $_ :empty?) :!)
-              }
-          )
-        PATTERN
-
-        def_node_matcher :not_blank?, '(send (send $_ :blank?) :!)'
-
-        def_node_matcher :unless_blank?, <<-PATTERN
-          (:if $(send $_ :blank?) {nil? (...)} ...)
-        PATTERN
-
-        def on_send(node)
-          return unless cop_config['NotBlank']
-
-          not_blank?(node) do |receiver|
-            add_offense(node,
-                        message: format(MSG_NOT_BLANK,
-                                        replacement(receiver),
-                                        node.source))
-          end
-        end
-
-        def on_and(node)
-          return unless cop_config['NotNilAndNotEmpty']
-
-          exists_and_not_empty?(node) do |variable1, variable2|
-            return unless variable1 == variable2
-
-            add_offense(node,
-                        message: format(MSG_EXISTS_AND_NOT_EMPTY,
-                                        replacement(variable1),
-                                        node.source))
-          end
-        end
-
-        def on_or(node)
-          return unless cop_config['NilOrEmpty']
-
-          exists_and_not_empty?(node) do |variable1, variable2|
-            return unless variable1 == variable2
-
-            add_offense(node, message: MSG_EXISTS_AND_NOT_EMPTY)
-          end
-        end
-
-        def on_if(node)
-          return unless cop_config['UnlessBlank']
-          return unless node.unless?
-
-          unless_blank?(node) do |method_call, receiver|
-            range = unless_condition(node, method_call)
-            msg = format(MSG_UNLESS_BLANK, replacement(receiver), range.source)
-            add_offense(node, location: range, message: msg)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            method_call, variable1 = unless_blank?(node)
-
-            if method_call
-              corrector.replace(node.loc.keyword, 'if')
-              range = method_call.loc.expression
-            else
-              variable1, _variable2 =
-                exists_and_not_empty?(node) || not_blank?(node)
-              range = node.loc.expression
-            end
-
-            corrector.replace(range, replacement(variable1))
-          end
-        end
-
-        private
-
-        def unless_condition(node, method_call)
-          if node.modifier_form?
-            node.loc.keyword.join(node.loc.expression.end)
-          else
-            node.loc.expression.begin.join(method_call.loc.expression)
-          end
-        end
-
-        def replacement(node)
-          node.respond_to?(:source) ? "#{node.source}.present?" : 'present?'
-        end
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for the use of the read_attribute or
-      # write_attribute methods.
-      #
-      # @example
-      #
-      #   # bad
-      #   x = read_attribute(:attr)
-      #   write_attribute(:attr, val)
-      #
-      #   # good
-      #   x = self[:attr]
-      #   self[:attr] = val
-      class ReadWriteAttribute < Cop
-        MSG = 'Prefer `%s` over `%s`.'.freeze
-
-        def_node_matcher :read_write_attribute?, <<-PATTERN
-          {
-            (send nil? :read_attribute _)
-            (send nil? :write_attribute _ _)
-          }
-        PATTERN
-
-        def on_send(node)
-          return unless read_write_attribute?(node)
-
-          add_offense(node, location: :selector)
-        end
-
-        private
-
-        def message(node)
-          if node.method?(:read_attribute)
-            format(MSG, 'self[:attr]', 'read_attribute(:attr)')
-          else
-            format(MSG, 'self[:attr] = val', 'write_attribute(:attr, val)')
-          end
-        end
-
-        def autocorrect(node)
-          case node.method_name
-          when :read_attribute
-            replacement = read_attribute_replacement(node)
-          when :write_attribute
-            replacement = write_attribute_replacement(node)
-          end
-
-          ->(corrector) { corrector.replace(node.source_range, replacement) }
-        end
-
-        def read_attribute_replacement(node)
-          "self[#{node.first_argument.source}]"
-        end
-
-        def write_attribute_replacement(node)
-          "self[#{node.first_argument.source}] = #{node.last_argument.source}"
-        end
-      end
-    end
-  end
-end