rubocop-rails 2.4.2 → 2.7.0

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

@@ -10,37 +10,41 @@ module RuboCop
       # @example
       #   # bad
       #   User.find_by_name(name)
-      #
-      #   # bad
       #   User.find_by_name_and_email(name)
-      #
-      #   # bad
       #   User.find_by_email!(name)
       #
       #   # good
       #   User.find_by(name: name)
+      #   User.find_by(name: name, email: email)
+      #   User.find_by!(email: email)
+      #
+      # @example AllowedMethods: find_by_sql
+      #   # bad
+      #   User.find_by_query(users_query)
       #
       #   # good
-      #   User.find_by(name: name, email: email)
+      #   User.find_by_sql(users_sql)
+      #
+      # @example AllowedReceivers: Gem::Specification
+      #   # bad
+      #   Specification.find_by_name('backend').gem_dir
       #
       #   # good
-      #   User.find_by!(email: email)
+      #   Gem::Specification.find_by_name('backend').gem_dir
       class DynamicFindBy < Cop
         MSG = 'Use `%<static_name>s` instead of dynamic `%<method>s`.'
         METHOD_PATTERN = /^find_by_(.+?)(!)?$/.freeze
 
         def on_send(node)
-          method_name = node.method_name.to_s
-
-          return if whitelist.include?(method_name)
+          return if allowed_invocation?(node)
 
+          method_name = node.method_name
           static_name = static_method_name(method_name)
-
           return unless static_name
 
           add_offense(node,
                       message: format(MSG, static_name: static_name,
-                                           method: node.method_name))
+                                           method: method_name))
         end
         alias on_csend on_send
 
@@ -57,6 +61,31 @@ module RuboCop
 
         private
 
+        def allowed_invocation?(node)
+          allowed_method?(node) || allowed_receiver?(node) ||
+            whitelisted?(node)
+        end
+
+        def allowed_method?(node)
+          return unless cop_config['AllowedMethods']
+
+          cop_config['AllowedMethods'].include?(node.method_name.to_s)
+        end
+
+        def allowed_receiver?(node)
+          return unless cop_config['AllowedReceivers'] && node.receiver
+
+          cop_config['AllowedReceivers'].include?(node.receiver.source)
+        end
+
+        # config option `WhiteList` will be deprecated soon
+        def whitelisted?(node)
+          whitelist_config = cop_config['Whitelist']
+          return unless whitelist_config
+
+          whitelist_config.include?(node.method_name.to_s)
+        end
+
         def autocorrect_method_name(corrector, node)
           corrector.replace(node.loc.selector,
                             static_method_name(node.method_name.to_s))
@@ -68,10 +97,6 @@ module RuboCop
           end
         end
 
-        def whitelist
-          cop_config['Whitelist']
-        end
-
         def column_keywords(method)
           keyword_string = method.to_s[METHOD_PATTERN, 1]
           keyword_string.split('_and_').map { |keyword| "#{keyword}: " }

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

@@ -16,52 +16,98 @@ module RuboCop
       #   # good
       #   Rails.env.production?
       class EnvironmentComparison < Cop
-        MSG = "Favor `Rails.env.%<env>s?` over `Rails.env == '%<env>s'`."
+        MSG = 'Favor `%<bang>sRails.env.%<env>s?` over `%<source>s`.'
 
         SYM_MSG = 'Do not compare `Rails.env` with a symbol, it will always ' \
           'evaluate to `false`.'
 
-        def_node_matcher :environment_str_comparison?, <<~PATTERN
+        def_node_matcher :comparing_str_env_with_rails_env_on_lhs?, <<~PATTERN
           (send
             (send (const {nil? cbase} :Rails) :env)
-            :==
+            {:== :!=}
             $str
           )
         PATTERN
 
-        def_node_matcher :environment_sym_comparison?, <<~PATTERN
+        def_node_matcher :comparing_str_env_with_rails_env_on_rhs?, <<~PATTERN
+          (send
+            $str
+            {:== :!=}
+            (send (const {nil? cbase} :Rails) :env)
+          )
+        PATTERN
+
+        def_node_matcher :comparing_sym_env_with_rails_env_on_lhs?, <<~PATTERN
           (send
             (send (const {nil? cbase} :Rails) :env)
-            :==
+            {:== :!=}
             $sym
           )
         PATTERN
 
+        def_node_matcher :comparing_sym_env_with_rails_env_on_rhs?, <<~PATTERN
+          (send
+            $sym
+            {:== :!=}
+            (send (const {nil? cbase} :Rails) :env)
+          )
+        PATTERN
+
+        def_node_matcher :content, <<~PATTERN
+          ({str sym} $_)
+        PATTERN
+
         def on_send(node)
