rubocop 0.90.0 → 0.93.1

data/lib/rubocop/config_store.rb

@@ -54,9 +54,9 @@ module RuboCop
       @path_cache[dir] ||= ConfigLoader.configuration_file_for(dir)
       path = @path_cache[dir]
       @object_cache[path] ||= begin
-                                print "For #{dir}: " if ConfigLoader.debug?
-                                ConfigLoader.configuration_from_file(path)
-                              end
+        print "For #{dir}: " if ConfigLoader.debug?
+        ConfigLoader.configuration_from_file(path)
+      end
     end
   end
 end

data/lib/rubocop/cop/bundler/duplicated_gem.rb

@@ -53,7 +53,11 @@ module RuboCop
           gem_declarations(processed_source.ast)
             .group_by(&:first_argument)
             .values
-            .select { |nodes| nodes.size > 1 }
+            .select { |nodes| nodes.size > 1 && !condition?(nodes) }
+        end
+
+        def condition?(nodes)
+          nodes[0].parent&.if_type? && nodes[0].parent == nodes[1].parent
         end
 
         def register_offense(node, gem_name, line_of_first_occurrence)

data/lib/rubocop/cop/bundler/gem_comment.rb

@@ -64,6 +64,7 @@ module RuboCop
         MSG = 'Missing gem description comment.'
         CHECKED_OPTIONS_CONFIG = 'OnlyFor'
         VERSION_SPECIFIERS_OPTION = 'version_specifiers'
+        RESTRICT_ON_SEND = %i[gem].freeze
 
         def_node_matcher :gem_declaration?, '(send nil? :gem str ...)'
 

data/lib/rubocop/cop/bundler/insecure_protocol_source.rb

@@ -34,6 +34,8 @@ module RuboCop
               "Please change your source to 'https://rubygems.org' " \
               "if possible, or 'http://rubygems.org' if not."
 
+        RESTRICT_ON_SEND = %i[source].freeze
+
         def_node_matcher :insecure_protocol_source?, <<~PATTERN
           (send nil? :source
             $(sym ${:gemcutter :rubygems :rubyforge}))

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/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/generator.rb

@@ -59,7 +59,7 @@ module RuboCop
                 # TODO: Implement the cop in here.
                 #
                 # In many cases, you can use a node matcher for matching node pattern.
-                # See https://github.com/rubocop-hq/rubocop-ast/blob/master/lib/rubocop/node_pattern.rb
+                # See https://github.com/rubocop-hq/rubocop-ast/blob/master/lib/rubocop/ast/node_pattern.rb
                 #
                 # For example
                 MSG = 'Use `#good_method` instead of `#bad_method`.'

data/lib/rubocop/cop/internal_affairs/method_name_equal.rb

@@ -18,6 +18,7 @@ module RuboCop
 
         MSG = 'Use `method?(%<method_name>s)` instead of ' \
               '`method_name == %<method_name>s`.'
+        RESTRICT_ON_SEND = %i[==].freeze
 
         def_node_matcher :method_name?, <<~PATTERN
           (send

data/lib/rubocop/cop/internal_affairs/node_type_predicate.rb

@@ -17,6 +17,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `#%<type>s_type?` to check node type.'
+        RESTRICT_ON_SEND = %i[==].freeze
 
         def_node_matcher :node_type_check, <<~PATTERN
           (send (send $_ :type) :== (sym $_))

data/lib/rubocop/cop/internal_affairs/offense_location_keyword.rb

@@ -18,6 +18,7 @@ module RuboCop
 
         MSG = 'Use `:%<keyword>s` as the location argument to ' \
               '`#add_offense`.'
+        RESTRICT_ON_SEND = %i[add_offense].freeze
 
         def on_send(node)
           node_type_check(node) do |node_arg, kwargs|

data/lib/rubocop/cop/internal_affairs/redundant_location_argument.rb

@@ -21,6 +21,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant location argument to `#add_offense`.'
+        RESTRICT_ON_SEND = %i[add_offense].freeze
 
         def_node_matcher :redundant_location_argument, <<~PATTERN
           (send nil? :add_offense _

data/lib/rubocop/cop/internal_affairs/redundant_message_argument.rb

@@ -24,6 +24,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant message argument to `#add_offense`.'
+        RESTRICT_ON_SEND = %i[add_offense].freeze
 
         def_node_matcher :node_type_check, <<~PATTERN
           (send nil? :add_offense $_node $hash)

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/begin_end_alignment.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks whether the end keyword of `begin` is aligned properly.
+      #
+      # Two modes are supported through the `EnforcedStyleAlignWith` configuration
+      # parameter. If it's set to `start_of_line` (which is the default), the
+      # `end` shall be aligned with the start of the line where the `begin`
+      # keyword is. If it's set to `begin`, the `end` shall be aligned with the
+      # `begin` keyword.
+      #
+      # `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
+      # by default. On the other hand, `||= begin` that this cop targets tends to
+      # align with the start of the line, it defaults to `EnforcedStyleAlignWith: start_of_line`.
+      # These style can be configured by each cop.
+      #
+      # @example EnforcedStyleAlignWith: start_of_line (default)
+      #   # bad
+      #   foo ||= begin
+      #             do_something
+      #           end
+      #
+      #   # good
+      #   foo ||= begin
+      #     do_something
+      #   end
+      #
+      # @example EnforcedStyleAlignWith: begin
+      #   # bad
+      #   foo ||= begin
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   foo ||= begin
+      #             do_something
+      #           end
+      #
+      class BeginEndAlignment < Base
+        include EndKeywordAlignment
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'
+
+        def on_kwbegin(node)
+          check_begin_alignment(node)
+        end
+
+        private
+
+        def check_begin_alignment(node)
+          align_with = {
+            begin: node.loc.begin,
+            start_of_line: start_line_range(node)
+          }
+          check_end_kw_alignment(node, align_with)
+        end
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.align_end(corrector, processed_source, node, alignment_node(node))
+        end
+
+        def alignment_node(node)
+          case style
+          when :begin
+            node
+          else
+            start_line_range(node)
+          end
+        end
+      end
+    end
+  end
+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

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

@@ -46,7 +46,7 @@ module RuboCop
         alias on_defs on_def
 
         def on_send(node)
-          return unless node.def_modifier?
+          return if !node.def_modifier? || node.method?(:using)
 
           method_def = node.each_descendant(:def, :defs).first
           expr = node.source_range

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) unless next_sibling_empty?(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 if next_sibling_empty?(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,11 +113,6 @@ module RuboCop
           processed_source[line].blank?
         end
 
-        def next_sibling_empty?(node)
-          next_sibling = node.parent.children[node.sibling_index + 1]
-          next_sibling.nil?
-        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/end_alignment.rb

@@ -17,6 +17,11 @@ module RuboCop
       # If it's set to `start_of_line`, the `end` shall be aligned with the
       # start of the line where the matching keyword appears.
       #
+      # This `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
+      # by default. On the other hand, `Layout/BeginEndAlignment` cop aligns with
+      # `EnforcedStyleAlignWith: start_of_line` by default due to `||= begin` tends
+      # to align with the start of the line. These style can be configured by each cop.
+      #
       # @example EnforcedStyleAlignWith: keyword (default)
       #   # bad
       #
@@ -173,16 +178,6 @@ module RuboCop
             node
           end
         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)
-
-          range_between(range.begin_pos + (source =~ /\S/),
-                        range.begin_pos + (source =~ /\s*\z/))
-        end
       end
     end
   end