rubocop 0.35.1 → 0.36.0

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

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

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -9,7 +10,7 @@ module RuboCop
         include SurroundingSpace
         include ConfigurableEnforcedStyle
 
-        MSG = 'Space inside %s.'
+        MSG = 'Space inside %s.'.freeze
 
         def on_hash(node)
           b_ix = index_of_first_token(node)
@@ -19,6 +20,8 @@ module RuboCop
           return unless tokens[b_ix].type == :tLBRACE
 
           e_ix = index_of_last_token(node)
+          return unless tokens[e_ix].type == :tRCURLY
+
           check(tokens[b_ix], tokens[b_ix + 1])
           check(tokens[e_ix - 1], tokens[e_ix]) unless b_ix == e_ix - 1
         end

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

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

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -18,7 +19,7 @@ module RuboCop
       #   # good
       #   'a'..'z'
       class SpaceInsideRangeLiteral < Cop
-        MSG = 'Space inside range literal.'
+        MSG = 'Space inside range literal.'.freeze
 
         def on_irange(node)
           check(node)
@@ -31,7 +32,7 @@ module RuboCop
         private
 
         def check(node)
-          expression = node.loc.expression.source
+          expression = node.source
           op = node.loc.operator.source
           escaped_op = op.gsub(/\./, '\.')
 
@@ -44,13 +45,13 @@ module RuboCop
         end
 
         def autocorrect(node)
