rubocop 0.48.1 → 1.16.0

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop is used to identify usages of `all.each` and
-      # change them to use `all.find_each` instead.
-      #
-      # @example
-      #   # bad
-      #   User.all.each
-      #
-      #   # good
-      #   User.all.find_each
-      class FindEach < Cop
-        MSG = 'Use `find_each` instead of `each`.'.freeze
-
-        SCOPE_METHODS = %i[all where not].freeze
-        IGNORED_METHODS = %i[order limit select].freeze
-
-        def on_send(node)
-          return unless node.receiver && node.method?(:each)
-
-          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)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'find_each') }
-        end
-
-        private
-
-        def method_chain(node)
-          [*node.ancestors, node].map(&:method_name)
-        end
-
-        def ignored_by_find_each?(relation_method)
-          # Active Record's #find_each ignores various extra parameters
-          IGNORED_METHODS.include?(relation_method)
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for the use of the has_and_belongs_to_many macro.
-      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)
-        end
-      end
-    end
-  end
-end

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

@@ -1,106 +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 not 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?, <<-END
-          (send nil {#{HTTP_METHODS.map(&:inspect).join(' ')}} !nil $_data ...)
-        END
-
-        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, node.loc.selector, 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.type == :sym
-        end
-
-        def format_arg?(node)
-          node.children.first == :format if node.type == :sym
-        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 use 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 :has_default?, <<-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| has_default?(pair) }
-
-          null_false = pairs.find { |pair| null_false?(pair) }
-          return unless null_false
-
-          add_offense(null_false, :expression)
-        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, :selector)
-        end
-      end
-    end
-  end
-end

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

@@ -1,54 +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 and
-      # raw.
-      #
-      # @example
-      #   # bad
-      #   "<p>#{text}</p>".html_safe
-      #
-      #   # good
-      #   content_tag(:p, text)
-      #
-      #   # bad
-      #   out = ""
-      #   out << content_tag(:li, "one")
-      #   out << content_tag(:li, "two")
-      #   out.html_safe
-      #
-      #   # good
-      #   out = []
-      #   out << content_tag(:li, "one")
-      #   out << content_tag(:li, "two")
-      #   safe_join(out)
-      #
-      class OutputSafety < Cop
-        MSG = 'Tagging a string as html safe may be a security risk, ' \
-              'prefer `safe_join` or other Rails tag helpers instead.'.freeze
-
-        def on_send(node)
-          ignore_node(node) if node.method?(:safe_join)
-
-          return unless !part_of_ignored_node?(node) &&
-                        (looks_like_rails_html_safe?(node) ||
-                        looks_like_rails_raw?(node))
-
-          add_offense(node, :selector)
-        end
-
-        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
-      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, :expression)
-        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 == 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,137 +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.present?` instead of `%s`.'.freeze
-        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%s.present?` instead of `%s`.'.freeze
-        MSG_UNLESS_BLANK = 'Use `if %s.present?` 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,
-                        :expression,
-                        format(MSG_NOT_BLANK, receiver.source, 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,
-                        :expression,
-                        format(MSG_EXISTS_AND_NOT_EMPTY,
-                               variable1.source,
-                               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, :expression, 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)
-            add_offense(node,
-                        range,
-                        format(MSG_UNLESS_BLANK, receiver.source, range.source))
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            method_call, variable1 = unless_blank?(node)
-
-            if method_call && variable1
-              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, "#{variable1.source}.present?")
-          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
-      end
-    end
-  end
-end