rubocop 0.35.1 → 0.36.0

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -21,7 +22,7 @@ module RuboCop
         include FirstElementLineBreak
 
         MSG = 'Add a line break before the first element of a ' \
-              'multi-line array.'
+              'multi-line array.'.freeze
 
         def on_array(node)
           return if !node.loc.begin && !assignment_on_same_line?(node)
@@ -32,7 +33,7 @@ module RuboCop
         private
 
         def assignment_on_same_line?(node)
-          source = node.loc.expression.source_line[0...node.loc.column]
+          source = node.source_range.source_line[0...node.loc.column]
           source =~ /\s*\=\s*$/
         end
       end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -20,14 +21,12 @@ module RuboCop
         include FirstElementLineBreak
 
         MSG = 'Add a line break before the first element of a ' \
-              'multi-line hash.'
+              'multi-line hash.'.freeze
 
         def on_hash(node)
-          if node.loc.begin
-            check_children_line_break(node, node.children)
-          elsif method_uses_parens?(node.parent, node)
-            check_children_line_break(node, node.children, node.parent)
-          end
+          # node.loc.begin tells us whether the hash opens with a {
+          # If it doesn't, Style/FirstMethodArgumentLineBreak will handle it
+          check_children_line_break(node, node.children) if node.loc.begin
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -24,11 +25,23 @@ module RuboCop
         include FirstElementLineBreak
 
         MSG = 'Add a line break before the first argument of a ' \
-              'multi-line method argument list.'
+              'multi-line method argument list.'.freeze
 
         def on_send(node)
           _receiver, _name, *args = *node
 
+          # If there is a trailing hash arg without explicit braces, like this:
+          #
+          #    method(1, 'key1' => value1, 'key2' => value2)
+          #
+          # ...then each key/value pair is treated as a method 'argument'
+          # when determining where line breaks should appear.
+          if (last_arg = args.last)
+            if last_arg.hash_type? && !last_arg.loc.begin # no explicit {
+              args = args.concat(args.pop.children)
+            end
+          end
+
           check_method_line_break(node, args)
         end
       end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -31,7 +32,7 @@ module RuboCop
         include FirstElementLineBreak
 
         MSG = 'Add a line break before the first parameter of a ' \
-              'multi-line method parameter list.'
+              'multi-line method parameter list.'.freeze
 
         def on_method_def(node, _method_name, args, _body)
           check_method_line_break(node, args.to_a)

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -69,13 +70,13 @@ module RuboCop
 
           # The node must begin inside the parent, otherwise node is the first
           # part of a chained method call.
-          node.loc.expression.begin_pos > parent.loc.expression.begin_pos
+          node.source_range.begin_pos > parent.source_range.begin_pos
         end
 
         def base_range(send_node, arg_node)
           Parser::Source::Range.new(processed_source.buffer,
-                                    send_node.loc.expression.begin_pos,
-                                    arg_node.loc.expression.begin_pos)
+                                    send_node.source_range.begin_pos,
+                                    arg_node.source_range.begin_pos)
         end
 
         # Returns the column of the given range. For single line ranges, this
@@ -94,7 +95,8 @@ module RuboCop
         # line.
         def previous_code_line(line_number)
           @comment_lines ||=
-            processed_source.comments
+            processed_source
+            .comments
             .select { |c| begins_its_line?(c.loc.expression) }
             .map { |c| c.loc.line }
 

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

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop looks for uses of flip flop operator
       class FlipFlop < Cop
-        MSG = 'Avoid the use of flip flop operators.'
+        MSG = 'Avoid the use of flip flop operators.'.freeze
 
         def on_iflipflop(node)
           add_offense(node, :expression)

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -31,7 +32,7 @@ module RuboCop
           return unless method_name == :each && args.empty?
 
           if style == :for
-            end_pos = method.loc.expression.end_pos
+            end_pos = method.source_range.end_pos
             range = Parser::Source::Range.new(processed_source.buffer,
                                               end_pos - EACH_LENGTH,
                                               end_pos)

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop

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

