rubocop 0.37.2 → 0.38.0

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

@@ -11,7 +11,7 @@ module RuboCop
       # Rails time zone. You must use Time.zone.today instead.
       #
       # The cop also reports warnings when you are using 'to_time' method,
-      # because it doesn't know about Rails time zone too.
+      # because it doesn't know about Rails time zone either.
       #
       # Two styles are supported for this cop. When EnforcedStyle is 'strict'
       # then the Date methods (today, current, yesterday, tomorrow)
@@ -57,6 +57,10 @@ module RuboCop
         def on_send(node)
           receiver, method_name, *args = *node
           return unless receiver && bad_methods.include?(method_name)
+
+          chain = extract_method_chain(node)
+          return if safe_chain?(chain)
+
           return if method_name == :to_time && args.length == 1
 
           add_offense(node, :selector,
@@ -105,6 +109,10 @@ module RuboCop
           receiver == node
         end
 
+        def safe_chain?(chain)
+          (chain & bad_methods).empty? || !(chain & good_methods).empty?
+        end
+
         def good_days
           style == :strict ? [] : [:current, :yesterday, :tomorrow]
         end
@@ -116,6 +124,10 @@ module RuboCop
         def bad_methods
           style == :strict ? [:to_time, :to_time_in_current_zone] : [:to_time]
         end
+
+        def good_methods
+          style == :strict ? [] : TimeZone::ACCEPTED_METHODS
+        end
       end
     end
   end

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

@@ -13,7 +13,8 @@ module RuboCop
                      :print,
                      :p,
                      :pp,
-                     :pretty_print].freeze
+                     :pretty_print,
+                     :ap].freeze
 
         def on_send(node)
           receiver, method_name, *args = *node

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

@@ -25,7 +25,7 @@ module RuboCop
                                       month: :months,
                                       year: :years }.freeze
 
-        PLURAL_DURATION_METHODS = SINGULAR_DURATION_METHODS.invert
+        PLURAL_DURATION_METHODS = SINGULAR_DURATION_METHODS.invert.freeze
 
         MSG = 'Prefer `%s.%s`.'.freeze
 

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

@@ -10,7 +10,7 @@ module RuboCop
       # @example
       #
       #   # bad
-      #   x = read_attributed(:attr)
+      #   x = read_attribute(:attr)
       #   write_attribute(:attr, val)
       #
       #   # good

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

@@ -6,7 +6,6 @@ module RuboCop
     module Style
       # This cop checks for uses of *and* and *or*.
       class AndOr < Cop
-        include AutocorrectUnlessChangingAST
         include ConfigurableEnforcedStyle
 
         MSG = 'Use `%s` instead of `%s`.'.freeze
@@ -59,7 +58,7 @@ module RuboCop
           add_offense(node, :operator, format(MSG, OPS[op], op))
         end
 
-        def correction(node)
+        def autocorrect(node)
           expr1, expr2 = *node
           replacement = (node.type == :and ? '&&' : '||')
           lambda do |corrector|

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

@@ -8,24 +8,24 @@ module RuboCop
       # multi-line blocks.
       class BlockDelimiters < Cop
         include ConfigurableEnforcedStyle
-        include AutocorrectUnlessChangingAST
+
+        def_node_matcher :block_method_name, '(block (send _ $_ ...) ...)'
 
         def on_send(node)
           _receiver, method_name, *args = *node
-          return unless args.any?
-
-          block = get_block(args.last)
-          return unless block && !parentheses?(node) && !operator?(method_name)
-
-          # If there are no parentheses around the arguments, then braces and
-          # do-end have different meaning due to how they bind, so we allow
-          # either.
-          ignore_node(block)
+          return if args.empty?
+          return if parentheses?(node) || operator?(method_name)
+
+          get_blocks(args.last) do |block|
+            # If there are no parentheses around the arguments, then braces and
+            # do-end have different meaning due to how they bind, so we allow
+            # either.
+            ignore_node(block)
+          end
         end
 
         def on_block(node)
           return if ignored_node?(node)
-
           return if proper_block_style?(node)
 
           add_offense(node, :begin)
@@ -34,9 +34,7 @@ module RuboCop
         private
 
         def line_count_based_message(node)
-          block_length = block_length(node)
-
-          if block_length > 0
+          if block_length(node) > 0
             'Avoid using `{...}` for multi-line blocks.'
           else
             'Prefer `{...}` over `do...end` for single-line blocks.'
@@ -54,9 +52,7 @@ module RuboCop
         end
 
         def braces_for_chaining_message(node)
-          block_length = block_length(node)
-
-          if block_length > 0
+          if block_length(node) > 0
             if return_value_chaining?(node)
               'Prefer `{...}` over `do...end` for multi-line chained blocks.'
             else
@@ -78,7 +74,9 @@ module RuboCop
           end
         end
 
-        def correction(node)
+        def autocorrect(node)
+          return if correction_would_break_code?(node)
+
           lambda do |corrector|
             b = node.loc.begin
             e = node.loc.end
