rubocop-rails 2.0.1 → 2.19.1

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Looks for enums written with array syntax.
+      #
+      # When using array syntax, adding an element in a
+      # position other than the last causes all previous
+      # definitions to shift. Explicitly specifying the
+      # value for each key prevents this from happening.
+      #
+      # @example
+      #   # bad
+      #   enum status: [:active, :archived]
+      #
+      #   # good
+      #   enum status: { active: 0, archived: 1 }
+      #
+      class EnumHash < Base
+        extend AutoCorrector
+
+        MSG = 'Enum defined as an array found in `%<enum>s` enum declaration. Use hash syntax instead.'
+        RESTRICT_ON_SEND = %i[enum].freeze
+
+        def_node_matcher :enum?, <<~PATTERN
+          (send nil? :enum (hash $...))
+        PATTERN
+
+        def_node_matcher :array_pair?, <<~PATTERN
+          (pair $_ $array)
+        PATTERN
+
+        def on_send(node)
+          enum?(node) do |pairs|
+            pairs.each do |pair|
+              key, array = array_pair?(pair)
+              next unless key
+
+              add_offense(array, message: format(MSG, enum: enum_name(key))) do |corrector|
+                hash = array.children.each_with_index.map do |elem, index|
+                  "#{source(elem)} => #{index}"
+                end.join(', ')
+
+                corrector.replace(array, "{#{hash}}")
+              end
+            end
+          end
+        end
+
+        private
+
+        def enum_name(key)
+          case key.type
+          when :sym, :str
+            key.value
+          else
+            key.source
+          end
+        end
+
+        def source(elem)
+          case elem.type
+          when :str
+            elem.value.dump
+          when :sym
+            elem.value.inspect
+          else
+            elem.source
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for duplicate values in enum declarations.
+      # Looks for duplicate values in enum declarations.
       #
       # @example
       #   # bad
@@ -17,28 +17,46 @@ module RuboCop
       #
       #   # good
       #   enum status: [:active, :archived]
-      class EnumUniqueness < Cop
+      class EnumUniqueness < Base
         include Duplication
 
-        MSG = 'Duplicate value `%<value>s` found in `%<enum>s` ' \
-              'enum declaration.'
+        MSG = 'Duplicate value `%<value>s` found in `%<enum>s` enum declaration.'
+        RESTRICT_ON_SEND = %i[enum].freeze
 
-        def_node_matcher :enum_declaration, <<-PATTERN
-          (send nil? :enum (hash (pair (_ $_) ${array hash})))
+        def_node_matcher :enum?, <<~PATTERN
+          (send nil? :enum (hash $...))
+        PATTERN
+
+        def_node_matcher :enum_values, <<~PATTERN
+          (pair $_ ${array hash})
         PATTERN
 
         def on_send(node)
-          enum_declaration(node) do |name, args|
-            items = args.values
+          enum?(node) do |pairs|
+            pairs.each do |pair|
+              enum_values(pair) do |key, args|
+                items = args.values
 
-            return unless duplicates?(items)
+                next unless duplicates?(items)
 
-            consecutive_duplicates(items).each do |item|
-              add_offense(item, message: format(MSG, value: item.source,
-                                                     enum: name))
+                consecutive_duplicates(items).each do |item|
+                  add_offense(item, message: format(MSG, value: item.source, enum: enum_name(key)))
+                end
+              end
             end
           end
         end
+
+        private
+
+        def enum_name(key)
+          case key.type
+          when :sym, :str
+            key.value
+          else
+            key.source
+          end
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that Rails.env is compared using `.production?`-like
+      # Checks that Rails.env is compared using `.production?`-like
       # methods instead of equality against a string or symbol.
       #
       # @example
@@ -15,53 +15,101 @@ module RuboCop
       #
       #   # good
       #   Rails.env.production?
-      class EnvironmentComparison < Cop
-        MSG = "Favor `Rails.env.%<env>s?` over `Rails.env == '%<env>s'`."
+      class EnvironmentComparison < Base
+        extend AutoCorrector
 
-        SYM_MSG = 'Do not compare `Rails.env` with a symbol, it will always ' \
-          'evaluate to `false`.'
+        MSG = 'Favor `%<bang>sRails.env.%<env>s?` over `%<source>s`.'
 
