rubocop 0.41.2 → 0.42.0

data/lib/rubocop/cop/mixin/array_hash_indentation.rb

@@ -27,7 +27,7 @@ module RuboCop
                           configured_indentation_width + offset
         @column_delta = expected_column - actual_column
 
-        if @column_delta == 0
+        if @column_delta.zero?
           # which column was actually used as 'base column' for indentation?
           # (not the column which we think should be the 'base column',
           # but the one which has actually been used for that purpose)

data/lib/rubocop/cop/mixin/autocorrect_alignment.rb

@@ -77,7 +77,7 @@ module RuboCop
              begins_its_line?(current.source_range)
             @column_delta = base_column - display_column(current.source_range)
 
-            yield current if @column_delta != 0
+            yield current if @column_delta.nonzero?
           end
           prev_line = current.loc.line
         end

data/lib/rubocop/cop/mixin/empty_lines_around_body.rb

@@ -28,12 +28,10 @@ module RuboCop
           # the presence OR absence of an empty line
           # But if style is `no_empty_lines`, there must not be an empty line
           return unless body || style == :no_empty_lines
+          return if node.single_line?
 
-          start_line = node.loc.keyword.line
-          end_line = node.loc.end.line
-          return if start_line == end_line
-
-          check_source(start_line, end_line)
+          check_source(node.loc.expression.first_line,
+                       node.loc.expression.last_line)
         end
 
         def check_source(start_line, end_line)

data/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb

@@ -60,24 +60,24 @@ module RuboCop
       def handle_new_line(node)
         return unless closing_brace_on_same_line?(node)
 
-        add_offense(node, :expression, self.class::ALWAYS_NEW_LINE_MESSAGE)
+        add_offense(node, :end, self.class::ALWAYS_NEW_LINE_MESSAGE)
       end
 
       def handle_same_line(node)
         return if closing_brace_on_same_line?(node)
 
-        add_offense(node, :expression, self.class::ALWAYS_SAME_LINE_MESSAGE)
+        add_offense(node, :end, self.class::ALWAYS_SAME_LINE_MESSAGE)
       end
 
       def handle_symmetrical(node)
         if opening_brace_on_same_line?(node)
           return if closing_brace_on_same_line?(node)
 
-          add_offense(node, :expression, self.class::SAME_LINE_MESSAGE)
+          add_offense(node, :end, self.class::SAME_LINE_MESSAGE)
         else
           return unless closing_brace_on_same_line?(node)
 
-          add_offense(node, :expression, self.class::NEW_LINE_MESSAGE)
+          add_offense(node, :end, self.class::NEW_LINE_MESSAGE)
         end
       end
 

data/lib/rubocop/cop/mixin/space_inside.rb

@@ -11,24 +11,39 @@ module RuboCop
 
       def investigate(processed_source)
         @processed_source = processed_source
+        each_extraneous_space(processed_source.tokens) do |kind, range|
+          add_offense(range, range, format(MSG, kind))
+        end
+      end
+
+      def autocorrect(range)
+        ->(corrector) { corrector.remove(range) }
+      end
+
+      private
+
+      def each_extraneous_space(tokens)
         brackets = Brackets.new(*specifics)
-        processed_source.tokens.each_cons(2) do |t1, t2|
-          next unless brackets.left_side?(t1) || brackets.right_side?(t2)
+        tokens.each_cons(2) do |t1, t2|
+          next unless matching_brackets?(brackets, t1, t2)
 
           # If the second token is a comment, that means that a line break
           # follows, and that the rules for space inside don't apply.
           next if t2.type == :tCOMMENT
           next unless t2.pos.line == t1.pos.line && space_between?(t1, t2)
 
-          range = Parser::Source::Range.new(processed_source.buffer,
-                                            t1.pos.end_pos,
-                                            t2.pos.begin_pos)
-          add_offense(range, range, format(MSG, brackets.kind))
+          yield brackets.kind, range_between_tokens(t1, t2)
         end
       end
 
-      def autocorrect(range)
-        ->(corrector) { corrector.remove(range) }
+      def matching_brackets?(brackets, t1, t2)
+        brackets.left_side?(t1) || brackets.right_side?(t2)
+      end
+
+      def range_between_tokens(t1, t2)
+        Parser::Source::Range.new(processed_source.buffer,
+                                  t1.pos.end_pos,
+                                  t2.pos.begin_pos)
       end
 
       # Wraps info about the brackets. Makes it easy to check whether a token

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -15,7 +15,7 @@ module RuboCop
 
         body_length = body_length(body)
 
