rubocop 0.91.0 → 1.0.0

data/lib/rubocop/cop/correctors/line_break_corrector.rb

@@ -52,8 +52,8 @@ module RuboCop
         end
 
         def semicolon(node)
-          @semicolon ||= {}
-          @semicolon[node.object_id] ||= tokens(node).find(&:semicolon?)
+          @semicolon ||= {}.compare_by_identity
+          @semicolon[node] ||= processed_source.tokens_within(node).find(&:semicolon?)
         end
       end
     end

data/lib/rubocop/cop/correctors/percent_literal_corrector.rb

@@ -89,7 +89,7 @@ module RuboCop
         begin_line_num = previous_line_num - base_line_num + 1
         end_line_num = node.first_line - base_line_num + 1
         lines = source_in_lines[begin_line_num...end_line_num]
-        "\n#{(lines.join("\n").split(node.source).first || '')}"
+        "\n#{lines.join("\n").split(node.source).first || ''}"
       end
 
       def fix_escaped_content(word_node, escape, delimiters)

data/lib/rubocop/cop/gemspec/required_ruby_version.rb

@@ -58,24 +58,22 @@ module RuboCop
           (send _ :required_ruby_version= $_)
         PATTERN
 
-        def_node_matcher :string_version?, <<~PATTERN
-          {(str _) (array (str _))}
+        def_node_matcher :defined_ruby_version, <<~PATTERN
+          {$(str _) $(array (str _) (str _))
+            (send (const (const nil? :Gem) :Requirement) :new $(str _))}
         PATTERN
 
         # rubocop:disable Metrics/AbcSize
         def investigate(processed_source)
-          version = required_ruby_version(processed_source.ast).first
+          version_def = required_ruby_version(processed_source.ast).first
 
-          if version
-            return unless string_version?(version)
-
-            ruby_version = extract_ruby_version(version)
-
-            return if ruby_version == target_ruby_version.to_s
+          if version_def
+            ruby_version = extract_ruby_version(defined_ruby_version(version_def))
+            return if !ruby_version || ruby_version == target_ruby_version.to_s
 
             add_offense(
               processed_source.ast,
-              location: version.loc.expression,
+              location: version_def.loc.expression,
               message: not_equal_message(ruby_version, target_ruby_version)
             )
           else
@@ -88,6 +86,8 @@ module RuboCop
         private
 
         def extract_ruby_version(required_ruby_version)
+          return unless required_ruby_version
+
           if required_ruby_version.array_type?
             required_ruby_version = required_ruby_version.children.detect do |v|
               /[>=]/.match?(v.str_content)

data/lib/rubocop/cop/layout/array_alignment.rb

@@ -44,6 +44,7 @@ module RuboCop
 
         def on_array(node)
           return if node.children.size < 2
+          return if node.parent&.masgn_type?
 
           check_alignment(node.children, base_column(node, node.children))
         end

data/lib/rubocop/cop/layout/case_indentation.rb

@@ -105,7 +105,10 @@ module RuboCop
         end
 
         def incorrect_style(when_node)
-          add_offense(when_node.loc.keyword) do |corrector|
+          depth = indent_one_step? ? 'one step more than' : 'as deep as'
+          message = format(MSG, depth: depth, base: style)
+
+          add_offense(when_node.loc.keyword, message: message) do |corrector|
             detect_incorrect_style(when_node)
 
             whitespace = whitespace_range(when_node)
@@ -125,12 +128,6 @@ module RuboCop
           end
         end
 
-        def find_message(*)
-          depth = indent_one_step? ? 'one step more than' : 'as deep as'
-
-          format(MSG, depth: depth, base: style)
-        end
-
         def base_column(case_node, base)
           case base
           when :case then case_node.location.keyword.column

data/lib/rubocop/cop/layout/class_structure.rb

@@ -169,7 +169,7 @@ module RuboCop
         # Autocorrect by swapping between two nodes autocorrecting them
         def autocorrect(corrector, node)
           node_classification = classify(node)
