rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -21,30 +20,40 @@ module RuboCop
       # When EnforcedStyle is 'flexible' then only 'Date.today' is prohibited
       # and only 'to_time' is reported as warning.
       #
-      # @example
-      #   # no offense
-      #   Time.zone.today
-      #   Time.zone.today - 1.day
-      #
-      #   # acceptable
+      # @example EnforcedStyle: strict
+      #   # bad
       #   Date.current
       #   Date.yesterday
+      #   Date.today
+      #   date.to_time
+      #   date.to_time_in_current_zone
+      #
+      #   # good
+      #   Time.zone.today
+      #   Time.zone.today - 1.day
       #
-      #   # always reports offense
+      # @example EnforcedStyle: flexible (default)
+      #   # bad
       #   Date.today
       #   date.to_time
       #
-      #   # reports offense only when style is 'strict'
+      #   # good
+      #   Time.zone.today
+      #   Time.zone.today - 1.day
+      #   Date.current
+      #   Date.yesterday
       #   date.to_time_in_current_zone
+      #
       class Date < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Do not use `%s` without zone. Use `%s` instead.'.freeze
+        MSG = 'Do not use `Date.%<day>s` without zone. Use ' \
+              '`Time.zone.%<day>s` instead.'.freeze
 
-        MSG_SEND = 'Do not use `%s` on Date objects, because they ' \
+        MSG_SEND = 'Do not use `%<method>s` on Date objects, because they ' \
                    'know nothing about the time zone in use.'.freeze
 
-        BAD_DAYS = [:today, :current, :yesterday, :tomorrow].freeze
+        BAD_DAYS = %i[today current yesterday tomorrow].freeze
 
         def on_const(node)
           mod, klass = *node.children
@@ -55,45 +64,29 @@ module RuboCop
         end
 
         def on_send(node)
-          receiver, method_name, *args = *node
-          return unless receiver && bad_methods.include?(method_name)
+          return unless node.receiver && bad_methods.include?(node.method_name)
 
-          chain = extract_method_chain(node)
-          return if safe_chain?(chain)
-
-          return if method_name == :to_time && args.length == 1
+          return if safe_chain?(node) || safe_to_time?(node)
 
-          add_offense(node, :selector,
-                      format(MSG_SEND,
-                             method_name))
+          add_offense(node, location: :selector,
+                            message: format(MSG_SEND, method: node.method_name))
         end
 
         private
 
         def check_date_node(node)
           chain = extract_method_chain(node)
+
           return if (chain & bad_days).empty?
 
           method_name = (chain & bad_days).join('.')
 
-          add_offense(node, :selector,
-                      format(MSG,
-                             "Date.#{method_name}",
-                             "Time.zone.#{method_name}"))
+          add_offense(node, location: :selector,
+                            message: format(MSG, day: method_name.to_s))
         end
 
         def extract_method_chain(node)
-          chain = []
-          while !node.nil? && node.send_type?
-            chain << extract_method(node)
-            node = node.parent
-          end
-          chain
-        end
-
-        def extract_method(node)
-          _receiver, method_name, *_args = *node
-          method_name
+          [node, *node.each_ancestor(:send)].map(&:method_name)
         end
 
         # checks that parent node of send_type
@@ -101,17 +94,29 @@ module RuboCop
         def method_send?(node)
           return false unless node.parent && node.parent.send_type?
 
-          receiver, _method_name, *_args = *node.parent
-
-          receiver == node
+          node.parent.receiver == node
         end
 
-        def safe_chain?(chain)
+        def safe_chain?(node)
+          chain = extract_method_chain(node)
+
           (chain & bad_methods).empty? || !(chain & good_methods).empty?
         end
 
+        def safe_to_time?(node)
+          return unless node.method?(:to_time)
+
+          if node.receiver.str_type?
+            zone_regexp = /([+-][\d:]+|\dZ)\z/
+
+            node.receiver.str_content.match(zone_regexp)
+          else
+            node.arguments.one?
+          end
+        end
+
         def good_days
-          style == :strict ? [] : [:current, :yesterday, :tomorrow]
+          style == :strict ? [] : %i[current yesterday tomorrow]
         end
 
         def bad_days
@@ -119,7 +124,7 @@ module RuboCop
         end
 
         def bad_methods
-          style == :strict ? [:to_time, :to_time_in_current_zone] : [:to_time]
+          style == :strict ? %i[to_time to_time_in_current_zone] : [:to_time]
         end
 
         def good_methods

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

