rubocop-rails 2.4.1

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for code that can be written with simpler conditionals
+      # using `Object#present?` defined by Active Support.
+      #
+      # Interaction with `Style/UnlessElse`:
+      # The configuration of `NotBlank` will not produce an offense in the
+      # context of `unless else` if `Style/UnlessElse` is inabled. This is
+      # to prevent interference between the auto-correction of the two cops.
+      #
+      # @example NotNilAndNotEmpty: true (default)
+      #   # Converts usages of `!nil? && !empty?` to `present?`
+      #
+      #   # bad
+      #   !foo.nil? && !foo.empty?
+      #
+      #   # bad
+      #   foo != nil && !foo.empty?
+      #
+      #   # good
+      #   foo.present?
+      #
+      # @example NotBlank: true (default)
+      #   # Converts usages of `!blank?` to `present?`
+      #
+      #   # bad
+      #   !foo.blank?
+      #
+      #   # bad
+      #   not foo.blank?
+      #
+      #   # good
+      #   foo.present?
+      #
+      # @example UnlessBlank: true (default)
+      #   # Converts usages of `unless blank?` to `if present?`
+      #
+      #   # bad
+      #   something unless foo.blank?
+      #
+      #   # good
+      #   something if foo.present?
+      class Present < Cop
+        MSG_NOT_BLANK = 'Use `%<prefer>s` instead of `%<current>s`.'
+        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%<prefer>s` instead of ' \
+                                   '`%<current>s`.'
+        MSG_UNLESS_BLANK = 'Use `if %<prefer>s` instead of ' \
+                           '`%<current>s`.'
+
+        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,
+                                        prefer: replacement(receiver),
+                                        current: node.source))
+          end
+        end
+
+        def on_and(node)
+          return unless cop_config['NotNilAndNotEmpty']
+
+          exists_and_not_empty?(node) do |var1, var2|
+            return unless var1 == var2
+
+            add_offense(node,
+                        message: format(MSG_EXISTS_AND_NOT_EMPTY,
+                                        prefer: replacement(var1),
+                                        current: node.source))
+          end
+        end
+
+        def on_or(node)
+          return unless cop_config['NilOrEmpty']
+
+          exists_and_not_empty?(node) do |var1, var2|
+            return unless var1 == var2
+
+            add_offense(node, message: MSG_EXISTS_AND_NOT_EMPTY)
+          end
+        end
+
+        def on_if(node)
+          return unless cop_config['UnlessBlank']
+          return unless node.unless?
+          return if node.else? && config.for_cop('Style/UnlessElse')['Enabled']
+
+          unless_blank?(node) do |method_call, receiver|
+            range = unless_condition(node, method_call)
+            msg = format(MSG_UNLESS_BLANK, prefer: replacement(receiver),
+                                           current: 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/rake_environment.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for Rake tasks without the `:environment` task
+      # dependency. The `:environment` task loads application code for other
+      # Rake tasks. Without it, tasks cannot make use of application code like
+      # models.
+      #
+      # You can ignore the offense if the task satisfies at least one of the
+      # following conditions:
+      #
+      # * The task does not need application code.
+      # * The task invokes the `:environment` task.
+      #
+      # @example
+      #   # bad
+      #   task :foo do
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   task foo: :environment do
+      #     do_something
+      #   end
+      #
+      class RakeEnvironment < Cop
+        MSG = 'Include `:environment` task as a dependency for all Rake tasks.'
+
+        def_node_matcher :task_definition?, <<~PATTERN
+          (send nil? :task ...)
+        PATTERN
+
+        def on_send(node)
+          return unless task_definition?(node)
+          return if task_name(node) == :default
+          return if with_dependencies?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def task_name(node)
+          first_arg = node.arguments[0]
+          case first_arg&.type
+          when :sym, :str
+            first_arg.value.to_sym
+          when :hash
+            return nil if first_arg.children.size != 1
+
+            pair = first_arg.children.first
+            key = pair.children.first
+            case key.type
+            when :sym, :str
+              key.value.to_sym
+            end
+          end
+        end
+
+        def with_dependencies?(node)
+          first_arg = node.arguments[0]
+          return false unless first_arg
+
+          if first_arg.hash_type?
+            with_hash_style_dependencies?(first_arg)
+          else
+            task_args = node.arguments[1]
+            return false unless task_args
+            return false unless task_args.hash_type?
+
+            with_hash_style_dependencies?(task_args)
+          end
+        end
+
+        def with_hash_style_dependencies?(hash_node)
+          deps = hash_node.pairs.first&.value
+          return false unless deps
+
+          case deps.type
+          when :array
+            !deps.values.empty?
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for the use of the `read_attribute` or `write_attribute`
+      # methods and recommends square brackets instead.
+      #
+      # If an attribute is missing from the instance (for example, when
+      # initialized by a partial `select`) then `read_attribute`
+      # will return nil, but square brackets will raise
+      # an `ActiveModel::MissingAttributeError`.
+      #
+      # Explicitly raising an error in this situation is preferable, and that
+      # is why rubocop recommends using square brackets.
+      #
+      # @example
+      #
+      #   # bad
+      #   x = read_attribute(:attr)
+      #   write_attribute(:attr, val)
+      #
+      #   # good
+      #   x = self[:attr]
+      #   self[:attr] = val
+      class ReadWriteAttribute < Cop
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+
+        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
+
+        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
+
+        private
+
+        def message(node)
+          if node.method?(:read_attribute)
+            format(MSG, prefer: 'self[:attr]', current: 'read_attribute(:attr)')
+          else
+            format(MSG, prefer: 'self[:attr] = val',
+                        current: 'write_attribute(:attr, val)')
+          end
+        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

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks Rails model validations for a redundant `allow_nil` when
+      # `allow_blank` is present.
+      #
+      # @example
+      #   # bad
+      #   validates :x, length: { is: 5 }, allow_nil: true, allow_blank: true
+      #
+      #   # bad
+      #   validates :x, length: { is: 5 }, allow_nil: false, allow_blank: true
+      #
+      #   # bad
+      #   validates :x, length: { is: 5 }, allow_nil: false, allow_blank: false
+      #
+      #   # good
+      #   validates :x, length: { is: 5 }, allow_blank: true
+      #
+      #   # good
+      #   validates :x, length: { is: 5 }, allow_blank: false
+      #
+      #   # good
+      #   # Here, `nil` is valid but `''` is not
+      #   validates :x, length: { is: 5 }, allow_nil: true, allow_blank: false
+      #
+      class RedundantAllowNil < Cop
+        include RangeHelp
+
+        MSG_SAME =
+          '`allow_nil` is redundant when `allow_blank` has the same value.'
+
+        MSG_ALLOW_NIL_FALSE =
+          '`allow_nil: false` is redundant when `allow_blank` is true.'
+
+        def on_send(node)
+          return unless node.method?(:validates)
+
+          allow_nil, allow_blank = find_allow_nil_and_allow_blank(node)
+          return unless allow_nil && allow_blank
+
+          allow_nil_val = allow_nil.children.last
+          allow_blank_val = allow_blank.children.last
+
+          offense(allow_nil_val, allow_blank_val, allow_nil)
+        end
+
+        def autocorrect(node)
+          prv_sib = previous_sibling(node)
+          nxt_sib = next_sibling(node)
+
+          lambda do |corrector|
+            if nxt_sib
+              corrector.remove(range_between(node_beg(node), node_beg(nxt_sib)))
+            elsif prv_sib
+              corrector.remove(range_between(node_end(prv_sib), node_end(node)))
+            else
+              corrector.remove(node.loc.expression)
+            end
+          end
+        end
+
+        private
+
+        def offense(allow_nil_val, allow_blank_val, allow_nil)
+          if allow_nil_val.type == allow_blank_val.type
+            add_offense(allow_nil, message: MSG_SAME)
+          elsif allow_nil_val.false_type? && allow_blank_val.true_type?
+            add_offense(allow_nil, message: MSG_ALLOW_NIL_FALSE)
+          end
+        end
+
+        def find_allow_nil_and_allow_blank(node)
+          allow_nil = nil
+          allow_blank = nil
+
+          node.each_descendant do |descendant|
+            next unless descendant.pair_type?
+
+            key = descendant.children.first.source
+
+            allow_nil = descendant if key == 'allow_nil'
+            allow_blank = descendant if key == 'allow_blank'
+
+            break if allow_nil && allow_blank
+          end
+
+          [allow_nil, allow_blank]
+        end
+
+        def previous_sibling(node)
+          node.parent.children[node.sibling_index - 1]
+        end
+
+        def next_sibling(node)
+          node.parent.children[node.sibling_index + 1]
+        end
+
+        def node_beg(node)
+          node.loc.expression.begin_pos
+        end
+
+        def node_end(node)
+          node.loc.expression.end_pos
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for redundant receiver in `with_options`.
+      # Receiver is implicit from Rails 4.2 or higher.
+      #
+      # @example
+      #   # bad
+      #   class Account < ApplicationRecord
+      #     with_options dependent: :destroy do |assoc|
+      #       assoc.has_many :customers
+      #       assoc.has_many :products
+      #       assoc.has_many :invoices
+      #       assoc.has_many :expenses
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Account < ApplicationRecord
+      #     with_options dependent: :destroy do
+      #       has_many :customers
+      #       has_many :products
+      #       has_many :invoices
+      #       has_many :expenses
+      #     end
+      #   end
+      #
+      # @example
+      #   # bad
+      #   with_options options: false do |merger|
+      #     merger.invoke(merger.something)
+      #   end
+      #
+      #   # good
+      #   with_options options: false do
+      #     invoke(something)
+      #   end
+      #
+      #   # good
+      #   client = Client.new
+      #   with_options options: false do |merger|
+      #     client.invoke(merger.something, something)
+      #   end
+      #
+      #   # ok
+      #   # When `with_options` includes a block, all scoping scenarios
+      #   # cannot be evaluated. Thus, it is ok to include the explicit
+      #   # receiver.
+      #   with_options options: false do |merger|
+      #     merger.invoke
+      #     with_another_method do |another_receiver|
+      #       merger.invoke(another_receiver)
+      #     end
+      #   end
+      class RedundantReceiverInWithOptions < Cop
+        extend TargetRailsVersion
+        include RangeHelp
+
+        minimum_target_rails_version 4.2
+
+        MSG = 'Redundant receiver in `with_options`.'
+
+        def_node_matcher :with_options?, <<~PATTERN
+          (block
+            (send nil? :with_options
+              (...))
+            (args
+              $_arg)
+            $_body)
+        PATTERN
+
+        def_node_search :all_block_nodes_in, <<~PATTERN
+          (block ...)
+        PATTERN
+
+        def_node_search :all_send_nodes_in, <<~PATTERN
+          (send ...)
+        PATTERN
+
+        def on_block(node)
+          with_options?(node) do |arg, body|
+            return if body.nil?
+            return unless all_block_nodes_in(body).count.zero?
+
+            send_nodes = all_send_nodes_in(body)
+
+            if send_nodes.all? { |n| same_value?(arg, n.receiver) }
+              send_nodes.each do |send_node|
+                receiver = send_node.receiver
+                add_offense(send_node, location: receiver.source_range)
+              end
+            end
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.receiver.source_range)
+            corrector.remove(node.loc.dot)
+            corrector.remove(block_argument_range(node))
+          end
+        end
+
+        private
+
+        def block_argument_range(node)
+          block_node = node.each_ancestor(:block).first
+          block_argument = block_node.children[1].source_range
+
+          range_between(
+            search_begin_pos_of_space_before_block_argument(
+              block_argument.begin_pos
+            ),
+            block_argument.end_pos
+          )
+        end
+
+        def search_begin_pos_of_space_before_block_argument(begin_pos)
+          position = begin_pos - 1
+
+          if processed_source.raw_source[position] == ' '
+            search_begin_pos_of_space_before_block_argument(position)
+          else
+            begin_pos
+          end
+        end
+
+        def same_value?(arg_node, recv_node)
+          recv_node && recv_node.children[0] == arg_node.children[0]
+        end
+      end
+    end
+  end
+end