rubocop 0.33.0 → 0.34.0

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

@@ -6,23 +6,46 @@ module RuboCop
       # This cop checks whether method definitions are
       # separated by empty lines.
       class EmptyLineBetweenDefs < Cop
-        MSG = 'Use empty lines between defs.'
+        include OnMethodDef
+        MSG = 'Use empty lines between method definitions.'
 
-        def on_def(node)
-          if @prev_def_end && (def_start(node) - @prev_def_end) == 1
-            unless @prev_was_single_line && singe_line_def?(node) &&
-                   cop_config['AllowAdjacentOneLineDefs']
-              add_offense(node, :keyword)
-            end
-          end
+        def on_method_def(node, _method_name, _args, _body)
+          return unless node.parent && node.parent.begin_type?
 
-          @prev_def_end = def_end(node)
-          @prev_was_single_line = singe_line_def?(node)
+          nodes = [prev_node(node), node]
+
+          return unless nodes.all?(&method(:def_node?))
+          return if blank_lines_between?(*nodes)
+          return if nodes.all?(&method(:single_line_def?)) &&
+                    cop_config['AllowAdjacentOneLineDefs']
+
+          add_offense(node, :keyword)
         end
 
         private
 
-        def singe_line_def?(node)
+        def def_node?(node)
+          return unless node
+          node.def_type? || node.defs_type?
+        end
+
+        def blank_lines_between?(first_def_node, second_def_node)
+          lines_between_defs(first_def_node, second_def_node).any?(&:blank?)
+        end
+
+        def prev_node(node)
+          return nil unless node.sibling_index > 0
+
+          node.parent.children[node.sibling_index - 1]
+        end
+
+        def lines_between_defs(first_def_node, second_def_node)
+          line_range = def_end(first_def_node)..(def_start(second_def_node) - 2)
+
+          processed_source.lines[line_range]
+        end
+
+        def single_line_def?(node)
           def_start(node) == def_end(node)
         end
 
@@ -35,8 +58,14 @@ module RuboCop
         end
 
         def autocorrect(node)
-          range = range_with_surrounding_space(node.loc.expression, :left)
-          ->(corrector) { corrector.insert_before(range, "\n") }
+          prev_def = prev_node(node)
+          end_pos = prev_def.loc.end.end_pos
+          source_buffer = prev_def.loc.end.source_buffer
+          newline_pos = source_buffer.source.index("\n", end_pos)
+          newline = Parser::Source::Range.new(source_buffer,
+                                              newline_pos,
+                                              newline_pos + 1)
+          ->(corrector) { corrector.insert_after(newline, "\n") }
         end
       end
     end

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

@@ -49,7 +49,13 @@ module RuboCop
 
           pre = (token.pos.line - 2).downto(0)
           post = token.pos.line.upto(processed_source.lines.size - 1)
-          aligned_with?(pre, token) || aligned_with?(post, token)
+          return true if aligned_with?(pre, token) || aligned_with?(post, token)
+
+          # If no aligned token was found, search for an aligned token on the
+          # nearest line with the same indentation as the checked line.
+          base_indentation = processed_source.lines[token.pos.line - 1] =~ /\S/
+          aligned_with?(pre, token, base_indentation) ||
+            aligned_with?(post, token, base_indentation)
         end
 
         def aligned_comments?(token)
@@ -72,11 +78,19 @@ module RuboCop
           processed_source.comments[ix].loc.column
         end
 
-        def aligned_with?(indices_to_check, token)
+        # Returns true if the previous or next line, not counting empty or
+        # comment lines, contains a token that's aligned with the given
+        # token. If base_indentation is given, lines with different indentation
+        # than the base indentation are also skipped.
+        def aligned_with?(indices_to_check, token, base_indentation = nil)
           indices_to_check.each do |ix|
             next if comment_lines.include?(ix + 1)
             line = processed_source.lines[ix]
             next if line.strip.empty?
