rubocop 0.51.0 → 0.87.0

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

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cops checks the indentation of the here document bodies. The bodies
-      # are indented one step.
-      # In Ruby 2.3 or newer, squiggly heredocs (`<<~`) should be used. If you
-      # use the older rubies, you should introduce some library to your project
-      # (e.g. ActiveSupport, Powerpack or Unindent).
-      #
-      # @example
-      #
-      #   # bad
-      #   <<-RUBY
-      #   something
-      #   RUBY
-      #
-      #   # good
-      #   # When EnforcedStyle is squiggly, bad code is auto-corrected to the
-      #   # following code.
-      #   <<~RUBY
-      #     something
-      #   RUBY
-      #
-      #   # good
-      #   # When EnforcedStyle is active_support, bad code is auto-corrected to
-      #   # the following code.
-      #   <<-RUBY.strip_heredoc
-      #     something
-      #   RUBY
-      class IndentHeredoc < Cop
-        include Heredoc
-        include ConfigurableEnforcedStyle
-        include SafeMode
-
-        RUBY23_MSG = 'Use %d spaces for indentation in a heredoc by using ' \
-                     '`<<~` instead of `%s`.'.freeze
-        LIBRARY_MSG = 'Use %d spaces for indentation in a heredoc by using %s.'
-                      .freeze
-        StripMethods = {
-          unindent: 'unindent',
-          active_support: 'strip_heredoc',
-          powerpack: 'strip_indent'
-        }.freeze
-
-        def on_heredoc(node)
-          body = heredoc_body(node)
-          return if body =~ /\A\s*\z/
-
-          body_indent_level = indent_level(body)
-
-          if heredoc_indent_type(node) == '~'
-            expected_indent_level = base_indent_level(node) + indentation_width
-            return if expected_indent_level == body_indent_level
-          else
-            return unless body_indent_level.zero?
-          end
-
-          add_offense(node, location: :heredoc_body)
-        end
-
-        def autocorrect(node)
-          check_style!
-
-          case style
-          when :squiggly
-            correct_by_squiggly(node)
-          else
-            correct_by_library(node)
-          end
-        end
-
-        private
-
-        def style
-          style = super
-          return style unless style == :auto_detection
-
-          if target_ruby_version >= 2.3
-            :squiggly
-          elsif rails?
-            :active_support
-          end
-        end
-
-        def message(node)
-          case style
-          when :squiggly
-            current_indent_type = "<<#{heredoc_indent_type(node)}"
-            format(RUBY23_MSG, indentation_width, current_indent_type)
-          when nil
-            method = "some library(e.g. ActiveSupport's `String#strip_heredoc`)"
-            format(LIBRARY_MSG, indentation_width, method)
-          else
-            method = "`String##{StripMethods[style]}`"
-            format(LIBRARY_MSG, indentation_width, method)
-          end
-        end
-
-        def correct_by_squiggly(node)
-          return if target_ruby_version < 2.3
-          lambda do |corrector|
-            if heredoc_indent_type(node) == '~'
-              corrector.replace(node.loc.heredoc_body, indented_body(node))
-            else
-              heredoc_beginning = node.loc.expression.source
-              corrected = heredoc_beginning.sub(/<<-?/, '<<~')
-              corrector.replace(node.loc.expression, corrected)
-            end
-          end
-        end
-
-        def correct_by_library(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.heredoc_body, indented_body(node))
-            corrected = ".#{StripMethods[style]}"
-            corrector.insert_after(node.loc.expression, corrected)
-          end
-        end
-
-        def check_style!
-          case style
-          when nil
-            raise Warning, "Auto-correction does not work for #{cop_name}. " \
-                           'Please configure EnforcedStyle.'
-          when :squiggly
-            if target_ruby_version < 2.3
-              raise Warning, '`squiggly` style is selectable only on Ruby ' \
-                             "2.3 or higher for #{cop_name}."
-            end
-          end
-        end
-
-        def indented_body(node)
-          body = heredoc_body(node)
-          body_indent_level = indent_level(body)
-          correct_indent_level = base_indent_level(node) + indentation_width
-          body.gsub(/^\s{#{body_indent_level}}/, ' ' * correct_indent_level)
-        end
-
-        def base_indent_level(node)
-          base_line_num = node.loc.expression.line
-          base_line = processed_source.lines[base_line_num - 1]
-          indent_level(base_line)
-        end
-
-        def indent_level(str)
-          indentations = str.scan(/^\s*/).reject { |line| line == "\n" }
-          indentations.empty? ? 0 : indentations.min_by(&:size).size
-        end
-
-        # Returns '~', '-' or nil
-        def heredoc_indent_type(node)
-          node.source[/^<<([~-])/, 1]
-        end
-
-        def indentation_width
-          @config.for_cop('IndentationWidth')['Width'] || 2
-        end
-
-        def heredoc_body(node)
-          node.loc.heredoc_body.source.scrub
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for spaces inside square brackets.
-      class SpaceInsideBrackets < Cop
-        include SpaceInside
-
-        def specifics
-          [
-            %i[tLBRACK tLBRACK2],
-            :tRBRACK,
-            'square brackets'
-          ]
-        end
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cop checks for tabs inside the source code.
-      class Tab < Cop
-        include AutocorrectAlignment
-
-        MSG = 'Tab detected.'.freeze
-
-        def investigate(processed_source)
-          str_lines = string_literal_lines(processed_source.ast)
-
-          processed_source.lines.each_with_index do |line, index|
-            match = line.match(/^( *)[\t ]*\t/)
-            next unless match
-            next if str_lines.include?(index + 1)
-
-            spaces = match.captures[0]
-            range = source_range(processed_source.buffer,
-                                 index + 1,
-                                 (spaces.length)...(match.end(0)))
-
-            add_offense(range, location: range)
-          end
-        end
-
-        private
-
-        def autocorrect(range)
-          lambda do |corrector|
-            spaces = ' ' * configured_indentation_width
-            corrector.replace(range, range.source.gsub(/\t/, spaces))
-          end
-        end
-
-        def string_literal_lines(ast)
-          # which lines start inside a string literal?
-          return [] if ast.nil?
-
-          ast.each_node(:str, :dstr).each_with_object(Set.new) do |str, lines|
-            loc = str.location
-
-            str_lines = if loc.is_a?(Parser::Source::Map::Heredoc)
-                          body = loc.heredoc_body
-                          (body.first_line)..(body.last_line)
-                        else
-                          (loc.first_line + 1)..(loc.last_line)
-                        end
-
-            lines.merge(str_lines.to_a)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for END blocks in method definitions.
-      #
-      # @example
-      #
-      #   # bad
-      #
-      #   def some_method
-      #     END { do_something }
-      #   end
-      #
-      # @example
-      #
-      #   # good
-      #
-      #   def some_method
-      #     at_exit { do_something }
-      #   end
-      #
-      # @example
-      #
-      #   # good
-      #
-      #   # outside defs
-      #   END { do_something }
-      class EndInMethod < Cop
-        MSG = '`END` found in method definition. Use `at_exit` instead.'.freeze
-
-        def on_postexe(node)
-          inside_of_method = node.each_ancestor(:def, :defs).count.nonzero?
-          add_offense(node, location: :keyword) if inside_of_method
-        end
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for *rescue* blocks with no body.
-      #
-      # @example
-      #
-      #   # bad
-      #
-      #   def some_method
-      #     do_something
-      #   rescue
-      #     # do nothing
-      #   end
-      #
-      # @example
-      #
-      #   # bad
-      #
-      #   begin
-      #     do_something
-      #   rescue
-      #     # do nothing
-      #   end
-      #
-      # @example
-      #
-      #   # good
-      #
-      #   def some_method
-      #     do_something
-      #   rescue
-      #     handle_exception
-      #   end
-      #
-      # @example
-      #
-      #   # good
-      #
-      #   begin
-      #     do_something
-      #   rescue
-      #     handle_exception
-      #   end
-      class HandleExceptions < Cop
-        MSG = 'Do not suppress exceptions.'.freeze
-
-        def on_resbody(node)
-          add_offense(node) unless node.body
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for uses of `rescue` with no error class specified.
-      #
-      # @example
-      #
-      #   # good
-      #   begin
-      #     foo
-      #   rescue BarError
-      #     bar
-      #   end
-      #
-      #   # bad
-      #   begin
-      #     foo
-      #   rescue
-      #     bar
-      #   end
-      class RescueWithoutErrorClass < Cop
-        include RescueNode
-
-        MSG = 'Avoid rescuing without specifying an error class.'.freeze
-
-        def_node_matcher :rescue_without_error_class?, <<-PATTERN
-          (resbody nil? _ _)
-        PATTERN
-
-        def on_resbody(node)
-          return unless rescue_without_error_class?(node) &&
-                        !rescue_modifier?(node)
-
-          add_offense(node, location: :keyword)
-        end
-      end
-    end
-  end
-end

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

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-require 'uri'
-
-module RuboCop
-  module Cop
-    module Metrics
-      # This cop checks the length of lines in the source code.
-      # The maximum length is configurable.
-      class LineLength < Cop
-        include ConfigurableMax
-        include IgnoredPattern
-
-        MSG = 'Line is too long. [%d/%d]'.freeze
-
-        def investigate(processed_source)
-          heredocs = extract_heredocs(processed_source.ast) if allow_heredoc?
-          processed_source.lines.each_with_index do |line, index|
-            check_line(line, index, heredocs)
-          end
-        end
-
-        private
-
-        def check_line(line, index, heredocs)
-          return if line.length <= max
-          return if ignored_line?(line, index, heredocs)
-
-          if ignore_cop_directives? && directive_on_source_line?(index)
-            return check_directive_line(line, index)
-          end
-          return check_uri_line(line, index) if allow_uri?
-
-          register_offense(
-            source_range(processed_source.buffer, index + 1, 0...line.length),
-            line
-          )
-        end
-
-        def ignored_line?(line, index, heredocs)
-          matches_ignored_pattern?(line) ||
-            heredocs && line_in_whitelisted_heredoc?(heredocs, index.succ)
-        end
-
-        def register_offense(loc, line)
-          message = format(MSG, line.length, max)
-
-          add_offense(nil, location: loc, message: message) do
-            self.max = line.length
-          end
-        end
-
-        def excess_range(uri_range, line, index)
-          excessive_position = if uri_range && uri_range.begin < max
-                                 uri_range.end
-                               else
-                                 max
-                               end
-
-          source_range(processed_source.buffer, index + 1,
-                       excessive_position...(line.length))
-        end
-
-        def max
-          cop_config['Max']
-        end
-
-        def allow_heredoc?
-          allowed_heredoc
-        end
-
-        def allowed_heredoc
-          cop_config['AllowHeredoc']
-        end
-
-        def extract_heredocs(ast)
-          return [] unless ast
-          ast.each_node.with_object([]) do |node, heredocs|
-            next unless node.location.is_a?(Parser::Source::Map::Heredoc)
-            body = node.location.heredoc_body
-            delimiter = node.location.heredoc_end.source.strip
-            heredocs << [body.first_line...body.last_line, delimiter]
-          end
-        end
-
-        def line_in_whitelisted_heredoc?(heredocs, line_number)
-          heredocs.any? do |range, delimiter|
-            range.cover?(line_number) &&
-              (allowed_heredoc == true || allowed_heredoc.include?(delimiter))
-          end
-        end
-
-        def allow_uri?
-          cop_config['AllowURI']
-        end
-
-        def ignore_cop_directives?
-          cop_config['IgnoreCopDirectives']
-        end
-
-        def allowed_uri_position?(line, uri_range)
-          uri_range.begin < max && uri_range.end == line.length
-        end
-
-        def find_excessive_uri_range(line)
-          last_uri_match = match_uris(line).last
-          return nil unless last_uri_match
-          begin_position, end_position = last_uri_match.offset(0)
-          return nil if begin_position < max && end_position < max
-          begin_position...end_position
-        end
-
-        def match_uris(string)
-          matches = []
-          string.scan(uri_regexp) do
-            matches << $LAST_MATCH_INFO if valid_uri?($LAST_MATCH_INFO[0])
-          end
-          matches
-        end
-
-        def valid_uri?(uri_ish_string)
-          URI.parse(uri_ish_string)
-          true
-        rescue URI::InvalidURIError, NoMethodError
-          false
-        end
-
-        def uri_regexp
-          @regexp ||= URI::DEFAULT_PARSER.make_regexp(cop_config['URISchemes'])
-        end
-
-        def check_directive_line(line, index)
-          return if line_length_without_directive(line) <= max
-
-          range = max..(line_length_without_directive(line) - 1)
-          register_offense(
-            source_range(
-              processed_source.buffer,
-              index + 1,
-              range
-            ),
-            line
-          )
-        end
-
-        def directive_on_source_line?(index)
-          source_line_number = index + processed_source.buffer.first_line
-          comment =
-            processed_source
-            .comments
-            .detect { |e| e.location.line == source_line_number }
-
-          return false unless comment
-          comment.text.match(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-        end
-
-        def line_length_without_directive(line)
-          before_comment, = line.split(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-          before_comment.rstrip.length
-        end
-
-        def check_uri_line(line, index)
-          uri_range = find_excessive_uri_range(line)
-          return if uri_range && allowed_uri_position?(line, uri_range)
-
-          register_offense(excess_range(uri_range, line, index), line)
-        end
-      end
-    end
-  end
-end

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

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # This module does auto-correction of nodes that should just be moved to
-    # the left or to the right, amount being determined by the instance
-    # variable @column_delta.
-    module AutocorrectAlignment
-      SPACE = ' '.freeze
-
-      def configured_indentation_width
-        cop_config['IndentationWidth'] ||
-          config.for_cop('IndentationWidth')['Width']
-      end
-
-      def indentation(node)
-        offset(node) + (SPACE * configured_indentation_width)
-      end
-
-      def offset(node)
-        SPACE * node.loc.column
-      end
-
-      def display_column(range)
-        line = processed_source.lines[range.line - 1]
-        Unicode::DisplayWidth.of(line[0, range.column])
-      end
-
-      def check_alignment(items, base_column = nil)
-        unless items.empty?
-          base_column ||= display_column(items.first.source_range)
-        end
-
-        each_bad_alignment(items, base_column) do |current|
-          expr = current.source_range
-          if offenses.any? { |o| within?(expr, o.location) }
-            # If this offense is within a line range that is already being
-            # realigned by autocorrect, we report the offense without
-            # autocorrecting it. Two rewrites in the same area by the same
-            # cop can not be handled. The next iteration will find the
-            # offense again and correct it.
-            add_offense(nil, location: expr)
-          else
-            add_offense(current)
-          end
-        end
-      end
-
-      def autocorrect(arg)
-        return unless arg
-
-        heredoc_ranges = heredoc_ranges(arg)
-        expr = arg.respond_to?(:loc) ? arg.loc.expression : arg
-
-        # We can't use the instance variable inside the lambda. That would just
-        # give each lambda the same reference and they would all get the last
-        # value of @column_delta. A local variable fixes the problem.
-        column_delta = @column_delta
-
-        return if block_comment_within?(expr)
-
-        lambda do |corrector|
-          each_line(expr) do |line_begin_pos|
-            autocorrect_line(corrector, line_begin_pos, expr, column_delta,
-                             heredoc_ranges)
-          end
-        end
-      end
-
-      private
-
-      def each_bad_alignment(items, base_column)
-        prev_line = -1
-        items.each do |current|
-          if current.loc.line > prev_line &&
-             begins_its_line?(current.source_range)
-            @column_delta = base_column - display_column(current.source_range)
-
-            yield current if @column_delta.nonzero?
-          end
-          prev_line = current.loc.line
-        end
-      end
-
-      def autocorrect_line(corrector, line_begin_pos, expr, column_delta,
-                           heredoc_ranges)
-        range = calculate_range(expr, line_begin_pos, column_delta)
-        # We must not change indentation of heredoc strings.
-        return if heredoc_ranges.any? { |h| within?(range, h) }
-
-        if column_delta > 0
-          unless range.source == "\n"
-            corrector.insert_before(range, ' ' * column_delta)
-          end
-        elsif range.source =~ /\A[ \t]+\z/
-          remove(range, corrector)
-        end
-      end
-
-      def heredoc_ranges(arg)
-        return [] unless arg.is_a?(Parser::AST::Node)
-
-        arg.each_node(:dstr)
-           .select { |n| n.loc.respond_to?(:heredoc_body) }
-           .map { |n| n.loc.heredoc_body.join(n.loc.heredoc_end) }
-      end
-
-      def block_comment_within?(expr)
-        processed_source.comments.select(&:document?).any? do |c|
-          within?(c.loc.expression, expr)
-        end
-      end
-
-      def within?(inner, outer)
-        inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
-      end
-
-      def calculate_range(expr, line_begin_pos, column_delta)
-        starts_with_space = expr.source_buffer.source[line_begin_pos] =~ / /
-        pos_to_remove = if column_delta > 0 || starts_with_space
-                          line_begin_pos
-                        else
-                          line_begin_pos - column_delta.abs
-                        end
-
-        range_between(pos_to_remove, pos_to_remove + column_delta.abs)
-      end
-
-      def remove(range, corrector)
-        original_stderr = $stderr
-        $stderr = StringIO.new # Avoid error messages on console
-        corrector.remove(range)
-      rescue RuntimeError
-        range = range_between(range.begin_pos + 1, range.end_pos + 1)
-        retry if range.source =~ /^ +$/
-      ensure
-        $stderr = original_stderr
-      end
-
-      def each_line(expr)
-        line_begin_pos = expr.begin_pos
-        expr.source.each_line do |line|
-          yield line_begin_pos
-          line_begin_pos += line.length
-        end
-      end
-    end
-  end
-end