-          previous = left_siblings_of(node).find do |sibling|
+          previous = node.left_siblings.find do |sibling|
             classification = classify(sibling)
             !ignore?(classification) && node_classification != classification
           end
@@ -265,6 +265,9 @@ module RuboCop
         end
 
         def end_position_for(node)
+          heredoc = find_heredoc(node)
+          return heredoc.location.heredoc_end.end_pos + 1 if heredoc
+
           end_line = buffer.line_for_position(node.loc.expression.end_pos)
           buffer.line_range(end_line).end_pos
         end
@@ -284,6 +287,10 @@ module RuboCop
           buffer.line_range(node.loc.line).begin_pos - 1
         end
 
+        def find_heredoc(node)
+          node.each_node(:str, :dstr, :xstr).find(&:heredoc?)
+        end
+
         def buffer
           processed_source.buffer
         end

data/lib/rubocop/cop/layout/dot_position.rb

@@ -29,17 +29,14 @@ module RuboCop
         def on_send(node)
           return unless node.dot? || ampersand_dot?(node)
 
-          if proper_dot_position?(node)
-            correct_style_detected
-          else
-            return unless opposite_style_detected
+          return correct_style_detected if proper_dot_position?(node)
 
-            dot = node.loc.dot
-            message = message(dot)
+          opposite_style_detected
+          dot = node.loc.dot
+          message = message(dot)
 
-            add_offense(dot, message: message) do |corrector|
-              autocorrect(corrector, dot, node)
-            end
+          add_offense(dot, message: message) do |corrector|
+            autocorrect(corrector, dot, node)
           end
         end
         alias on_csend on_send

data/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb

@@ -95,7 +95,7 @@ module RuboCop
         end
 
         def next_sibling_parent_empty_or_else?(node)
-          next_sibling = node.parent.children[node.sibling_index + 1]
+          next_sibling = node.right_sibling
           return true if next_sibling.nil?
 
           parent = next_sibling.parent
@@ -104,7 +104,7 @@ module RuboCop
         end
 
         def next_sibling_empty_or_guard_clause?(node)
-          next_sibling = node.parent.children[node.sibling_index + 1]
+          next_sibling = node.right_sibling
           return true if next_sibling.nil?
 
           next_sibling.if_type? && contains_guard_clause?(next_sibling)

data/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb

@@ -53,7 +53,6 @@ module RuboCop
       #
       class EmptyLineAfterMultilineCondition < Base
         include RangeHelp
-        include RescueNode
         extend AutoCorrector
 
         MSG = 'Use empty line after multiline condition.'
@@ -62,7 +61,7 @@ module RuboCop
           return if node.ternary?
 
           if node.modifier_form?
-            check_condition(node.condition) if right_sibling(node)
+            check_condition(node.condition) if node.right_sibling
           else
             check_condition(node.condition)
           end
@@ -74,7 +73,7 @@ module RuboCop
         alias on_until on_while
 
         def on_while_post(node)
-          return unless right_sibling(node)
+          return unless node.right_sibling
 
           check_condition(node.condition)
         end
@@ -92,10 +91,8 @@ module RuboCop
         end
 
         def on_rescue(node)
-          _body, *resbodies, _else = *node
-
-          resbodies.each do |resbody|
-            rescued_exceptions = rescued_exceptions(resbody)
+          node.resbody_branches.each do |resbody|
+            rescued_exceptions = resbody.exceptions
             next if !multiline_rescue_exceptions?(rescued_exceptions) ||
                     next_line_empty?(rescued_exceptions.last.last_line)
 
@@ -116,12 +113,6 @@ module RuboCop
           processed_source[line].blank?
         end
 
-        def right_sibling(node)
-          return unless node.parent
-
-          node.parent.children[node.sibling_index + 1]
-        end
-
         def multiline_when_condition?(when_node)
           when_node.conditions.first.first_line != when_node.conditions.last.last_line
         end

data/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb

@@ -84,14 +84,8 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless node.bare_access_modifier?
-
-          case style
-          when :around
-            return if empty_lines_around?(node)
-          when :only_before
-            return if allowed_only_before_style?(node)
-          end
+          return unless node.bare_access_modifier? && !node.parent&.block_type?
+          return if expected_empty_lines?(node)
 
           message = message(node)
           add_offense(node, message: message) do |corrector|