-        def_node_matcher :environment_str_comparison?, <<-PATTERN
+        SYM_MSG = 'Do not compare `Rails.env` with a symbol, it will always evaluate to `false`.'
+
+        RESTRICT_ON_SEND = %i[== !=].freeze
+
+        def_node_matcher :comparing_str_env_with_rails_env_on_lhs?, <<~PATTERN
           (send
             (send (const {nil? cbase} :Rails) :env)
-            :==
+            {:== :!=}
+            $str
+          )
+        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 :environment_sym_comparison?, <<-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?(:!=) ? '!' : ''
+            message = format(MSG, bang: bang, env: env, source: node.source)
+
+            add_offense(node, message: message) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
-          environment_sym_comparison?(node) do |_|
-            add_offense(node, message: SYM_MSG)
+
+          return unless comparing_sym_env_with_rails_env_on_lhs?(node) || comparing_sym_env_with_rails_env_on_rhs?(node)
+
+          add_offense(node, message: SYM_MSG) do |corrector|
+            autocorrect(corrector, node)
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, replacement(node))
+        private
+
+        def autocorrect(corrector, node)
+          replacement = build_predicate_method(node)
+
+          corrector.replace(node, replacement)
+        end
+
+        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
 
-        private
+        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?(:!=) ? '!' : ''
 
-        def replacement(node)
-          "#{node.receiver.source}.#{content(node.first_argument)}?"
+          "#{bang}#{node.receiver.source}.#{content(node.first_argument)}?"
         end
 
-        def_node_matcher :content, <<-PATTERN
-          ({str sym} $_)
-        PATTERN
+        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/environment_variable_access.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Looks for direct access to environment variables through the
+      # `ENV` variable within the application code. This can lead to runtime
+      # errors due to misconfiguration that could have been discovered at boot
+      # time if the environment variables were loaded as part of initialization
+      # and copied into the application's configuration or secrets. The cop can
+      # be configured to allow either reads or writes if required.
+      #
+      # @example
+      #   # good
+      #   Rails.application.config.foo
+      #   Rails.application.config.x.foo.bar
+      #   Rails.application.secrets.foo
+      #   Rails.application.config.foo = "bar"
+      #
+      # @example AllowReads: false (default)
+      #   # bad
+      #   ENV["FOO"]
+      #   ENV.fetch("FOO")
+      #
+      # @example AllowReads: true
+      #   # good
+      #   ENV["FOO"]
+      #   ENV.fetch("FOO")
+      #
+      # @example AllowWrites: false (default)
+      #   # bad
+      #   ENV["FOO"] = "bar"
+      #
+      # @example AllowWrites: true
+      #   # good
+      #   ENV["FOO"] = "bar"
+      class EnvironmentVariableAccess < Base
+        READ_MSG = 'Do not read from `ENV` directly post initialization.'
+        WRITE_MSG = 'Do not write to `ENV` directly post initialization.'
+
+        def on_const(node)
+          add_offense(node, message: READ_MSG) if env_read?(node) && !allow_reads?
+          add_offense(node, message: WRITE_MSG) if env_write?(node) && !allow_writes?
+        end
+
+        def_node_search :env_read?, <<~PATTERN
+          ^(send (const {cbase nil?} :ENV) !:[]= ...)
+        PATTERN
+
+        def_node_search :env_write?, <<~PATTERN
+          {^(indexasgn (const {cbase nil?} :ENV) ...)
+           ^(send (const {cbase nil?} :ENV) :[]= ...)}
+        PATTERN
+
+        private
+
+        def allow_reads?
+          cop_config['AllowReads'] == true
+        end
+
+        def allow_writes?
+          cop_config['AllowWrites'] == true
+        end
+      end
+    end
+  end
+end

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

@@ -3,17 +3,17 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop enforces that `exit` calls are not used within a rails app.
+      # Enforces that `exit` calls are not used within a rails app.
       # Valid options are instead to raise an error, break, return, or some
       # other form of stopping execution of current request.
       #
       # 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.
       #
@@ -23,27 +23,21 @@ module RuboCop
       #
       #   # good
       #   raise 'a bad error has happened'
-      class Exit < Cop
+      class Exit < Base
         include ConfigurableEnforcedStyle
 
         MSG = 'Do not use `exit` in Rails applications.'