@@ -98,14 +96,23 @@ module RuboCop
           node.source_buffer.source[node.begin_pos - 1, 1] =~ /\s/
         end
 
-        def get_block(node)
+        def get_blocks(node, &block)
           case node.type
           when :block
-            node
+            yield node
           when :send
             receiver, _method_name, *_args = *node
-            get_block(receiver) if receiver
+            get_blocks(receiver, &block) if receiver
+          when :hash
+            # A hash which is passed as method argument may have no braces
+            # In that case, one of the K/V pairs could contain a block node
+            # which could change in meaning if do...end replaced {...}
+            return if node.loc.begin
+            node.children.each { |child| get_blocks(child, &block) }
+          when :pair
+            node.children.each { |child| get_blocks(child, &block) }
           end
+          nil
         end
 
         def proper_block_style?(node)
@@ -120,18 +127,13 @@ module RuboCop
         end
 
         def line_count_based_block_style?(node)
-          block_length = block_length(node)
           block_begin = node.loc.begin.source
 
-          if block_length > 0
-            block_begin != '{'
-          else
-            block_begin == '{'
-          end
+          (block_length(node) > 0) ^ (block_begin == '{')
         end
 
         def semantic_block_style?(node)
-          method_name = extract_method_name_from_block(node)
+          method_name = block_method_name(node)
           return true if ignored_method?(method_name)
 
           block_begin = node.loc.begin.source
@@ -158,19 +160,22 @@ module RuboCop
           node.parent && node.parent.send_type? && node.parent.loc.dot
         end
 
-        def extract_method_name_from_block(block)
-          node, _args, _body = *block
-          _receiver, method_name, *_args = *node
-
-          method_name
+        def correction_would_break_code?(node)
+          if node.loc.begin.is?('do')
+            # Converting `obj.method arg do |x| end` to use `{}` would cause
+            # a syntax error.
+            send = node.children.first
+            _receiver, _method_name, *args = *send
+            !args.empty? && !parentheses?(send)
+          end
         end
 
         def ignored_method?(method_name)
-          ignored_methods.include?(method_name)
+          cop_config['IgnoredMethods'].map(&:to_sym).include?(method_name)
         end
 
         def functional_method?(method_name)
-          functional_methods.include?(method_name)
+          cop_config['FunctionalMethods'].map(&:to_sym).include?(method_name)
         end
 
         def functional_block?(node)
@@ -178,7 +183,7 @@ module RuboCop
         end
 
         def procedural_method?(method_name)
-          procedural_methods.include?(method_name)
+          cop_config['ProceduralMethods'].map(&:to_sym).include?(method_name)
         end
 
         def return_value_used?(node)
@@ -200,18 +205,6 @@ module RuboCop
             node.parent.children.last == node
         end
 
-        def procedural_methods
-          cop_config['ProceduralMethods'].map(&:to_sym)
-        end
-
-        def functional_methods
-          cop_config['FunctionalMethods'].map(&:to_sym)
-        end
-
-        def ignored_methods
-          cop_config['IgnoredMethods'].map(&:to_sym)
-        end
-
         def conditional?(node)
           node.if_type? || node.or_type? || node.and_type?
         end

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

@@ -8,7 +8,6 @@ module RuboCop
       # if the last parameter is a hash.
       class BracesAroundHashParameters < Cop
         include ConfigurableEnforcedStyle
-        include AutocorrectUnlessChangingAST
 
         MSG = '%s curly braces around a hash parameter.'.freeze
 
@@ -55,7 +54,7 @@ module RuboCop
         # node, because that context is needed. When parsing the code to see if
         # the AST has changed, a braceless hash would not be parsed as a hash
         # otherwise.
-        def correction(send_node)
+        def autocorrect(send_node)
           _receiver, _method_name, *args = *send_node
           node = args.last
           lambda do |corrector|
@@ -71,6 +70,9 @@ module RuboCop
           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)