-          expression = node.loc.expression.source
+          expression = node.source
           operator = node.loc.operator.source
           operator_escaped = operator.gsub(/\./, '\.')
 
           lambda do |corrector|
             corrector.replace(
-              node.loc.expression,
+              node.source_range,
               expression
                 .sub(/\s+#{operator_escaped}/, operator)
                 .sub(/#{operator_escaped}\s+/, operator)

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -14,15 +15,15 @@ module RuboCop
       class SpaceInsideStringInterpolation < Cop
         include ConfigurableEnforcedStyle
 
-        NO_SPACE_MSG = 'Space inside string interpolation detected.'
-        SPACE_MSG = 'Missing space around string interpolation detected.'
+        NO_SPACE_MSG = 'Space inside string interpolation detected.'.freeze
+        SPACE_MSG = 'Missing space around string interpolation detected.'.freeze
 
         def on_dstr(node)
           node.children.select { |n| n.type == :begin }.each do |begin_node|
             final_node = begin_node.children.last
             next unless final_node
 
-            interp = final_node.loc.expression
+            interp = final_node.source_range
             interp_with_surrounding_space = range_with_surrounding_space(interp)
             if style == :no_space
               if interp_with_surrounding_space != interp
@@ -39,20 +40,10 @@ module RuboCop
         private
 
         def autocorrect(node)
-          if style == :no_space
-            lambda do |corrector|
-              corrector.replace(
-                range_with_surrounding_space(node.loc.expression),
-                node.loc.expression.source
-              )
-            end
-          elsif style == :space
-            lambda do |corrector|
-              corrector.replace(
-                range_with_surrounding_space(node.loc.expression),
-                " #{node.loc.expression.source} "
-              )
-            end
+          new_source = (style == :no_space) ? node.source : " #{node.source} "
+          lambda do |corrector|
+            corrector.replace(range_with_surrounding_space(node.source_range),
+                              new_source)
           end
         end
       end

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

@@ -1,90 +1,135 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop looks for uses of Perl-style global variables.
       class SpecialGlobalVars < Cop
+        include ConfigurableEnforcedStyle
+
         MSG_BOTH = 'Prefer `%s` from the stdlib \'English\' module, ' \
-        'or `%s` over `%s`.'
+        'or `%s` over `%s`.'.freeze
         MSG_ENGLISH = 'Prefer `%s` from the stdlib \'English\' module ' \
-        'over `%s`.'
-        MSG_REGULAR = 'Prefer `%s` over `%s`.'
-
-        PREFERRED_VARS = {
-          '$:' => ['$LOAD_PATH'],
-          '$"' => ['$LOADED_FEATURES'],
-          '$0' => ['$PROGRAM_NAME'],
-          '$!' => ['$ERROR_INFO'],
-          '$@' => ['$ERROR_POSITION'],
-          '$;' => ['$FIELD_SEPARATOR', '$FS'],
-          '$,' => ['$OUTPUT_FIELD_SEPARATOR', '$OFS'],
-          '$/' => ['$INPUT_RECORD_SEPARATOR', '$RS'],
-          '$\\' => ['$OUTPUT_RECORD_SEPARATOR', '$ORS'],
-          '$.' => ['$INPUT_LINE_NUMBER', '$NR'],
-          '$_' => ['$LAST_READ_LINE'],
-          '$>' => ['$DEFAULT_OUTPUT'],
-          '$<' => ['$DEFAULT_INPUT'],
-          '$$' => ['$PROCESS_ID', '$PID'],
-          '$?' => ['$CHILD_STATUS'],
-          '$~' => ['$LAST_MATCH_INFO'],
-          '$=' => ['$IGNORECASE'],
-          '$*' => ['$ARGV', 'ARGV'],
-          '$&' => ['$MATCH'],
-          '$`' => ['$PREMATCH'],
-          '$\'' => ['$POSTMATCH'],
-          '$+' => ['$LAST_PAREN_MATCH']
-        }.symbolize_keys
+        'over `%s`.'.freeze
+        MSG_REGULAR = 'Prefer `%s` over `%s`.'.freeze
+
+        ENGLISH_VARS = { # rubocop:disable Style/MutableConstant
+          :$: => [:$LOAD_PATH],
+          :$" => [:$LOADED_FEATURES],
+          :$0 => [:$PROGRAM_NAME],
+          :$! => [:$ERROR_INFO],
+          :$@ => [:$ERROR_POSITION],
+          :$; => [:$FIELD_SEPARATOR, :$FS],
+          :$, => [:$OUTPUT_FIELD_SEPARATOR, :$OFS],
+          :$/ => [:$INPUT_RECORD_SEPARATOR, :$RS],
+          :$\ => [:$OUTPUT_RECORD_SEPARATOR, :$ORS],
+          :$. => [:$INPUT_LINE_NUMBER, :$NR],
+          :$_ => [:$LAST_READ_LINE],
+          :$> => [:$DEFAULT_OUTPUT],
+          :$< => [:$DEFAULT_INPUT],
+          :$$ => [:$PROCESS_ID, :$PID],
+          :$? => [:$CHILD_STATUS],
+          :$~ => [:$LAST_MATCH_INFO],
+          :$= => [:$IGNORECASE],
+          :$* => [:$ARGV, :ARGV],
+          :$& => [:$MATCH],
+          :$` => [:$PREMATCH],
+          :$' => [:$POSTMATCH],
+          :$+ => [:$LAST_PAREN_MATCH]
+        }
+
+        PERL_VARS =
+          Hash[ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }]
+
+        ENGLISH_VARS.merge!(
+          Hash[ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }])
+        PERL_VARS.merge!(
+          Hash[PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }])
+        ENGLISH_VARS.each { |_, v| v.freeze }.freeze
+        PERL_VARS.each { |_, v| v.freeze }.freeze
 
         # Anything *not* in this set is provided by the English library.
         NON_ENGLISH_VARS = Set.new([
-          '$LOAD_PATH',
-          '$LOADED_FEATURES',
-          '$PROGRAM_NAME',
-          'ARGV'
-        ])
+                                     :$LOAD_PATH,
+                                     :$LOADED_FEATURES,
+                                     :$PROGRAM_NAME,
+                                     :ARGV
+                                   ]).freeze
 
         def on_gvar(node)
           global_var, = *node
 
-          add_offense(node, :expression) if PREFERRED_VARS[global_var]
+          return unless (preferred = preferred_names(global_var))
+
+          if preferred.include?(global_var)
+            correct_style_detected
+          else
+            opposite_style_detected
+            add_offense(node, :expression)
+          end
         end
 
         def message(node)
           global_var, = *node
 
-          regular, english = PREFERRED_VARS[global_var].partition do |var|
-            NON_ENGLISH_VARS.include? var
-          end
+          if style == :use_english_names
+            regular, english = ENGLISH_VARS[global_var].partition do |var|
+              NON_ENGLISH_VARS.include? var
+            end
 
-          # For now, we assume that lists are 2 items or less. Easy grammar!
-          regular_msg = regular.join('` or `')
-          english_msg = english.join('` or `')
+            # For now, we assume that lists are 2 items or less. Easy grammar!
+            regular_msg = regular.join('` or `')
+            english_msg = english.join('` or `')
 
-          if regular.length > 0 && english.length > 0
-            format(MSG_BOTH, english_msg, regular_msg, global_var)
-          elsif regular.length > 0
-            format(MSG_REGULAR, regular_msg, global_var)
-          elsif english.length > 0
-            format(MSG_ENGLISH, english_msg, global_var)
+            if regular.length > 0 && english.length > 0
+              format(MSG_BOTH, english_msg, regular_msg, global_var)
+            elsif regular.length > 0
+              format(MSG_REGULAR, regular_msg, global_var)
+            elsif english.length > 0
+              format(MSG_ENGLISH, english_msg, global_var)
+            else
+              fail 'Bug in SpecialGlobalVars - global var w/o preferred vars!'
+            end
           else
-            fail 'Bug in SpecialGlobalVars - global var w/o preferred vars!'
+            format(MSG_REGULAR, preferred_names(global_var).first, global_var)
           end
         end
 
         def autocorrect(node)
           lambda do |corrector|
             global_var, = *node
-            parent_type = node.parent ? node.parent.type : nil
+
+            while node.parent && node.parent.begin_type? &&
+                  node.parent.children.one?
+              node = node.parent
+            end
+            parent_type = node.parent && node.parent.type
+
             if [:dstr, :xstr, :regexp].include?(parent_type)
-              corrector.replace(node.loc.expression,
-                                "{#{PREFERRED_VARS[global_var].first}}")
+              if style == :use_english_names
+                corrector.replace(node.source_range,
+                                  "{#{preferred_names(global_var).first}}")
+              else
+                corrector.replace(node.source_range,
+                                  "##{preferred_names(global_var).first}")
+              end
             else
-              corrector.replace(node.loc.expression,
-                                PREFERRED_VARS[global_var].first)
+              corrector.replace(node.source_range,
+                                preferred_names(global_var).first.to_s)
             end
           end
         end
+
+        private
+
+        def preferred_names(global)
+          if style == :use_english_names
+            ENGLISH_VARS[global]
+          else
+            PERL_VARS[global]
+          end
+        end
       end
     end
   end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 module RuboCop
   module Cop
     module Style
@@ -18,13 +19,15 @@ module RuboCop
       #   # require_parentheses - good
       #   ->a,b,c { a + b + c}
       class StabbyLambdaParentheses < Cop
-        MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'
-        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments with parentheses.'
-
         include ConfigurableEnforcedStyle
 
+        MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'.freeze
+        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments ' \
+                         'with parentheses.'.freeze
+        ARROW = '->'.freeze
+
         def on_send(node)
-          return unless lambda_with_args?(node)
+          return unless arrow_lambda_with_args?(node)
 
           if style == :require_parentheses
             if parentheses?(node)
@@ -63,7 +66,7 @@ module RuboCop
 
         def missing_parentheses_corrector(node)
           lambda do |corrector|
-            args_loc = node_args(node).loc.expression
+            args_loc = node_args(node).source_range
 
             corrector.insert_before(args_loc, '(')
             corrector.insert_after(args_loc, ')')
@@ -79,13 +82,17 @@ module RuboCop
           end
         end
 
-        def lambda_with_args?(node)
-          lambda_node?(node) && args?(node)
+        def arrow_lambda_with_args?(node)
+          lambda_node?(node) && arrow_form?(node) && args?(node)
         end
 
         def lambda_node?(node)
-          _nil, call = *node
-          call == :lambda
+          receiver, call = *node
+          receiver.nil? && call == :lambda
+        end
+
+        def arrow_form?(node)
+          node.loc.selector.source == ARROW
         end
 
         def node_args(node)

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -8,6 +9,28 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp
 
+        MSG_INCONSISTENT = 'Inconsistent quote style.'.freeze
+
+        def on_dstr(node)
+          # Strings which are continued across multiple lines using \
+          # are parsed as a `dstr` node with `str` children
+          # If one part of that continued string contains interpolations,
+          # then it will be parsed as a nested `dstr` node
+          return unless consistent_multiline?
+
+          children = node.children
+          return unless children.all? { |c| c.str_type? || c.dstr_type? }
+
+          quote_styles = children.map { |c| c.loc.begin.source }.uniq
+          if quote_styles.size > 1
+            add_offense(node, :expression, MSG_INCONSISTENT)
+          else
+            check_multiline_quote_style(node, quote_styles[0])
+          end
+
+          ignore_node(node)
+        end
+
         private
 
         def message(*)
@@ -25,7 +48,24 @@ module RuboCop
           # for this cop.
           return false if inside_interpolation?(node)
 
-          wrong_quotes?(node, style)
+          wrong_quotes?(node)
+        end
+
+        def consistent_multiline?
+          cop_config['ConsistentQuotesInMultiline']
+        end
+
+        def check_multiline_quote_style(node, quote)
+          range = node.source_range
+          children = node.children
+          if quote == "'" && style == :double_quotes
+            add_offense(node, range) if children.all? { |c| wrong_quotes?(c) }
+          elsif quote == '"' && style == :single_quotes
+            if children.none?(&:dstr_type?) &&
+               children.none? { |c| double_quotes_acceptable?(c.str_content) }
+              add_offense(node, range)
+            end
+          end
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -22,7 +23,7 @@ module RuboCop
           # offense for this cop.
           return false unless inside_interpolation?(node)
 
-          wrong_quotes?(node, style)
+          wrong_quotes?(node)
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -8,7 +9,7 @@ module RuboCop
       class StringMethods < Cop
         include MethodPreference
 
-        MSG = 'Prefer `%s` over `%s`.'
+        MSG = 'Prefer `%s` over `%s`.'.freeze
 
         def on_send(node)
           _receiver, method_name, *_args = *node