rubocop-rails 2.0.0

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

@@ -0,0 +1,107 @@
+# 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 `%<number>s.%<correct>s`.'
+
+        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
+
+        def autocorrect(node)
+          lambda do |corrector|
+            method_name = node.loc.selector.source
+
+            corrector.replace(node.loc.selector, correct_method(method_name))
+          end
+        end
+
+        private
+
+        def message(node)
+          number, = *node.receiver
+
+          format(MSG, number: number,
+                      correct: correct_method(node.method_name.to_s))
+        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/presence.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks code that can be written more easily using
+      # `Object#presence` defined by Active Support.
+      #
+      # @example
+      #   # bad
+      #   a.present? ? a : nil
+      #
+      #   # bad
+      #   !a.present? ? nil : a
+      #
+      #   # bad
+      #   a.blank? ? nil : a
+      #
+      #   # bad
+      #   !a.blank? ? a : nil
+      #
+      #   # good
+      #   a.presence
+      #
+      # @example
+      #   # bad
+      #   a.present? ? a : b
+      #
+      #   # bad
+      #   !a.present? ? b : a
+      #
+      #   # bad
+      #   a.blank? ? b : a
+      #
+      #   # bad
+      #   !a.blank? ? a : b
+      #
+      #   # good
+      #   a.presence || b
+      class Presence < Cop
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+
+        def_node_matcher :redundant_receiver_and_other, <<-PATTERN
+          {
+            (if
+              (send $_recv :present?)
+              _recv
+              $!begin
+            )
+            (if
+              (send $_recv :blank?)
+              $!begin
+              _recv
+            )
+          }
+        PATTERN
+
+        def_node_matcher :redundant_negative_receiver_and_other, <<-PATTERN
+          {
+            (if
+              (send (send $_recv :present?) :!)
+              $!begin
+              _recv
+            )
+            (if
+              (send (send $_recv :blank?) :!)
+              _recv
+              $!begin
+            )
+          }
+        PATTERN
+
+        def on_if(node)
+          return if ignore_if_node?(node)
+
+          redundant_receiver_and_other(node) do |receiver, other|
+            unless ignore_other_node?(other) || receiver.nil?
+              add_offense(node, message: message(node, receiver, other))
+            end
+          end
+
+          redundant_negative_receiver_and_other(node) do |receiver, other|
+            unless ignore_other_node?(other) || receiver.nil?
+              add_offense(node, message: message(node, receiver, other))
+            end
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            redundant_receiver_and_other(node) do |receiver, other|
+              corrector.replace(node.source_range, replacement(receiver, other))
+            end
+
+            redundant_negative_receiver_and_other(node) do |receiver, other|
+              corrector.replace(node.source_range, replacement(receiver, other))
+            end
+          end
+        end
+
+        private
+
+        def ignore_if_node?(node)
+          node.elsif?
+        end
+
+        def ignore_other_node?(node)
+          node && (node.if_type? || node.rescue_type? || node.while_type?)
+        end
+
+        def message(node, receiver, other)
+          format(MSG,
+                 prefer: replacement(receiver, other),
+                 current: node.source)
+        end
+
+        def replacement(receiver, other)
+          or_source = other.nil? || other.nil_type? ? '' : " || #{other.source}"
+          "#{receiver.source}.presence" + or_source
+        end
+      end
+    end
+  end
+end

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/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