+            if base_indentation
+              indentation = line =~ /\S/
+              next if indentation != base_indentation
+            end
             return (aligned_words?(token, line) ||
                     aligned_assignments?(token, line) ||
                     aligned_same_character?(token, line))
@@ -104,7 +118,7 @@ module RuboCop
         end
 
         def aligned_same_character?(token, line)
-          line[token.pos.column] == token.text[0]
+          line[token.pos.column] == token.text.to_s[0]
         end
       end
     end

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

@@ -99,7 +99,7 @@ module RuboCop
             .map { |c| c.loc.line }
 
           line = ''
-          while line =~ /^\s*$/ || @comment_lines.include?(line_number)
+          while line.blank? || @comment_lines.include?(line_number)
             line_number -= 1
             line = processed_source.lines[line_number - 1]
           end

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

@@ -101,6 +101,11 @@ module RuboCop
 
         def valid_19_syntax_symbol?(sym_name)
           sym_name.sub!(/\A:/, '')
+
+          # 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?
         end
 

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

@@ -13,6 +13,7 @@ module RuboCop
       #    end
       #   end
       class IndentationWidth < Cop # rubocop:disable Metrics/ClassLength
+        include EndKeywordAlignment
         include AutocorrectAlignment
         include OnMethodDef
         include CheckAssignment
@@ -174,7 +175,7 @@ module RuboCop
 
           end_config = config.for_cop('Lint/EndAlignment')
           style = end_config['Enabled'] ? end_config['AlignWith'] : 'keyword'
-          base = style == 'variable' ? node : rhs
+          base = variable_alignment?(node.loc, rhs, style.to_sym) ? node : rhs
 
           case rhs.type
           when :if            then on_if(rhs, base)
@@ -255,6 +256,11 @@ module RuboCop
           first_char_pos_on_line = body_node.loc.expression.source_line =~ /\S/
           return false unless body_node.loc.column == first_char_pos_on_line
 
+          if [:rescue, :ensure].include?(body_node.type)
+            block_body, *_ = *body_node
+            return unless block_body
+          end
+
           true
         end
 

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

@@ -17,6 +17,11 @@ module RuboCop
 
           with_space = range_with_surrounding_space(first_token.pos, :left,
                                                     nil, !:with_newline)
+          # If the file starts with a byte order mark (BOM), the column can be
+          # non-zero, but then we find out here if there's no space to the left
+          # of the first token.
+          return if with_space == first_token.pos
+
           space = Parser::Source::Range.new(processed_source.buffer,
                                             with_space.begin_pos,
                                             first_token.pos.begin_pos)

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

@@ -12,7 +12,7 @@ module RuboCop
       #   b
       #     something
       #   end
-      class MultilineOperationIndentation < Cop # rubocop:disable ClassLength
+      class MultilineOperationIndentation < Cop
         include ConfigurableEnforcedStyle
         include AutocorrectAlignment
 

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether some constant value isn't a
+      # mutable literal (e.g. array or hash).
+      #
+      # @example
+      #   # bad
+      #   CONST = [1, 2, 3]
+      #
+      #   # good
+      #   CONST = [1, 2, 3].freeze
+      class MutableConstant < Cop
+        MSG = 'Freeze mutable objects assigned to constants.'
+
+        MUTABLE_TYPES = [:array, :hash, :str, :dstr].freeze
+
+        def on_casgn(node)
+          _scope, _const_name, value = *node
+
+          return if value && !MUTABLE_TYPES.include?(value.type)
+
+          add_offense(value, :expression)
+        end
+
+        def autocorrect(node)
+          expr = node.loc.expression
+          ->(corrector) { corrector.replace(expr, "#{expr.source}.freeze") }
+        end
+      end
+    end
+  end
+end

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

@@ -23,28 +23,32 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include MinBodyLength
 