@@ -105,6 +99,17 @@ module RuboCop
 
         private
 
+        def expected_empty_lines?(node)
+          case style
+          when :around
+            return true if empty_lines_around?(node)
+          when :only_before
+            return true if allowed_only_before_style?(node)
+          end
+
+          false
+        end
+
         def allowed_only_before_style?(node)
           if node.special_modifier?
             return true if processed_source[node.last_line] == 'end'

data/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb

@@ -88,7 +88,7 @@ module RuboCop
         end
 
         def require_empty_line?(node)
-          return false unless node&.respond_to?(:type)
+          return false unless node.respond_to?(:type)
 
           !allow_alias?(node) && !attribute_or_allowed_method?(node)
         end
@@ -96,7 +96,7 @@ module RuboCop
         def next_line_node(node)
           return if node.parent.if_type?
 
-          node.parent.children[node.sibling_index + 1]
+          node.right_sibling
         end
 
         def allow_alias?(node)

data/lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb

@@ -113,10 +113,9 @@ module RuboCop
         end
 
         def keyword_locations_in_rescue(node)
-          _begin_body, *resbodies, _else_body = *node
           [
             node.loc.else,
-            *resbodies.map { |body| body.loc.keyword }
+            *node.resbody_branches.map { |body| body.loc.keyword }
           ].compact
         end
 

data/lib/rubocop/cop/layout/rescue_ensure_alignment.rb

@@ -191,7 +191,16 @@ module RuboCop
         end
 
         def begin_end_alignment_style
-          config.for_cop('Layout/BeginEndAlignment')['EnforcedStyleAlignWith']
+          # FIXME: Workaround for pending status for `Layout/BeginEndAlignment` cop
+          #        When RuboCop 1.0 is released, please replace it with the following condition.
+          #
+          # config.for_cop('Layout/BeginEndAlignment')['Enabled'] &&
+          #   config.for_cop('Layout/BeginEndAlignment')['EnforcedStyleAlignWith']
+          if config.for_all_cops['NewCops'] == 'enable' ||
+             config.for_cop('Layout/BeginEndAlignment')['Enabled'] &&
+             config.for_cop('Layout/BeginEndAlignment')['Enabled'] != 'pending'
+            config.for_cop('Layout/BeginEndAlignment')['EnforcedStyleAlignWith']
+          end
         end
       end
     end

data/lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb

@@ -36,8 +36,8 @@ module RuboCop
         MSG = 'Surrounding space %<type>s in default value assignment.'
 
         def on_optarg(node)
-          index = index_of_first_token(node)
-          arg, equals, value = processed_source.tokens[index, 3]
+          tokens = processed_source.tokens_within(node)
+          arg, equals, value = tokens.take(3)
           check_optarg(arg, equals, value)
         end
 
@@ -51,22 +51,13 @@ module RuboCop
              style == :no_space && no_surrounding_space
             correct_style_detected
           else
-            incorrect_style_detected(arg, value, space_on_both_sides,
-                                     no_surrounding_space)
+            incorrect_style_detected(arg, value)
           end
         end
 
-        def incorrect_style_detected(arg, value, space_on_both_sides,
-                                     no_surrounding_space)
+        def incorrect_style_detected(arg, value)
           range = range_between(arg.end_pos, value.begin_pos)
 
-          if style == :space && no_surrounding_space ||
-             style == :no_space && space_on_both_sides
-            return unless opposite_style_detected
-          else
-            return unless unrecognized_style_detected
-          end
-
           add_offense(range) do |corrector|
             autocorrect(corrector, range)
           end

data/lib/rubocop/cop/layout/space_around_operators.rb

@@ -5,6 +5,8 @@ module RuboCop
     module Layout
       # Checks that operators have space around them, except for ** which
       # should or shouldn't have surrounding space depending on configuration.