@@ -1,11 +1,19 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for delegations, that could have been created
-      # automatically with delegate method.
+      # This cop looks for delegations that could have been created
+      # automatically with the `delegate` method.
+      #
+      # Safe navigation `&.` is ignored because Rails' `allow_nil`
+      # option checks not just for nil but also delegates if nil
+      # responds to the delegated method.
+      #
+      # The `EnforceForPrefixed` option (defaulted to `true`) means that
+      # using the target object as a prefix of the method name
+      # without using the `delegate` method will be a violation.
+      # When set to `false`, this case is legal.
       #
       # @example
       #   # bad
@@ -16,6 +24,18 @@ module RuboCop
       #   # good
       #   delegate :bar, to: :foo
       #
+      #   # good
+      #   def bar
+      #     foo&.bar
+      #   end
+      #
+      #   # good
+      #   private
+      #   def bar
+      #     foo.bar
+      #   end
+      #
+      #   # EnforceForPrefixed: true
       #   # bad
       #   def foo_bar
       #     foo.bar
@@ -24,27 +44,29 @@ module RuboCop
       #   # good
       #   delegate :bar, to: :foo, prefix: true
       #
+      #   # EnforceForPrefixed: false
       #   # good
-      #   private
-      #   def bar
+      #   def foo_bar
       #     foo.bar
       #   end
+      #
+      #   # good
+      #   delegate :bar, to: :foo, prefix: true
       class Delegate < Cop
         MSG = 'Use `delegate` to define delegations.'.freeze
 
         def on_def(node)
-          method_name, args, body = *node
-          return unless trivial_delegate?(method_name, args, body)
+          return unless trivial_delegate?(node)
           return if private_or_protected_delegation(node)
-          add_offense(node, :keyword, MSG)
-        end
 
-        private
+          add_offense(node, location: :keyword)
+        end
 
         def autocorrect(node)
           method_name, _args, body = *node
-          delegation = ["delegate :#{body.children[1]}",
-                        "to: :#{body.children[0].children[1]}"]
+          delegation = ["delegate :#{body.method_name}",
+                        "to: :#{body.receiver.method_name}"]
+
           if method_name == prefixed_method_name(body)
             delegation << ['prefix: true']
           end
@@ -54,49 +76,49 @@ module RuboCop
           end
         end
 
-        def trivial_delegate?(method_name, args, body)
-          body && delegate?(body) &&
+        private
+
+        def trivial_delegate?(def_node)
+          method_name, args, body = *def_node
+
+          delegate?(body) &&
             method_name_matches?(method_name, body) &&
             arguments_match?(args, body)
         end
 
         def delegate?(body)
-          receiver, * = *body
-          return false unless receiver.is_a? Parser::AST::Node
-          return false unless receiver.type == :send
-          receiver.child_nodes.empty?
+          body && body.send_type? && body.receiver &&
+            body.receiver.send_type? && !body.receiver.receiver
         end
 
-        def arguments_match?(args, body)
-          _receiver, _method_name, *arguments = *body
-          arg_array = Array(args)
-          argument_array = Array(arguments)
-          arg_array.size == argument_array.size && (
-            arg_array == argument_array ||
+        def arguments_match?(arg_array, body)
+          argument_array = body.arguments
+
+          arg_array == argument_array ||
             arg_array.map(&:children) == argument_array.map(&:children)
-          )
         end
 
         def method_name_matches?(method_name, body)
-          _receiver, property_name, *_args = *body
-          method_name == property_name ||
-            method_name == prefixed_method_name(body)
+          method_name == body.method_name ||
+            include_prefix_case? && method_name == prefixed_method_name(body)
+        end
+
+        def include_prefix_case?
+          cop_config['EnforceForPrefixed']
         end
 
         def prefixed_method_name(body)
-          receiver, property_name, *_args = *body
-          _receiver, target, *_args = *receiver
-          [target, property_name].join('_').to_sym
+          [body.receiver.method_name, body.method_name].join('_').to_sym
         end
 
         def private_or_protected_delegation(node)
-          line = node.loc.line
+          line = node.first_line
           private_or_protected_before(line) ||
             private_or_protected_inline(line)
         end
 
         def private_or_protected_before(line)