@@ -0,0 +1,89 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop is designed to help upgrade to Ruby 3.0. It will add the
+      # comment `# frozen_string_literal: true` to the top of files to
+      # enable frozen string literals. Frozen string literals will be default
+      # in Ruby 3.0. The comment will be added below a shebang and encoding
+      # comment. The frozen string literal comment is only valid in Ruby 2.3+.
+      class FrozenStringLiteralComment < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Missing frozen string literal comment.'.freeze
+        FROZEN_STRING_LITERAL = '# frozen_string_literal:'.freeze
+        FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'.freeze
+        SHEBANG = '#!'.freeze
+
+        def_node_matcher :frozen_strings, '{(send {dstr str} :<< ...)
+                                            (send {dstr str} :freeze)}'
+
+        def investigate(processed_source)
+          return unless style == :always
+          return if processed_source.buffer.source.empty?
+
+          return if frozen_string_literal_comment_exists?(processed_source)
+
+          offense(processed_source)
+        end
+
+        def on_send(node)
+          return if target_ruby_version < 2.3 && RUBY_VERSION < '2.3.0'
+          return unless style == :when_needed
+          return if frozen_string_literal_comment_exists?(processed_source)
+
+          frozen_strings(node) { offense(processed_source) }
+        end
+
+        def autocorrect(_node)
+          lambda do |corrector|
+            last_special_comment = last_special_comment(processed_source)
+            if last_special_comment.nil?
+              corrector.insert_before(processed_source.tokens[0].pos,
+                                      "#{FROZEN_STRING_LITERAL_ENABLED}\n")
+            else
+              corrector.insert_after(last_special_comment.pos,
+                                     "\n#{FROZEN_STRING_LITERAL_ENABLED}")
+            end
+          end
+        end
+
+        private
+
+        def frozen_string_literal_comment_exists?(processed_source)
+          first_three_lines =
+            [processed_source[0], processed_source[1], processed_source[2]]
+          first_three_lines.compact!
+          first_three_lines.any? do |line|
+            line.start_with?(FROZEN_STRING_LITERAL)
+          end
+        end
+
+        def last_special_comment(processed_source)
+          token_number = 0
+          if processed_source.tokens[token_number].text.start_with?(SHEBANG)
+            token = processed_source.tokens[token_number]
+            token_number += 1
+          end
+
+          if processed_source.tokens[token_number].text =~
+             Encoding::ENCODING_PATTERN
+            token = processed_source.tokens[token_number]
+          end
+
+          token
+        end
+
+        def offense(processed_source)
+          last_special_comment = last_special_comment(processed_source)
+          last_special_comment ||= processed_source.tokens[0]
+          range = source_range(processed_source.buffer, 0, 0)
+
+          add_offense(last_special_comment, range, MSG)
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -10,7 +11,7 @@ module RuboCop
       #
       # Note that backreferences like $1, $2, etc are not global variables.
       class GlobalVars < Cop
-        MSG = 'Do not introduce global variables.'
+        MSG = 'Do not introduce global variables.'.freeze
 
         # predefined global variables their English aliases
         # http://www.zenspider.com/Languages/Ruby/QuickRef.html

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -24,45 +25,96 @@ module RuboCop
       #   def test
       #     work if something
       #   end
+      #
+      #   # bad
+      #   if something
+      #     raise 'exception'
+      #   else
+      #     ok
+      #   end
+      #
+      #   # good
+      #   raise 'exception' if something
+      #   ok
       class GuardClause < Cop
         include ConfigurableEnforcedStyle
         include IfNode
         include MinBodyLength
 
         MSG = 'Use a guard clause instead of wrapping the code inside a ' \
-              'conditional expression.'
+              'conditional expression.'.freeze
+
+        def_node_matcher :single_line_control_flow_exit?, <<-PATTERN
+          [{(send nil {:raise :fail} ...) return break next} single_line?]
+        PATTERN
 
         def on_def(node)
           _, _, body = *node
           return unless body
 
           if if?(body)
-            check_if_node(body)
-          elsif body.type == :begin
-            expressions = *body
-            last_expr = expressions.last
-
-            check_if_node(last_expr) if if?(last_expr)
+            check_trailing_if(body)
+          elsif body.begin_type?
+            last_expr = body.children.last
+            check_trailing_if(last_expr) if if?(last_expr)
           end
         end
 
+        def on_if(node)
+          cond, body, else_body = *node
+
+          return unless body && else_body
+          # discard modifier ifs and ternary_ops
+          return if modifier_if?(node) || ternary_op?(node) || elsif?(node)
+
+          return unless single_line_control_flow_exit?(body) ||
+                        single_line_control_flow_exit?(else_body)
+          return if cond.multiline?
+          return if line_too_long_when_corrected?(node)
+
+          add_offense(node, :keyword, MSG)
+        end
+
         private
 
-        def if?(body)
-          body && body.type == :if
+        def if?(node)
+          node && node.if_type?
         end
 
-        def check_if_node(node)
-          _cond, body, else_body = *node
+        def elsif?(node)
+          node.children.last.if_type?
+        end
+
+        def check_trailing_if(node)
+          cond, body, else_body = *node
 
           return if body && else_body
           # discard modifier ifs and ternary_ops
           return if modifier_if?(node) || ternary_op?(node)
+          return if cond.multiline?
           # discard short ifs
           return unless min_body_length?(node)
+          return if line_too_long_when_corrected?(node)
 
           add_offense(node, :keyword, MSG)
         end
+
+        def line_too_long_when_corrected?(node)
+          cond, body, else_body = *node
+
+          if single_line_control_flow_exit?(body) || !else_body
+            line_too_long?(node, body, 'if', cond)
+          else
+            line_too_long?(node, else_body, 'unless', cond)
+          end
+        end
+
+        def line_too_long?(node, body, keyword, condition)
+          max    = config.for_cop('Metrics/LineLength')['Max'] || 80
+          indent = node.loc.column
+          # 2 is for spaces on left and right of keyword
+          indent + (body.source + keyword + condition.source).length + 2 > max
+        end
       end
     end
   end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -12,9 +13,9 @@ module RuboCop
       class HashSyntax < Cop
         include ConfigurableEnforcedStyle
 