-        return false if body_length == 0
+        return false if body_length.zero?
         return false if cond.each_node.any?(&:lvasgn_type?)
         return false if body_has_comment?(body)
         return false if end_keyword_has_comment?(node)

data/lib/rubocop/cop/offense.rb

@@ -92,15 +92,9 @@ module RuboCop
       # @return [Parser::Source::Range]
       #   the range of the code that is highlighted
       def highlighted_area
-        column_length = if location.first_line == location.last_line
-                          location.column_range.count
-                        else
-                          location.source_line.length - location.column
-                        end
-
-        Parser::Source::Range.new(location.source_line,
-                                  location.column,
-                                  location.column + column_length)
+        Parser::Source::Range.new(source_line,
+                                  column,
+                                  column + column_length)
       end
 
       # @api private
@@ -120,6 +114,35 @@ module RuboCop
         location.column
       end
 
+      # @api private
+      def source_line
+        location.source_line
+      end
+
+      # @api private
+      def column_length
+        if first_line == last_line
+          column_range.count
+        else
+          source_line.length - column
+        end
+      end
+
+      # @api private
+      def first_line
+        location.first_line
+      end
+
+      # @api private
+      def last_line
+        location.last_line
+      end
+
+      # @api private
+      def column_range
+        location.column_range
+      end
+
       # @api private
       #
       # Internally we use column number that start at 0, but when
@@ -157,7 +180,7 @@ module RuboCop
       def <=>(other)
         COMPARISON_ATTRIBUTES.each do |attribute|
           result = send(attribute) <=> other.send(attribute)
-          return result unless result == 0
+          return result unless result.zero?
         end
         0
       end

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

@@ -81,29 +81,31 @@ module RuboCop
         def autocorrect(node)
           *conditions, _body = *node
 
-          new_condition =
-            conditions.each_with_object([]) do |condition, correction|
-              variable, = *condition
-              if variable.respond_to?(:array_type?) && variable.array_type?
-                correction << expand_percent_array(variable)
-                next
-              end
-
-              correction << condition.source
-            end
-          new_condition = new_condition.join(', ')
-
           lambda do |corrector|
             if needs_reorder?(conditions)
-              reorder_condition(corrector, node, new_condition)
+              reorder_condition(corrector, node, replacement(conditions))
             else
-              inline_fix_branch(corrector, node, conditions, new_condition)
+              inline_fix_branch(corrector, node, conditions,
+                                replacement(conditions))
             end
           end
         end
 
         private
 