+      # It allows vertical alignment consisting of one or more whitespace
+      # around operators.
       #
       # This cop has `AllowForAlignment` option. When `true`, allows most
       # uses of extra spacing if the intent is to align with an operator on
@@ -207,7 +209,8 @@ module RuboCop
           token            = Token.new(operator, nil, operator.source)
           align_preceding  = aligned_with_preceding_assignment(token)
 
-          return align_preceding == :no unless align_preceding == :none
+          return false if align_preceding == :yes ||
+                          aligned_with_subsequent_assignment(token) == :none
 
           aligned_with_subsequent_assignment(token) != :yes
         end

data/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb

@@ -108,11 +108,11 @@ module RuboCop
         end
 
         def left_array_bracket(node)
-          tokens(node).find(&:left_array_bracket?)
+          processed_source.tokens_within(node).find(&:left_array_bracket?)
         end
 
         def right_array_bracket(node)
-          tokens(node).reverse.find(&:right_bracket?)
+          processed_source.tokens_within(node).reverse.find(&:right_bracket?)
         end
 
         def empty_config
@@ -120,7 +120,7 @@ module RuboCop
         end
 
         def next_to_newline?(node, token)
-          tokens(node)[index_for(node, token) + 1].line != token.line
+          processed_source.tokens_within(node)[index_for(node, token) + 1].line != token.line
         end
 
         def end_has_own_line?(token)
@@ -131,7 +131,7 @@ module RuboCop
         end
 
         def index_for(node, token)
-          tokens(node).index(token)
+          processed_source.tokens_within(node).index(token)
         end
 
         def line_and_column_for(token)
@@ -153,7 +153,7 @@ module RuboCop
         end
 
         def next_to_comment?(node, token)
-          tokens(node)[index_for(node, token) + 1].comment?
+          processed_source.tokens_within(node)[index_for(node, token) + 1].comment?
         end
 
         def compact_offenses(node, left, right, start_ok, end_ok)
@@ -184,9 +184,9 @@ module RuboCop
         def multi_dimensional_array?(node, token, side: :right)
           i = index_for(node, token)
           if side == :right
-            tokens(node)[i - 1].right_bracket?
+            processed_source.tokens_within(node)[i - 1].right_bracket?
           else
-            tokens(node)[i + 1].left_array_bracket?
+            processed_source.tokens_within(node)[i + 1].left_array_bracket?
           end
         end
 

data/lib/rubocop/cop/layout/space_inside_block_braces.rb

@@ -206,8 +206,6 @@ module RuboCop
 
         def no_space(begin_pos, end_pos, msg)
           if style == :space
-            return unless opposite_style_detected
-
             offense(begin_pos, end_pos, msg)
           else
             correct_style_detected
@@ -216,8 +214,6 @@ module RuboCop
 
         def space(begin_pos, end_pos, msg)
           if style == :no_space
-            return unless opposite_style_detected
-
             offense(begin_pos, end_pos, msg)
           else
             correct_style_detected

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

@@ -72,29 +72,15 @@ module RuboCop
         MSG = 'Space inside %<problem>s.'
 
         def on_hash(node)
-          tokens = processed_source.tokens
+          tokens = processed_source.tokens_within(node)
+          return unless tokens.first.left_brace? && tokens.last.right_curly_brace?
 
-          hash_literal_with_braces(node) do |begin_index, end_index|
-            check(tokens[begin_index], tokens[begin_index + 1])
-            return if begin_index == end_index - 1
-
-            check(tokens[end_index - 1], tokens[end_index])
-          end
+          check(tokens[0], tokens[1])
+          check(tokens[-2], tokens[-1]) if tokens.size > 2
         end
 
         private
 
-        def hash_literal_with_braces(node)
-          tokens = processed_source.tokens
-          begin_index = index_of_first_token(node)
-          return unless tokens[begin_index].left_brace?
-
-          end_index = index_of_last_token(node)
-          return unless tokens[end_index].right_curly_brace?
-
-          yield begin_index, end_index
-        end
-
         def check(token1, token2)
           # No offense if line break inside.
           return if token1.line < token2.line