rubocop 0.75.1

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop looks for error classes inheriting from `Exception`
+      # and its standard library subclasses, excluding subclasses of
+      # `StandardError`. It is configurable to suggest using either
+      # `RuntimeError` (default) or `StandardError` instead.
+      #
+      # @example EnforcedStyle: runtime_error (default)
+      #   # bad
+      #
+      #   class C < Exception; end
+      #
+      #   C = Class.new(Exception)
+      #
+      #   # good
+      #
+      #   class C < RuntimeError; end
+      #
+      #   C = Class.new(RuntimeError)
+      #
+      # @example EnforcedStyle: standard_error
+      #   # bad
+      #
+      #   class C < Exception; end
+      #
+      #   C = Class.new(Exception)
+      #
+      #   # good
+      #
+      #   class C < StandardError; end
+      #
+      #   C = Class.new(StandardError)
+      class InheritException < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Inherit from `%<prefer>s` instead of `%<current>s`.'
+        PREFERRED_BASE_CLASS = {
+          runtime_error: 'RuntimeError',
+          standard_error: 'StandardError'
+        }.freeze
+        ILLEGAL_CLASSES = %w[
+          Exception
+          SystemStackError
+          NoMemoryError
+          SecurityError
+          NotImplementedError
+          LoadError
+          SyntaxError
+          ScriptError
+          Interrupt
+          SignalException
+          SystemExit
+        ].freeze
+
+        def_node_matcher :class_new_call?, <<~PATTERN
+          (send
+            (const {cbase nil?} :Class) :new
+            $(const {cbase nil?} _))
+        PATTERN
+
+        def on_class(node)
+          return unless node.parent_class &&
+                        illegal_class_name?(node.parent_class)
+
+          add_offense(node.parent_class)
+        end
+
+        def on_send(node)
+          constant = class_new_call?(node)
+          return unless constant && illegal_class_name?(constant)
+
+          add_offense(constant)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, preferred_base_class)
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG, prefer: preferred_base_class, current: node.const_name)
+        end
+
+        def illegal_class_name?(class_node)
+          ILLEGAL_CLASSES.include?(class_node.const_name)
+        end
+
+        def preferred_base_class
+          PREFERRED_BASE_CLASS[style]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for interpolation in a single quoted string.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   foo = 'something with #{interpolation} inside'
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   foo = "something with #{interpolation} inside"
+      class InterpolationCheck < Cop
+        MSG = 'Interpolation in single quoted string detected. '\
+              'Use double quoted strings if you need interpolation.'
+
+        def on_str(node)
+          return if heredoc?(node)
+
+          parent = node.parent
+          return if parent && (parent.dstr_type? || parent.regexp_type?)
+          return unless node.source.scrub =~ /(?<!\\)#\{.*\}/
+
+          add_offense(node)
+        end
+
+        def heredoc?(node)
+          node.loc.is_a?(Parser::Source::Map::Heredoc) ||
+            (node.parent && heredoc?(node.parent))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for literals used as the conditions or as
+      # operands in and/or expressions serving as the conditions of
+      # if/while/until.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   if 20
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   if some_var && true
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   if some_var && some_condition
+      #     do_something
+      #   end
+      class LiteralAsCondition < Cop
+        MSG = 'Literal `%<literal>s` appeared as a condition.'
+
+        def on_if(node)
+          check_for_literal(node)
+        end
+
+        def on_while(node)
+          check_for_literal(node)
+        end
+
+        def on_while_post(node)
+          check_for_literal(node)
+        end
+
+        def on_until(node)
+          check_for_literal(node)
+        end
+
+        def on_until_post(node)
+          check_for_literal(node)
+        end
+
+        def on_case(case_node)
+          if case_node.condition
+            check_case(case_node)
+          else
+            case_node.each_when do |when_node|
+              next unless when_node.conditions.all?(&:literal?)
+
+              add_offense(when_node)
+            end
+          end
+        end
+
+        def on_send(node)
+          return unless node.negation_method?
+
+          check_for_literal(node)
+        end
+
+        def message(node)
+          format(MSG, literal: node.source)
+        end
+
+        private
+
+        def check_for_literal(node)
+          cond = condition(node)
+          if cond.literal?
+            add_offense(cond)
+          else
+            check_node(cond)
+          end
+        end
+
+        def basic_literal?(node)
+          if node.array_type?
+            primitive_array?(node)
+          else
+            node.basic_literal?
+          end
+        end
+
+        def primitive_array?(node)
+          node.children.all? { |n| basic_literal?(n) }
+        end
+
+        def check_node(node)
+          if node.send_type? && node.prefix_bang?
+            handle_node(node.receiver)
+          elsif node.operator_keyword?
+            node.each_child_node { |op| handle_node(op) }
+          elsif node.begin_type? && node.children.one?
+            handle_node(node.children.first)
+          end
+        end
+
+        def handle_node(node)
+          if node.literal?
+            add_offense(node)
+          elsif %i[send and or begin].include?(node.type)
+            check_node(node)
+          end
+        end
+
+        def check_case(case_node)
+          condition = case_node.condition
+
+          return if condition.array_type? && !primitive_array?(condition)
+          return if condition.dstr_type?
+
+          handle_node(condition)
+        end
+
+        def condition(node)
+          if node.send_type?
+            node.receiver
+          else
+            node.condition
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for interpolated literals.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   "result is #{10}"
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   "result is 10"
+      class LiteralInInterpolation < Cop
+        include Interpolation
+        include RangeHelp
+        include PercentLiteral
+
+        MSG = 'Literal interpolation detected.'
+        COMPOSITE = %i[array hash pair irange erange].freeze
+
+        def on_interpolation(begin_node)
+          final_node = begin_node.children.last
+          return unless final_node
+          return if special_keyword?(final_node)
+          return unless prints_as_self?(final_node)
+
+          add_offense(final_node)
+        end
+
+        def autocorrect(node)
+          return if node.dstr_type? # nested, fixed in next iteration
+
+          value = autocorrected_value(node)
+          ->(corrector) { corrector.replace(node.parent.source_range, value) }
+        end
+
+        private
+
+        def special_keyword?(node)
+          # handle strings like __FILE__
+          (node.str_type? && !node.loc.respond_to?(:begin)) ||
+            node.source_range.is?('__LINE__')
+        end
+
+        def autocorrected_value(node)
+          case node.type
+          when :int
+            node.children.last.to_i.to_s
+          when :float
+            node.children.last.to_f.to_s
+          when :str
+            autocorrected_value_for_string(node)
+          when :sym
+            autocorrected_value_for_symbol(node)
+          when :array
+            autocorrected_value_for_array(node)
+          else
+            node.source.gsub('"', '\"')
+          end
+        end
+
+        def autocorrected_value_for_string(node)
+          if node.source.start_with?("'", '%q')
+            node.children.last.inspect[1..-2]
+          else
+            node.children.last
+          end
+        end
+
+        def autocorrected_value_for_symbol(node)
+          end_pos =
+            node.loc.end ? node.loc.end.begin_pos : node.loc.expression.end_pos
+
+          range_between(node.loc.begin.end_pos, end_pos).source
+        end
+
+        def autocorrected_value_for_array(node)
+          return node.source.gsub('"', '\"') unless node.percent_literal?
+
+          contents_range(node).source.split(' ').to_s.gsub('"', '\"')
+        end
+
+        # Does node print its own source when converted to a string?
+        def prints_as_self?(node)
+          node.basic_literal? ||
+            (COMPOSITE.include?(node.type) &&
+              node.children.all? { |child| prints_as_self?(child) })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for uses of *begin...end while/until something*.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # using while
+      #   begin
+      #     do_something
+      #   end while some_condition
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # using until
+      #   begin
+      #     do_something
+      #   end until some_condition
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # using while
+      #   while some_condition
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # using until
+      #   until some_condition
+      #     do_something
+      #   end
+      class Loop < Cop
+        MSG = 'Use `Kernel#loop` with `break` rather than ' \
+              '`begin/end/until`(or `while`).'
+
+        def on_while_post(node)
+          register_offense(node)
+        end
+
+        def on_until_post(node)
+          register_offense(node)
+        end
+
+        private
+
+        def register_offense(node)
+          add_offense(node, location: :keyword)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/UnneededCopDisableDirective
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there is an `# rubocop:enable ...` statement
+      # after a `# rubocop:disable ...` statement. This will prevent leaving
+      # cop disables on wide ranges of code, that latter contributors to
+      # a file wouldn't be aware of.
+      #
+      # @example
+      #   # Lint/MissingCopEnableDirective:
+      #   #   MaximumRangeSize: .inf
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #   # y = 1
+      #   # EOF
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # EOF
+      #
+      # @example
+      #   # Lint/MissingCopEnableDirective:
+      #   #   MaximumRangeSize: 2
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # With the previous, there are 2 lines on which cop is disabled.
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   x += 1
+      #   # Including this, that's 3 lines on which the cop is disabled.
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #
+      class MissingCopEnableDirective < Cop
+        include RangeHelp
+
+        MSG = 'Re-enable %<cop>s cop with `# rubocop:enable` after ' \
+              'disabling it.'
+        MSG_BOUND = 'Re-enable %<cop>s cop within %<max_range>s lines after ' \
+                    'disabling it.'
+
+        def investigate(processed_source)
+          max_range = cop_config['MaximumRangeSize']
+          processed_source.disabled_line_ranges.each do |cop, line_ranges|
+            line_ranges.each do |line_range|
+              # This has to remain a strict inequality to handle
+              # the case when max_range is Float::INFINITY
+              next if line_range.max - line_range.min < max_range + 2
+
+              range = source_range(processed_source.buffer,
+                                   line_range.min,
+                                   (0..0))
+              add_offense(range,
+                          location: range,
+                          message: message(max_range: max_range, cop: cop))
+            end
+          end
+        end
+
+        private
+
+        def message(max_range:, cop:)
+          if max_range == Float::INFINITY
+            format(MSG, cop: cop)
+          else
+            format(MSG_BOUND, cop: cop, max_range: max_range)
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Lint/UnneededCopDisableDirective, Layout/SpaceAroundOperators