-          (processed_source[0..line].map(&:strip) & %w(private protected)).any?
+          (processed_source[0..line].map(&:strip) & %w[private protected]).any?
         end
 
         def private_or_protected_inline(line)

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for delegations that pass :allow_blank as an option
+      # instead of :allow_nil. :allow_blank is not a valid option to pass
+      # to ActiveSupport#delegate.
+      #
+      # @example
+      #   # bad
+      #   delegate :foo, to: :bar, allow_blank: true
+      #
+      #   # good
+      #   delegate :foo, to: :bar, allow_nil: true
+      class DelegateAllowBlank < Cop
+        MSG = '`allow_blank` is not a valid option, use `allow_nil`.'.freeze
+
+        def_node_matcher :delegate_options, <<-PATTERN
+          (send nil? :delegate _ $hash)
+        PATTERN
+
+        def_node_matcher :allow_blank_option?, <<-PATTERN
+          (pair (sym :allow_blank) true)
+        PATTERN
+
+        def on_send(node)
+          offending_node = allow_blank_option(node)
+
+          return unless offending_node
+
+          add_offense(offending_node)
+        end
+
+        def autocorrect(pair_node)
+          lambda do |corrector|
+            corrector.replace(pair_node.key.source_range, 'allow_nil')
+          end
+        end
+
+        private
+
+        def allow_blank_option(node)
+          delegate_options(node) do |hash|
+            hash.pairs.find { |opt| allow_blank_option?(opt) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks dynamic `find_by_*` methods.
+      # Use `find_by` instead of dynamic method.
+      # See. https://github.com/bbatsov/rails-style-guide#find_by
+      #
+      # @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)
+      #
+      #   # good
+      #   User.find_by(name: name, email: email)
+      #
+      #   # good
+      #   User.find_by!(email: email)
+      class DynamicFindBy < Cop
+        MSG = 'Use `%<static_name>s` instead of dynamic `%<method>s`.'.freeze
+        METHOD_PATTERN = /^find_by_(.+?)(!)?$/
+
+        def on_send(node)
+          method_name = node.method_name.to_s
+
+          return if whitelist.include?(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))
+        end
+
+        def autocorrect(node)
+          _receiver, method, *args = *node
+          static_name = static_method_name(method.to_s)
+          keywords = column_keywords(method)
+
+          return if keywords.size != args.size
+
+          lambda do |corrector|
+            corrector.replace(node.loc.selector, static_name)
+            keywords.each.with_index do |keyword, idx|
+              corrector.insert_before(args[idx].loc.expression, keyword)
+            end
+          end
+        end
+
+        private
+
+        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}: " }
+        end
+
+        # Returns static method name.
+        # If code isn't wrong, returns nil
+        def static_method_name(method_name)
+          match = METHOD_PATTERN.match(method_name)
+          return nil unless match
+          match[2] ? 'find_by!' : 'find_by'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for duplicate values in enum declarations.
+      #
+      # @example
+      #   # bad
+      #   enum status: { active: 0, archived: 0 }
+      #
+      #   # good
+      #   enum status: { active: 0, archived: 1 }
+      #
+      #   # bad
+      #   enum status: [:active, :archived, :active]
+      #
+      #   # good
+      #   enum status: [:active, :archived]
+      class EnumUniqueness < Cop
+        include Duplication
+
+        MSG = 'Duplicate value `%<value>s` found in `%<enum>s` ' \
+              'enum declaration.'.freeze
+
+        def_node_matcher :enum_declaration, <<-PATTERN
+          (send nil? :enum (hash (pair (_ $_) ${array hash})))
+        PATTERN
+
+        def on_send(node)
+          enum_declaration(node) do |name, args|
+            items = args.values
+
+            return unless duplicates?(items)
+
+            consecutive_duplicates(items).each do |item|
+              add_offense(item, message: format(MSG, value: item.source,
+                                                     enum: name))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that Rails.env is compared using `.production?`-like
+      # methods instead of equality against a string or symbol.
+      #
+      # @example
+      #   # bad
+      #   Rails.env == 'production'
+      #
+      #   # bad, always returns false
+      #   Rails.env == :test
+      #
+      #   # good
+      #   Rails.env.production?
+      class EnvironmentComparison < Cop
+        MSG = "Favor `Rails.env.%<env>s?` over `Rails.env == '%<env>s'`.".freeze
+
+        SYM_MSG = 'Do not compare `Rails.env` with a symbol, it will always ' \
+          'evaluate to `false`.'.freeze
+
+        def_node_matcher :environment_str_comparison?, <<-PATTERN
+          (send
+            (send (const {nil? cbase} :Rails) :env)
+            :==
+            $str
+          )
+        PATTERN
+
+        def_node_matcher :environment_sym_comparison?, <<-PATTERN
+          (send
+            (send (const {nil? cbase} :Rails) :env)
+            :==
+            $sym
+          )
+        PATTERN
+
+        def on_send(node)
+          environment_str_comparison?(node) do |env_node|
+            env, = *env_node
+            add_offense(node, message: format(MSG, env: env))
+          end
+          environment_sym_comparison?(node) do |_|
+            add_offense(node, message: SYM_MSG)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, replacement(node))
+          end
+        end
+
+        private
+
+        def replacement(node)
+          receiver, _, compared = *node
+          environment, = *compared
+          "#{receiver.source}.#{environment}?"
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -17,25 +16,30 @@ module RuboCop
       # - 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.
