rubocop 0.59.1 → 0.59.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c194b5622ecc91385098a2b68a32fefb80dfe3c1
-  data.tar.gz: 6b77f223ef06685ee4af7543faed16456c38d7cb
+  metadata.gz: 28eeb813f59ba82f401cfac05daa5a118a1014af
+  data.tar.gz: 63b3201d008b9f790f93cc5a724c1a596bd75dd4
 SHA512:
-  metadata.gz: 14a31079c85a1f77781219df27ffaeb0756ef006ca737c92a4690ff50f3cff68e407520b3d389bb03cdba4853eddcb07fa375955478547d4bfd219f8dc1e84dc
-  data.tar.gz: cee68c85b7430c9fb32e11206d9e8b8b1f87dd3cc29b0a878daf62b91e26cbd54793e4ead915b4894e1082c5f6d7dcd8584bf5f0a96e4123df32009ca11ff438
+  metadata.gz: c79b61631cdc0e7fd9f0a8b17b0d04956827286239a7f65948e5a9cfec8f4a286dc1e6f062d9d0f5f2bdeaab06ff6dd2d2e10ddcd962dc6446f46ddd64bdbb5a
+  data.tar.gz: b348fe1df3db7a302023b32fd4fafa3ab2a4b09edd99efdfc55f3d8dba27ac18dd118eeeb008702467cd188c96104309b99800a428224de17758a6cd4d95c3eb

data/README.md

@@ -53,7 +53,7 @@ haven't reached version 1.0 yet). To prevent an unwanted RuboCop update you
 might want to use a conservative version locking in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 0.59.1', require: false