-        MSG_19 = 'Use the new Ruby 1.9 hash syntax.'
-        MSG_RUBY19_NO_MIXED_KEYS = "Don't mix styles in the same hash."
-        MSG_HASH_ROCKETS = 'Use hash rockets syntax.'
+        MSG_19 = 'Use the new Ruby 1.9 hash syntax.'.freeze
+        MSG_RUBY19_NO_MIXED_KEYS = "Don't mix styles in the same hash.".freeze
+        MSG_HASH_ROCKETS = 'Use hash rockets syntax.'.freeze
 
         @force_hash_rockets = false
 
@@ -95,8 +96,7 @@ module RuboCop
 
           return false unless key.sym_type?
 
-          sym_name = key.loc.expression.source
-          valid_19_syntax_symbol?(sym_name)
+          valid_19_syntax_symbol?(key.source)
         end
 
         def valid_19_syntax_symbol?(sym_name)
@@ -105,15 +105,15 @@ module RuboCop
           # Most hash keys can be matched against a simple regex.
           return true if sym_name =~ /\A[_a-z]\w*[?!]?\z/i
 
-          # For more complicated hash keys, let the Parser validate the syntax.
-          RuboCop::ProcessedSource.new("{ #{sym_name}: :foo }").valid_syntax?
+          # For more complicated hash keys, let the parser validate the syntax.
+          parse("{ #{sym_name}: :foo }").valid_syntax?
         end
 
         def check(pairs, delim, msg)
           pairs.each do |pair|
             if pair.loc.operator && pair.loc.operator.is?(delim)
               add_offense(pair,
-                          pair.loc.expression.begin.join(pair.loc.operator),
+                          pair.source_range.begin.join(pair.loc.operator),
                           msg) do
                 opposite_style_detected
               end
@@ -124,7 +124,7 @@ module RuboCop
         end
 
         def autocorrect_ruby19(corrector, node)
-          key = node.children.first.loc.expression
+          key = node.children.first.source_range
           op = node.loc.operator
 
           range = Parser::Source::Range.new(key.source_buffer,
@@ -135,7 +135,7 @@ module RuboCop
         end
 
         def autocorrect_hash_rockets(corrector, node)
-          key = node.children.first.loc.expression
+          key = node.children.first.source_range
           op = node.loc.operator
 
           corrector.insert_after(key, ' => ')

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

@@ -0,0 +1,93 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for identical lines at the end of each branch of a
+      # conditional statement.
+      #
+      # @example
+      #   @bad
+      #   if condition
+      #     do_x
+      #     do_z
+      #   else
+      #     do_y
+      #     do_z
+      #   end
+      #
+      #   @good
+      #   if condition
+      #     do_x
+      #   else
+      #     do_y
+      #   end
+      #   do_z
+      class IdenticalConditionalBranches < Cop
+        include IfNode
+
+        MSG = 'Move `%s` out of the conditional.'.freeze
+
+        def on_if(node)
+          return if elsif?(node)
+          _condition, if_branch, else_branch = *node
+          branches = expand_elses(else_branch).unshift(if_branch)
+
+          # return if any branch is empty. An empty branch can be an `if`
+          # without an `else`, or a branch that contains only comments.
+          return if branches.any?(&:nil?)
+
+          check_node(branches)
+        end
+
+        def on_case(node)
+          return unless node.loc.else
+          _condition, *when_branches, else_branch = *node
+          return unless else_branch # empty else
+          when_branches = expand_when_branches(when_branches)
+
+          check_node(when_branches.push(else_branch))
+        end
+
+        private
+
+        def check_node(branches)
+          branches = branches.map { |branch| tail(branch) }
+
+          return unless branches.all? { |branch| branch == branches[0] }
+          branches.each do |branch|
+            add_offense(branch, :expression, format(MSG, branch.source))
+          end
+        end
+
+        # `elsif` branches show up in the if node as nested `else` branches. We
+        # need to recursively iterate over all `else` branches.
+        def expand_elses(branch)
+          if branch.nil?
+            [nil]
+          elsif branch.if_type?
+            _condition, elsif_branch, else_branch = *branch
+            expand_elses(else_branch).unshift(elsif_branch)
+          else
+            [branch]
+          end
+        end
+
+        # `when` nodes contain the entire branch including the condition.
+        # We only need the contents of the branch, not the condition.
+        def expand_when_branches(when_branches)
+          when_branches.map { |branch| branch.children[1] }
+        end
+
+        def tail(node)
+          if node && node.begin_type?
+            node.children.last
+          else
+            node
+          end
+        end
+      end
+    end
+  end
+end