rubocop 0.35.1 → 0.36.0

data/lib/rubocop/cop/lint/empty_interpolation.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -9,7 +10,7 @@ module RuboCop
       #
       #   "result is #{}"
       class EmptyInterpolation < Cop
-        MSG = 'Empty interpolation detected.'
+        MSG = 'Empty interpolation detected.'.freeze
 
         def on_dstr(node)
           node.children.select { |n| n.type == :begin }.each do |begin_node|

data/lib/rubocop/cop/lint/end_alignment.rb

@@ -1,51 +1,64 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Lint
       # This cop checks whether the end keywords are aligned properly.
       #
-      # Two modes are supported through the AlignWith configuration
-      # parameter. If it's set to `keyword` (which is the default), the `end`
-      # shall be aligned with the start of the keyword (if, class, etc.). If
-      # it's set to `variable` the `end` shall be aligned with the
+      # Three modes are supported through the `AlignWith` configuration
+      # parameter:
+      #
+      # If it's set to `keyword` (which is the default), the `end`
+      # shall be aligned with the start of the keyword (if, class, etc.).
+      #
+      # If it's set to `variable` the `end` shall be aligned with the
       # left-hand-side of the variable assignment, if there is one.
       #
-      # @example
+      # If it's set to `start_of_line`, the `end` shall be aligned with the
+      # start of the line where the matching keyword appears.
       #
+      # @example
+      #   @good
+      #   # keyword style
       #   variable = if true
       #              end
+      #
+      #   # variable style
+      #   variable = if true
+      #   end
+      #
+      #   # start_of_line style
+      #   puts(if true
+      #   end)
       class EndAlignment < Cop
         include CheckAssignment
         include EndKeywordAlignment
         include IfNode
 
         def on_class(node)
-          check_offset_of_node(node)
+          check_other_alignment(node)
         end
 
         def on_module(node)
-          check_offset_of_node(node)
+          check_other_alignment(node)
         end
 
         def on_if(node)
-          check_offset_of_node(node) unless ternary_op?(node)
+          check_other_alignment(node) unless ternary_op?(node)
         end
 
         def on_while(node)
-          check_offset_of_node(node)
+          check_other_alignment(node)
         end
 
         def on_until(node)
-          check_offset_of_node(node)
+          check_other_alignment(node)
         end
 
         def on_case(node)
-          if argument_case?(node)
-            return check_alignment(node.ancestors.first, node)
-          end
-
-          check_offset_of_node(node)
+          return check_asgn_alignment(node.parent, node) if argument_case?(node)
+          check_other_alignment(node)
         end
 
         private
@@ -54,47 +67,72 @@ module RuboCop
           # If there are method calls chained to the right hand side of the
           # assignment, we let rhs be the receiver of those method calls before
           # we check if it's an if/unless/while/until.
-          rhs = first_part_of_call_chain(rhs)
-
-          return unless rhs
-
+          return unless (rhs = first_part_of_call_chain(rhs))
           return unless [:if, :while, :until, :case].include?(rhs.type)
           return if ternary_op?(rhs)
 
-          check_alignment(node, rhs)
+          check_asgn_alignment(node, rhs)
         end
 
-        def check_alignment(outer_node, inner_node)
-          expr = outer_node.loc.expression
-          if variable_alignment?(expr, inner_node, style)
-            range = Parser::Source::Range.new(expr.source_buffer,
-                                              expr.begin_pos,
-                                              inner_node.loc.keyword.end_pos)
-            offset =
-              inner_node.loc.keyword.column - outer_node.loc.expression.column
-          else
-            range = inner_node.loc.keyword
-            offset = 0
-          end
+        def check_asgn_alignment(outer_node, inner_node)
+          expr = outer_node.source_range
+
+          align_with = {
+            keyword: inner_node.loc.keyword,
+            start_of_line: start_line_range(outer_node)
+          }
 
-          check_offset(inner_node, range.source, offset)
+          align_with[:variable] =
+            if !line_break_before_keyword?(expr, inner_node)
+              Parser::Source::Range.new(expr.source_buffer,
+                                        expr.begin_pos,
+                                        inner_node.loc.keyword.end_pos)
+            else
+              inner_node.loc.keyword
+            end
+
+          check_end_kw_alignment(inner_node, align_with)
           ignore_node(inner_node) # Don't check again.
         end
 
+        def check_other_alignment(node)
+          align_with = {
+            keyword: node.loc.keyword,
+            variable: node.loc.keyword,
+            start_of_line: start_line_range(node)
+          }
+          check_end_kw_alignment(node, align_with)
+        end
+
         def autocorrect(node)
           align(node, alignment_node(node))
         end
 
         def alignment_node(node)