-        TARGET_METHODS = %i[exit exit!].freeze
+        RESTRICT_ON_SEND = %i[exit exit!].freeze
         EXPLICIT_RECEIVERS = %i[Kernel Process].freeze
 
         def on_send(node)
-          add_offense(node, location: :selector) if offending_node?(node)
+          add_offense(node.loc.selector) if offending_node?(node)
         end
 
         private
 
         def offending_node?(node)
-          right_method_name?(node.method_name) &&
-            right_argument_count?(node.arguments) &&
-            right_receiver?(node.receiver)
-        end
-
-        def right_method_name?(method_name)
-          TARGET_METHODS.include?(method_name)
+          right_argument_count?(node.arguments) && right_receiver?(node.receiver)
         end
 
         # More than 1 argument likely means it is a different

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for expanded date range. It only compatible `..` range is targeted.
+      # Incompatible `...` range is ignored.
+      #
+      # @example
+      #   # bad
+      #   date.beginning_of_day..date.end_of_day
+      #   date.beginning_of_week..date.end_of_week
+      #   date.beginning_of_month..date.end_of_month
+      #   date.beginning_of_quarter..date.end_of_quarter
+      #   date.beginning_of_year..date.end_of_year
+      #
+      #   # good
+      #   date.all_day
+      #   date.all_week
+      #   date.all_month
+      #   date.all_quarter
+      #   date.all_year
+      #
+      class ExpandedDateRange < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Use `%<preferred_method>s` instead.'
+
+        minimum_target_rails_version 5.1
+
+        PREFERRED_METHODS = {
+          beginning_of_day: 'all_day',
+          beginning_of_week: 'all_week',
+          beginning_of_month: 'all_month',
+          beginning_of_quarter: 'all_quarter',
+          beginning_of_year: 'all_year'
+        }.freeze
+
+        MAPPED_DATE_RANGE_METHODS = {
+          beginning_of_day: :end_of_day,
+          beginning_of_week: :end_of_week,
+          beginning_of_month: :end_of_month,
+          beginning_of_quarter: :end_of_quarter,
+          beginning_of_year: :end_of_year
+        }.freeze
+
+        def on_irange(node)
+          begin_node = node.begin
+          end_node = node.end
+          return if allow?(begin_node, end_node)
+
+          preferred_method = preferred_method(begin_node)
+          if begin_node.method?(:beginning_of_week) && begin_node.arguments.one?
+            return unless same_argument?(begin_node, end_node)
+
+            preferred_method << "(#{begin_node.first_argument.source})"
+          elsif any_arguments?(begin_node, end_node)
+            return
+          end
+
+          register_offense(node, preferred_method)
+        end
+
+        private
+
+        def allow?(begin_node, end_node)
+          return true unless (begin_source = receiver_source(begin_node))
+          return true unless (end_source = receiver_source(end_node))
+
+          begin_source != end_source || MAPPED_DATE_RANGE_METHODS[begin_node.method_name] != end_node.method_name
+        end
+
+        def receiver_source(node)
+          return if !node&.send_type? || node.receiver.nil?
+
+          node.receiver.source
+        end
+
+        def same_argument?(begin_node, end_node)
+          begin_node.first_argument.source == end_node.first_argument.source
+        end
+
+        def preferred_method(begin_node)
+          +"#{begin_node.receiver.source}.#{PREFERRED_METHODS[begin_node.method_name]}"
+        end
+
+        def any_arguments?(begin_node, end_node)
+          begin_node.arguments.any? || end_node.arguments.any?
+        end
+
+        def register_offense(node, preferred_method)
+          message = format(MSG, preferred_method: preferred_method)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, preferred_method)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,55 +3,66 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop is used to identify usages of file path joining process
-      # to use `Rails.root.join` clause. It is used to add uniformity when
-      # joining paths.
+      # Identifies usages of file path joining process to use `Rails.root.join` clause.
+      # It is used to add uniformity when joining paths.
       #
-      # @example EnforcedStyle: arguments (default)
+      # @example EnforcedStyle: slashes (default)
       #   # bad
+      #   Rails.root.join('app', 'models', 'goober')
+      #
+      #   # good
       #   Rails.root.join('app/models/goober')
+      #
+      #   # bad
       #   File.join(Rails.root, 'app/models/goober')
       #   "#{Rails.root}/app/models/goober"
       #
       #   # good
