rubbycop 0.49.0

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 = '`%s` (on line %d) does not make singleton methods %s. ' \
+              'Use %s instead.'.freeze
+        ALTERNATIVE_PRIVATE = '`private_class_method` or `private` inside a ' \
+                              '`class << self` block'.freeze
+        ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` ' \
+                                'block'.freeze
+
+        def_node_matcher :access_modifier, <<-PATTERN
+          (send nil ${:public :protected :private})
+        PATTERN
+
+        def_node_matcher :private_class_method, <<-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 clear
+          @useless = {}
+          @last_access_modifier = nil
+        end
+
+        def check_node(node)
+          return unless node && node.begin_type?
+
+          clear
+          check_scope(node)
+
+          @useless.each do |_name, (defs_node, visibility, modifier)|
+            add_offense(defs_node, :keyword,
+                        format_message(visibility, modifier))
+          end
+        end
+
+        def format_message(visibility, modifier)
+          alternative = if visibility == :private
+                          ALTERNATIVE_PRIVATE
+                        else
+                          ALTERNATIVE_PROTECTED
+                        end
+          format(MSG, visibility, modifier.location.expression.line, visibility,
+                 alternative)
+        end
+
+        def check_scope(node, cur_vis = :public)
+          node.children.reduce(cur_vis) do |visibility, child|
+            check_child_scope(child, visibility)
+          end
+        end
+
+        def check_child_scope(node, cur_vis)
+          if (new_vis = access_modifier(node))
+            cur_vis = change_visibility(node, new_vis)
+          elsif node.defs_type?
+            mark_method_as_useless(node, cur_vis) if cur_vis != :public
+          elsif (methods = private_class_method(node))
+            # don't warn about defs nodes which are followed by a call to
+            # `private_class_method :name`
+            # obviously the programmer knows what they are doing
+            revert_method_uselessness(methods)
+          elsif node.kwbegin_type?
+            cur_vis = check_scope(node, cur_vis)
+          end
+
+          cur_vis
+        end
+
+        def change_visibility(node, new_vis)
+          @last_access_modifier = node
+          new_vis
+        end
+
+        def mark_method_as_useless(node, cur_vis)
+          _, method_name, = *node
+          @useless[method_name] = [node, cur_vis, @last_access_modifier]
+        end
+
+        def revert_method_uselessness(methods)
+          methods.each do |sym|
+            next unless sym.sym_type?
+            @useless.delete(sym.children[0])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+      #
+      #   # bad
+      #
+      #   class C < Exception; end
+      #
+      # @example
+      #
+      #   # EnforcedStyle: runtime_error (default)
+      #
+      #   # good
+      #
+      #   class C < RuntimeError; end
+      #
+      # @example
+      #
+      #   # EnforcedStyle: standard_error
+      #
+      #   # good
+      #
+      #   class C < StandardError; end
+      class InheritException < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Inherit from `%s` instead of `%s`.'.freeze
+        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 on_class(node)
+          _class, base_class, _body = *node
+
+          return if base_class.nil?
+
+          check(base_class)
+        end
+
+        private
+
+        def check(node)
+          return unless ILLEGAL_CLASSES.include?(node.const_name)
+
+          msg = format(MSG, preferred_base_class, node.const_name)
+          add_offense(node, :expression, msg)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, preferred_base_class)
+          end
+        end
+
+        def preferred_base_class
+          PREFERRED_BASE_CLASS[style]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+      #
+      #   # bad
+      #
+      #   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/rubbycop/cop/lint/literal_in_condition.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 LiteralInCondition < Cop
+        MSG = 'Literal `%s` appeared in a condition.'.freeze
+
+        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, :expression)
+            end
+          end
+        end
+
+        def message(node)
+          format(MSG, node.source)
+        end
+
+        private
+
+        def check_for_literal(node)
+          if node.condition.literal?
+            add_offense(node.condition, :expression)
+          else
+            check_node(node.condition)
+          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)
+          return unless node
+
+          if node.keyword_bang?
+            receiver, = *node
+
+            handle_node(receiver)
+          elsif LOGICAL_OPERATOR_NODES.include?(node.type)
+            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, :expression)
+          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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for interpolated literals.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   "result is #{10}"
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   "result is 10"
+      class LiteralInInterpolation < Cop
+        MSG = 'Literal interpolation detected.'.freeze
+        COMPOSITE = %i[array hash pair irange erange].freeze
+
+        def on_dstr(node)
+          node.each_child_node(:begin) do |begin_node|
+            final_node = begin_node.children.last
+            next unless final_node
+            next if special_keyword?(final_node)
+            next unless prints_as_self?(final_node)
+
+            add_offense(final_node, :expression)
+          end
+        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 :str
+            node.children.last
+          when :sym
+            autocorrected_value_for_symbol(node)
+          else
+            node.source.gsub('"', '\"')
+          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
+
+        # 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