rubocop 0.42.0 → 0.52.1

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

@@ -1,39 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for invalid character literals with a non-escaped
-      # whitespace character (e.g. `? `).
-      # However, currently it's unclear whether there's a way to emit this
-      # warning without syntax errors.
-      #
-      #     $ ruby -w
-      #     p(? )
-      #     -:1: warning: invalid character syntax; use ?\s
-      #     -:1: syntax error, unexpected '?', expecting ')'
-      #     p(? )
-      #        ^
-      #
-      # @example
-      #   p(? )
-      class InvalidCharacterLiteral < Cop
-        include ParserDiagnostic
-
-        private
-
-        def relevant_diagnostic?(diagnostic)
-          diagnostic.reason == :invalid_escape_use
-        end
-
-        def alternative_message(diagnostic)
-          diagnostic
-            .message
-            .capitalize
-            .gsub('character syntax', 'character literal')
-        end
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for unncessary array splats.
-      #
-      # @example
-      #
-      # # bad:
-      #
-      # a, b = *[1, 2, 3]
-      #
-      # # good:
-      #
-      # a, b = [1, 2, 3]
-      #
-      # # bad:
-      #
-      # a = *[1, 2, 3]
-      #
-      # # good:
-      #
-      # a = [1, 2, 3]
-      class UselessArraySplat < Cop
-        MSG = 'Unnecessary array splat.'.freeze
-        ARRAY_NEW_PATTERN = '(send (const nil :Array) :new ...)'.freeze
-
-        %w(m lv cv iv c gv).each do |var_type|
-          define_method("on_#{var_type}asgn") do |node|
-            *, rhs = *node
-
-            return unless rhs.is_a?(Node) && rhs.array_type?
-
-            add_offense(rhs, splat_source_range(rhs)) if array_splat?(rhs)
-          end
-        end
-
-        private
-
-        def_node_matcher :array_splat?, <<-PATTERN
-          (array (splat {(array ...) (block #{ARRAY_NEW_PATTERN} ...) #{ARRAY_NEW_PATTERN}} ...))
-        PATTERN
-
-        def splat_source_range(node)
-          node.loc.expression.begin.resize(1)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.remove(splat_source_range(node)) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking modifier nodes.
-    module AccessModifierNode
-      extend RuboCop::Sexp
-
-      PRIVATE_NODE = s(:send, nil, :private)
-      PROTECTED_NODE = s(:send, nil, :protected)
-      PUBLIC_NODE = s(:send, nil, :public)
-      MODULE_FUNCTION_NODE = s(:send, nil, :module_function)
-
-      # Returns true when the node is an access modifier.
-      def modifier_node?(node)
-        modifier_structure?(node) && class_or_module_parent?(node)
-      end
-
-      # Returns true when the node looks like an access modifier.
-      def modifier_structure?(node)
-        [PRIVATE_NODE,
-         PROTECTED_NODE,
-         PUBLIC_NODE,
-         MODULE_FUNCTION_NODE].include?(node)
-      end
-
-      # Returns true when the parent of what looks like an access modifier
-      # is a Class or Module. Filters out simple method calls to similarly
-      # named private, protected or public.
-      def class_or_module_parent?(node)
-        node.each_ancestor do |a|
-          if a.type == :block
-            return true if a.class_constructor?
-          elsif a.type != :begin
-            return [:casgn, :sclass, :class, :module].include?(a.type)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,152 +0,0 @@
-# encoding: utf-8
-# 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, expr)
-          else
-            add_offense(current, :expression)
-          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
-        Parser::Source::Range.new(expr.source_buffer, 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 = Parser::Source::Range.new(range.source_buffer,
-                                          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

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

@@ -1,15 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking hash nodes.
-    module HashNode
-      def any_pairs_on_the_same_line?(node)
-        node.children.butfirst.any? do |pair|
-          !Util.begins_its_line?(pair.loc.expression)
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking if nodes.
-    module IfNode
-      def ternary?(node)
-        node.loc.respond_to?(:question)
-      end
-
-      def modifier_if?(node)
-        node.loc.respond_to?(:keyword) &&
-          %w(if unless).include?(node.loc.keyword.source) && node.modifier_form?
-      end
-
-      def elsif?(node)
-        node.loc.respond_to?(:keyword) && node.loc.keyword &&
-          node.loc.keyword.is?('elsif')
-      end
-
-      def if_else?(node)
-        node.loc.respond_to?(:else) && node.loc.else
-      end
-
-      def if_node_parts(node)
-        case node.loc.keyword.source
-        when 'if', 'elsif' then condition, body, else_clause = *node
-        when 'unless'      then condition, else_clause, body = *node
-        else                    condition, body = *node
-        end
-
-        [condition, body, else_clause]
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking instance methods and singleton methods.
-    module OnMethodDef
-      def on_def(node)
-        method_name, args, body = *node
-        on_method_def(node, method_name, args, body)
-      end
-
-      def on_defs(node)
-        _scope, method_name, args, body = *node
-        on_method_def(node, method_name, args, body)
-      end
-
-      private
-
-      # Returns true for constructs such as
-      # private def my_method
-      # which are allowed in Ruby 2.1 and later.
-      def modifier_and_def_on_same_line?(send_node)
-        send_node.receiver.nil? &&
-          send_node.method_name != :def &&
-          send_node.method_args.size == 1 &&
-          [:def, :defs].include?(send_node.method_args.first.type)
-      end
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking for spaces inside various
-    # kinds of brackets.
-    module SpaceInside
-      include SurroundingSpace
-      MSG = 'Space inside %s detected.'.freeze
-
-      def investigate(processed_source)
-        @processed_source = processed_source
-        each_extraneous_space(processed_source.tokens) do |kind, range|
-          add_offense(range, range, format(MSG, kind))
-        end
-      end
-
-      def autocorrect(range)
-        ->(corrector) { corrector.remove(range) }
-      end
-
-      private
-
-      def each_extraneous_space(tokens)
-        brackets = Brackets.new(*specifics)
-        tokens.each_cons(2) do |t1, t2|
-          next unless matching_brackets?(brackets, t1, t2)
-
-          # If the second token is a comment, that means that a line break
-          # follows, and that the rules for space inside don't apply.
-          next if t2.type == :tCOMMENT
-          next unless t2.pos.line == t1.pos.line && space_between?(t1, t2)
-
-          yield brackets.kind, range_between_tokens(t1, t2)
-        end
-      end
-
-      def matching_brackets?(brackets, t1, t2)
-        brackets.left_side?(t1) || brackets.right_side?(t2)
-      end
-
-      def range_between_tokens(t1, t2)
-        Parser::Source::Range.new(processed_source.buffer,
-                                  t1.pos.end_pos,
-                                  t2.pos.begin_pos)
-      end
-
-      # Wraps info about the brackets. Makes it easy to check whether a token
-      # is one of the brackets.
-      #
-      # @example Parentheses `()`
-      #   Brackets.new(:tLPAREN, :tRPAREN, 'parentheses')
-      #
-      # @example Square brackets `[]`
-      #   Brackets.new([:tLBRACK, :tLBRACK2], :tRBRACK, 'square brackets')
-      #
-      class Brackets
-        attr_reader :kind
-
-        def initialize(left, right, kind)
-          @left_side_types = [left].flatten
-          @right_side_type = right
-          @kind = kind
-        end
-
-        def left_side?(token)
-          # Left side bracket has to be able to match multiple types
-          # (e.g. :tLBRACK and :tLBRACK2)
-          @left_side_types.include?(token.type)
-        end
-
-        def right_side?(token)
-          @right_side_type == token.type
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/performance/hash_each.rb

@@ -1,86 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop checks for uses of `each_key` & `each_value` Hash methods.
-      #
-      # @example
-      #   # bad
-      #   hash.keys.each { |k| p k }
-      #   hash.values.each { |v| p v }
-      #   hash.each { |k, _v| p k }
-      #   hash.each { |_k, v| p v }
-      #
-      #   # good
-      #   hash.each_key { |k| p k }
-      #   hash.each_value { |v| p v }
-      class HashEachMethods < Cop
-        include Lint::UnusedArgument
-
-        MSG = 'Use `%s` instead of `%s`.'.freeze
-
-        def_node_matcher :plain_each, <<-END
-          (block $(send (send _ :hash) :each) (args (arg $_k) (arg $_v)) ...)
-        END
-
-        def_node_matcher :kv_each, <<-END
-          (block $(send (send (send _ :hash) ${:keys :values}) :each) ...)
-        END
-
-        def on_block(node)
-          plain_each(node) do |target, k, v|
-            return if @args[k] && @args[v]
-            used = @args[k] ? :key : :value
-            add_offense(target, range(target), format(message,
-                                                      "each_#{used}",
-                                                      :each))
-          end
-          kv_each(node) do |target, method|
-            add_offense(target, range(target), format(message,
-                                                      "each_#{method[0..-2]}",
-                                                      "#{method}.each"))
-          end
-        end
-
-        def check_argument(variable)
-          return unless variable.block_argument?
-          (@args ||= {})[variable.name] = variable.used?
-        end
-
-        def autocorrect(node)
-          receiver, _second_method = *node
-          caller, first_method = *receiver
-          lambda do |corrector|
-            if first_method == :hash
-              method = @args.values.first ? :key : :value
-              new_source = receiver.source + ".each_#{method}"
-              corrector.replace(node.loc.expression, new_source)
-              correct_args(node, corrector)
-            else
-              new_source = caller.source + ".each_#{first_method[0..-2]}"
-              corrector.replace(node.loc.expression, new_source)
-            end
-          end
-        end
-
-        private
-
-        def correct_args(node, corrector)
-          args = node.parent.children[1]
-          used_arg = "|#{@args.detect { |_k, v| v }.first}|"
-          args_range = Parser::Source::Range.new(node.parent.source,
-                                                 args.loc.begin.begin_pos,
-                                                 args.loc.end.end_pos)
-          corrector.replace(args_range, used_arg)
-        end
-
-        def range(outer_node)
-          inner_node = outer_node.children.first
-          inner_node.loc.selector.join(outer_node.loc.selector)
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/performance/push_splat.rb

@@ -1,47 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop is used to identify usages of
-      #
-      # @example
-      #   # bad
-      #   [].push(*a)
-      #
-      #   # good
-      #   [].concat(a)
-      class PushSplat < Cop
-        include Parentheses
-
-        MSG = 'Use `concat` instead of `push(*)`.'.freeze
-
-        def_node_matcher :push_splat, <<-END
-          (send _ :push (splat ...))
-        END
-
-        def on_send(node)
-          push_splat(node) do
-            add_offense(node, :expression, MSG)
-          end
-        end
-
-        def autocorrect(node)
-          _receiver, _method, splat = *node
-          body, = *splat
-          lambda do |corrector|
-            corrector.replace(node.location.selector, 'concat')
-
-            source = if parens_required?(splat)
-                       "(#{body.source})"
-                     else
-                       body.source
-                     end
-            corrector.replace(splat.loc.expression, source)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop makes sure that accessor methods are named properly.
-      #
-      # @example
-      #   # bad
-      #   def set_attribute(value) ...
-      #
-      #   # good
-      #   def attribute=(value)
-      #
-      #   # bad
-      #   def get_attribute ...
-      #
-      #   # good
-      #   def attribute ...
-      class AccessorMethodName < Cop
-        include OnMethodDef
-
-        private
-
-        def on_method_def(node, method_name, args, _body)
-          if bad_reader_name?(method_name.to_s, args)
-            add_offense(node, :name,
-                        'Do not prefix reader method names with `get_`.')
-          elsif bad_writer_name?(method_name.to_s, args)
-            add_offense(node, :name,
-                        'Do not prefix writer method names with `set_`.')
-          end
-        end
-
-        def bad_reader_name?(method_name, args)
-          method_name.start_with?('get_') && args.to_a.empty?
-        end
-
-        def bad_writer_name?(method_name, args)
-          method_name.start_with?('set_') && args.to_a.one?
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Here we check if the elements of a multi-line array literal are
-      # aligned.
-      class AlignArray < Cop
-        include AutocorrectAlignment
-
-        MSG = 'Align the elements of an array literal if they span more ' \
-              'than one line.'.freeze
-
-        def on_array(node)
-          check_alignment(node.children)
-        end
-      end
-    end
-  end
-end