rubbycop 0.49.0

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop identifies possible cases where Active Record save! or related
+      # 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 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
+      #
+      #   # bad
+      #   user.save
+      #   user.update(name: 'Joe')
+      #   user.find_or_create_by(name: 'Joe')
+      #   user.destroy
+      #
+      #   # 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
+
+        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 do |_name, 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, node.loc.selector,
+                      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 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))
+        end
+
+        def autocorrect(node)
+          save_loc = node.loc.selector
+          new_method = "#{node.method_name}!"
+
+          ->(corrector) { corrector.replace(save_loc, new_method) }
+        end
+
+        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, node.loc.selector,
+                        format(CREATE_CONDITIONAL_MSG,
+                               node.method_name.to_s))
+          end
+
+          true
+        end
+
+        def conditional?(node)
+          node.parent && (node.parent.if_type? && node.sibling_index.zero? ||
+            conditional?(node.parent))
+        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_assigned?(node)
+          return false unless node.parent
+          node.parent.lvasgn_type? ||
+            (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.arguments? ||
+            (node.arguments.one? &&
+              node.method_name != :destroy &&
+              (node.first_argument.hash_type? ||
+              !node.first_argument.literal?))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop checks for scope calls where it was passed
+      # a method (usually a scope) instead of a lambda/proc.
+      #
+      # @example
+      #
+      #   # bad
+      #   scope :something, where(something: true)
+      #
+      #   # good
+      #   scope :something, -> { where(something: true) }
+      class ScopeArgs < Cop
+        MSG = 'Use `lambda`/`proc` instead of a plain method call.'.freeze
+
+        def_node_matcher :scope?, '(send nil :scope _ $send)'
+
+        def on_send(node)
+          scope?(node) do |second_arg|
+            add_offense(second_arg, :expression)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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')
+      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 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
+
+          add_offense(node, :selector)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, node.method_name)
+        end
+
+        def blacklist
+          cop_config['Blacklist'] || []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop checks for the use of Time methods without zone.
+      #
+      # Built on top of Ruby on Rails style guide (https://github.com/searls/rails-style-guide#time)
+      # and the article http://danilenko.org/2012/7/6/rails_timezones/ .
+      #
+      # Two styles are supported for this cop. When EnforcedStyle is 'strict'
+      # then only use of Time.zone is allowed.
+      #
+      # When EnforcedStyle is 'flexible' then it's also allowed
+      # to use Time.in_time_zone.
+      #
+      # @example
+      #   # always offense
+      #   Time.now
+      #   Time.parse('2015-03-02 19:05:37')
+      #
+      #   # no offense
+      #   Time.zone.now
+      #   Time.zone.parse('2015-03-02 19:05:37')
+      #
+      #   # 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
+      class TimeZone < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Do not use `%s` without zone. Use `%s` instead.'.freeze
+
+        MSG_ACCEPTABLE = 'Do not use `%s` without zone. ' \
+                         'Use one of %s instead.'.freeze
+
+        MSG_LOCALTIME = 'Do not use `Time.localtime` without ' \
+                        'offset or zone.'.freeze
+
+        MSG_CURRENT = 'Do not use `%s`. Use `Time.zone.now` instead.'.freeze
+
+        TIMECLASS = %i[Time DateTime].freeze
+
+        GOOD_METHODS = %i[zone zone_default find_zone find_zone!].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
+          # we should only check core class
+          # (`DateTime`/`Time` or `::Date`/`::DateTime`)
+          return unless (mod.nil? || mod.cbase_type?) && method_send?(node)
+
+          check_time_node(klass, node.parent) if TIMECLASS.include?(klass)
+        end
+
+        private
+
+        def check_time_node(klass, node)
+          chain = extract_method_chain(node)
+          return if danger_chain?(chain)
+
+          return check_localtime(node) if need_check_localtime?(chain)
+
+          method_name = (chain & DANGEROUS_METHODS).join('.')
+
+          return if offset_provided?(node)
+
+          message = build_message(klass, method_name, node)
+
+          add_offense(node, :selector, message)
+        end
+
+        def build_message(klass, method_name, node)
+          if acceptable?
+            format(MSG_ACCEPTABLE,
+                   "#{klass}.#{method_name}",
+                   acceptable_methods(klass, method_name, node).join(', '))
+          elsif method_name == 'current'
+            format(MSG_CURRENT,
+                   "#{klass}.#{method_name}")
+          else
+            safe_method_name = safe_method(method_name, node)
+            format(MSG,
+                   "#{klass}.#{method_name}",
+                   "Time.zone.#{safe_method_name}")
+          end
+        end
+
+        def extract_method_chain(node)
+          chain = []
+          while !node.nil? && node.send_type?
+            chain << extract_method(node) if method_from_time_class?(node)
+            node = node.parent
+          end
+          chain
+        end
+
+        def extract_method(node)
+          _receiver, method_name, *_args = *node
+          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? RubbyCop::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)
+          return false unless node.parent && node.parent.send_type?
+
+          receiver, _method_name, *_args = *node.parent
+
+          receiver == node
+        end
+
+        def safe_method(method_name, node)
+          return method_name unless method_name == 'new'
+
+          if node.arguments?
+            'local'
+          else
+            'now'
+          end
+        end
+
+        def check_localtime(node)
+          selector_node = node
+
+          while node && node.send_type?
+            break if extract_method(node) == :localtime
+            node = node.parent
+          end
+
+          return if node.arguments?
+
+          add_offense(selector_node, :selector, MSG_LOCALTIME)
+        end
+
+        def danger_chain?(chain)
+          (chain & DANGEROUS_METHODS).empty? || !(chain & good_methods).empty?
+        end
+
+        def need_check_localtime?(chain)
+          acceptable? && chain.include?(:localtime)
+        end
+
+        def acceptable?
+          style == :flexible
+        end
+
+        def good_methods
+          if style == :strict
+            GOOD_METHODS
+          else
+            GOOD_METHODS + [:current] + ACCEPTED_METHODS
+          end
+        end
+
+        def acceptable_methods(klass, method_name, node)
+          acceptable = [
+            "`Time.zone.#{safe_method(method_name, node)}`",
+            "`#{klass}.current`"
+          ]
+
+          ACCEPTED_METHODS.each do |am|
+            acceptable << "`#{klass}.#{method_name}.#{am}`"
+          end
+
+          acceptable
+        end
+
+        # Time.new can be called with a time zone offset
+        # When it is, that should be considered safe
+        # Example:
+        # Time.new(1988, 3, 15, 3, 0, 0, "-05:00")
+        def offset_provided?(node)
+          node.arguments.size >= 7
+        end
+      end
+    end
+  end
+end