rubocop 0.42.0 → 0.43.0

data/lib/rubocop/cop/performance/sort_with_block.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `sort { |a, b| a.foo <=> b.foo }`
+      # can be replaced by `sort_by(&:foo)`.
+      #
+      # @example
+      #   @bad
+      #   array.sort { |a, b| a.foo <=> b.foo }
+      #
+      #   @good
+      #   array.sort_by(&:foo)
+      #   array.sort_by { |v| v.foo }
+      #   array.sort_by do |var|
+      #     var.foo
+      #   end
+      class SortWithBlock < Cop
+        MSG = 'Use `sort_by(&:%s)` instead of ' \
+              '`sort { |%s, %s| %s.%s <=> %s.%s }`.'.freeze
+
+        def_node_matcher :sort, <<-END
+          (block $(send _ :sort) (args (arg $_a) (arg $_b)) (send (send (lvar _a) $_m) :<=> (send (lvar _b) $_m)))
+        END
+
+        def on_block(node)
+          sort(node) do |send, var_a, var_b, method|
+            range = sort_range(send, node)
+            add_offense(node, range,
+                        format(MSG, method, var_a, var_b,
+                               var_a, method, var_b, method))
+          end
+        end
+
+        def autocorrect(node)
+          send, = *node
+
+          lambda do |corrector|
+            method = node.children.last.children.last.children.last
+            corrector.replace(sort_range(send, node), "sort_by(&:#{method})")
+          end
+        end
+
+        private
+
+        def sort_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/performance/string_replacement.rb

@@ -160,9 +160,7 @@ module RuboCop
         end
 
         def range(node)
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    node.loc.selector.begin_pos,
-                                    node.source_range.end_pos)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
         def replacement_method(method, first_source, second_source)
@@ -192,10 +190,8 @@ module RuboCop
         end
 
         def remove_second_param(corrector, node, first_param)
-          end_range =
-            Parser::Source::Range.new(node.source_range.source_buffer,
-                                      first_param.source_range.end_pos,
-                                      node.source_range.end_pos)
+          end_range = range_between(first_param.source_range.end_pos,
+                                    node.source_range.end_pos)
 
           corrector.replace(end_range, method_suffix(node))
         end

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

@@ -61,9 +61,8 @@ module RuboCop
         end
 
         def delegate?(body)
-          receiver, * = *body
-          return false unless receiver.is_a? Parser::AST::Node
-          return false unless receiver.type == :send
+          receiver, = *body
+          return false unless receiver.is_a?(Node) && receiver.send_type?
           receiver.child_nodes.empty?
         end
 

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

@@ -26,9 +26,8 @@ module RuboCop
           return unless (recv_and_method = where_first(node))
           receiver, second_method = *recv_and_method
 
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            receiver.loc.selector.begin_pos,
-                                            node.loc.selector.end_pos)
+          range = range_between(receiver.loc.selector.begin_pos,
+                                node.loc.selector.end_pos)
 
           add_offense(node, range, format(MSG, second_method))
         end
@@ -41,11 +40,8 @@ module RuboCop
           return if second_method == :first
 
           where_loc = receiver.loc.selector
-          first_loc = Parser::Source::Range.new(
-            node.source_range.source_buffer,
-            node.loc.dot.begin_pos,
-            node.loc.selector.end_pos
-          )
+          first_loc = range_between(node.loc.dot.begin_pos,
+                                    node.loc.selector.end_pos)
 
           lambda do |corrector|
             corrector.replace(where_loc, 'find_by')

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for add_column call with NOT NULL constraint
+      # in migration file.
+      #
+      # @example
+      #   # bad
+      #   add_column :users, :name, :string, null: false
+      #
+      #   # good
+      #   add_column :users, :name, :string, null: true
+      #   add_column :users, :name, :string, null: false, default: ''
+      class NotNullColumn < Cop
+        MSG = 'Do not add a NOT NULL column without a default value'.freeze
+
+        def_node_matcher :add_not_null_column?, <<-PATTERN
+          (send nil :add_column _ _ _ (hash $...))
+        PATTERN
+
+        def_node_matcher :null_false?, <<-PATTERN
+          (pair (sym :null) (false))
+        PATTERN
+
+        def_node_matcher :has_default?, <<-PATTERN
+          (pair (sym :default) !(:nil))
+        PATTERN
+
+        def on_send(node)
+          pairs = add_not_null_column?(node)
+          return unless pairs
+          return if pairs.any? { |pair| has_default?(pair) }
+
+          null_false = pairs.find { |pair| null_false?(pair) }
+          return unless null_false
+
+          add_offense(null_false, :expression)
+        end
+      end
+    end
+  end
+end

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

@@ -10,9 +10,9 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         def on_send(node)
-          if offense?(node)
-            add_offense(node.source_range, node.source_range, message)
-          end
+          return unless offense?(node)
+
+          add_offense(node.source_range, node.source_range, message)
         end
 
         def autocorrect(node)

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