-      #   Rails.root.join('app', 'models', 'goober')
+      #   Rails.root.join('app/models/goober').to_s
       #
-      # @example EnforcedStyle: slashes
+      # @example EnforcedStyle: arguments
       #   # bad
+      #   Rails.root.join('app/models/goober')
+      #
+      #   # good
       #   Rails.root.join('app', 'models', 'goober')
+      #
+      #   # bad
       #   File.join(Rails.root, 'app/models/goober')
       #   "#{Rails.root}/app/models/goober"
       #
       #   # good
-      #   Rails.root.join('app/models/goober')
+      #   Rails.root.join('app', 'models', 'goober').to_s
       #
-      class FilePath < Cop
+      class FilePath < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
 
-        MSG_SLASHES = 'Please use `Rails.root.join(\'path/to\')` ' \
-                      'instead.'
-        MSG_ARGUMENTS = 'Please use `Rails.root.join(\'path\', \'to\')` ' \
-                        'instead.'
+        MSG_SLASHES = 'Prefer `Rails.root.join(\'path/to\')%<to_s>s`.'
+        MSG_ARGUMENTS = 'Prefer `Rails.root.join(\'path\', \'to\')%<to_s>s`.'
+        RESTRICT_ON_SEND = %i[join].freeze
 
-        def_node_matcher :file_join_nodes?, <<-PATTERN
-          (send (const nil? :File) :join ...)
+        def_node_matcher :file_join_nodes?, <<~PATTERN
+          (send (const {nil? cbase} :File) :join ...)
         PATTERN
 
-        def_node_search :rails_root_nodes?, <<-PATTERN
-          (send (const nil? :Rails) :root)
+        def_node_search :rails_root_nodes?, <<~PATTERN
+          (send (const {nil? cbase} :Rails) :root)
         PATTERN
 
-        def_node_matcher :rails_root_join_nodes?, <<-PATTERN
-          (send (send (const nil? :Rails) :root) :join ...)
+        def_node_matcher :rails_root_join_nodes?, <<~PATTERN
+          (send #rails_root_nodes? :join ...)
         PATTERN
 
         def on_dstr(node)
           return unless rails_root_nodes?(node)
-          return unless node.children.last.source.start_with?('.') ||
-                        node.children.last.source.include?(File::SEPARATOR)
+          return unless node.children.last.str_type?
 
-          register_offense(node)
+          last_child_source = node.children.last.source
+          return unless last_child_source.start_with?('.') || last_child_source.include?(File::SEPARATOR)
+          return if last_child_source.start_with?(':')
+
+          register_offense(node, require_to_s: true)
         end
 
         def on_send(node)
@@ -66,7 +77,7 @@ module RuboCop
           return unless file_join_nodes?(node)
           return unless node.arguments.any? { |e| rails_root_nodes?(e) }
 
-          register_offense(node)
+          register_offense(node, require_to_s: true)
         end
 
         def check_for_rails_root_join_with_string_arguments(node)
@@ -76,7 +87,7 @@ module RuboCop
           return unless node.arguments.size > 1
           return unless node.arguments.all?(&:str_type?)
 
-          register_offense(node)
+          register_offense(node, require_to_s: false)
         end
 
         def check_for_rails_root_join_with_slash_separated_path(node)
@@ -85,22 +96,28 @@ module RuboCop
           return unless rails_root_join_nodes?(node)
           return unless node.arguments.any? { |arg| string_with_slash?(arg) }
 
-          register_offense(node)
+          register_offense(node, require_to_s: false)
         end
 
         def string_with_slash?(node)
-          node.str_type? && node.source =~ %r{/}
+          node.str_type? && node.source.include?('/')
         end
 
-        def register_offense(node)
+        def register_offense(node, require_to_s:)
           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)
+          source_range = source_range(processed_source.buffer, node.first_line, line_range)
+          require_to_s = false if node.dstr_type?
+
+          message = build_message(require_to_s)
+
+          add_offense(source_range, message: message)
         end
 
-        def message(_node)
-          format(style == :arguments ? MSG_ARGUMENTS : MSG_SLASHES)
+        def build_message(require_to_s)
+          message_template = style == :arguments ? MSG_ARGUMENTS : MSG_SLASHES
+          to_s = require_to_s ? '.to_s' : ''
+
+          format(message_template, to_s: to_s)
         end
       end
     end