-          return node unless style == :variable
-          return node.ancestors.first if argument_case?(node)
-
-          node.each_ancestor(:lvasgn).first
+          if style == :keyword
+            node
+          elsif style == :variable
+            return node.parent if argument_case?(node)
+            # Fall back to 'keyword' style if this node is not on the RHS
+            # of an assignment
+            node.ancestors.find(&:assignment?) || node
+          else
+            start_line_range(node)
+          end
         end
 
         def argument_case?(node)
-          node.case_type? && !node.ancestors.empty? &&
-            node.ancestors.first.send_type?
+          node.case_type? && node.parent && node.parent.send_type?
+        end
+
+        def start_line_range(node)
+          expr   = node.source_range
+          buffer = expr.source_buffer
+          source = buffer.source_line(expr.line)
+          range  = buffer.line_range(expr.line)
+          Parser::Source::Range.new(buffer,
+                                    range.begin_pos + (source =~ /\S/),
+                                    range.begin_pos + (source =~ /\s*\z/))
         end
       end
     end

data/lib/rubocop/cop/lint/end_in_method.rb

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Lint
       # This cop checks for END blocks in method definitions.
       class EndInMethod < Cop
-        MSG = '`END` found in method definition. Use `at_exit` instead.'
+        MSG = '`END` found in method definition. Use `at_exit` instead.'.freeze
 
         def on_postexe(node)
           inside_of_method = node.each_ancestor(:def, :defs).count.nonzero?

data/lib/rubocop/cop/lint/ensure_return.rb

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Lint
       # This cop checks for *return* from an *ensure* block.
       class EnsureReturn < Cop
-        MSG = 'Do not return from an `ensure` block.'
+        MSG = 'Do not return from an `ensure` block.'.freeze
 
         def on_ensure(node)
           _body, ensure_body = *node

data/lib/rubocop/cop/lint/eval.rb

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Lint
       # This cop checks for the use of *Kernel#eval*.
       class Eval < Cop
-        MSG = 'The use of `eval` is a serious security risk.'
+        MSG = 'The use of `eval` is a serious security risk.'.freeze
 
         def on_send(node)
           receiver, method_name, *args = *node

data/lib/rubocop/cop/lint/float_out_of_range.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop identifies Float literals which are, like, really really really
+      # really really really really really big. Too big. No-one needs Floats
+      # that big. If you need a float that big, something is wrong with you.
+      #
+      # @example
+      #   # bad
+      #   float = 3.0e400
+      #
+      #   # good
+      #   float = 42.9
+      class FloatOutOfRange < Cop
+        MSG = 'Float out of range.'.freeze
+
+        def on_float(node)
+          value, = *node
+          if value.infinite?
+            add_offense(node, :expression, MSG)
+          elsif value.zero? && node.source =~ /[1-9]/
+            add_offense(node, :expression, MSG)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/format_parameter_mismatch.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -13,15 +14,17 @@ module RuboCop
       #
       class FormatParameterMismatch < Cop
         # http://rubular.com/r/CvpbxkcTzy
