rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,10 +7,12 @@ module RuboCop
       # should be used instead of save because the model might have failed to
       # save and an exception is better than unhandled failure.
       #
-      # This will ignore calls that are assigned to a variable or used as the
-      # condition in an if/unless statement.  It will also ignore any call with
-      # more than 2 arguments as that is likely not an Active Record call or
-      # if a Model.update(id, attributes) call.
+      # This will ignore calls that return a boolean for success if the result
+      # is assigned to a variable or used as the condition in an if/unless
+      # statement.  It will also ignore calls that return a model assigned to a
+      # variable that has a call to `persisted?`. Finally, it will ignore any
+      # call with more than 2 arguments as that is likely not an Active Record
+      # call or a Model.update(id, attributes) call.
       #
       # @example
       #
@@ -23,28 +24,70 @@ module RuboCop
       #
       #   # good
       #   unless user.save
-      #      . . .
+      #     # ...
       #   end
       #   user.save!
       #   user.update!(name: 'Joe')
       #   user.find_or_create_by!(name: 'Joe')
       #   user.destroy!
+      #
+      #   user = User.find_or_create_by(name: 'Joe')
+      #   unless user.persisted?
+      #     # ...
+      #   end
       class SaveBang < Cop
         MSG = 'Use `%s` instead of `%s` if the return value is not checked.'
               .freeze
+        CREATE_MSG = (MSG +
+                      ' Or check `persisted?` on model returned from `%s`.')
+                     .freeze
+        CREATE_CONDITIONAL_MSG = '`%s` returns a model which is always truthy.'
+                                 .freeze
 
-        PERSIST_METHODS = [:save, :create, :update, :destroy,
-                           :first_or_create, :find_or_create_by].freeze
+        CREATE_PERSIST_METHODS = %i[create
+                                    first_or_create find_or_create_by].freeze
+        MODIFY_PERSIST_METHODS = %i[save
+                                    update update_attributes destroy].freeze
+        PERSIST_METHODS = (CREATE_PERSIST_METHODS +
+                           MODIFY_PERSIST_METHODS).freeze
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            variable.assignments.each do |assignment|
+              check_assignment(assignment)
+            end
+          end
+        end
+
+        def check_assignment(assignment)
+          node = right_assignment_node(assignment)
+          return unless node
+          return unless CREATE_PERSIST_METHODS.include?(node.method_name)
+          return unless expected_signature?(node)
+          return if persisted_referenced?(assignment)
+
+          add_offense(node, location: :selector,
+                            message: format(CREATE_MSG,
+                                            "#{node.method_name}!",
+                                            node.method_name.to_s,
+                                            node.method_name.to_s))
+        end
 
         def on_send(node)
           return unless PERSIST_METHODS.include?(node.method_name)
-          return if return_value_used?(node)
           return unless expected_signature?(node)
+          return if return_value_assigned?(node)
+          return if check_used_in_conditional(node)
+          return if last_call_of_method?(node)
 
-          add_offense(node, node.loc.selector,
-                      format(MSG,
-                             "#{node.method_name}!",
-                             node.method_name.to_s))
+          add_offense(node, location: :selector,
+                            message: format(MSG,
+                                            "#{node.method_name}!",
+                                            node.method_name.to_s))
         end
 
         def autocorrect(node)
@@ -56,20 +99,62 @@ module RuboCop
 
         private
 
+        def right_assignment_node(assignment)
+          node = assignment.node.child_nodes.first
+          return node unless node && node.block_type?
+          node.child_nodes.first
+        end
+
+        def persisted_referenced?(assignment)
+          return unless assignment.referenced?
+
+          assignment.variable.references.any? do |reference|
+            call_to_persisted?(reference.node.parent)
+          end
+        end
+
+        def call_to_persisted?(node)
+          node.send_type? && node.method?(:persisted?)
+        end
+
+        def check_used_in_conditional(node)
+          return false unless conditional?(node)
+
+          unless MODIFY_PERSIST_METHODS.include?(node.method_name)
+            add_offense(node, location: :selector,
+                              message: format(CREATE_CONDITIONAL_MSG,
+                                              node.method_name.to_s))
+          end
+
+          true
+        end
+
+        def conditional?(node)
+          node.parent && (
+            node.parent.if_type? || node.parent.case_type? ||
+            node.parent.or_type? || node.parent.and_type?
+          )
+        end
+
+        def last_call_of_method?(node)
+          node.parent && node.parent.children.size == node.sibling_index + 1
+        end
+
         # Ignore simple assignment or if condition
