rubocop 0.87.1

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for `private` or `protected` access modifiers which are
+      # applied to a singleton method. These access modifiers do not make
+      # singleton methods private/protected. `private_class_method` can be
+      # used for that.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   class C
+      #     private
+      #
+      #     def self.method
+      #       puts 'hi'
+      #     end
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   class C
+      #     def self.method
+      #       puts 'hi'
+      #     end
+      #
+      #     private_class_method :method
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   class C
+      #     class << self
+      #       private
+      #
+      #       def method
+      #         puts 'hi'
+      #       end
+      #     end
+      #   end
+      class IneffectiveAccessModifier < Cop
+        MSG = '`%<modifier>s` (on line %<line>d) does not make singleton ' \
+              'methods %<modifier>s. Use %<alternative>s instead.'
+        ALTERNATIVE_PRIVATE = '`private_class_method` or `private` inside a ' \
+                              '`class << self` block'
+        ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` ' \
+                                'block'
+
+        def_node_search :private_class_methods, <<~PATTERN
+          (send nil? :private_class_method $...)
+        PATTERN
+
+        def on_class(node)
+          check_node(node.children[2]) # class body
+        end
+
+        def on_module(node)
+          check_node(node.children[1]) # module body
+        end
+
+        private
+
+        def check_node(node)
+          return unless node&.begin_type?
+
+          ignored_methods = private_class_method_names(node)
+
+          ineffective_modifier(node, ignored_methods) do |defs_node, modifier|
+            add_offense(defs_node,
+                        location: :keyword,
+                        message: format_message(modifier))
+          end
+        end
+
+        def private_class_method_names(node)
+          private_class_methods(node).to_a.flatten
+                                     .select(&:basic_literal?)
+                                     .map(&:value)
+        end
+
+        def format_message(modifier)
+          visibility = modifier.method_name
+          alternative = if visibility == :private
+                          ALTERNATIVE_PRIVATE
+                        else
+                          ALTERNATIVE_PROTECTED
+                        end
+          format(MSG, modifier: visibility,
+                      line: modifier.location.expression.line,
+                      alternative: alternative)
+        end
+
+        def ineffective_modifier(node, ignored_methods, modifier = nil, &block)
+          node.each_child_node do |child|
+            case child.type
+            when :send
+              modifier = child if access_modifier?(child)
+            when :defs
+              next if correct_visibility?(child, modifier, ignored_methods)
+
+              yield child, modifier
+            when :kwbegin
+              ineffective_modifier(child, ignored_methods, modifier, &block)
+            end
+          end
+        end
+
+        def access_modifier?(node)
+          node.bare_access_modifier? && !node.method?(:module_function)
+        end
+
+        def correct_visibility?(node, modifier, ignored_methods)
+          return true if modifier.nil? || modifier.method?(:public)
+
+          ignored_methods.include?(node.method_name)
+        end
+      end
+    end
+  end
+end

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, 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,53 @@
+# 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 /(?<!\\)#\{.*\}/.match?(node.source.scrub)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            starting_token, ending_token = if node.source.include?('"')
+                                             ['%{', '}']
+                                           else
+                                             ['"', '"']
+                                           end
+
+            corrector.replace(node.loc.begin, starting_token)
+            corrector.replace(node.loc.end, ending_token)
+          end
+        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,135 @@
+# 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
+      #
+      #   # bad
+      #   if some_var && true
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if some_var && some_condition
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   # When using a boolean value for an infinite loop.
+      #   while true
+      #     break if condition
+      #   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)
+          return if condition(node).true_type?
+
+          check_for_literal(node)
+        end
+        alias on_while_post on_while
+
+        def on_until(node)
+          return if condition(node).false_type?
+
+          check_for_literal(node)
+        end
+        alias on_until_post on_until
+
+        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, 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