+gem 'rubocop', '~> 0.59.2', require: false
 ```
 
 ## Quickstart
@@ -67,7 +67,7 @@ $ rubocop
 
 ## Official manual
 
-You can read a ton more about RuboCop in its [official manual](http://docs.rubocop.org).
+You can read a ton more about RuboCop in its [official manual](https://docs.rubocop.org).
 
 ## Compatibility
 

data/config/default.yml

@@ -1597,6 +1597,7 @@ Metrics/LineLength:
 Metrics/MethodLength:
   CountComments: false  # count full line comments?
   Max: 10
+  ExcludedMethods: []
 
 Metrics/ModuleLength:
   CountComments: false  # count full line comments?

data/lib/rubocop.rb

@@ -130,6 +130,7 @@ require_relative 'rubocop/cop/mixin/parser_diagnostic'
 require_relative 'rubocop/cop/mixin/percent_array'
 require_relative 'rubocop/cop/mixin/percent_literal'
 require_relative 'rubocop/cop/mixin/preceding_following_alignment'
+require_relative 'rubocop/cop/mixin/preferred_delimiters'
 require_relative 'rubocop/cop/mixin/rescue_node'
 require_relative 'rubocop/cop/mixin/safe_assignment'
 require_relative 'rubocop/cop/mixin/safe_mode'
@@ -154,6 +155,7 @@ require_relative 'rubocop/cop/correctors/line_break_corrector'
 require_relative 'rubocop/cop/correctors/multiline_literal_brace_corrector'
 require_relative 'rubocop/cop/correctors/ordered_gem_corrector'
 require_relative 'rubocop/cop/correctors/parentheses_corrector'
+require_relative 'rubocop/cop/correctors/percent_literal_corrector'
 require_relative 'rubocop/cop/correctors/punctuation_corrector'
 require_relative 'rubocop/cop/correctors/space_corrector'
 require_relative 'rubocop/cop/correctors/string_literal_corrector'

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects percent literals
+    class PercentLiteralCorrector
+      include Util
+
+      attr_reader :config, :preferred_delimiters
+
+      def initialize(config, preferred_delimiters)
+        @config = config
+        @preferred_delimiters = preferred_delimiters
+      end
+
+      def correct(node, char)
+        escape = escape_words?(node)
+        char = char.upcase if escape
+        delimiters = delimiters_for("%#{char}")
+        contents = new_contents(node, escape, delimiters)
+        wrap_contents(node, contents, char, delimiters)
+      end
+
+      private
+
+      def wrap_contents(node, contents, char, delimiters)
+        lambda do |corrector|
+          corrector.replace(
+            node.source_range,
+            "%#{char}#{delimiters[0]}#{contents}#{delimiters[1]}"
+          )
+        end
+      end
+
+      def escape_words?(node)
+        node.children.any? { |w| needs_escaping?(w.children[0]) }
+      end
+
+      def delimiters_for(type)
+        PreferredDelimiters
+          .new(type, config, preferred_delimiters)
+          .delimiters
+      end
+
+      def new_contents(node, escape, delimiters)
+        if node.multiline?
+          autocorrect_multiline_words(node, escape, delimiters)
+        else
+          autocorrect_words(node, escape, delimiters)
+        end
+      end
+
+      def autocorrect_multiline_words(node, escape, delimiters)
+        contents = process_multiline_words(node, escape, delimiters)
+        contents << end_content(node.source)
+        contents.join('')
+      end
+
+      def autocorrect_words(node, escape, delimiters)
+        node.children.map do |word_node|
+          fix_escaped_content(word_node, escape, delimiters)
+        end.join(' ')
+      end
+
+      def process_multiline_words(node, escape, delimiters)
+        base_line_num = node.first_line
+        prev_line_num = base_line_num
+        node.children.map.with_index do |word_node, index|
+          line_breaks = line_breaks(word_node,
+                                    node.source,
+                                    prev_line_num,
+                                    base_line_num,
+                                    index)
+          prev_line_num = word_node.first_line
+          content = fix_escaped_content(word_node, escape, delimiters)
+          line_breaks + content
+        end
+      end
+
+      def line_breaks(node, source, previous_line_num, base_line_num, node_indx)
+        source_in_lines = source.split("\n")
+        if first_line?(node, previous_line_num)
+          node_indx.zero? && node.first_line == base_line_num ? '' : ' '
+        else
+          process_lines(node, previous_line_num, base_line_num, source_in_lines)
+        end
+      end
+
+      def first_line?(node, previous_line_num)
+        node.first_line == previous_line_num
+      end
+
+      def process_lines(node, previous_line_num, base_line_num, source_in_lines)
+        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
+      end
+
+      def fix_escaped_content(word_node, escape, delimiters)
+        content = word_node.children.first.to_s
+        content = escape_string(content) if escape
+        substitute_escaped_delimiters(content, delimiters)
+        content
+      end
+
+      def substitute_escaped_delimiters(content, delimiters)
+        delimiters.each { |delim| content.gsub!(delim, "\\#{delim}") }
+      end
+
+      def end_content(source)
+        result = /\A(\s*)\]/.match(source.split("\n").last)
+        ("\n" + result[1]) if result
+      end
+    end
+  end
+end

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

@@ -44,22 +44,16 @@ module RuboCop
         def on_if(node)
           return if correct_style?(node)
 
-          if last_argument_is_heredoc?(node)
+          if node.modifier_form? && last_argument_is_heredoc?(node)
             heredoc_node = last_argument(node)
 
-            heredoc_body = heredoc_node.loc.heredoc_body
-            num_of_heredoc_lines =
-              heredoc_body.last_line - heredoc_body.first_line
-
-            line = node.last_line + num_of_heredoc_lines + END_OF_HEREDOC_LINE
-
-            return if next_line_empty?(line)
+            return if next_line_empty?(heredoc_line(node, heredoc_node))
 
             add_offense(heredoc_node, location: :heredoc_end)
           else
             return if next_line_empty?(node.last_line)
 
-            add_offense(node)
+            add_offense(node, location: offense_location(node))
           end
         end
 
@@ -126,6 +120,22 @@ module RuboCop
         def last_argument(node)
           node.if_branch.children.last
         end
+
+        def heredoc_line(node, heredoc_node)
+          heredoc_body = heredoc_node.loc.heredoc_body
+          num_of_heredoc_lines =
+            heredoc_body.last_line - heredoc_body.first_line
+
+          node.last_line + num_of_heredoc_lines + END_OF_HEREDOC_LINE
+        end
+
+        def offense_location(node)
+          if node.loc && node.loc.end
+            :end
+          else
+            :expression
+          end
+        end
       end
     end
   end

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

@@ -29,6 +29,26 @@ module RuboCop
         MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after ' \
                                '`%<modifier>s`.'.freeze
 
+        def on_class(node)
+          _name, superclass, _body = *node
+
+          @class_or_module_def_line = if superclass
+                                        superclass.first_line
+                                      else
+                                        node.source_range.first_line
+                                      end
+        end
+
+        def on_module(node)
+          @class_or_module_def_line = node.source_range.first_line
+        end
+
+        def on_sclass(node)
+          self_node, _body = *node
+
+          @class_or_module_def_line = self_node.source_range.first_line
+        end
+
         def on_send(node)
           return unless node.bare_access_modifier?
 
@@ -40,11 +60,10 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             send_line = node.first_line
-            previous_line = processed_source[send_line - 2]
             next_line = processed_source[send_line]
             line = range_by_whole_lines(node.source_range)
 
-            unless previous_line_empty?(previous_line)
+            unless previous_line_empty?(send_line)
               corrector.insert_before(line, "\n")
             end
 
@@ -62,9 +81,12 @@ module RuboCop
           end
         end
 
-        def previous_line_empty?(previous_line)
+        def previous_line_empty?(send_line)
+          previous_line = previous_line_ignoring_comments(processed_source,
+                                                          send_line)
+
           block_start?(previous_line) ||
-            class_def?(previous_line) ||
+            class_def?(send_line) ||
             previous_line.blank?
         end
 
@@ -74,15 +96,16 @@ module RuboCop
 
         def empty_lines_around?(node)
           send_line = node.first_line
-          previous_line = previous_line_ignoring_comments(processed_source,
-                                                          send_line)
+
           next_line = processed_source[send_line]
 
-          previous_line_empty?(previous_line) && next_line_empty?(next_line)
+          previous_line_empty?(send_line) && next_line_empty?(next_line)
         end
 
         def class_def?(line)
-          line =~ /^\s*(class|module)/
+          return false unless @class_or_module_def_line
+
+          line == @class_or_module_def_line + 1
         end
 
         def block_start?(line)
@@ -94,10 +117,11 @@ module RuboCop
         end
 
         def message(node)
-          previous_line = processed_source[node.first_line - 2]
+          send_line = node.first_line
+          previous_line = processed_source[send_line - 2]
 
           if block_start?(previous_line) ||
-             class_def?(previous_line)
+             class_def?(send_line)
             format(MSG_AFTER, modifier: node.loc.selector.source)
           else
             format(MSG_BEFORE_AND_AFTER, modifier: node.loc.selector.source)

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

@@ -24,12 +24,13 @@ module RuboCop
         # The array of regular expressions representing percent literals that,
         # if found within a percent literal expression, will cause a
         # NestedPercentLiteral violation to be emitted.
-        REGEXES = PercentLiteral::PERCENT_LITERAL_TYPES.map do |percent_literal|
+        PERCENT_LITERAL_TYPES = PreferredDelimiters::PERCENT_LITERAL_TYPES
+        REGEXES = PERCENT_LITERAL_TYPES.map do |percent_literal|
           /\A#{percent_literal}\W/
         end.freeze
 
         def on_array(node)
-          process(node, *PercentLiteral::PERCENT_LITERAL_TYPES)
+          process(node, *PERCENT_LITERAL_TYPES)
         end
 
         def on_percent_literal(node)

data/lib/rubocop/cop/metrics/block_length.rb

@@ -14,6 +14,7 @@ module RuboCop
 
         def on_block(node)
           return if excluded_method?(node)
+          return if node.class_constructor?
 
           check_code_length(node)
         end

data/lib/rubocop/cop/metrics/class_length.rb

@@ -13,8 +13,18 @@ module RuboCop
           check_code_length(node)
         end
 
+        def on_casgn(node)
+          class_definition?(node) do
+            check_code_length(node)
+          end
+        end
+
         private
 
+        def_node_matcher :class_definition?, <<-PATTERN
+          (casgn nil? _ (block (send (const nil? :Class) :new) ...))
+        PATTERN
+
         def message(length, max_length)
           format('Class has too many lines. [%<length>d/%<max>d]',
                  length: length,

data/lib/rubocop/cop/metrics/line_length.rb

@@ -123,8 +123,8 @@ module RuboCop
 
         def allowed_uri_position?(line, uri_range)
           uri_range.begin < max &&
-            (uri_range.end == line_length(line) ||
-             uri_range.end == line_length(line) - 1)
+            (uri_range.end == line.length ||
+             uri_range.end == line.length - 1)
         end
 
         def find_excessive_uri_range(line)

data/lib/rubocop/cop/metrics/method_length.rb

@@ -12,6 +12,9 @@ module RuboCop
         LABEL = 'Method'.freeze
 
         def on_def(node)
+          excluded_methods = cop_config['ExcludedMethods']
+          return if excluded_methods.include?(String(node.method_name))
+
           check_code_length(node)
         end
         alias on_defs on_def

data/lib/rubocop/cop/metrics/module_length.rb

@@ -13,8 +13,18 @@ module RuboCop
           check_code_length(node)
         end
 
+        def on_casgn(node)
+          module_definition?(node) do
+            check_code_length(node)
+          end
+        end
+
         private
 
+        def_node_matcher :module_definition?, <<-PATTERN
+          (casgn nil? _ (block (send (const nil? :Module) :new) ...))
+        PATTERN
+
         def message(length, max_length)
           format('Module has too many lines. [%<length>d/%<max>d]',
                  length: length,

data/lib/rubocop/cop/mixin/code_length.rb

@@ -18,9 +18,13 @@ module RuboCop
 
       def check_code_length(node)
         length = code_length(node)
+
         return unless length > max_length
 
-        add_offense(node, message: message(length, max_length)) do
+        location = node.casgn_type? ? :name : :expression
+
+        add_offense(node, location: location,
+                          message: message(length, max_length)) do
           self.max = length
         end
       end

data/lib/rubocop/cop/mixin/percent_literal.rb

@@ -6,8 +6,6 @@ module RuboCop
     module PercentLiteral
       include RangeHelp
 
-      PERCENT_LITERAL_TYPES = %w[% %i %I %q %Q %r %s %w %W %x].freeze
-
       private
 
       def percent_literal?(node)
@@ -35,117 +33,6 @@ module RuboCop
       def contents_range(node)
         range_between(node.loc.begin.end_pos, node.loc.end.begin_pos)
       end
-
-      # ['a', 'b', 'c'] => %w(a b c)
-      def correct_percent(node, char)
-        words = node.children
-        escape = words.any? { |w| needs_escaping?(w.children[0]) }
-        char = char.upcase if escape
-        delimiters = preferred_delimiters_for("%#{char}")
-        contents = new_contents(node, escape, delimiters)
-
-        lambda do |corrector|
-          corrector.replace(
-            node.source_range,
-            "%#{char}#{delimiters[0]}#{contents}#{delimiters[1]}"
-          )
-        end
-      end
-
-      def new_contents(node, escape, delimiters)
-        if node.multiline?
-          autocorrect_multiline_words(node, escape, delimiters)
-        else
-          autocorrect_words(node, escape, delimiters)
-        end
-      end
-
-      def autocorrect_multiline_words(node, escape, delimiters)
-        base_line_number = node.first_line
-        previous_line_number = base_line_number
-        contents = node.children.map.with_index do |word_node, index|
-          line_breaks = line_breaks(word_node,
-                                    node.source,
-                                    previous_line_number,
-                                    base_line_number,
-                                    index)
-          previous_line_number = word_node.first_line
-          content = escaped_content(word_node, escape, delimiters)
-          line_breaks + content
-        end
-        contents << end_content(node.source)
-        contents.join('')
-      end
-
-      def autocorrect_words(node, escape, delimiters)
-        node.children.map do |word_node|
-          content = word_node.children.first.to_s
-          content = escape ? escape_string(content) : content
-          delimiters.each do |delimiter|
-            content.gsub!(delimiter, "\\#{delimiter}")
-          end
-          content
-        end.join(' ')
-      end
-
-      def line_breaks(node, source, previous_line_num, base_line_num, node_idx)
-        source_in_lines = source.split("\n")
-        if node.first_line == previous_line_num
-          node_idx.zero? && node.first_line == base_line_num ? '' : ' '
-        else
-          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
-        end
-      end
-
-      def escaped_content(word_node, escape, delimiters)
-        content = word_node.children.first.to_s
-        content = escape_string(content) if escape
-        delimiters.each do |delimiter|
-          content.gsub!(delimiter, "\\#{delimiter}")
-        end
-        content
-      end
-
-      def end_content(source)
-        result = /\A(\s*)\]/.match(source.split("\n").last)
-        ("\n" + result[1]) if result
-      end
-
-      def ensure_valid_preferred_delimiters
-        invalid = preferred_delimiters_config.keys -
-                  (PERCENT_LITERAL_TYPES + %w[default])
-        return if invalid.empty?
-
-        raise ArgumentError,
-              "Invalid preferred delimiter config key: #{invalid.join(', ')}"
-      end
-
-      def preferred_delimiters
-        @preferred_delimiters ||=
-          begin
-            ensure_valid_preferred_delimiters
-
-            if preferred_delimiters_config.key?('default')
-              Hash[PERCENT_LITERAL_TYPES.map do |type|
-                [type, preferred_delimiters_config[type] ||
-                  preferred_delimiters_config['default']]
-              end]
-            else
-              preferred_delimiters_config
-            end
-          end
-      end
-
-      def preferred_delimiters_config
-        @config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']
-      end
-
-      def preferred_delimiters_for(type)
-        preferred_delimiters[type].split(//)
-      end
     end
   end
 end

data/lib/rubocop/cop/mixin/preferred_delimiters.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling percent literal delimiters.
+    class PreferredDelimiters
+      attr_reader :type, :config
+
+      PERCENT_LITERAL_TYPES = %w[% %i %I %q %Q %r %s %w %W %x].freeze
+
+      def initialize(type, config, preferred_delimiters)
+        @type = type
+        @config = config
+        @preferred_delimiters = preferred_delimiters
+      end
+
+      def delimiters
+        preferred_delimiters[type].split(//)
+      end
+
+      private
+
+      def ensure_valid_preferred_delimiters
+        invalid = preferred_delimiters_config.keys -
+                  (PERCENT_LITERAL_TYPES + %w[default])
+        return if invalid.empty?
+
+        raise ArgumentError,
+              "Invalid preferred delimiter config key: #{invalid.join(', ')}"
+      end
+
+      def preferred_delimiters
+        @preferred_delimiters ||=
+          begin
+            ensure_valid_preferred_delimiters
+
+            if preferred_delimiters_config.key?('default')
+              Hash[PERCENT_LITERAL_TYPES.map do |type|
+                [type, preferred_delimiters_config[type] ||
+                  preferred_delimiters_config['default']]
+              end]
+            else
+              preferred_delimiters_config
+            end
+          end
+      end
+
+      def preferred_delimiters_config
+        config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -43,7 +43,7 @@ module RuboCop
       #     @foo ||= calculate_expensive_thing(helper_variable)
       #   end
       #
-      # @example EnforcedStyleForLeadingUnderscores :required
+      # @example EnforcedStyleForLeadingUnderscores: required
       #   # bad
       #   def foo
       #     @something ||= calculate_expensive_thing

data/lib/rubocop/cop/rails/delegate.rb

@@ -35,7 +35,7 @@ module RuboCop
       #     foo.bar
       #   end
       #
-      #   # EnforceForPrefixed: true
+      # @example EnforceForPrefixed: true (default)
       #   # bad
       #   def foo_bar
       #     foo.bar
@@ -44,7 +44,7 @@ module RuboCop
       #   # good
       #   delegate :bar, to: :foo, prefix: true
       #
-      #   # EnforceForPrefixed: false
+      # @example EnforceForPrefixed: false
       #   # good
       #   def foo_bar
       #     foo.bar

data/lib/rubocop/cop/rails/has_many_or_has_one_dependent.rb

@@ -23,6 +23,10 @@ module RuboCop
       class HasManyOrHasOneDependent < Cop
         MSG = 'Specify a `:dependent` option.'.freeze
 
+        def_node_search :active_resource_class?, <<-PATTERN
+          (const (const nil? :ActiveResource) :Base)
+        PATTERN
+
         def_node_matcher :association_without_options?, <<-PATTERN
           (send nil? {:has_many :has_one} _)
         PATTERN
@@ -47,6 +51,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return if active_resource?(node.parent)
+
           unless association_without_options?(node)
             return if valid_options?(association_with_options?(node))
           end
@@ -88,6 +94,12 @@ module RuboCop
 
           false
         end
+
+        def active_resource?(node)
+          return false if node.nil?
+
+          active_resource_class?(node)
+        end
       end
     end
   end

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

@@ -99,12 +99,37 @@ module RuboCop
 
         def autocorrect_to_each(node)
           item, enumerable = deconstruct_for(node)
-          replacement_range = replacement_range(node, node.loc.begin.end_pos)
-          correction = "#{enumerable.source}.each do |#{item.source}|"
 
+          end_pos = end_position(node, enumerable)
+
+          replacement_range = replacement_range(node, end_pos)
+
+          enum_source = enumerable_source(enumerable)
+
+          correction = "#{enum_source}.each do |#{item.source}|"
           ->(corrector) { corrector.replace(replacement_range, correction) }
         end
 
+        def end_position(node, enumerable)
+          if node.do?
+            node.loc.begin.end_pos
+          elsif enumerable.begin_type?
+            enumerable.loc.end.end_pos
+          else
+            enumerable.loc.expression.end.end_pos
+          end
+        end
+
+        def enumerable_source(enumerable)
+          return "(#{enumerable.source})" if wrap_into_parentheses?(enumerable)
+
+          enumerable.source
+        end
+
+        def wrap_into_parentheses?(enumerable)
+          enumerable.irange_type? || enumerable.erange_type?
+        end
+
         def autocorrect_to_for(node)
           enumerable, items = deconstruct_each(node)
           variables = extract_variables(items)

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

@@ -31,8 +31,11 @@ module RuboCop
         ASSIGNMENT_TYPES = %i[lvasgn casgn cvasgn
                               gvasgn ivasgn masgn].freeze
 
+        NAMED_CAPTURE = /\?<.+>/
+
         def on_if(node)
           return unless eligible_node?(node)
+          return if named_capture_in_condition?(node)
 
           add_offense(node, location: :keyword,
                             message: format(MSG, keyword: node.keyword))
@@ -46,6 +49,10 @@ module RuboCop
 
         private
 
+        def named_capture_in_condition?(node)
+          node.condition.match_with_lvasgn_type?
+        end
+
         def eligible_node?(node)
           !non_eligible_if?(node) && !node.chained? &&
             !node.nested_conditional? && single_line_as_modifier?(node)

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

@@ -77,6 +77,12 @@ module RuboCop
           add_offense(node)
         end
 
+        def preferred_delimiters_for(type)
+          PreferredDelimiters
+            .new(type, @config, @preferred_delimiters)
+            .delimiters
+        end
+
         def uses_preferred_delimiter?(node, type)
           preferred_delimiters_for(type)[0] == begin_source(node)[-1]
         end

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

@@ -39,14 +39,18 @@ module RuboCop
           exprs_lines = exprs.map { |e| e.source_range.line }
           lines = exprs_lines.group_by { |i| i }
 
-          # every line with more than 1 expression on it is an offense
           lines.each do |line, expr_on_line|
+            # Every line with more than one expression on it is a
+            # potential offense
             next unless expr_on_line.size > 1
 
             # TODO: Find the correct position of the semicolon. We don't know
             # if the first semicolon on the line is a separator of
             # expressions. It's just a guess.
             column = @processed_source[line - 1].index(';')
+
+            next unless column
+
             convention_on(line, column, false)
           end
         end

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

@@ -31,7 +31,6 @@ module RuboCop
         include ArrayMinSize
         include ArraySyntax
         include ConfigurableEnforcedStyle
-        include PercentLiteral
         include PercentArray
 
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'.freeze
@@ -53,7 +52,9 @@ module RuboCop
 
         def autocorrect(node)
           if style == :percent
-            correct_percent(node, 'i')
+            PercentLiteralCorrector
+              .new(@config, @preferred_delimiters)
+              .correct(node, 'i')
           else
             correct_bracketed(node)
           end

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

@@ -32,7 +32,6 @@ module RuboCop
         include ArraySyntax
         include ConfigurableEnforcedStyle
         include PercentArray
-        include PercentLiteral
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'.freeze
         ARRAY_MSG = 'Use `[]` for an array of words.'.freeze
@@ -53,7 +52,9 @@ module RuboCop
 
         def autocorrect(node)
           if style == :percent
-            correct_percent(node, 'w')
+            PercentLiteralCorrector
+              .new(@config, @preferred_delimiters)
+              .correct(node, 'w')
           else
             correct_bracketed(node)
           end

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

@@ -50,6 +50,8 @@ module RuboCop
 
           lhs, opr, rhs = zero_length_predicate
 
+          return if non_polymorphic_collection?(node)
+
           add_offense(
             node,
             message: format(ZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
@@ -63,6 +65,8 @@ module RuboCop
 
           lhs, opr, rhs = nonzero_length_predicate
 
+          return if non_polymorphic_collection?(node)
+
           add_offense(
             node,
             message: format(NONZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
@@ -99,6 +103,14 @@ module RuboCop
           {(send (send $_ _) _ _)
            (send _ _ (send $_ _))}
         PATTERN
+
+        # Some collection like objects in the Ruby standard library
+        # implement `#size`, but not `#empty`. We ignore those to
+        # reduce false positives.
+        def_node_matcher :non_polymorphic_collection?, <<-PATTERN
+          {(send (send (send (const nil? :File) :stat _) ...) ...)
+           (send (send (send (const nil? {:Tempfile :StringIO}) {:new :open} ...) ...) ...)}
+        PATTERN
       end
     end
   end

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '0.59.1'.freeze
+    STRING = '0.59.2'.freeze
 
     MSG = '%<version>s (using Parser %<parser_version>s, running on ' \
           '%<ruby_engine>s %<ruby_version>s %<ruby_platform>s)'.freeze

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 0.59.1
+  version: 0.59.2
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-15 00:00:00.000000000 Z
+date: 2018-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jaro_winkler
@@ -239,6 +239,7 @@ files:
 - lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb
 - lib/rubocop/cop/correctors/ordered_gem_corrector.rb
 - lib/rubocop/cop/correctors/parentheses_corrector.rb