-        def return_value_used?(node)
+        def return_value_assigned?(node)
           return false unless node.parent
           node.parent.lvasgn_type? ||
-            (node.parent.if_type? && node.sibling_index.zero?)
+            (node.parent.block_type? && node.parent.parent &&
+              node.parent.parent.lvasgn_type?)
         end
 
         # Check argument signature as no arguments or one hash
         def expected_signature?(node)
-          node.method_args.empty? ||
-            (node.method_args.length == 1 &&
+          !node.arguments? ||
+            (node.arguments.one? &&
               node.method_name != :destroy &&
-              (node.method_args.first.hash_type? ||
-              !node.method_args.first.literal?))
+              (node.first_argument.hash_type? ||
+              !node.first_argument.literal?))
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -17,16 +16,12 @@ module RuboCop
       class ScopeArgs < Cop
         MSG = 'Use `lambda`/`proc` instead of a plain method call.'.freeze
 
-        def on_send(node)
-          return unless node.command?(:scope)
-
-          _receiver, _method_name, *args = *node
-
-          return unless args.size == 2
+        def_node_matcher :scope?, '(send nil? :scope _ $send)'
 
-          second_arg = args[1]
-
-          add_offense(second_arg, :expression) if second_arg.type == :send
+        def on_send(node)
+          scope?(node) do |second_arg|
+            add_offense(second_arg)
+          end
         end
       end
     end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for the use of methods which skip
+      # validations which are listed in
+      # http://guides.rubyonrails.org/active_record_validations.html#skipping-validations
+      #
+      # @example
+      #   # bad
+      #   Article.first.decrement!(:view_count)
+      #   DiscussionBoard.decrement_counter(:post_count, 5)
+      #   Article.first.increment!(:view_count)
+      #   DiscussionBoard.increment_counter(:post_count, 5)
+      #   person.toggle :active
+      #   product.touch
+      #   Billing.update_all("category = 'authorized', author = 'David'")
+      #   user.update_attribute(website: 'example.com')
+      #   user.update_columns(last_request_at: Time.current)
+      #   Post.update_counters 5, comment_count: -1, action_count: 1
+      #
+      #   # good
+      #   user.update_attributes(website: 'example.com')
+      #   FileUtils.touch('file')
+      class SkipsModelValidations < Cop
+        MSG = 'Avoid using `%s` because it skips validations.'.freeze
+
+        METHODS_WITH_ARGUMENTS = %w[decrement!
+                                    decrement_counter
+                                    increment!
+                                    increment_counter
+                                    toggle!
+                                    update_all
+                                    update_attribute
+                                    update_column
+                                    update_columns
+                                    update_counters].freeze
+
+        def_node_matcher :good_touch?, <<-PATTERN
+          (send (const nil? :FileUtils) :touch ...)
+        PATTERN
+
+        def on_send(node)
+          return unless blacklist.include?(node.method_name.to_s)
+
+          _receiver, method_name, *args = *node
+
+          if METHODS_WITH_ARGUMENTS.include?(method_name.to_s) && args.empty?
+            return
+          end
+
+          return if good_touch?(node)
+
+          add_offense(node, location: :selector)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, node.method_name)
+        end
+
+        def blacklist
+          cop_config['Blacklist'] || []
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -24,7 +23,7 @@ module RuboCop
       #   Time.zone.now
       #   Time.zone.parse('2015-03-02 19:05:37')
       #
-      #   # no offense only if style is 'acceptable'
+      #   # no offense only if style is 'flexible'
       #   Time.current
       #   DateTime.strptime(str, "%Y-%m-%d %H:%M %Z").in_time_zone
       #   Time.at(timestamp).in_time_zone
@@ -41,14 +40,16 @@ module RuboCop
 
         MSG_CURRENT = 'Do not use `%s`. Use `Time.zone.now` instead.'.freeze
 
-        TIMECLASS = [:Time, :DateTime].freeze
+        TIMECLASS = %i[Time DateTime].freeze
 
-        DANGEROUS_METHODS = [:now, :local, :new, :strftime,
-                             :parse, :at, :current].freeze
+        GOOD_METHODS = %i[zone zone_default find_zone find_zone!].freeze
 
