package org.sonar.python.checks;

import org.sonar.check.Rule;

import org.sonar.plugins.python.api.symbols.Symbol;

import static org.sonar.plugins.python.api.symbols.Symbol.Kind.CLASS;

@Rule(key = "S3985")

public class UnreadPrivateInnerClassesCheck extends AbstractUnreadPrivateMembersCheck {

@Override

String memberPrefix() {

return "_";

}

@Override

Symbol.Kind kind() {

return CLASS;

}

@Override

String message(String memberName) {

return "Remove this unused private '" + memberName + "' class.";

}

}

<p>"Private" nested classes that are never used inside the enclosing class are usually dead code: unnecessary, inoperative code that should be

removed. Cleaning out dead code decreases the size of the maintained codebase, making it easier to understand the program and preventing bugs from

being introduced.</p>

<p>Python has no real private classes. Every class is accessible. There are however two conventions indicating that a class is not meant to be

"public":</p>

<li> classes with a name starting with a single underscore (ex: <code>_MyClass</code>) should be seen as non-public and might change without prior

notice. They should not be used by third-party libraries or software. It is ok to use those classes inside the library defining them but it should

be done with caution. </li>

<li> "class-private" classes are defined inside another class, and have a name starting with at least two underscores and ending with at most one

underscore. These classes' names will be automatically mangled to avoid collision with subclasses' nested classes. For example

<code>__MyClass</code> will be renamed as <code>_classname__MyClass</code>, where <code>classname</code> is the enclosing class's name without its

leading underscore(s). Class-Private classes shouldn't be used outside of their enclosing class. </li>

<p>This rule raises an issue when a private nested class (either with one or two leading underscores) is never used inside its parent class.</p>

<h2>Noncompliant Code Example</h2>

class Noncompliant:

class __MyClas1s(): # Noncompliant

pass

class _MyClass2(): # Noncompliant

pass

<h2>Compliant Solution</h2>

class Compliant:

class __MyClass1():

pass

class _MyClass2():

pass

def process(self):

return Compliant.__MyClass1()

def process(self):

return Compliant._MyClass2()

<h2>See</h2>

<li> <a href="https://docs.python.org/3.8/tutorial/classes.html#private-variables">Python documentation <del></del> Private Variables</a> </li>

<li> <a href="https://www.python.org/dev/peps/pep-0008/#designing-for-inheritance">PEP 8 <del></del> Style Guide for Python Code</a> </li>

{

"title": "Unused private nested classes should be removed",

"type": "CODE_SMELL",

"status": "ready",

"remediation": {

"func": "Constant\/Issue",

"constantCost": "2min"

},

"tags": [

"unused"

],

"defaultSeverity": "Major",

"ruleSpecification": "RSPEC-3985",

"sqKey": "S3985",

"scope": "All"

}

"S3985",

package org.sonar.python.checks;

import org.junit.Test;

import org.sonar.python.checks.utils.PythonCheckVerifier;

public class UnreadPrivateInnerClassesCheckTest {

@Test

public void test() {

PythonCheckVerifier.verify("src/test/resources/checks/unreadPrivateInnerClasses.py", new UnreadPrivateInnerClassesCheck());

}

}

class A:

__foo = 42 # OK, raised by S4487

def __unused(self): ... # OK, raised by S1144

class __unused_cls: ... # Noncompliant {{Remove this unused private '__unused_cls' class.}}

# ^^^^^^^^^^^^

class _unused_cls: ... # Noncompliant

class __used_cls: ...

class __other_used_cls: ...

def __init__(self):

print(self.__used_cls)

print(A.__other_used_cls)