-          environment_str_comparison?(node) do |env_node|
+          if (env_node = comparing_str_env_with_rails_env_on_lhs?(node) ||
+                         comparing_str_env_with_rails_env_on_rhs?(node))
             env, = *env_node
-            add_offense(node, message: format(MSG, env: env))
+            bang = node.method?(:!=) ? '!' : ''
+
+            add_offense(node, message: format(
+              MSG, bang: bang, env: env, source: node.source
+            ))
           end
-          environment_sym_comparison?(node) do |_|
+
+          if comparing_sym_env_with_rails_env_on_lhs?(node) ||
+             comparing_sym_env_with_rails_env_on_rhs?(node)
             add_offense(node, message: SYM_MSG)
           end
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, replacement(node))
+            replacement = build_predicate_method(node)
+
+            corrector.replace(node.source_range, replacement)
           end
         end
 
         private
 
-        def replacement(node)
-          "#{node.receiver.source}.#{content(node.first_argument)}?"
+        def build_predicate_method(node)
+          if rails_env_on_lhs?(node)
+            build_predicate_method_for_rails_env_on_lhs(node)
+          else
+            build_predicate_method_for_rails_env_on_rhs(node)
+          end
         end
 
-        def_node_matcher :content, <<~PATTERN
-          ({str sym} $_)
-        PATTERN
+        def rails_env_on_lhs?(node)
+          comparing_str_env_with_rails_env_on_lhs?(node) ||
+            comparing_sym_env_with_rails_env_on_lhs?(node)
+        end
+
+        def build_predicate_method_for_rails_env_on_lhs(node)
+          bang = node.method?(:!=) ? '!' : ''
+
+          "#{bang}#{node.receiver.source}.#{content(node.first_argument)}?"
+        end
+
+        def build_predicate_method_for_rails_env_on_rhs(node)
+          bang = node.method?(:!=) ? '!' : ''
+
+          "#{bang}#{node.first_argument.source}.#{content(node.receiver)}?"
+        end
       end
     end
   end

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

@@ -9,11 +9,11 @@ module RuboCop
       #
       # There are two obvious cases where `exit` is particularly harmful:
       #
-      # - Usage in library code for your application. Even though Rails will
+      # * Usage in library code for your application. Even though Rails will
       # rescue from a `SystemExit` and continue on, unit testing that library
       # code will result in specs exiting (potentially silently if `exit(0)`
       # is used.)
-      # - Usage in application code outside of the web process could result in
+      # * Usage in application code outside of the web process could result in
       # the program exiting, which could result in the code failing to run and
       # do its job.
       #

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

@@ -48,6 +48,7 @@ module RuboCop
 
         def on_dstr(node)
           return unless rails_root_nodes?(node)
+          return unless node.children.last.str_type?
           return unless node.children.last.source.start_with?('.') ||
                         node.children.last.source.include?(File::SEPARATOR)
 
@@ -89,7 +90,7 @@ module RuboCop
         end
 
         def string_with_slash?(node)