-        MSG = 'Use `next` to skip iteration.'
-        ENUMERATORS = [:collect, :detect, :downto, :each, :find, :find_all,
-                       :inject, :loop, :map!, :map, :reduce, :reverse_each,
-                       :select, :times, :upto]
+        MSG = 'Use `next` to skip iteration.'.freeze
+        EXIT_TYPES = [:break, :return].freeze
+        EACH_ = 'each_'.freeze
+        ENUMERATORS = [:collect, :collect_concat, :detect, :downto, :each,
+                       :find, :find_all, :find_index, :inject, :loop, :map!,
+                       :map, :reduce, :reject, :reject!, :reverse_each, :select,
+                       :select!, :times, :upto].freeze
 
         def on_block(node)
           block_owner, _, body = *node
-          return unless block_owner.type == :send
-          return if body.nil?
+          return unless block_owner.send_type?
+          return unless body && ends_with_condition?(body)
 
           _, method_name = *block_owner
           return unless enumerator?(method_name)
-          return unless ends_with_condition?(body)
 
-          add_offense(block_owner, :selector, MSG)
+          offense_node = offense_node(body)
+          add_offense(offense_node, offense_location(offense_node), MSG)
         end
 
         def on_while(node)
           _, body = *node
           return unless body && ends_with_condition?(body)
 
-          add_offense(node, :keyword, MSG)
+          offense_node = offense_node(body)
+          add_offense(offense_node, offense_location(offense_node), MSG)
         end
         alias_method :on_until, :on_while
 
@@ -52,25 +56,27 @@ module RuboCop
           _, _, body = *node
           return unless body && ends_with_condition?(body)
 
-          add_offense(node, :keyword, MSG)
+          offense_node = offense_node(body)
+          add_offense(offense_node, offense_location(offense_node), MSG)
         end
 
         private
 
         def enumerator?(method_name)
-          ENUMERATORS.include?(method_name) || /\Aeach_/.match(method_name)
+          ENUMERATORS.include?(method_name) ||
+            method_name.to_s.start_with?(EACH_)
         end
 
         def ends_with_condition?(body)
           return true if simple_if_without_break?(body)
 
-          body.type == :begin && simple_if_without_break?(body.children.last)
+          body.begin_type? && simple_if_without_break?(body.children.last)
         end
 
         def simple_if_without_break?(node)
+          return false unless node.if_type?
           return false if ternary_op?(node)
           return false if if_else?(node)
-          return false unless node.type == :if
           return false if style == :skip_modifier_ifs && modifier_if?(node)
           return false if !modifier_if?(node) && !min_body_length?(node)
 
@@ -79,7 +85,18 @@ module RuboCop
           _conditional, if_body, _else_body = *node
           return true unless if_body
 
-          ![:break, :return].include?(if_body.type)
+          !EXIT_TYPES.include?(if_body.type)
+        end
+
+        def offense_node(body)
+          *_, condition = *body
+          (condition && condition.if_type?) ? condition : body
+        end
+
+        def offense_location(offense_node)
+          condition_expression, = *offense_node
+          offense_begin_pos = offense_node.loc.expression.begin
+          offense_begin_pos.join(condition_expression.loc.expression)
         end
       end
     end

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

@@ -33,7 +33,7 @@ module RuboCop
           # asserting last argument is an optional argument
           return unless last_arg.optarg_type?
 
-          _, default_value = *last_arg
+          arg, default_value = *last_arg
 
           # asserting default value is a hash
           return unless default_value.hash_type?
@@ -42,6 +42,9 @@ module RuboCop
           *key_value_pairs = *default_value
           return unless key_value_pairs.empty?
 
+          # Check for suspicious argument names
+          return unless name_in_suspicious_param_names?(arg)
+
           add_offense(last_arg, :expression, MSG)
         end
 
@@ -50,6 +53,11 @@ module RuboCop
         def supports_keyword_arguments?
           RUBY_VERSION >= '2.0.0'
         end