+
           if comments.any? { |c| c.loc.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

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

@@ -17,18 +17,18 @@ module RuboCop
       #   class Foo::Bar
       #   end
       #
-      # The compact style is only forced, for classes / modules with one child.
+      # The compact style is only forced for classes/modules with one child.
       class ClassAndModuleChildren < Cop
         include ConfigurableEnforcedStyle
 
         NESTED_MSG = 'Use nested module/class definitions instead of ' \
                      'compact style.'.freeze
-
         COMPACT_MSG = 'Use compact module/class definition instead of ' \
                       'nested style.'.freeze
 
         def on_class(node)
-          _name, _superclass, body = *node
+          _name, superclass, body = *node
+          return if superclass
           check_style(node, body)
         end
 

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

@@ -23,17 +23,9 @@ module RuboCop
             next unless annotation?(comment) &&
                         !correct_annotation?(first_word, colon, space, note)
 
-            start = comment.loc.expression.begin_pos + margin.length
             length = first_word.length + colon.to_s.length + space.to_s.length
-            source_buffer = comment.loc.expression.source_buffer
-            range = Parser::Source::Range.new(source_buffer,
-                                              start,
-                                              start + length)
-            if note
-              add_offense(comment, range, format(MSG, first_word))
-            else
-              add_offense(comment, range, format(MISSING_NOTE, first_word))
-            end
+            add_offense(comment, annotation_range(comment, margin, length),
+                        format(note ? MSG : MISSING_NOTE, first_word))
           end
         end
 
@@ -43,6 +35,12 @@ module RuboCop
           ix == 0 || comments[ix - 1].loc.line < comments[ix].loc.line - 1
         end
 
+        def annotation_range(comment, margin, length)
+          start = comment.loc.expression.begin_pos + margin.length
+          source_buffer = comment.loc.expression.source_buffer
+          Parser::Source::Range.new(source_buffer, start, start + length)
+        end
+
         def autocorrect(comment)
           margin, first_word, colon, space, note = split_comment(comment)
           start = comment.loc.expression.begin_pos + margin.length

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

@@ -252,16 +252,21 @@ module RuboCop
         def correction_exceeds_line_limit?(node, branches)
           return false unless config.for_cop(LINE_LENGTH)[ENABLED]
           assignment = lhs(tail(branches[0]))
-          assignment_regex = /#{assignment.gsub(' ', '\s*')}/
           max_line_length = config.for_cop(LINE_LENGTH)[MAX]
           indentation_width = config.for_cop(INDENTATION_WIDTH)[WIDTH] || 2
           return true if longest_rhs(branches) + indentation_width +
                          assignment.length > max_line_length
+
+          longest_line(node, assignment).length > max_line_length
+        end
+
+        def longest_line(node, assignment)
+          assignment_regex = /#{Regexp.escape(assignment).gsub(' ', '\s*')}/
           lines = node.source.lines.map do |line|
             line.chomp.sub(assignment_regex, '')
           end
           longest_line = lines.max_by(&:length)
-          (longest_line + assignment).length > max_line_length
+          longest_line + assignment
         end
 
         def longest_rhs(branches)

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

@@ -25,22 +25,27 @@ module RuboCop
           return if processed_source.buffer.source.empty?
 
           line_number = encoding_line_number(processed_source)
-          message = offense(processed_source, line_number)
+          return unless (@message = offense(processed_source, line_number))
 
-          return unless message
-
-          range = source_range(processed_source.buffer, line_number + 1, 0)
-          add_offense(range, range, message)
+          range = processed_source.buffer.line_range(line_number + 1)
+          add_offense(range, range, @message)
         end
 
         def autocorrect(range)
-          encoding = cop_config[AUTO_CORRECT_ENCODING_COMMENT]
-          if encoding && encoding =~ ENCODING_PATTERN
-            lambda do |corrector|
-              corrector.insert_before(range, "#{encoding}\n")
+          if @message == MSG_MISSING
+            encoding = cop_config[AUTO_CORRECT_ENCODING_COMMENT]
+            if encoding && encoding =~ ENCODING_PATTERN
+              lambda do |corrector|
+                corrector.insert_before(range, "#{encoding}\n")
+              end
+            else
+              raise "#{encoding} does not match #{ENCODING_PATTERN}"
             end
           else
-            raise "#{encoding} does not match #{ENCODING_PATTERN}"
+            # Need to remove unnecessary encoding comment
+            lambda do |corrector|
+              corrector.remove(range_with_surrounding_space(range, :right))
+            end
           end
         end
 

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

@@ -27,8 +27,6 @@ module RuboCop
         MSG_UNALIGNED_ASGN = '`=` is not aligned with the %s assignment.'.freeze
 
         def investigate(processed_source)
-          ast = processed_source.ast
-
           if force_equal_sign_alignment?
             @asgn_tokens = processed_source.tokens.select { |t| equal_sign?(t) }
             # Only attempt to align the first = on each line
@@ -39,16 +37,7 @@ module RuboCop
           end
 
           processed_source.tokens.each_cons(2) do |t1, t2|
-            next if t2.type == :tNL
-
-            if force_equal_sign_alignment? &&
-               @asgn_tokens.include?(t2) &&
-               (@asgn_lines.include?(t2.pos.line - 1) ||
-                @asgn_lines.include?(t2.pos.line + 1))
-              check_assignment(t2)
-            else
-              check_other(t1, t2, ast)
-            end
+            check_tokens(processed_source.ast, t1, t2)
           end
         end
 
@@ -64,6 +53,19 @@ module RuboCop
 
         private
 
+        def check_tokens(ast, t1, t2)
+          return if t2.type == :tNL
+
+          if force_equal_sign_alignment? &&
+             @asgn_tokens.include?(t2) &&
+             (@asgn_lines.include?(t2.pos.line - 1) ||
+              @asgn_lines.include?(t2.pos.line + 1))
+            check_assignment(t2)
+          else
+            check_other(t1, t2, ast)
+          end
+        end
+
         def check_assignment(token)
           # minus 2 is because pos.line is zero-based
           line = processed_source.lines[token.pos.line - 2]