-        ACCEPTED_METHODS = [:in_time_zone, :utc, :getlocal,
-                            :iso8601, :jisx0301, :rfc3339,
-                            :to_i, :to_f].freeze
+        DANGEROUS_METHODS = %i[now local new strftime
+                               parse at current].freeze
+
+        ACCEPTED_METHODS = %i[in_time_zone utc getlocal
+                              iso8601 jisx0301 rfc3339
+                              to_i to_f].freeze
 
         def on_const(node)
           mod, klass = *node
@@ -73,7 +74,7 @@ module RuboCop
 
           message = build_message(klass, method_name, node)
 
-          add_offense(node, :selector, message)
+          add_offense(node, location: :selector, message: message)
         end
 
         def build_message(klass, method_name, node)
@@ -95,7 +96,7 @@ module RuboCop
         def extract_method_chain(node)
           chain = []
           while !node.nil? && node.send_type?
-            chain << extract_method(node)
+            chain << extract_method(node) if method_from_time_class?(node)
             node = node.parent
           end
           chain
@@ -106,6 +107,17 @@ module RuboCop
           method_name
         end
 
+        # Only add the method to the chain if the method being
+        # called is part of the time class.
+        def method_from_time_class?(node)
+          receiver, method_name, *_args = *node
+          if (receiver.is_a? RuboCop::AST::Node) && !receiver.cbase_type?
+            method_from_time_class?(receiver)
+          else
+            TIMECLASS.include? method_name
+          end
+        end
+
         # checks that parent node of send_type
         # and receiver is the given node
         def method_send?(node)
@@ -117,25 +129,27 @@ module RuboCop
         end
 
         def safe_method(method_name, node)
-          _receiver, _method_name, *args = *node
           return method_name unless method_name == 'new'
 
-          if args.empty?
-            'now'
-          else
+          if node.arguments?
             'local'
+          else
+            'now'
           end
         end
 
         def check_localtime(node)
           selector_node = node
-          while !node.nil? && node.send_type?
+
+          while node && node.send_type?
             break if extract_method(node) == :localtime
             node = node.parent
           end
-          _receiver, _method, args = *node
 
-          add_offense(selector_node, :selector, MSG_LOCALTIME) if args.nil?
+          return if node.arguments?
+
+          add_offense(selector_node,
+                      location: :selector, message: MSG_LOCALTIME)
         end
 
         def danger_chain?(chain)
@@ -152,9 +166,9 @@ module RuboCop
 
         def good_methods
           if style == :strict
-            [:zone, :zone_default]
+            GOOD_METHODS
           else
-            [:zone, :zone_default, :current] + ACCEPTED_METHODS
+            GOOD_METHODS + [:current] + ACCEPTED_METHODS
           end
         end
 
@@ -176,8 +190,7 @@ module RuboCop
         # Example:
         # Time.new(1988, 3, 15, 3, 0, 0, "-05:00")
         def offset_provided?(node)
-          _, _, *args = *node
-          args.length >= 7
+          node.arguments.size >= 7
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -16,18 +15,18 @@ module RuboCop
       #   # good
       #   Model.uniq.pluck(:id)
       #
-      # This cop has two different enforcement modes. When the EnforcedMode
+      # This cop has two different enforcement modes. When the EnforcedStyle
       # is conservative (the default) then only calls to pluck on a constant
       # (i.e. a model class) before uniq are added as offenses.
       #
-      # When the EnforcedMode is aggressive then all calls to pluck before
+      # When the EnforcedStyle is aggressive then all calls to pluck before
       # uniq are added as offenses. This may lead to false positives as the cop
       # cannot distinguish between calls to pluck on an ActiveRecord::Relation
       # vs a call to pluck on an ActiveRecord::Associations::CollectionProxy.
       #
       # @example
       #   # this will return a Relation that pluck is called on
-      #   Model.where(...).pluck(:id).uniq
+      #   Model.where(cond: true).pluck(:id).uniq
       #
       #   # an association on an instance will return a CollectionProxy
       #   instance.assoc.pluck(:id).uniq
@@ -36,7 +35,9 @@ module RuboCop
       # false positives.
       #
       class UniqBeforePluck < RuboCop::Cop::Cop
-        MSG = 'Use `%s` before `pluck`'.freeze
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use `%s` before `pluck`.'.freeze
         NEWLINE = "\n".freeze
         PATTERN = '[!^block (send (send %s :pluck ...) ${:uniq :distinct} ...)]'
                   .freeze
@@ -48,33 +49,35 @@ module RuboCop
                          format(PATTERN, '_')
 
         def on_send(node)