+- lib/rubocop/cop/correctors/percent_literal_corrector.rb
 - lib/rubocop/cop/correctors/punctuation_corrector.rb
 - lib/rubocop/cop/correctors/space_corrector.rb
 - lib/rubocop/cop/correctors/string_literal_corrector.rb
@@ -466,6 +467,7 @@ files:
 - lib/rubocop/cop/mixin/percent_array.rb
 - lib/rubocop/cop/mixin/percent_literal.rb
 - lib/rubocop/cop/mixin/preceding_following_alignment.rb
+- lib/rubocop/cop/mixin/preferred_delimiters.rb
 - lib/rubocop/cop/mixin/range_help.rb
 - lib/rubocop/cop/mixin/rescue_node.rb
 - lib/rubocop/cop/mixin/safe_assignment.rb
@@ -799,10 +801,10 @@ homepage: https://github.com/rubocop-hq/rubocop
 licenses:
 - MIT
 metadata:
-  homepage_uri: http://www.rubocop.org/
+  homepage_uri: https://www.rubocop.org/
   changelog_uri: https://github.com/rubocop-hq/rubocop/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop-hq/rubocop/
-  documentation_uri: http://docs.rubocop.org/
+  documentation_uri: https://docs.rubocop.org/
   bug_tracker_uri: https://github.com/rubocop-hq/rubocop/issues
 post_install_message: 
 rdoc_options: []