@@ -0,0 +1,89 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop converts usages of `try!` to `&.`. It can also be configured
+      # to convert `try`. It will convert code to use safe navigation if the
+      # target Ruby version is set to 2.3+
+      #
+      # @example
+      #   # ConvertTry: false
+      #     # bad
+      #     foo.try!(:bar)
+      #     foo.try!(:bar, baz)
+      #     foo.try!(:bar) { |e| e.baz }
+      #
+      #     foo.try!(:[], 0)
+      #
+      #     # good
+      #     foo.try(:bar)
+      #     foo.try(:bar, baz)
+      #     foo.try(:bar) { |e| e.baz }
+      #
+      #     foo&.bar
+      #     foo&.bar(baz)
+      #     foo&.bar { |e| e.baz }
+      #
+      #
+      #   # ConvertTry: true
+      #     # bad
+      #     foo.try!(:bar)
+      #     foo.try!(:bar, baz)
+      #     foo.try!(:bar) { |e| e.baz }
+      #     foo.try(:bar)
+      #     foo.try(:bar, baz)
+      #     foo.try(:bar) { |e| e.baz }
+      #
+      #     # good
+      #     foo&.bar
+      #     foo&.bar(baz)
+      #     foo&.bar { |e| e.baz }
+      class SafeNavigation < Cop
+        MSG = 'Use safe navigation (`&.`) instead of `%s`.'.freeze
+
+        def_node_matcher :try_call, <<-PATTERN
+          (send _ ${:try :try!} $_ ...)
+        PATTERN
+
+        def on_send(node)
+          return if target_ruby_version < 2.3
+
+          try_call(node) do |try_method, method_to_try|
+            return if try_method == :try && !cop_config['ConvertTry']
+            return unless method_to_try.sym_type?
+            method, = *method_to_try
+            return unless method =~ /\w+[=!?]?/
+            add_offense(node, :expression, format(MSG, try_method))
+          end
+        end
+
+        private
+
+        def autocorrect(node)
+          _receiver, _try, method_node, *params = *node
+          method = method_node.source[1..-1]
+          range = range_between(node.loc.dot.begin_pos,
+                                node.loc.expression.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(range, replacement(method, params))
+          end
+        end
+
+        def replacement(method, params)
+          new_params = params.map(&:source).join(', ')
+
+          if method.end_with?('=')
+            "&.#{method[0...-1]} = #{new_params}"
+          elsif params.empty?
+            "&.#{method}"
+          else
+            "&.#{method}(#{new_params})"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,10 +8,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
       #
@@ -29,17 +31,57 @@ module RuboCop
       #   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 = [:create,
+                                  :first_or_create, :find_or_create_by].freeze
+        MODIFY_PERSIST_METHODS = [:save, :update, :destroy].freeze
+        PERSIST_METHODS = (CREATE_PERSIST_METHODS +
+                           MODIFY_PERSIST_METHODS).freeze
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
 
-        PERSIST_METHODS = [:save, :create, :update, :destroy,
-                           :first_or_create, :find_or_create_by].freeze
+        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 if return_value_used?(node)
           return unless expected_signature?(node)
+          return if return_value_assigned?(node)
+          return if check_used_in_conditional(node)
 
           add_offense(node, node.loc.selector,
                       format(MSG,
@@ -56,11 +98,38 @@ 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|
+            reference.node.parent.method_name == :persisted?
+          end
+        end
+
+        def check_used_in_conditional(node)
+          return false unless node.parent
+          return false unless node.parent.if_type? && node.sibling_index.zero?
+
+          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
+
         # 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

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

@@ -26,7 +26,9 @@ module RuboCop
 
           second_arg = args[1]
 
-          add_offense(second_arg, :expression) if second_arg.type == :send
+          return unless second_arg.send_type?
+
+          add_offense(second_arg, :expression)
         end
       end
     end

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

@@ -72,9 +72,8 @@ module RuboCop
         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/validation.rb

@@ -51,7 +51,7 @@ module RuboCop
 
         def correct_validate_type(corrector, node)
           _receiver, method_name, *args = *node
-          options = args.find { |arg| arg.type != :sym }
+          options = args.find { |arg| !arg.sym_type? }
           validate_type = method_name.to_s.split('_')[1]
 
           if options

data/lib/rubocop/cop/security/json_load.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # This cop checks for the use of unsecure JSON methods.
+      #
+      # @example
+      #   # always offense
+      #   JSON.load("{}")
+      #   JSON.restore("{}")
+      #
+      #   # no offense
+      #   JSON.parse("{}")
+      #
+      class JSONLoad < Cop
+        MSG = 'Prefer `JSON.parse` instead of `JSON#%s`.'.freeze
+
+        def_node_matcher :json_load, <<-END
+          (send (const nil :JSON) ${:load :restore} ...)
+        END
+
+        def on_send(node)
+          json_load(node) do |method|
+            add_offense(node, :selector, format(MSG, method))
+          end
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.selector, 'parse') }
+        end
+      end
+    end
+  end
+end