+        def replacement(conditions)
+          new_condition = conditions.map do |condition|
+            variable, = *condition
+            if variable.respond_to?(:array_type?) && variable.array_type?
+              expand_percent_array(variable)
+            else
+              condition.source
+            end
+          end
+
+          new_condition.join(', ')
+        end
+
         def inline_fix_branch(corrector, node, conditions, new_condition)
           range =
             Parser::Source::Range.new(node.loc.expression.source_buffer,

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

@@ -89,7 +89,6 @@ module RuboCop
             arg.source if arg
           end
 
-          # FIXME: use Range#size once Ruby 1.9 support is dropped
           def range_size(range_node)
             vals = *range_node
             return :unknown unless vals.all?(&:int_type?)

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

@@ -0,0 +1,77 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  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 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.
+      #
+      # @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!
+      class SaveBang < Cop
+        MSG = 'Use `%s` instead of `%s` if the return value is not checked.'
+              .freeze
+
+        PERSIST_METHODS = [:save, :create, :update, :destroy,
+                           :first_or_create, :find_or_create_by].freeze
+
+        def on_send(node)
+          return unless PERSIST_METHODS.include?(node.method_name)
+          return if return_value_used?(node)
+          return unless expected_signature?(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
+
+        # Ignore simple assignment or if condition
+        def return_value_used?(node)
+          return false unless node.parent
+          node.parent.lvasgn_type? ||
+            (node.parent.if_type? && node.sibling_index.zero?)
+        end
+
+        # Check argument signature as no arguments or one hash
+        def expected_signature?(node)
+          node.method_args.empty? ||
+            (node.method_args.length == 1 &&
+              node.method_name != :destroy &&
+              (node.method_args.first.hash_type? ||
+              !node.method_args.first.literal?))
+        end
+      end
+    end
+  end
+end

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

@@ -43,23 +43,23 @@ module RuboCop
         end
 
         def autocorrect(node)
-          _receiver, method_name, *args = *node
-          options = args.find { |arg| arg.type != :sym }
           lambda do |corrector|
-            validate_type = method_name.to_s.split('_')[1]
             corrector.replace(node.loc.selector, 'validates')
-            cop_config['AllowUnusedKeywordArguments']
-            if options
-              corrector.replace(
-                options.loc.expression,
-                "#{validate_type}: { #{options.source} }"
-              )
-            else
-              corrector.insert_after(
-                node.loc.expression,
-                ", #{validate_type}: true"
-              )
-            end
+            correct_validate_type(corrector, node)
+          end
+        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]
+
+          if options
+            corrector.replace(options.loc.expression,
+                              "#{validate_type}: { #{options.source} }")
+          else
+            corrector.insert_after(node.loc.expression,
+                                   ", #{validate_type}: true")
           end
         end
       end

data/lib/rubocop/cop/style/access_modifier_indentation.rb

@@ -49,7 +49,7 @@ module RuboCop
           offset = access_modifier_start_col - class_start_col
 
           @column_delta = expected_indent_offset - offset
-          if @column_delta == 0
+          if @column_delta.zero?
             correct_style_detected
           else
             add_offense(send_node, :expression) do

data/lib/rubocop/cop/style/align_hash.rb

@@ -248,7 +248,7 @@ module RuboCop
         end
 
         def good_alignment?
-          @column_deltas.values.compact.none? { |v| v != 0 }
+          @column_deltas.values.compact.all?(&:zero?)
         end
       end
     end

data/lib/rubocop/cop/style/block_comments.rb

@@ -23,15 +23,13 @@ module RuboCop
 
           lambda do |corrector|
             corrector.remove(eq_begin)
-            # rubocop:disable Style/ZeroLengthPredicate
-            unless contents.length == 0
+            unless contents.length.zero?
               corrector.replace(contents,
                                 contents.source
                                   .gsub(/\A/, '# ')
                                   .gsub(/\n\n/, "\n#\n")
                                   .gsub(/\n(?=[^\z#])/, "\n# "))
             end
-            # rubocop:enable Style/ZeroLengthPredicate
             corrector.remove(eq_end)
           end
         end

data/lib/rubocop/cop/style/braces_around_hash_parameters.rb

@@ -59,26 +59,21 @@ module RuboCop
           node = args.last
           lambda do |corrector|
             if braces?(node)
-              remove_braces(corrector, node)
+              remove_braces_with_whitespace(corrector, node)
             else
               add_braces(corrector, node)
             end
           end
         end
 
-        def remove_braces(corrector, node)
-          comments = processed_source.comments
-          right_brace_and_space = range_with_surrounding_space(node.loc.end,
-                                                               :left)
-          right_brace_and_space =
-            range_with_surrounding_comma(right_brace_and_space, :left)
+        def remove_braces_with_whitespace(corrector, node)
+          right_brace_and_space = right_brace_and_space(node.loc.end)
 
-          if comments.any? { |c| c.loc.line == right_brace_and_space.line }
+          if comment_on_line?(right_brace_and_space.line)
             # Removing a line break between a comment and the closing
             # parenthesis would cause a syntax error, so we only remove the
             # braces in that case.
-            corrector.remove(node.loc.begin)
-            corrector.remove(node.loc.end)
+            remove_braces(corrector, node)
           else
             left_brace_and_space = range_with_surrounding_space(node.loc.begin,
                                                                 :right)
@@ -87,6 +82,20 @@ module RuboCop
           end
         end
 
+        def right_brace_and_space(loc_end)
+          brace_and_space = range_with_surrounding_space(loc_end, :left)
+          range_with_surrounding_comma(brace_and_space, :left)
+        end
+
+        def comment_on_line?(line)
+          processed_source.comments.any? { |c| c.loc.line == line }
+        end
+
+        def remove_braces(corrector, node)
+          corrector.remove(node.loc.begin)
+          corrector.remove(node.loc.end)
+        end
+
         def add_braces(corrector, node)
           corrector.insert_before(node.source_range, '{')
           corrector.insert_after(node.source_range, '}')