-        MSG = 'Number arguments (%i) to `%s` mismatches expected fields (%i).'
-        FIELD_REGEX = /(%(([\s#+-0\*])?(\d*)?(.\d+)?(\.)?[bBdiouxXeEfgGaAcps]|%))/.freeze # rubocop:disable Metrics/LineLength
-        NAMED_FIELD_REGEX = /%\{[_a-zA-Z][_a-zA-Z]+\}/.freeze
+        MSG = "Number of arguments (%i) to `%s` doesn't match the number of " \
+              'fields (%i).'.freeze
+        FIELD_REGEX =
+          /(%(([\s#+-0\*]*)(\d*)?(.\d+)?[bBdiouxXeEfgGaAcps]|%))/
+        NAMED_FIELD_REGEX = /%\{[_a-zA-Z][_a-zA-Z]+\}/
         KERNEL = 'Kernel'.freeze
         SHOVEL = '<<'.freeze
         PERCENT = '%'.freeze
         PERCENT_PERCENT = '%%'.freeze
-        SPLAT = '*'.freeze
         STRING_TYPES = [:str, :dstr].freeze
+        NAMED_INTERPOLATION = /%(?:<\w+>|\{\w+\})/
 
         def on_send(node)
           add_offense(node, :selector) if offending_node?(node)
@@ -65,7 +68,7 @@ module RuboCop
                             receiver_node
                           end
 
-          relevant_node.loc.expression.source.scan(NAMED_FIELD_REGEX).size > 0
+          relevant_node.source.scan(NAMED_FIELD_REGEX).size > 0
         end
 
         def node_with_splat_args?(node)
@@ -73,22 +76,13 @@ module RuboCop
 
           _receiver_node, _method_name, *args = *node
 
-          args[1..-1].any? { |arg| arg.type == :splat }
+          args.butfirst.any? { |arg| arg.type == :splat }
         end
 
         def heredoc?(node)
           _receiver, _name, args = *node
 
-          args.loc.expression.source[0, 2] == SHOVEL
-        end
-
-        def literal?(node)
-          node.int_type? ||
-            node.str_type? ||
-            node.sym_type? ||
-            node.float_type? ||
-            node.dstr_type? ||
-            node.dsym_type?
+          args.source[0, 2] == SHOVEL
         end
 
         def count_matches(node)
@@ -99,17 +93,7 @@ module RuboCop
             number_of_expected_fields = expected_fields_count(args.first)
           elsif percent?(node) && args.first.array_type?
             number_of_expected_fields = expected_fields_count(receiver_node)
-
-            first_child_argument = args.first
-            if first_child_argument.array_type?
-              number_of_args_for_format = args.first.child_nodes.size
-            elsif literal?(first_child_argument)
-              number_of_args_for_format = 1
-            else
-              # non-literals might evaluate to an Array, or they might not
-              # so we can't tell just how many format args there will be
-              number_of_args_for_format = :unknown
-            end
+            number_of_args_for_format = args.first.child_nodes.size
           else
             number_of_args_for_format = number_of_expected_fields = :unknown
           end
@@ -131,13 +115,13 @@ module RuboCop
 
         def expected_fields_count(node)
           return :unknown unless node.str_type?
+          return 1 if node.source =~ NAMED_INTERPOLATION
+
           node
-            .loc
-            .expression
             .source
             .scan(FIELD_REGEX)
             .select { |x| x.first != PERCENT_PERCENT }
-            .reduce(0) { |a, e| a + (e[2] == SPLAT ? 2 : 1) }
+            .reduce(0) { |a, e| a + (e[2] =~ /\*/ ? 2 : 1) }
         end
 
         def format?(node)

data/lib/rubocop/cop/lint/handle_exceptions.rb

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Lint
       # This cop checks for *rescue* blocks with no body.
       class HandleExceptions < Cop
-        MSG = 'Do not suppress exceptions.'
+        MSG = 'Do not suppress exceptions.'.freeze
 
         def on_resbody(node)
           _exc_list_node, _exc_var_node, body_node = *node

data/lib/rubocop/cop/lint/implicit_string_concatenation.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for implicit string concatenation of string literals
+      # which are on the same line.
+      #
+      # @example
+      #   @bad
+      #   array = ['Item 1' 'Item 2']
+      #
+      #   @good
+      #   array = ['Item 1Item 2']
+      #   array = ['Item 1' + 'Item 2']
+      #   array = [
+      #     'Item 1' \
+      #     'Item 2'
+      #   ]
+      class ImplicitStringConcatenation < Cop
+        MSG = 'Combine %s and %s into a single string literal, rather than ' \
+              'using implicit string concatenation.'.freeze
+        FOR_ARRAY = ' Or, if they were intended to be separate array ' \
+                    'elements, separate them with a comma.'.freeze
+        FOR_METHOD = ' Or, if they were intended to be separate method ' \
+                     'arguments, separate them with a comma.'.freeze
+
+        def on_dstr(node)
+          node.children.each_cons(2) do |child1, child2|
+            # `'abc' 'def'` -> (dstr (str "abc") (str "def"))
+            next unless string_literal?(child1) && string_literal?(child2)
+            next unless child1.loc.last_line == child2.loc.line
+
+            # Make sure we don't flag a string literal which simply has
+            # embedded newlines
+            # `"abc\ndef"` also -> (dstr (str "abc") (str "def"))
+            next unless child1.source[-1] == ending_delimiter(child1)
+
+            range   = child1.source_range.join(child2.source_range)
+            message = format(MSG, display_str(child1), display_str(child2))
+            if node.parent && node.parent.array_type?
+              message << FOR_ARRAY
+            elsif node.parent && node.parent.send_type?
+              message << FOR_METHOD
+            end
+            add_offense(node, range, message)
+          end
+        end
+
+        private
+
+        def ending_delimiter(str)
+          # implicit string concatenation does not work with %{}, etc.
+          if str.source[0] == "'"
+            "'"
+          elsif str.source[0] == '"'
+            '"'
+          end
+        end
+
+        def string_literal?(node)
+          node.str_type? ||
+            (node.dstr_type? && node.children.all? { |c| string_literal?(c) })
+        end
+
+        def display_str(node)
+          if node.source =~ /\n/
+            str_content(node).inspect
+          else
+            node.source
+          end
+        end
+
+        def str_content(node)
+          if node.str_type?
+            node.children[0]
+          else
+            node.children.map { |c| str_content(c) }.join
+          end
+        end
+      end
+    end
+  end
+end