-          method = if mode == :conservative
+          method = if style == :conservative
                      conservative_node_match(node)
                    else
                      aggressive_node_match(node)
                    end
 
-          add_offense(node, :selector, format(MSG, method)) if method
+          return unless method
+
+          add_offense(node, location: :selector, message: format(MSG, method))
         end
 
         def autocorrect(node)
-          send_pluck, method, *_args = *node
           lambda do |corrector|
+            method = node.method_name
+
             corrector.remove(dot_method_with_whitespace(method, node))
-            corrector.insert_before(send_pluck.loc.dot.begin, ".#{method}")
+            corrector.insert_before(node.receiver.loc.dot.begin, ".#{method}")
           end
         end
 
         private
 
-        def mode
-          @mode ||= cop_config['EnforcedMode'].to_sym
+        def style_parameter_name
+          'EnforcedStyle'
         end
 
         def dot_method_with_whitespace(method, node)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    dot_method_begin_pos(method, node),
-                                    node.loc.selector.end_pos)
+          range_between(dot_method_begin_pos(method, node),
+                        node.loc.selector.end_pos)
         end
 
         def dot_method_begin_pos(method, node)

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that environments called with `Rails.env` predicates
+      # exist.
+      #
+      # @example
+      #   # bad
+      #   Rails.env.proudction?
+      #
+      #   # good
+      #   Rails.env.production?
+      class UnknownEnv < Cop
+        include NameSimilarity
+
+        MSG = 'Unknown environment `%<name>s`.'.freeze
+        MSG_SIMILAR = 'Unknown environment `%<name>s`. ' \
+                      'Did you mean `%<similar>s`?'.freeze
+
+        def_node_matcher :unknown_environment?, <<-PATTERN
+          (send
+            (send
+              {(const nil? :Rails) (const (cbase) :Rails)}
+              :env)
+            $#unknown_env_name?)
+        PATTERN
+
+        def on_send(node)
+          unknown_environment?(node) do |name|
+            add_offense(node, location: :selector, message: message(name))
+          end
+        end
+
+        private
+
+        def collect_variable_like_names(_scope)
+          environments.map { |env| env + '?' }
+        end
+
+        def message(name)
+          similar = find_similar_name(name.to_s, [])
+          if similar
+            format(MSG_SIMILAR, name: name, similar: similar)
+          else
+            format(MSG, name: name)
+          end
+        end
+
+        def unknown_env_name?(name)
+          name = name.to_s
+          name.end_with?('?') &&
+            !environments.include?(name[0..-2])
+        end
+
+        def environments
+          cop_config['Environments']
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,7 +7,7 @@ module RuboCop
       class Validation < Cop
         MSG = 'Prefer the new style validations `%s` over `%s`.'.freeze
 
-        TYPES = %w(
+        TYPES = %w[
           acceptance
           confirmation
           exclusion
@@ -19,27 +18,15 @@ module RuboCop
           presence
           size
           uniqueness
-        ).freeze
+        ].freeze
 
         BLACKLIST = TYPES.map { |p| "validates_#{p}_of".to_sym }.freeze
-
         WHITELIST = TYPES.map { |p| "validates :column, #{p}: value" }.freeze
 
         def on_send(node)
-          receiver, method_name, *_args = *node
-          return unless receiver.nil? && BLACKLIST.include?(method_name)
-
-          add_offense(node,
-                      :selector,
-                      format(MSG,
-                             preferred_method(method_name),
-                             method_name))
-        end
-
-        private
+          return unless !node.receiver && BLACKLIST.include?(node.method_name)
 
-        def preferred_method(method)
-          WHITELIST[BLACKLIST.index(method.to_sym)]
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)
@@ -49,10 +36,19 @@ module RuboCop
           end
         end
 
+        private
+
+        def message(node)
+          format(MSG, preferred_method(node.method_name), node.method_name)
+        end
+
+        def preferred_method(method)
+          WHITELIST[BLACKLIST.index(method.to_sym)]
+        end
+
         def correct_validate_type(corrector, node)
-          _receiver, method_name, *args = *node
-          options = args.find { |arg| arg.type != :sym }
-          validate_type = method_name.to_s.split('_')[1]
+          options = node.arguments.find { |arg| !arg.sym_type? }
+          validate_type = node.method_name.to_s.split('_')[1]
 
           if options
             corrector.replace(options.loc.expression,