-          node.str_type? && node.source =~ %r{/}
+          node.str_type? && node.source.match?(%r{/})
         end
 
         def register_offense(node)

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces that `ActiveRecord#find` is used instead of
+      # `where.take!`, `find_by!`, and `find_by_id!` to retrieve a single record
+      # by primary key when you expect it to be found.
+      #
+      # @example
+      #   # bad
+      #   User.where(id: id).take!
+      #   User.find_by_id!(id)
+      #   User.find_by!(id: id)
+      #
+      #   # good
+      #   User.find(id)
+      #
+      class FindById < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+
+        def_node_matcher :where_take?, <<~PATTERN
+          (send
+            $(send _ :where
+              (hash
+                (pair (sym :id) $_))) :take!)
+        PATTERN
+
+        def_node_matcher :find_by?, <<~PATTERN
+          {
+            (send _ :find_by_id! $_)
+            (send _ :find_by! (hash (pair (sym :id) $_)))
+          }
+        PATTERN
+
+        def on_send(node)
+          where_take?(node) do |where, id_value|
+            range = where_take_offense_range(node, where)
+
+            good_method = build_good_method(id_value)
+            bad_method = build_where_take_bad_method(id_value)
+            message = format(MSG, good_method: good_method, bad_method: bad_method)
+
+            add_offense(node, location: range, message: message)
+          end
+
+          find_by?(node) do |id_value|
+            range = find_by_offense_range(node)
+
+            good_method = build_good_method(id_value)
+            bad_method = build_find_by_bad_method(node, id_value)
+            message = format(MSG, good_method: good_method, bad_method: bad_method)
+
+            add_offense(node, location: range, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          if (matches = where_take?(node))
+            where, id_value = *matches
+            range = where_take_offense_range(node, where)
+          elsif (id_value = find_by?(node))
+            range = find_by_offense_range(node)
+          end
+
+          lambda do |corrector|
+            replacement = build_good_method(id_value)
+            corrector.replace(range, replacement)
+          end
+        end
+
+        private
+
+        def where_take_offense_range(node, where)
+          range_between(where.loc.selector.begin_pos, node.loc.expression.end_pos)
+        end
+
+        def find_by_offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
+        end
+
+        def build_good_method(id_value)
+          "find(#{id_value.source})"
+        end
+
+        def build_where_take_bad_method(id_value)
+          "where(id: #{id_value.source}).take!"
+        end
+
+        def build_find_by_bad_method(node, id_value)
+          case node.method_name
+          when :find_by_id!
+            "find_by_id!(#{id_value.source})"
+          when :find_by!
+            "find_by!(id: #{id_value.source})"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,7 @@ module RuboCop
       # 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.
+      # .rubocop.yml file to 4.2.
       #
       # @example
       #   # bad
@@ -22,7 +22,7 @@ module RuboCop
         MSG = 'Use keyword arguments instead of ' \
               'positional arguments for http call: `%<verb>s`.'
         KEYWORD_ARGS = %i[
-          method params session body flash xhr as headers env
+          method params session body flash xhr as headers env to
         ].freeze
         HTTP_METHODS = %i[get post put patch delete head].freeze
 

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

@@ -83,6 +83,7 @@ module RuboCop
                         'to define HTTP status code.'
 
           attr_reader :node
+
           def initialize(node)
             @node = node
           end
@@ -124,6 +125,7 @@ module RuboCop
           PERMITTED_STATUS = %i[error success missing redirect].freeze
 
           attr_reader :node
+
           def initialize(node)
             @node = node
           end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for uses of `each_with_object({}) { ... }`,
+      # `map { ... }.to_h`, and `Hash[map { ... }]` that are transforming
+      # an enumerable into a hash where the values are the original elements.
+      # Rails provides the `index_by` method for this purpose.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].each_with_object({}) { |el, h| h[foo(el)] = el }
+      #   [1, 2, 3].map { |el| [foo(el), el] }.to_h
+      #   Hash[[1, 2, 3].collect { |el| [foo(el), el] }]
+      #
+      #   # good
+      #   [1, 2, 3].index_by { |el| foo(el) }
+      class IndexBy < Cop
+        include IndexMethod
+
+        def_node_matcher :on_bad_each_with_object, <<~PATTERN
+          (block
+            ({send csend} _ :each_with_object (hash))
+            (args (arg $_el) (arg _memo))
+            ({send csend} (lvar _memo) :[]= $_ (lvar _el)))
+        PATTERN
+
+        def_node_matcher :on_bad_map_to_h, <<~PATTERN
+          ({send csend}
+            (block
+              ({send csend} _ {:map :collect})
+              (args (arg $_el))
+              (array $_ (lvar _el)))
+            :to_h)
+        PATTERN
+
+        def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
+          (send
+            (const _ :Hash)
+            :[]
+            (block
+              ({send csend} _ {:map :collect})
+              (args (arg $_el))
+              (array $_ (lvar _el))))
+        PATTERN
+
+        private
+
+        def new_method_name
+          'index_by'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for uses of `each_with_object({}) { ... }`,
+      # `map { ... }.to_h`, and `Hash[map { ... }]` that are transforming
+      # an enumerable into a hash where the keys are the original elements.
+      # Rails provides the `index_with` method for this purpose.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].each_with_object({}) { |el, h| h[el] = foo(el) }
+      #   [1, 2, 3].map { |el| [el, foo(el)] }.to_h
+      #   Hash[[1, 2, 3].collect { |el| [el, foo(el)] }]
+      #
+      #   # good
+      #   [1, 2, 3].index_with { |el| foo(el) }
+      class IndexWith < Cop
+        extend TargetRailsVersion
+        include IndexMethod
+
+        minimum_target_rails_version 6.0
+
+        def_node_matcher :on_bad_each_with_object, <<~PATTERN
+          (block
+            ({send csend} _ :each_with_object (hash))
+            (args (arg $_el) (arg _memo))
+            ({send csend} (lvar _memo) :[]= (lvar _el) $_))
+        PATTERN
+
+        def_node_matcher :on_bad_map_to_h, <<~PATTERN
+          ({send csend}
+            (block
+              ({send csend} _ {:map :collect})
+              (args (arg $_el))
+              (array (lvar _el) $_))
+            :to_h)
+        PATTERN
+
+        def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
+          (send
+            (const _ :Hash)
+            :[]
+            (block
+              ({send csend} _ {:map :collect})
+              (args (arg $_el))
+              (array (lvar _el) $_)))
+        PATTERN
+
+        private
+
+        def new_method_name
+          'index_with'
+        end
+      end
+    end
+  end
+end