+
+        def name_in_suspicious_param_names?(arg_name)
+          cop_config.key?('SuspiciousParamNames') &&
+            cop_config['SuspiciousParamNames'].include?(arg_name.to_s)
+        end
       end
     end
   end

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

@@ -21,7 +21,6 @@ module RuboCop
       #   b = 2
       #   c = 3
       class ParallelAssignment < Cop
-        include AutocorrectAlignment
         include IfNode
 
         MSG = 'Do not use parallel assignment.'
@@ -56,11 +55,11 @@ module RuboCop
           lambda do |corrector|
             assignment_corrector =
               if modifier_statement?(node.parent)
-                ModifierCorrector.new(node, configured_indentation_width)
+                ModifierCorrector.new(node, config)
               elsif rescue_modifier?(node.parent)
-                RescueCorrector.new(node, configured_indentation_width)
+                RescueCorrector.new(node, config)
               else
-                GenericCorrector.new(node, configured_indentation_width)
+                GenericCorrector.new(node, config)
               end
 
             corrector.replace(assignment_corrector.correction_range,
@@ -98,35 +97,27 @@ module RuboCop
 
         # An internal class for correcting parallel assignment
         class GenericCorrector
-          attr_reader :correction, :correction_range
+          include AutocorrectAlignment
 
-          def initialize(node, indentation_width)
+          attr_reader :config, :node, :correction, :correction_range
+
+          def initialize(node, config)
             @node = node
-            @indentation_width = indentation_width
+            @config = config
           end
 
           def correction
-            "#{assignment.join("\n#{indent}")}"
+            "#{assignment.join("\n#{offset(node)}")}"
           end
 
           def correction_range
-            @node.loc.expression
+            node.loc.expression
           end
 
           protected
 
-          def space_offset
-            @node.loc.expression.column
-          end
-
-          def indent
-            ' ' * space_offset
-          end
-
-          attr_reader :indentation_width
-
           def assignment
-            left, right = *@node
+            left, right = *node
             l_vars = extract_sources(left)
             r_vars = extract_sources(right)
             groups = l_vars.zip(r_vars)
@@ -144,25 +135,18 @@ module RuboCop
         # protected by rescue
         class RescueCorrector < GenericCorrector
           def correction
-            _node, rescue_clause = *@node.parent
+            _node, rescue_clause = *node.parent
             _, _, rescue_result = *rescue_clause
 
             "begin\n" <<
-              indent << assignment.join("\n#{indent}") <<
-              "\nrescue\n" <<
-              indent << rescue_result.loc.expression.source <<
-              "\nend"
+              indentation(node) << assignment.join("\n#{indentation(node)}") <<
+              "\n#{offset(node)}rescue\n" <<
+              indentation(node) << rescue_result.loc.expression.source <<
+              "\n#{offset(node)}end"
           end
 
           def correction_range
-            @node.parent.loc.expression
-          end
-
-          protected
-
-          def space_offset
-            offset = super
-            offset + indentation_width
+            node.parent.loc.expression
           end
         end
 
@@ -170,7 +154,7 @@ module RuboCop
         # guarded by if, unless, while, or until
         class ModifierCorrector < GenericCorrector
           def correction
-            parent = @node.parent
+            parent = node.parent
 
             modifier_range =
               Parser::Source::Range.new(parent.loc.expression.source_buffer,
@@ -178,19 +162,12 @@ module RuboCop
                                         parent.loc.expression.end_pos)
 
             "#{modifier_range.source}\n" <<
-              indent << assignment.join("\n#{indent}") <<
-              "\nend"
+              indentation(node) << assignment.join("\n#{indentation(node)}") <<
+              "\n#{offset(node)}end"
           end
 
           def correction_range
-            @node.parent.loc.expression
-          end
-
-          protected
-
-          def space_offset
-            offset = super
-            offset + indentation_width
+            node.parent.loc.expression
           end
         end
       end