+      #
+      # @example
+      #   # bad
+      #   exit(0)
+      #
+      #   # good
+      #   raise 'a bad error has happened'
       class Exit < Cop
         include ConfigurableEnforcedStyle
 
         MSG = 'Do not use `exit` in Rails applications.'.freeze
-        TARGET_METHODS = [:exit, :exit!].freeze
-        EXPLICIT_RECEIVERS = [:Kernel, :Process].freeze
+        TARGET_METHODS = %i[exit exit!].freeze
+        EXPLICIT_RECEIVERS = %i[Kernel Process].freeze
 
         def on_send(node)
-          add_offense(node, :selector) if offending_node?(node)
+          add_offense(node, location: :selector) if offending_node?(node)
         end
 
         private
 
         def offending_node?(node)
-          receiver_node, method_name, *arg_nodes = *node
-
-          right_method_name?(method_name) &&
-            right_argument_count?(arg_nodes) &&
-            right_receiver?(receiver_node)
+          right_method_name?(node.method_name) &&
+            right_argument_count?(node.arguments) &&
+            right_receiver?(node.receiver)
         end
 
         def right_method_name?(method_name)
@@ -45,15 +49,17 @@ module RuboCop
         # More than 1 argument likely means it is a different
         # `exit` implementation than the one we are preventing.
         def right_argument_count?(arg_nodes)
-          arg_nodes.length <= 1
+          arg_nodes.size <= 1
         end
 
         # Only register if exit is being called explicitly on
         # Kernel or Process or if receiver node is nil for plain
         # `exit` calls.
         def right_receiver?(receiver_node)
-          return true if receiver_node.nil?
+          return true unless receiver_node
+
           _a, receiver_node_class, _c = *receiver_node
+
           EXPLICIT_RECEIVERS.include?(receiver_node_class)
         end
       end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop is used to identify usages of file path joining process
+      # to use `Rails.root.join` clause.
+      #
+      # @example
+      #  # bad
+      #  Rails.root.join('app/models/goober')
+      #  File.join(Rails.root, 'app/models/goober')
+      #  "#{Rails.root}/app/models/goober"
+      #
+      #  # good
+      #  Rails.root.join('app', 'models', 'goober')
+      class FilePath < Cop
+        MSG = 'Please use `Rails.root.join(\'path\', \'to\')` instead.'.freeze
+
+        def_node_matcher :file_join_nodes?, <<-PATTERN
+          (send (const nil? :File) :join ...)
+        PATTERN
+
+        def_node_search :rails_root_nodes?, <<-PATTERN
+          (send (const nil? :Rails) :root)
+        PATTERN
+
+        def_node_matcher :rails_root_join_nodes?, <<-PATTERN
+          (send (send (const nil? :Rails) :root) :join ...)
+        PATTERN
+
+        def on_dstr(node)
+          return unless rails_root_nodes?(node)
+          register_offense(node)
+        end
+
+        def on_send(node)
+          check_for_file_join_with_rails_root(node)
+          check_for_rails_root_join_with_slash_separated_path(node)
+        end
+
+        private
+
+        def check_for_file_join_with_rails_root(node)
+          return unless file_join_nodes?(node)
+          return unless node.arguments.any? { |e| rails_root_nodes?(e) }
+
+          register_offense(node)
+        end
+
+        def check_for_rails_root_join_with_slash_separated_path(node)
+          return unless rails_root_nodes?(node)
+          return unless rails_root_join_nodes?(node)
+          return unless node.arguments.any? { |arg| string_with_slash?(arg) }
+
+          register_offense(node)
+        end
+
+        def string_with_slash?(node)
+          node.str_type? && node.source =~ %r{/}
+        end
+
+        def register_offense(node)
+          line_range = node.loc.column...node.loc.last_column
+          source_range = source_range(processed_source.buffer, node.first_line,
+                                      line_range)
+          add_offense(node, location: source_range)
+        end
+      end
+    end
+  end
+end