rubbycop 0.49.0

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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/rubbycop/cop/rails/has_and_belongs_to_many.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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/rubbycop/cop/rails/http_positional_arguments.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+      # .rubbycop.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/rubbycop/cop/rails/not_null_column.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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/rubbycop/cop/rails/output.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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/rubbycop/cop/rails/output_safety.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop checks for the use of output safety calls like html_safe and
+      # raw. These methods do not escape content. They simply return a
+      # SafeBuffer containing the content as is. Instead, use safe_join
+      # to escape content and ensure its safety.
+      #
+      # @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)
+      #
+      #   # bad
+      #   (person.login + " " + content_tag(:span, person.email)).html_safe
+      #
+      #   # good
+      #   safe_join([person.login, " ", content_tag(:span, person.email)])
+      #
+      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)
+
+          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/rubbycop/cop/rails/pluralization_grammar.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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/rubbycop/cop/rails/present.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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.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,
+                               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,
+                        :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, 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